2010-05-25 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / elf32-iq2000.c
blob4dcc866e89fc41e52e693f5c65c88a071e457584
1 /* IQ2000-specific support for 32-bit ELF.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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 static bfd_reloc_status_type
310 iq2000_elf_relocate_offset16 (bfd *input_bfd,
311 Elf_Internal_Rela *rel,
312 bfd_byte *contents,
313 bfd_vma value,
314 bfd_vma location)
316 bfd_vma insn;
317 bfd_vma jtarget;
319 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
321 value += rel->r_addend;
323 if (value & 3)
324 return bfd_reloc_dangerous;
326 jtarget = (value & 0x3fffc) | (location & 0xf0000000L);
328 if (jtarget != value)
329 return bfd_reloc_overflow;
331 insn = (insn & ~0xFFFF) | ((value >> 2) & 0xFFFF);
333 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
334 return bfd_reloc_ok;
337 /* Map BFD reloc types to IQ2000 ELF reloc types. */
339 static reloc_howto_type *
340 iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
341 bfd_reloc_code_real_type code)
343 /* Note that the iq2000_elf_howto_table is indxed by the R_
344 constants. Thus, the order that the howto records appear in the
345 table *must* match the order of the relocation types defined in
346 include/elf/iq2000.h. */
348 switch (code)
350 case BFD_RELOC_NONE:
351 return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE];
352 case BFD_RELOC_16:
353 return &iq2000_elf_howto_table[ (int) R_IQ2000_16];
354 case BFD_RELOC_32:
355 return &iq2000_elf_howto_table[ (int) R_IQ2000_32];
356 case BFD_RELOC_MIPS_JMP:
357 return &iq2000_elf_howto_table[ (int) R_IQ2000_26];
358 case BFD_RELOC_IQ2000_OFFSET_16:
359 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16];
360 case BFD_RELOC_IQ2000_OFFSET_21:
361 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21];
362 case BFD_RELOC_16_PCREL_S2:
363 return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16];
364 case BFD_RELOC_HI16:
365 return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16];
366 case BFD_RELOC_IQ2000_UHI16:
367 return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16];
368 case BFD_RELOC_LO16:
369 return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16];
370 case BFD_RELOC_VTABLE_INHERIT:
371 return &iq2000_elf_vtinherit_howto;
372 case BFD_RELOC_VTABLE_ENTRY:
373 return &iq2000_elf_vtentry_howto;
374 default:
375 /* Pacify gcc -Wall. */
376 return NULL;
378 return NULL;
381 static reloc_howto_type *
382 iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
384 unsigned int i;
386 for (i = 0;
387 i < (sizeof (iq2000_elf_howto_table)
388 / sizeof (iq2000_elf_howto_table[0]));
389 i++)
390 if (iq2000_elf_howto_table[i].name != NULL
391 && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0)
392 return &iq2000_elf_howto_table[i];
394 if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0)
395 return &iq2000_elf_vtinherit_howto;
396 if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0)
397 return &iq2000_elf_vtentry_howto;
399 return NULL;
402 /* Perform a single relocation. By default we use the standard BFD
403 routines. */
405 static bfd_reloc_status_type
406 iq2000_final_link_relocate (reloc_howto_type * howto,
407 bfd * input_bfd,
408 asection * input_section,
409 bfd_byte * contents,
410 Elf_Internal_Rela * rel,
411 bfd_vma relocation)
413 return _bfd_final_link_relocate (howto, input_bfd, input_section,
414 contents, rel->r_offset,
415 relocation, rel->r_addend);
418 /* Set the howto pointer for a IQ2000 ELF reloc. */
420 static void
421 iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
422 arelent * cache_ptr,
423 Elf_Internal_Rela * dst)
425 unsigned int r_type;
427 r_type = ELF32_R_TYPE (dst->r_info);
428 switch (r_type)
430 case R_IQ2000_GNU_VTINHERIT:
431 cache_ptr->howto = & iq2000_elf_vtinherit_howto;
432 break;
434 case R_IQ2000_GNU_VTENTRY:
435 cache_ptr->howto = & iq2000_elf_vtentry_howto;
436 break;
438 default:
439 cache_ptr->howto = & iq2000_elf_howto_table [r_type];
440 break;
444 /* Look through the relocs for a section during the first phase.
445 Since we don't do .gots or .plts, we just need to consider the
446 virtual table relocs for gc. */
448 static bfd_boolean
449 iq2000_elf_check_relocs (bfd *abfd,
450 struct bfd_link_info *info,
451 asection *sec,
452 const Elf_Internal_Rela *relocs)
454 Elf_Internal_Shdr *symtab_hdr;
455 struct elf_link_hash_entry **sym_hashes;
456 const Elf_Internal_Rela *rel;
457 const Elf_Internal_Rela *rel_end;
458 bfd_boolean changed = FALSE;
460 if (info->relocatable)
461 return TRUE;
463 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
464 sym_hashes = elf_sym_hashes (abfd);
466 rel_end = relocs + sec->reloc_count;
467 for (rel = relocs; rel < rel_end; rel++)
469 struct elf_link_hash_entry *h;
470 unsigned long r_symndx;
472 r_symndx = ELF32_R_SYM (rel->r_info);
473 if (r_symndx < symtab_hdr->sh_info)
474 h = NULL;
475 else
477 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
478 while (h->root.type == bfd_link_hash_indirect
479 || h->root.type == bfd_link_hash_warning)
480 h = (struct elf_link_hash_entry *) h->root.u.i.link;
483 switch (ELF32_R_TYPE (rel->r_info))
485 /* This relocation describes the C++ object vtable
486 hierarchy. Reconstruct it for later use during GC. */
487 case R_IQ2000_GNU_VTINHERIT:
488 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
489 return FALSE;
490 break;
492 /* This relocation describes which C++ vtable entries
493 are actually used. Record for later use during GC. */
494 case R_IQ2000_GNU_VTENTRY:
495 BFD_ASSERT (h != NULL);
496 if (h != NULL
497 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
498 return FALSE;
499 break;
501 case R_IQ2000_32:
502 /* For debug section, change to special harvard-aware relocations. */
503 if (CONST_STRNEQ (sec->name, ".debug")
504 || CONST_STRNEQ (sec->name, ".stab")
505 || CONST_STRNEQ (sec->name, ".eh_frame"))
507 ((Elf_Internal_Rela *) rel)->r_info
508 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
509 changed = TRUE;
511 break;
515 if (changed)
516 /* Note that we've changed relocs, otherwise if !info->keep_memory
517 we'll free the relocs and lose our changes. */
518 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
520 return TRUE;
524 /* Relocate a IQ2000 ELF section.
525 There is some attempt to make this function usable for many architectures,
526 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
527 if only to serve as a learning tool.
529 The RELOCATE_SECTION function is called by the new ELF backend linker
530 to handle the relocations for a section.
532 The relocs are always passed as Rela structures; if the section
533 actually uses Rel structures, the r_addend field will always be
534 zero.
536 This function is responsible for adjusting the section contents as
537 necessary, and (if using Rela relocs and generating a relocatable
538 output file) adjusting the reloc addend as necessary.
540 This function does not have to worry about setting the reloc
541 address or the reloc symbol index.
543 LOCAL_SYMS is a pointer to the swapped in local symbols.
545 LOCAL_SECTIONS is an array giving the section in the input file
546 corresponding to the st_shndx field of each local symbol.
548 The global hash table entry for the global symbols can be found
549 via elf_sym_hashes (input_bfd).
551 When generating relocatable output, this function must handle
552 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
553 going to be the section symbol corresponding to the output
554 section, which means that the addend must be adjusted
555 accordingly. */
557 static bfd_boolean
558 iq2000_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
559 struct bfd_link_info * info,
560 bfd * input_bfd,
561 asection * input_section,
562 bfd_byte * contents,
563 Elf_Internal_Rela * relocs,
564 Elf_Internal_Sym * local_syms,
565 asection ** local_sections)
567 Elf_Internal_Shdr * symtab_hdr;
568 struct elf_link_hash_entry ** sym_hashes;
569 Elf_Internal_Rela * rel;
570 Elf_Internal_Rela * relend;
572 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
573 sym_hashes = elf_sym_hashes (input_bfd);
574 relend = relocs + input_section->reloc_count;
576 for (rel = relocs; rel < relend; rel ++)
578 reloc_howto_type * howto;
579 unsigned long r_symndx;
580 Elf_Internal_Sym * sym;
581 asection * sec;
582 struct elf_link_hash_entry * h;
583 bfd_vma relocation;
584 bfd_reloc_status_type r;
585 const char * name = NULL;
586 int r_type;
588 r_type = ELF32_R_TYPE (rel->r_info);
590 if ( r_type == R_IQ2000_GNU_VTINHERIT
591 || r_type == R_IQ2000_GNU_VTENTRY)
592 continue;
594 r_symndx = ELF32_R_SYM (rel->r_info);
596 howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
597 h = NULL;
598 sym = NULL;
599 sec = NULL;
601 if (r_symndx < symtab_hdr->sh_info)
603 asection *osec;
605 sym = local_syms + r_symndx;
606 osec = sec = local_sections [r_symndx];
607 if ((sec->flags & SEC_MERGE)
608 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
609 /* This relocation is relative to a section symbol that is
610 going to be merged. Change it so that it is relative
611 to the merged section symbol. */
612 rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, &sec,
613 rel->r_addend);
615 relocation = (sec->output_section->vma
616 + sec->output_offset
617 + sym->st_value);
619 name = bfd_elf_string_from_elf_section
620 (input_bfd, symtab_hdr->sh_link, sym->st_name);
621 name = (name == NULL) ? bfd_section_name (input_bfd, osec) : name;
623 else
625 bfd_boolean unresolved_reloc;
626 bfd_boolean warned;
628 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
629 r_symndx, symtab_hdr, sym_hashes,
630 h, sec, relocation,
631 unresolved_reloc, warned);
633 name = h->root.root.string;
636 if (sec != NULL && elf_discarded_section (sec))
638 /* For relocs against symbols from removed linkonce sections,
639 or sections discarded by a linker script, we just want the
640 section contents zeroed. Avoid any special processing. */
641 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
642 rel->r_info = 0;
643 rel->r_addend = 0;
644 continue;
647 if (info->relocatable)
648 continue;
650 switch (r_type)
652 case R_IQ2000_HI16:
653 r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
654 break;
656 case R_IQ2000_OFFSET_16:
657 r = iq2000_elf_relocate_offset16 (input_bfd, rel, contents, relocation,
658 input_section->output_section->vma
659 + input_section->output_offset
660 + rel->r_offset);
661 break;
663 case R_IQ2000_PC16:
664 rel->r_addend -= 4;
665 /* Fall through. */
667 default:
668 r = iq2000_final_link_relocate (howto, input_bfd, input_section,
669 contents, rel, relocation);
670 break;
673 if (r != bfd_reloc_ok)
675 const char * msg = (const char *) NULL;
677 switch (r)
679 case bfd_reloc_overflow:
680 r = info->callbacks->reloc_overflow
681 (info, (h ? &h->root : NULL), name, howto->name,
682 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
683 break;
685 case bfd_reloc_undefined:
686 r = info->callbacks->undefined_symbol
687 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
688 break;
690 case bfd_reloc_outofrange:
691 msg = _("internal error: out of range error");
692 break;
694 case bfd_reloc_notsupported:
695 msg = _("internal error: unsupported relocation error");
696 break;
698 case bfd_reloc_dangerous:
699 msg = _("internal error: dangerous relocation");
700 break;
702 default:
703 msg = _("internal error: unknown error");
704 break;
707 if (msg)
708 r = info->callbacks->warning
709 (info, msg, name, input_bfd, input_section, rel->r_offset);
711 if (! r)
712 return FALSE;
716 return TRUE;
720 /* Return the section that should be marked against GC for a given
721 relocation. */
723 static asection *
724 iq2000_elf_gc_mark_hook (asection *sec,
725 struct bfd_link_info *info,
726 Elf_Internal_Rela *rel,
727 struct elf_link_hash_entry *h,
728 Elf_Internal_Sym *sym)
730 if (h != NULL)
731 switch (ELF32_R_TYPE (rel->r_info))
733 case R_IQ2000_GNU_VTINHERIT:
734 case R_IQ2000_GNU_VTENTRY:
735 return NULL;
738 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
742 /* Return the MACH for an e_flags value. */
744 static int
745 elf32_iq2000_machine (bfd *abfd)
747 switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
749 case EF_IQ2000_CPU_IQ10:
750 return bfd_mach_iq10;
752 case EF_IQ2000_CPU_IQ2000:
753 default:
754 return bfd_mach_iq2000;
759 /* Function to set the ELF flag bits. */
761 static bfd_boolean
762 iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
764 elf_elfheader (abfd)->e_flags = flags;
765 elf_flags_init (abfd) = TRUE;
766 return TRUE;
769 /* Copy backend specific data from one object module to another. */
771 static bfd_boolean
772 iq2000_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
774 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
775 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
776 return TRUE;
778 BFD_ASSERT (!elf_flags_init (obfd)
779 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
781 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
782 elf_flags_init (obfd) = TRUE;
784 /* Copy object attributes. */
785 _bfd_elf_copy_obj_attributes (ibfd, obfd);
787 return TRUE;
790 /* Merge backend specific data from an object
791 file to the output object file when linking. */
793 static bfd_boolean
794 iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
796 flagword old_flags, old_partial;
797 flagword new_flags, new_partial;
798 bfd_boolean error = FALSE;
799 char new_opt[80];
800 char old_opt[80];
802 new_opt[0] = old_opt[0] = '\0';
803 new_flags = elf_elfheader (ibfd)->e_flags;
804 old_flags = elf_elfheader (obfd)->e_flags;
806 if (!elf_flags_init (obfd))
808 /* First call, no flags set. */
809 elf_flags_init (obfd) = TRUE;
810 elf_elfheader (obfd)->e_flags = new_flags;
813 else if (new_flags != old_flags)
815 /* Warn if different cpu is used, but allow a
816 specific cpu to override the generic cpu. */
817 new_partial = (new_flags & EF_IQ2000_CPU_MASK);
818 old_partial = (old_flags & EF_IQ2000_CPU_MASK);
820 if (new_partial != old_partial)
822 switch (new_partial)
824 case EF_IQ2000_CPU_IQ10:
825 strcat (new_opt, " -m10");
826 break;
828 default:
829 case EF_IQ2000_CPU_IQ2000:
830 strcat (new_opt, " -m2000");
831 break;
834 switch (old_partial)
836 case EF_IQ2000_CPU_IQ10:
837 strcat (old_opt, " -m10");
838 break;
840 default:
841 case EF_IQ2000_CPU_IQ2000:
842 strcat (old_opt, " -m2000");
843 break;
847 /* Print out any mismatches from above. */
848 if (new_opt[0])
850 error = TRUE;
851 _bfd_error_handler
852 (_("%s: compiled with %s and linked with modules compiled with %s"),
853 bfd_get_filename (ibfd), new_opt, old_opt);
856 new_flags &= ~ EF_IQ2000_ALL_FLAGS;
857 old_flags &= ~ EF_IQ2000_ALL_FLAGS;
859 /* Warn about any other mismatches. */
860 if (new_flags != old_flags)
862 error = TRUE;
864 _bfd_error_handler
865 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
866 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
870 if (error)
871 bfd_set_error (bfd_error_bad_value);
873 return !error;
877 static bfd_boolean
878 iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
880 FILE *file = (FILE *) ptr;
881 flagword flags;
883 BFD_ASSERT (abfd != NULL && ptr != NULL);
885 /* Print normal ELF private data. */
886 _bfd_elf_print_private_bfd_data (abfd, ptr);
888 flags = elf_elfheader (abfd)->e_flags;
889 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
891 switch (flags & EF_IQ2000_CPU_MASK)
893 case EF_IQ2000_CPU_IQ10:
894 fprintf (file, " -m10");
895 break;
896 case EF_IQ2000_CPU_IQ2000:
897 fprintf (file, " -m2000");
898 break;
899 default:
900 break;
903 fputc ('\n', file);
904 return TRUE;
907 static
908 bfd_boolean
909 iq2000_elf_object_p (bfd *abfd)
911 bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
912 elf32_iq2000_machine (abfd));
913 return TRUE;
917 #define ELF_ARCH bfd_arch_iq2000
918 #define ELF_MACHINE_CODE EM_IQ2000
919 #define ELF_MAXPAGESIZE 0x1000
921 #define TARGET_BIG_SYM bfd_elf32_iq2000_vec
922 #define TARGET_BIG_NAME "elf32-iq2000"
924 #define elf_info_to_howto_rel NULL
925 #define elf_info_to_howto iq2000_info_to_howto_rela
926 #define elf_backend_relocate_section iq2000_elf_relocate_section
927 #define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook
928 #define elf_backend_check_relocs iq2000_elf_check_relocs
929 #define elf_backend_object_p iq2000_elf_object_p
930 #define elf_backend_rela_normal 1
932 #define elf_backend_can_gc_sections 1
934 #define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup
935 #define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
936 #define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags
937 #define bfd_elf32_bfd_copy_private_bfd_data iq2000_elf_copy_private_bfd_data
938 #define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data
939 #define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data
941 #include "elf32-target.h"