projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use parameters to track whether we are doing a static link. Fix up
[deliverable/binutils-gdb.git] / bfd / elf32-iq2000.c
CommitLineData
a75473eb 1/* IQ2000-specific support for 32-bit ELF.
ab96bf03
AM		 2 Copyright (C) 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
a75473eb 4
58852c27 5 This file is part of BFD, the Binary File Descriptor library.
a75473eb 6
58852c27
NC		 7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
58852c27 10 (at your option) any later version.
a75473eb 11
58852c27
NC		 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
a75473eb 16
58852c27
NC		 17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
3e110533 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
a75473eb 20
a75473eb 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
a75473eb
SC		 23#include "libbfd.h"
24#include "elf-bfd.h"
25#include "elf/iq2000.h"
26
27/* Forward declarations. */
28
58852c27 29static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
a75473eb
SC		 30
31\f
32static reloc_howto_type iq2000_elf_howto_table [] =
33{
34 /* This reloc does nothing. */
35
36 HOWTO (R_IQ2000_NONE, /* type */
37 0, /* rightshift */
38 2, /* size (0 = byte, 1 = short, 2 = long) */
39 32, /* bitsize */
40 FALSE, /* pc_relative */
41 0, /* bitpos */
42 complain_overflow_bitfield, /* complain_on_overflow */
43 bfd_elf_generic_reloc, /* special_function */
44 "R_IQ2000_NONE", /* name */
45 FALSE, /* partial_inplace */
46 0, /* src_mask */
47 0, /* dst_mask */
48 FALSE), /* pcrel_offset */
49
50 /* A 16 bit absolute relocation. */
51 HOWTO (R_IQ2000_16, /* type */
52 0, /* rightshift */
53 1, /* size (0 = byte, 1 = short, 2 = long) */
54 16, /* bitsize */
55 FALSE, /* pc_relative */
56 0, /* bitpos */
57 complain_overflow_bitfield, /* complain_on_overflow */
58 bfd_elf_generic_reloc, /* special_function */
59 "R_IQ2000_16", /* name */
60 FALSE, /* partial_inplace */
61 0x0000, /* src_mask */
62 0xffff, /* dst_mask */
63 FALSE), /* pcrel_offset */
64
65 /* A 32 bit absolute relocation. */
66 HOWTO (R_IQ2000_32, /* type */
67 0, /* rightshift */
68 2, /* size (0 = byte, 1 = short, 2 = long) */
69 31, /* bitsize */
70 FALSE, /* pc_relative */
71 0, /* bitpos */
72 complain_overflow_bitfield, /* complain_on_overflow */
73 bfd_elf_generic_reloc, /* special_function */
74 "R_IQ2000_32", /* name */
75 FALSE, /* partial_inplace */
76 0x00000000, /* src_mask */
77 0x7fffffff, /* dst_mask */
78 FALSE), /* pcrel_offset */
79
80 /* 26 bit branch address. */
81 HOWTO (R_IQ2000_26, /* type */
82 2, /* rightshift */
83 2, /* size (0 = byte, 1 = short, 2 = long) */
84 26, /* bitsize */
85 FALSE, /* pc_relative */
86 0, /* bitpos */
87 complain_overflow_dont, /* complain_on_overflow */
88 /* This needs complex overflow
89 detection, because the upper four
90 bits must match the PC. */
91 bfd_elf_generic_reloc, /* special_function */
92 "R_IQ2000_26", /* name */
93 FALSE, /* partial_inplace */
94 0x00000000, /* src_mask */
95 0x03ffffff, /* dst_mask */
96 FALSE), /* pcrel_offset */
97
98 /* 16 bit PC relative reference. */
99 HOWTO (R_IQ2000_PC16, /* type */
100 2, /* rightshift */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
102 16, /* bitsize */
103 TRUE, /* pc_relative */
104 0, /* bitpos */
105 complain_overflow_signed, /* complain_on_overflow */
106 bfd_elf_generic_reloc, /* special_function */
107 "R_IQ2000_PC16", /* name */
108 FALSE, /* partial_inplace */
109 0x0000, /* src_mask */
110 0xffff, /* dst_mask */
111 TRUE), /* pcrel_offset */
112
113 /* high 16 bits of symbol value. */
114 HOWTO (R_IQ2000_HI16, /* type */
115 16, /* rightshift */
116 2, /* size (0 = byte, 1 = short, 2 = long) */
117 15, /* bitsize */
118 FALSE, /* pc_relative */
119 0, /* bitpos */
120 complain_overflow_dont, /* complain_on_overflow */
121 iq2000_elf_howto_hi16_reloc, /* special_function */
122 "R_IQ2000_HI16", /* name */
123 FALSE, /* partial_inplace */
124 0x0000, /* src_mask */
125 0x7fff, /* dst_mask */
126 FALSE), /* pcrel_offset */
127
128 /* Low 16 bits of symbol value. */
129 HOWTO (R_IQ2000_LO16, /* type */
130 0, /* rightshift */
131 2, /* size (0 = byte, 1 = short, 2 = long) */
132 16, /* bitsize */
133 FALSE, /* pc_relative */
134 0, /* bitpos */
135 complain_overflow_dont, /* complain_on_overflow */
136 bfd_elf_generic_reloc, /* special_function */
137 "R_IQ2000_LO16", /* name */
138 FALSE, /* partial_inplace */
139 0x0000, /* src_mask */
140 0xffff, /* dst_mask */
141 FALSE), /* pcrel_offset */
142
143 /* 16-bit jump offset. */
144 HOWTO (R_IQ2000_OFFSET_16, /* type */
145 2, /* rightshift */
146 2, /* size (0 = byte, 1 = short, 2 = long) */
147 16, /* bitsize */
148 FALSE, /* pc_relative */
149 0, /* bitpos */
150 complain_overflow_dont, /* complain_on_overflow */
151 bfd_elf_generic_reloc, /* special_function */
152 "R_IQ2000_OFFSET_16", /* name */
153 FALSE, /* partial_inplace */
154 0x0000, /* src_mask */
155 0xffff, /* dst_mask */
156 FALSE), /* pcrel_offset */
157
158 /* 21-bit jump offset. */
159 HOWTO (R_IQ2000_OFFSET_21, /* type */
160 2, /* rightshift */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
162 21, /* bitsize */
163 FALSE, /* pc_relative */
164 0, /* bitpos */
165 complain_overflow_dont, /* complain_on_overflow */
166 bfd_elf_generic_reloc, /* special_function */
167 "R_IQ2000_OFFSET_21", /* name */
168 FALSE, /* partial_inplace */
169 0x000000, /* src_mask */
170 0x1fffff, /* dst_mask */
171 FALSE), /* pcrel_offset */
172
173 /* unsigned high 16 bits of value. */
174 HOWTO (R_IQ2000_OFFSET_21, /* type */
175 16, /* rightshift */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
177 16, /* bitsize */
178 FALSE, /* pc_relative */
179 0, /* bitpos */
180 complain_overflow_dont, /* complain_on_overflow */
181 bfd_elf_generic_reloc, /* special_function */
182 "R_IQ2000_UHI16", /* name */
183 FALSE, /* partial_inplace */
184 0x0000, /* src_mask */
185 0x7fff, /* dst_mask */
186 FALSE), /* pcrel_offset */
187
188 /* A 32 bit absolute debug relocation. */
189 HOWTO (R_IQ2000_32_DEBUG, /* type */
190 0, /* rightshift */
191 2, /* size (0 = byte, 1 = short, 2 = long) */
192 32, /* bitsize */
193 FALSE, /* pc_relative */
194 0, /* bitpos */
195 complain_overflow_bitfield, /* complain_on_overflow */
196 bfd_elf_generic_reloc, /* special_function */
197 "R_IQ2000_32", /* name */
198 FALSE, /* partial_inplace */
199 0x00000000, /* src_mask */
200 0xffffffff, /* dst_mask */
201 FALSE), /* pcrel_offset */
202
203};
204
205/* GNU extension to record C++ vtable hierarchy. */
206static reloc_howto_type iq2000_elf_vtinherit_howto =
207 HOWTO (R_IQ2000_GNU_VTINHERIT, /* type */
208 0, /* rightshift */
209 2, /* size (0 = byte, 1 = short, 2 = long) */
210 0, /* bitsize */
211 FALSE, /* pc_relative */
212 0, /* bitpos */
213 complain_overflow_dont, /* complain_on_overflow */
214 NULL, /* special_function */
215 "R_IQ2000_GNU_VTINHERIT", /* name */
216 FALSE, /* partial_inplace */
217 0, /* src_mask */
218 0, /* dst_mask */
219 FALSE); /* pcrel_offset */
220
221/* GNU extension to record C++ vtable member usage. */
222static reloc_howto_type iq2000_elf_vtentry_howto =
223 HOWTO (R_IQ2000_GNU_VTENTRY, /* type */
224 0, /* rightshift */
225 2, /* size (0 = byte, 1 = short, 2 = long) */
226 0, /* bitsize */
227 FALSE, /* pc_relative */
228 0, /* bitpos */
229 complain_overflow_dont, /* complain_on_overflow */
230 NULL, /* special_function */
231 "R_IQ2000_GNU_VTENTRY", /* name */
232 FALSE, /* partial_inplace */
233 0, /* src_mask */
234 0, /* dst_mask */
235 FALSE); /* pcrel_offset */
236
237\f
a75473eb 238static bfd_reloc_status_type
58852c27
NC		 239iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
240 arelent *reloc_entry,
241 asymbol *symbol,
242 void * data,
243 asection *input_section,
244 bfd *output_bfd,
245 char **error_message ATTRIBUTE_UNUSED)
a75473eb
SC		 246{
247 bfd_reloc_status_type ret;
248 bfd_vma relocation;
249
58852c27
NC		 250 /* If we're relocating and this an external symbol,
251 we don't want to change anything. */
a75473eb
SC		 252 if (output_bfd != (bfd *) NULL
253 && (symbol->flags & BSF_SECTION_SYM) == 0
254 && reloc_entry->addend == 0)
255 {
256 reloc_entry->address += input_section->output_offset;
257 return bfd_reloc_ok;
258 }
259
260 if (bfd_is_com_section (symbol->section))
261 relocation = 0;
262 else
263 relocation = symbol->value;
264
265 relocation += symbol->section->output_section->vma;
266 relocation += symbol->section->output_offset;
267 relocation += reloc_entry->addend;
268
58852c27 269 /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion. */
a75473eb
SC		 270 if (relocation & 0x8000)
271 reloc_entry->addend += 0x10000;
272
273 /* Now do the reloc in the usual way. */
274 ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
275 input_section, output_bfd, error_message);
276
58852c27 277 /* Put it back the way it was. */
a75473eb
SC		 278 if (relocation & 0x8000)
279 reloc_entry->addend -= 0x10000;
280
281 return ret;
282}
283
284static bfd_reloc_status_type
58852c27
NC		 285iq2000_elf_relocate_hi16 (bfd *input_bfd,
286 Elf_Internal_Rela *relhi,
287 bfd_byte *contents,
288 bfd_vma value)
a75473eb
SC		 289{
290 bfd_vma insn;
291
292 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
293
294 value += relhi->r_addend;
58852c27 295 value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit. */
a75473eb 296
58852c27
NC		 297 /* If top-bit of %lo value is on, this means that %lo will
298 sign-propagate and so we compensate by adding 1 to %hi value. */
a75473eb
SC		 299 if (value & 0x8000)
300 value += 0x10000;
301
302 value >>= 16;
303 insn = ((insn & ~0xFFFF) | value);
304
305 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
306 return bfd_reloc_ok;
307}
308
6c408f53
NC		 309/* Map BFD reloc types to IQ2000 ELF reloc types. */
310
a75473eb 311static reloc_howto_type *
de52dba4
AM		 312iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
313 bfd_reloc_code_real_type code)
a75473eb
SC		 314{
315 /* Note that the iq2000_elf_howto_table is indxed by the R_
316 constants. Thus, the order that the howto records appear in the
317 table *must* match the order of the relocation types defined in
318 include/elf/iq2000.h. */
319
320 switch (code)
321 {
322 case BFD_RELOC_NONE:
323 return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE];
324 case BFD_RELOC_16:
325 return &iq2000_elf_howto_table[ (int) R_IQ2000_16];
326 case BFD_RELOC_32:
327 return &iq2000_elf_howto_table[ (int) R_IQ2000_32];
328 case BFD_RELOC_MIPS_JMP:
329 return &iq2000_elf_howto_table[ (int) R_IQ2000_26];
330 case BFD_RELOC_IQ2000_OFFSET_16:
331 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16];
332 case BFD_RELOC_IQ2000_OFFSET_21:
333 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21];
334 case BFD_RELOC_16_PCREL_S2:
335 return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16];
336 case BFD_RELOC_HI16:
337 return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16];
338 case BFD_RELOC_IQ2000_UHI16:
339 return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16];
340 case BFD_RELOC_LO16:
341 return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16];
342 case BFD_RELOC_VTABLE_INHERIT:
343 return &iq2000_elf_vtinherit_howto;
344 case BFD_RELOC_VTABLE_ENTRY:
345 return &iq2000_elf_vtentry_howto;
346 default:
347 /* Pacify gcc -Wall. */
348 return NULL;
349 }
350 return NULL;
351}
352
157090f7
AM		 353static reloc_howto_type *
354iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
355{
356 unsigned int i;
357
358 for (i = 0;
359 i < (sizeof (iq2000_elf_howto_table)
360 / sizeof (iq2000_elf_howto_table[0]));
361 i++)
362 if (iq2000_elf_howto_table[i].name != NULL
363 && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0)
364 return &iq2000_elf_howto_table[i];
365
366 if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0)
367 return &iq2000_elf_vtinherit_howto;
368 if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0)
369 return &iq2000_elf_vtentry_howto;
370
371 return NULL;
372}
a75473eb
SC		 373\f
374/* Perform a single relocation. By default we use the standard BFD
375 routines. */
376
377static bfd_reloc_status_type
58852c27
NC		 378iq2000_final_link_relocate (reloc_howto_type * howto,
379 bfd * input_bfd,
380 asection * input_section,
381 bfd_byte * contents,
382 Elf_Internal_Rela * rel,
383 bfd_vma relocation)
a75473eb
SC		 384{
385 return _bfd_final_link_relocate (howto, input_bfd, input_section,
386 contents, rel->r_offset,
387 relocation, rel->r_addend);
388}
389\f
390/* Set the howto pointer for a IQ2000 ELF reloc. */
391
392static void
58852c27
NC		 393iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
394 arelent * cache_ptr,
395 Elf_Internal_Rela * dst)
a75473eb
SC		 396{
397 unsigned int r_type;
398
399 r_type = ELF32_R_TYPE (dst->r_info);
400 switch (r_type)
401 {
402 case R_IQ2000_GNU_VTINHERIT:
403 cache_ptr->howto = & iq2000_elf_vtinherit_howto;
404 break;
405
406 case R_IQ2000_GNU_VTENTRY:
407 cache_ptr->howto = & iq2000_elf_vtentry_howto;
408 break;
409
410 default:
411 cache_ptr->howto = & iq2000_elf_howto_table [r_type];
412 break;
413 }
414}
415
416/* Look through the relocs for a section during the first phase.
417 Since we don't do .gots or .plts, we just need to consider the
418 virtual table relocs for gc. */
419
420static bfd_boolean
58852c27
NC		 421iq2000_elf_check_relocs (bfd *abfd,
422 struct bfd_link_info *info,
423 asection *sec,
424 const Elf_Internal_Rela *relocs)
a75473eb
SC		 425{
426 Elf_Internal_Shdr *symtab_hdr;
427 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
60d8b524
AM		 428 const Elf_Internal_Rela *rel;
429 const Elf_Internal_Rela *rel_end;
430 bfd_boolean changed = FALSE;
a75473eb 431
1049f94e 432 if (info->relocatable)
a75473eb
SC		 433 return TRUE;
434
435 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
436 sym_hashes = elf_sym_hashes (abfd);
58852c27 437 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
a75473eb
SC		 438 if (!elf_bad_symtab (abfd))
439 sym_hashes_end -= symtab_hdr->sh_info;
440
441 rel_end = relocs + sec->reloc_count;
442 for (rel = relocs; rel < rel_end; rel++)
443 {
444 struct elf_link_hash_entry *h;
445 unsigned long r_symndx;
446
447 r_symndx = ELF32_R_SYM (rel->r_info);
448 if (r_symndx < symtab_hdr->sh_info)
449 h = NULL;
450 else
973a3492
L		 451 {
452 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
453 while (h->root.type == bfd_link_hash_indirect
454 || h->root.type == bfd_link_hash_warning)
455 h = (struct elf_link_hash_entry *) h->root.u.i.link;
456 }
a75473eb
SC		 457
458 switch (ELF32_R_TYPE (rel->r_info))
459 {
58852c27
NC		 460 /* This relocation describes the C++ object vtable
461 hierarchy. Reconstruct it for later use during GC. */
a75473eb 462 case R_IQ2000_GNU_VTINHERIT:
c152c796 463 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
a75473eb
SC		 464 return FALSE;
465 break;
466
58852c27
NC		 467 /* This relocation describes which C++ vtable entries
468 are actually used. Record for later use during GC. */
a75473eb 469 case R_IQ2000_GNU_VTENTRY:
d17e0c6e
JB		 470 BFD_ASSERT (h != NULL);
471 if (h != NULL
472 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
a75473eb
SC		 473 return FALSE;
474 break;
475
476 case R_IQ2000_32:
58852c27 477 /* For debug section, change to special harvard-aware relocations. */
0112cd26
NC		 478 if (CONST_STRNEQ (sec->name, ".debug")
479 || CONST_STRNEQ (sec->name, ".stab")
480 || CONST_STRNEQ (sec->name, ".eh_frame"))
60d8b524
AM		 481 {
482 ((Elf_Internal_Rela *) rel)->r_info
483 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
484 changed = TRUE;
485 }
a75473eb
SC		 486 break;
487 }
488 }
60d8b524
AM		 489
490 if (changed)
491 /* Note that we've changed relocs, otherwise if !info->keep_memory
492 we'll free the relocs and lose our changes. */
d5cb4bb8 493 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
60d8b524 494
a75473eb
SC		 495 return TRUE;
496}
497
498\f
499/* Relocate a IQ2000 ELF section.
500 There is some attempt to make this function usable for many architectures,
501 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
502 if only to serve as a learning tool.
503
504 The RELOCATE_SECTION function is called by the new ELF backend linker
505 to handle the relocations for a section.
506
507 The relocs are always passed as Rela structures; if the section
508 actually uses Rel structures, the r_addend field will always be
509 zero.
510
511 This function is responsible for adjusting the section contents as
1049f94e 512 necessary, and (if using Rela relocs and generating a relocatable
a75473eb
SC		 513 output file) adjusting the reloc addend as necessary.
514
515 This function does not have to worry about setting the reloc
516 address or the reloc symbol index.
517
518 LOCAL_SYMS is a pointer to the swapped in local symbols.
519
520 LOCAL_SECTIONS is an array giving the section in the input file
521 corresponding to the st_shndx field of each local symbol.
522
523 The global hash table entry for the global symbols can be found
524 via elf_sym_hashes (input_bfd).
525
1049f94e 526 When generating relocatable output, this function must handle
a75473eb
SC		 527 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
528 going to be the section symbol corresponding to the output
529 section, which means that the addend must be adjusted
530 accordingly. */
531
532static bfd_boolean
58852c27
NC		 533iq2000_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
534 struct bfd_link_info * info,
535 bfd * input_bfd,
536 asection * input_section,
537 bfd_byte * contents,
538 Elf_Internal_Rela * relocs,
539 Elf_Internal_Sym * local_syms,
540 asection ** local_sections)
a75473eb
SC		 541{
542 Elf_Internal_Shdr * symtab_hdr;
543 struct elf_link_hash_entry ** sym_hashes;
544 Elf_Internal_Rela * rel;
545 Elf_Internal_Rela * relend;
546
547 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
548 sym_hashes = elf_sym_hashes (input_bfd);
549 relend = relocs + input_section->reloc_count;
550
551 for (rel = relocs; rel < relend; rel ++)
552 {
553 reloc_howto_type * howto;
554 unsigned long r_symndx;
555 Elf_Internal_Sym * sym;
556 asection * sec;
557 struct elf_link_hash_entry * h;
558 bfd_vma relocation;
559 bfd_reloc_status_type r;
560 const char * name = NULL;
561 int r_type;
562
563 r_type = ELF32_R_TYPE (rel->r_info);
564
565 if ( r_type == R_IQ2000_GNU_VTINHERIT
566 || r_type == R_IQ2000_GNU_VTENTRY)
567 continue;
568
569 r_symndx = ELF32_R_SYM (rel->r_info);
570
a75473eb
SC		 571 howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
572 h = NULL;
573 sym = NULL;
574 sec = NULL;
575
576 if (r_symndx < symtab_hdr->sh_info)
577 {
578 sym = local_syms + r_symndx;
579 sec = local_sections [r_symndx];
580 relocation = (sec->output_section->vma
581 + sec->output_offset
582 + sym->st_value);
583
584 name = bfd_elf_string_from_elf_section
585 (input_bfd, symtab_hdr->sh_link, sym->st_name);
586 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
a75473eb
SC		 587 }
588 else
589 {
560e09e9
NC		 590 bfd_boolean unresolved_reloc;
591 bfd_boolean warned;
592
b2a8e766
AM		 593 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
594 r_symndx, symtab_hdr, sym_hashes,
595 h, sec, relocation,
596 unresolved_reloc, warned);
a75473eb
SC		 597
598 name = h->root.root.string;
a75473eb
SC		 599 }
600
ab96bf03
AM		 601 if (sec != NULL && elf_discarded_section (sec))
602 {
603 /* For relocs against symbols from removed linkonce sections,
604 or sections discarded by a linker script, we just want the
605 section contents zeroed. Avoid any special processing. */
606 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
607 rel->r_info = 0;
608 rel->r_addend = 0;
609 continue;
610 }
611
612 if (info->relocatable)
613 continue;
614
a75473eb
SC		 615 switch (r_type)
616 {
617 case R_IQ2000_HI16:
618 r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
619 break;
620
621 case R_IQ2000_PC16:
622 rel->r_addend -= 4;
623 /* Fall through. */
624
625 default:
626 r = iq2000_final_link_relocate (howto, input_bfd, input_section,
627 contents, rel, relocation);
628 break;
629 }
630
631 if (r != bfd_reloc_ok)
632 {
633 const char * msg = (const char *) NULL;
634
635 switch (r)
636 {
637 case bfd_reloc_overflow:
638 r = info->callbacks->reloc_overflow
dfeffb9f
L		 639 (info, (h ? &h->root : NULL), name, howto->name,
640 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
a75473eb
SC		 641 break;
642
643 case bfd_reloc_undefined:
644 r = info->callbacks->undefined_symbol
645 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
646 break;
647
648 case bfd_reloc_outofrange:
649 msg = _("internal error: out of range error");
650 break;
651
652 case bfd_reloc_notsupported:
653 msg = _("internal error: unsupported relocation error");
654 break;
655
656 case bfd_reloc_dangerous:
657 msg = _("internal error: dangerous relocation");
658 break;
659
660 default:
661 msg = _("internal error: unknown error");
662 break;
663 }
664
665 if (msg)
666 r = info->callbacks->warning
667 (info, msg, name, input_bfd, input_section, rel->r_offset);
668
669 if (! r)
670 return FALSE;
671 }
672 }
673
674 return TRUE;
675}
676\f
677
a75473eb
SC		 678/* Return the section that should be marked against GC for a given
679 relocation. */
680
681static asection *
07adf181
AM		 682iq2000_elf_gc_mark_hook (asection *sec,
683 struct bfd_link_info *info,
684 Elf_Internal_Rela *rel,
685 struct elf_link_hash_entry *h,
686 Elf_Internal_Sym *sym)
a75473eb 687{
07adf181
AM		 688 if (h != NULL)
689 switch (ELF32_R_TYPE (rel->r_info))
690 {
691 case R_IQ2000_GNU_VTINHERIT:
692 case R_IQ2000_GNU_VTENTRY:
693 return NULL;
694 }
695
696 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
a75473eb
SC		 697}
698
699\f
700/* Return the MACH for an e_flags value. */
701
702static int
58852c27 703elf32_iq2000_machine (bfd *abfd)
a75473eb
SC		 704{
705 switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
706 {
58852c27
NC		 707 case EF_IQ2000_CPU_IQ10:
708 return bfd_mach_iq10;
a75473eb 709
58852c27
NC		 710 case EF_IQ2000_CPU_IQ2000:
711 default:
712 return bfd_mach_iq2000;
713 }
a75473eb
SC		 714}
715
716\f
717/* Function to set the ELF flag bits. */
718
719static bfd_boolean
58852c27 720iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
a75473eb
SC		 721{
722 elf_elfheader (abfd)->e_flags = flags;
723 elf_flags_init (abfd) = TRUE;
724 return TRUE;
725}
726
727/* Copy backend specific data from one object module to another. */
728
729static bfd_boolean
58852c27 730iq2000_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
a75473eb
SC		 731{
732 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
733 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
734 return TRUE;
735
736 BFD_ASSERT (!elf_flags_init (obfd)
737 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
738
739 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
740 elf_flags_init (obfd) = TRUE;
104d59d1
JM		 741
742 /* Copy object attributes. */
743 _bfd_elf_copy_obj_attributes (ibfd, obfd);
744
a75473eb
SC		 745 return TRUE;
746}
747
58852c27
NC		 748/* Merge backend specific data from an object
749 file to the output object file when linking. */
a75473eb
SC		 750
751static bfd_boolean
58852c27 752iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
a75473eb
SC		 753{
754 flagword old_flags, old_partial;
755 flagword new_flags, new_partial;
756 bfd_boolean error = FALSE;
757 char new_opt[80];
758 char old_opt[80];
759
760 new_opt[0] = old_opt[0] = '\0';
761 new_flags = elf_elfheader (ibfd)->e_flags;
762 old_flags = elf_elfheader (obfd)->e_flags;
763
a75473eb
SC		 764 if (!elf_flags_init (obfd))
765 {
766 /* First call, no flags set. */
767 elf_flags_init (obfd) = TRUE;
768 elf_elfheader (obfd)->e_flags = new_flags;
769 }
770
58852c27 771 else if (new_flags != old_flags)
a75473eb 772 {
58852c27
NC		 773 /* Warn if different cpu is used, but allow a
774 specific cpu to override the generic cpu. */
a75473eb
SC		 775 new_partial = (new_flags & EF_IQ2000_CPU_MASK);
776 old_partial = (old_flags & EF_IQ2000_CPU_MASK);
a75473eb 777
58852c27 778 if (new_partial != old_partial)
a75473eb
SC		 779 {
780 switch (new_partial)
781 {
58852c27
NC		 782 case EF_IQ2000_CPU_IQ10:
783 strcat (new_opt, " -m10");
784 break;
785
786 default:
787 case EF_IQ2000_CPU_IQ2000:
788 strcat (new_opt, " -m2000");
789 break;
a75473eb
SC		 790 }
791
792 switch (old_partial)
793 {
58852c27
NC		 794 case EF_IQ2000_CPU_IQ10:
795 strcat (old_opt, " -m10");
796 break;
797
798 default:
799 case EF_IQ2000_CPU_IQ2000:
800 strcat (old_opt, " -m2000");
801 break;
a75473eb
SC		 802 }
803 }
804
805 /* Print out any mismatches from above. */
806 if (new_opt[0])
807 {
808 error = TRUE;
58852c27 809 _bfd_error_handler
a75473eb
SC		 810 (_("%s: compiled with %s and linked with modules compiled with %s"),
811 bfd_get_filename (ibfd), new_opt, old_opt);
812 }
813
814 new_flags &= ~ EF_IQ2000_ALL_FLAGS;
815 old_flags &= ~ EF_IQ2000_ALL_FLAGS;
816
817 /* Warn about any other mismatches. */
818 if (new_flags != old_flags)
819 {
820 error = TRUE;
58852c27
NC		 821
822 _bfd_error_handler
a75473eb
SC		 823 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
824 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
825 }
826 }
827
828 if (error)
829 bfd_set_error (bfd_error_bad_value);
830
831 return !error;
832}
833
834\f
835static bfd_boolean
58852c27 836iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
a75473eb
SC		 837{
838 FILE *file = (FILE *) ptr;
839 flagword flags;
840
841 BFD_ASSERT (abfd != NULL && ptr != NULL);
842
843 /* Print normal ELF private data. */
844 _bfd_elf_print_private_bfd_data (abfd, ptr);
845
846 flags = elf_elfheader (abfd)->e_flags;
847 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
848
849 switch (flags & EF_IQ2000_CPU_MASK)
850 {
58852c27
NC		 851 case EF_IQ2000_CPU_IQ10:
852 fprintf (file, " -m10");
853 break;
854 case EF_IQ2000_CPU_IQ2000:
855 fprintf (file, " -m2000");
856 break;
857 default:
858 break;
a75473eb
SC		 859 }
860
861 fputc ('\n', file);
60d8b524 862 return TRUE;
a75473eb
SC		 863}
864
865static
866bfd_boolean
58852c27 867iq2000_elf_object_p (bfd *abfd)
a75473eb 868{
a75473eb
SC		 869 bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
870 elf32_iq2000_machine (abfd));
871 return TRUE;
872}
873
874\f
875#define ELF_ARCH bfd_arch_iq2000
876#define ELF_MACHINE_CODE EM_IQ2000
877#define ELF_MAXPAGESIZE 0x1000
878
879#define TARGET_BIG_SYM bfd_elf32_iq2000_vec
880#define TARGET_BIG_NAME "elf32-iq2000"
881
882#define elf_info_to_howto_rel NULL
883#define elf_info_to_howto iq2000_info_to_howto_rela
884#define elf_backend_relocate_section iq2000_elf_relocate_section
885#define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook
a75473eb
SC		 886#define elf_backend_check_relocs iq2000_elf_check_relocs
887#define elf_backend_object_p iq2000_elf_object_p
888#define elf_backend_rela_normal 1
889
890#define elf_backend_can_gc_sections 1
891
892#define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup
157090f7 893#define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
a75473eb
SC		 894#define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags
895#define bfd_elf32_bfd_copy_private_bfd_data iq2000_elf_copy_private_bfd_data
896#define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data
897#define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data
898
899#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.30211 seconds and 4 git commands to generate.