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