Update
[gdb.git] / bfd / elf32-iq2000.c
blob2a5ad780d4ee10d6619c5b8edf4c202a5788315b
1 /* IQ2000-specific support for 32-bit ELF.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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.
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
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/iq2000.h"
27 /* Forward declarations. */
29 static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
32 static reloc_howto_type iq2000_elf_howto_table [] =
34 /* This reloc does nothing. */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
205 /* GNU extension to record C++ vtable hierarchy. */
206 static 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 */
221 /* GNU extension to record C++ vtable member usage. */
222 static 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 */
238 static bfd_reloc_status_type
239 iq2000_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)
247 bfd_reloc_status_type ret;
248 bfd_vma relocation;
250 /* If we're relocating and this an external symbol,
251 we don't want to change anything. */
252 if (output_bfd != (bfd *) NULL
253 && (symbol->flags & BSF_SECTION_SYM) == 0
254 && reloc_entry->addend == 0)
256 reloc_entry->address += input_section->output_offset;
257 return bfd_reloc_ok;
260 if (bfd_is_com_section (symbol->section))
261 relocation = 0;
262 else
263 relocation = symbol->value;
265 relocation += symbol->section->output_section->vma;
266 relocation += symbol->section->output_offset;
267 relocation += reloc_entry->addend;
269 /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion. */
270 if (relocation & 0x8000)
271 reloc_entry->addend += 0x10000;
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);
277 /* Put it back the way it was. */
278 if (relocation & 0x8000)
279 reloc_entry->addend -= 0x10000;
281 return ret;
284 static bfd_reloc_status_type
285 iq2000_elf_relocate_hi16 (bfd *input_bfd,
286 Elf_Internal_Rela *relhi,
287 bfd_byte *contents,
288 bfd_vma value)
290 bfd_vma insn;
292 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
294 value += relhi->r_addend;
295 value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit. */
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. */
299 if (value & 0x8000)
300 value += 0x10000;
302 value >>= 16;
303 insn = ((insn & ~0xFFFF) | value);
305 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
306 return bfd_reloc_ok;
309 /* Map BFD reloc types to IQ2000 ELF reloc types. */
311 static reloc_howto_type *
312 iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
313 bfd_reloc_code_real_type code)
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. */
320 switch (code)
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;
350 return NULL;
353 static reloc_howto_type *
354 iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
356 unsigned int i;
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];
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;
371 return NULL;
374 /* Perform a single relocation. By default we use the standard BFD
375 routines. */
377 static bfd_reloc_status_type
378 iq2000_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)
385 return _bfd_final_link_relocate (howto, input_bfd, input_section,
386 contents, rel->r_offset,
387 relocation, rel->r_addend);
390 /* Set the howto pointer for a IQ2000 ELF reloc. */
392 static void
393 iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
394 arelent * cache_ptr,
395 Elf_Internal_Rela * dst)
397 unsigned int r_type;
399 r_type = ELF32_R_TYPE (dst->r_info);
400 switch (r_type)
402 case R_IQ2000_GNU_VTINHERIT:
403 cache_ptr->howto = & iq2000_elf_vtinherit_howto;
404 break;
406 case R_IQ2000_GNU_VTENTRY:
407 cache_ptr->howto = & iq2000_elf_vtentry_howto;
408 break;
410 default:
411 cache_ptr->howto = & iq2000_elf_howto_table [r_type];
412 break;
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. */
420 static bfd_boolean
421 iq2000_elf_check_relocs (bfd *abfd,
422 struct bfd_link_info *info,
423 asection *sec,
424 const Elf_Internal_Rela *relocs)
426 Elf_Internal_Shdr *symtab_hdr;
427 struct elf_link_hash_entry **sym_hashes;
428 const Elf_Internal_Rela *rel;
429 const Elf_Internal_Rela *rel_end;
430 bfd_boolean changed = FALSE;
432 if (info->relocatable)
433 return TRUE;
435 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
436 sym_hashes = elf_sym_hashes (abfd);
438 rel_end = relocs + sec->reloc_count;
439 for (rel = relocs; rel < rel_end; rel++)
441 struct elf_link_hash_entry *h;
442 unsigned long r_symndx;
444 r_symndx = ELF32_R_SYM (rel->r_info);
445 if (r_symndx < symtab_hdr->sh_info)
446 h = NULL;
447 else
449 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
450 while (h->root.type == bfd_link_hash_indirect
451 || h->root.type == bfd_link_hash_warning)
452 h = (struct elf_link_hash_entry *) h->root.u.i.link;
455 switch (ELF32_R_TYPE (rel->r_info))
457 /* This relocation describes the C++ object vtable
458 hierarchy. Reconstruct it for later use during GC. */
459 case R_IQ2000_GNU_VTINHERIT:
460 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
461 return FALSE;
462 break;
464 /* This relocation describes which C++ vtable entries
465 are actually used. Record for later use during GC. */
466 case R_IQ2000_GNU_VTENTRY:
467 BFD_ASSERT (h != NULL);
468 if (h != NULL
469 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
470 return FALSE;
471 break;
473 case R_IQ2000_32:
474 /* For debug section, change to special harvard-aware relocations. */
475 if (CONST_STRNEQ (sec->name, ".debug")
476 || CONST_STRNEQ (sec->name, ".stab")
477 || CONST_STRNEQ (sec->name, ".eh_frame"))
479 ((Elf_Internal_Rela *) rel)->r_info
480 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
481 changed = TRUE;
483 break;
487 if (changed)
488 /* Note that we've changed relocs, otherwise if !info->keep_memory
489 we'll free the relocs and lose our changes. */
490 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
492 return TRUE;
496 /* Relocate a IQ2000 ELF section.
497 There is some attempt to make this function usable for many architectures,
498 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
499 if only to serve as a learning tool.
501 The RELOCATE_SECTION function is called by the new ELF backend linker
502 to handle the relocations for a section.
504 The relocs are always passed as Rela structures; if the section
505 actually uses Rel structures, the r_addend field will always be
506 zero.
508 This function is responsible for adjusting the section contents as
509 necessary, and (if using Rela relocs and generating a relocatable
510 output file) adjusting the reloc addend as necessary.
512 This function does not have to worry about setting the reloc
513 address or the reloc symbol index.
515 LOCAL_SYMS is a pointer to the swapped in local symbols.
517 LOCAL_SECTIONS is an array giving the section in the input file
518 corresponding to the st_shndx field of each local symbol.
520 The global hash table entry for the global symbols can be found
521 via elf_sym_hashes (input_bfd).
523 When generating relocatable output, this function must handle
524 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
525 going to be the section symbol corresponding to the output
526 section, which means that the addend must be adjusted
527 accordingly. */
529 static bfd_boolean
530 iq2000_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
531 struct bfd_link_info * info,
532 bfd * input_bfd,
533 asection * input_section,
534 bfd_byte * contents,
535 Elf_Internal_Rela * relocs,
536 Elf_Internal_Sym * local_syms,
537 asection ** local_sections)
539 Elf_Internal_Shdr * symtab_hdr;
540 struct elf_link_hash_entry ** sym_hashes;
541 Elf_Internal_Rela * rel;
542 Elf_Internal_Rela * relend;
544 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
545 sym_hashes = elf_sym_hashes (input_bfd);
546 relend = relocs + input_section->reloc_count;
548 for (rel = relocs; rel < relend; rel ++)
550 reloc_howto_type * howto;
551 unsigned long r_symndx;
552 Elf_Internal_Sym * sym;
553 asection * sec;
554 struct elf_link_hash_entry * h;
555 bfd_vma relocation;
556 bfd_reloc_status_type r;
557 const char * name = NULL;
558 int r_type;
560 r_type = ELF32_R_TYPE (rel->r_info);
562 if ( r_type == R_IQ2000_GNU_VTINHERIT
563 || r_type == R_IQ2000_GNU_VTENTRY)
564 continue;
566 r_symndx = ELF32_R_SYM (rel->r_info);
568 howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
569 h = NULL;
570 sym = NULL;
571 sec = NULL;
573 if (r_symndx < symtab_hdr->sh_info)
575 sym = local_syms + r_symndx;
576 sec = local_sections [r_symndx];
577 relocation = (sec->output_section->vma
578 + sec->output_offset
579 + sym->st_value);
581 name = bfd_elf_string_from_elf_section
582 (input_bfd, symtab_hdr->sh_link, sym->st_name);
583 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
585 else
587 bfd_boolean unresolved_reloc;
588 bfd_boolean warned;
590 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
591 r_symndx, symtab_hdr, sym_hashes,
592 h, sec, relocation,
593 unresolved_reloc, warned);
595 name = h->root.root.string;
598 if (sec != NULL && elf_discarded_section (sec))
600 /* For relocs against symbols from removed linkonce sections,
601 or sections discarded by a linker script, we just want the
602 section contents zeroed. Avoid any special processing. */
603 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
604 rel->r_info = 0;
605 rel->r_addend = 0;
606 continue;
609 if (info->relocatable)
610 continue;
612 switch (r_type)
614 case R_IQ2000_HI16:
615 r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
616 break;
618 case R_IQ2000_PC16:
619 rel->r_addend -= 4;
620 /* Fall through. */
622 default:
623 r = iq2000_final_link_relocate (howto, input_bfd, input_section,
624 contents, rel, relocation);
625 break;
628 if (r != bfd_reloc_ok)
630 const char * msg = (const char *) NULL;
632 switch (r)
634 case bfd_reloc_overflow:
635 r = info->callbacks->reloc_overflow
636 (info, (h ? &h->root : NULL), name, howto->name,
637 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
638 break;
640 case bfd_reloc_undefined:
641 r = info->callbacks->undefined_symbol
642 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
643 break;
645 case bfd_reloc_outofrange:
646 msg = _("internal error: out of range error");
647 break;
649 case bfd_reloc_notsupported:
650 msg = _("internal error: unsupported relocation error");
651 break;
653 case bfd_reloc_dangerous:
654 msg = _("internal error: dangerous relocation");
655 break;
657 default:
658 msg = _("internal error: unknown error");
659 break;
662 if (msg)
663 r = info->callbacks->warning
664 (info, msg, name, input_bfd, input_section, rel->r_offset);
666 if (! r)
667 return FALSE;
671 return TRUE;
675 /* Return the section that should be marked against GC for a given
676 relocation. */
678 static asection *
679 iq2000_elf_gc_mark_hook (asection *sec,
680 struct bfd_link_info *info,
681 Elf_Internal_Rela *rel,
682 struct elf_link_hash_entry *h,
683 Elf_Internal_Sym *sym)
685 if (h != NULL)
686 switch (ELF32_R_TYPE (rel->r_info))
688 case R_IQ2000_GNU_VTINHERIT:
689 case R_IQ2000_GNU_VTENTRY:
690 return NULL;
693 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
697 /* Return the MACH for an e_flags value. */
699 static int
700 elf32_iq2000_machine (bfd *abfd)
702 switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
704 case EF_IQ2000_CPU_IQ10:
705 return bfd_mach_iq10;
707 case EF_IQ2000_CPU_IQ2000:
708 default:
709 return bfd_mach_iq2000;
714 /* Function to set the ELF flag bits. */
716 static bfd_boolean
717 iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
719 elf_elfheader (abfd)->e_flags = flags;
720 elf_flags_init (abfd) = TRUE;
721 return TRUE;
724 /* Copy backend specific data from one object module to another. */
726 static bfd_boolean
727 iq2000_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
729 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
730 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
731 return TRUE;
733 BFD_ASSERT (!elf_flags_init (obfd)
734 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
736 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
737 elf_flags_init (obfd) = TRUE;
739 /* Copy object attributes. */
740 _bfd_elf_copy_obj_attributes (ibfd, obfd);
742 return TRUE;
745 /* Merge backend specific data from an object
746 file to the output object file when linking. */
748 static bfd_boolean
749 iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
751 flagword old_flags, old_partial;
752 flagword new_flags, new_partial;
753 bfd_boolean error = FALSE;
754 char new_opt[80];
755 char old_opt[80];
757 new_opt[0] = old_opt[0] = '\0';
758 new_flags = elf_elfheader (ibfd)->e_flags;
759 old_flags = elf_elfheader (obfd)->e_flags;
761 if (!elf_flags_init (obfd))
763 /* First call, no flags set. */
764 elf_flags_init (obfd) = TRUE;
765 elf_elfheader (obfd)->e_flags = new_flags;
768 else if (new_flags != old_flags)
770 /* Warn if different cpu is used, but allow a
771 specific cpu to override the generic cpu. */
772 new_partial = (new_flags & EF_IQ2000_CPU_MASK);
773 old_partial = (old_flags & EF_IQ2000_CPU_MASK);
775 if (new_partial != old_partial)
777 switch (new_partial)
779 case EF_IQ2000_CPU_IQ10:
780 strcat (new_opt, " -m10");
781 break;
783 default:
784 case EF_IQ2000_CPU_IQ2000:
785 strcat (new_opt, " -m2000");
786 break;
789 switch (old_partial)
791 case EF_IQ2000_CPU_IQ10:
792 strcat (old_opt, " -m10");
793 break;
795 default:
796 case EF_IQ2000_CPU_IQ2000:
797 strcat (old_opt, " -m2000");
798 break;
802 /* Print out any mismatches from above. */
803 if (new_opt[0])
805 error = TRUE;
806 _bfd_error_handler
807 (_("%s: compiled with %s and linked with modules compiled with %s"),
808 bfd_get_filename (ibfd), new_opt, old_opt);
811 new_flags &= ~ EF_IQ2000_ALL_FLAGS;
812 old_flags &= ~ EF_IQ2000_ALL_FLAGS;
814 /* Warn about any other mismatches. */
815 if (new_flags != old_flags)
817 error = TRUE;
819 _bfd_error_handler
820 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
821 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
825 if (error)
826 bfd_set_error (bfd_error_bad_value);
828 return !error;
832 static bfd_boolean
833 iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
835 FILE *file = (FILE *) ptr;
836 flagword flags;
838 BFD_ASSERT (abfd != NULL && ptr != NULL);
840 /* Print normal ELF private data. */
841 _bfd_elf_print_private_bfd_data (abfd, ptr);
843 flags = elf_elfheader (abfd)->e_flags;
844 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
846 switch (flags & EF_IQ2000_CPU_MASK)
848 case EF_IQ2000_CPU_IQ10:
849 fprintf (file, " -m10");
850 break;
851 case EF_IQ2000_CPU_IQ2000:
852 fprintf (file, " -m2000");
853 break;
854 default:
855 break;
858 fputc ('\n', file);
859 return TRUE;
862 static
863 bfd_boolean
864 iq2000_elf_object_p (bfd *abfd)
866 bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
867 elf32_iq2000_machine (abfd));
868 return TRUE;
872 #define ELF_ARCH bfd_arch_iq2000
873 #define ELF_MACHINE_CODE EM_IQ2000
874 #define ELF_MAXPAGESIZE 0x1000
876 #define TARGET_BIG_SYM bfd_elf32_iq2000_vec
877 #define TARGET_BIG_NAME "elf32-iq2000"
879 #define elf_info_to_howto_rel NULL
880 #define elf_info_to_howto iq2000_info_to_howto_rela
881 #define elf_backend_relocate_section iq2000_elf_relocate_section
882 #define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook
883 #define elf_backend_check_relocs iq2000_elf_check_relocs
884 #define elf_backend_object_p iq2000_elf_object_p
885 #define elf_backend_rela_normal 1
887 #define elf_backend_can_gc_sections 1
889 #define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup
890 #define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
891 #define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags
892 #define bfd_elf32_bfd_copy_private_bfd_data iq2000_elf_copy_private_bfd_data
893 #define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data
894 #define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data
896 #include "elf32-target.h"