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