projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update the address and phone number of the FSF organization in the GPL notices
[deliverable/binutils-gdb.git] / bfd / elf32-iq2000.c
CommitLineData
a75473eb 1/* IQ2000-specific support for 32-bit ELF.
9553c638 2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
a75473eb 3
58852c27 4 This file is part of BFD, the Binary File Descriptor library.
a75473eb 5
58852c27
NC		 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.
a75473eb 10
58852c27
NC		 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.
a75473eb 15
58852c27
NC		 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
3e110533 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
a75473eb
SC		 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
58852c27 28static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
a75473eb
SC		 29
30\f
31static 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. */
205static 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. */
221static 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
a75473eb 237static bfd_reloc_status_type
58852c27
NC		 238iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
239 arelent *reloc_entry,
240 asymbol *symbol,
241 void * data,
242 asection *input_section,
243 bfd *output_bfd,
244 char **error_message ATTRIBUTE_UNUSED)
a75473eb
SC		 245{
246 bfd_reloc_status_type ret;
247 bfd_vma relocation;
248
58852c27
NC		 249 /* If we're relocating and this an external symbol,
250 we don't want to change anything. */
a75473eb
SC		 251 if (output_bfd != (bfd *) NULL
252 && (symbol->flags & BSF_SECTION_SYM) == 0
253 && reloc_entry->addend == 0)
254 {
255 reloc_entry->address += input_section->output_offset;
256 return bfd_reloc_ok;
257 }
258
259 if (bfd_is_com_section (symbol->section))
260 relocation = 0;
261 else
262 relocation = symbol->value;
263
264 relocation += symbol->section->output_section->vma;
265 relocation += symbol->section->output_offset;
266 relocation += reloc_entry->addend;
267
58852c27 268 /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion. */
a75473eb
SC		 269 if (relocation & 0x8000)
270 reloc_entry->addend += 0x10000;
271
272 /* Now do the reloc in the usual way. */
273 ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
274 input_section, output_bfd, error_message);
275
58852c27 276 /* Put it back the way it was. */
a75473eb
SC		 277 if (relocation & 0x8000)
278 reloc_entry->addend -= 0x10000;
279
280 return ret;
281}
282
283static bfd_reloc_status_type
58852c27
NC		 284iq2000_elf_relocate_hi16 (bfd *input_bfd,
285 Elf_Internal_Rela *relhi,
286 bfd_byte *contents,
287 bfd_vma value)
a75473eb
SC		 288{
289 bfd_vma insn;
290
291 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
292
293 value += relhi->r_addend;
58852c27 294 value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit. */
a75473eb 295
58852c27
NC		 296 /* If top-bit of %lo value is on, this means that %lo will
297 sign-propagate and so we compensate by adding 1 to %hi value. */
a75473eb
SC		 298 if (value & 0x8000)
299 value += 0x10000;
300
301 value >>= 16;
302 insn = ((insn & ~0xFFFF) | value);
303
304 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
305 return bfd_reloc_ok;
306}
307
6c408f53
NC		 308/* Map BFD reloc types to IQ2000 ELF reloc types. */
309
a75473eb 310static reloc_howto_type *
de52dba4
AM		 311iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
312 bfd_reloc_code_real_type code)
a75473eb
SC		 313{
314 /* Note that the iq2000_elf_howto_table is indxed by the R_
315 constants. Thus, the order that the howto records appear in the
316 table *must* match the order of the relocation types defined in
317 include/elf/iq2000.h. */
318
319 switch (code)
320 {
321 case BFD_RELOC_NONE:
322 return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE];
323 case BFD_RELOC_16:
324 return &iq2000_elf_howto_table[ (int) R_IQ2000_16];
325 case BFD_RELOC_32:
326 return &iq2000_elf_howto_table[ (int) R_IQ2000_32];
327 case BFD_RELOC_MIPS_JMP:
328 return &iq2000_elf_howto_table[ (int) R_IQ2000_26];
329 case BFD_RELOC_IQ2000_OFFSET_16:
330 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16];
331 case BFD_RELOC_IQ2000_OFFSET_21:
332 return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21];
333 case BFD_RELOC_16_PCREL_S2:
334 return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16];
335 case BFD_RELOC_HI16:
336 return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16];
337 case BFD_RELOC_IQ2000_UHI16:
338 return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16];
339 case BFD_RELOC_LO16:
340 return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16];
341 case BFD_RELOC_VTABLE_INHERIT:
342 return &iq2000_elf_vtinherit_howto;
343 case BFD_RELOC_VTABLE_ENTRY:
344 return &iq2000_elf_vtentry_howto;
345 default:
346 /* Pacify gcc -Wall. */
347 return NULL;
348 }
349 return NULL;
350}
351
352\f
353/* Perform a single relocation. By default we use the standard BFD
354 routines. */
355
356static bfd_reloc_status_type
58852c27
NC		 357iq2000_final_link_relocate (reloc_howto_type * howto,
358 bfd * input_bfd,
359 asection * input_section,
360 bfd_byte * contents,
361 Elf_Internal_Rela * rel,
362 bfd_vma relocation)
a75473eb
SC		 363{
364 return _bfd_final_link_relocate (howto, input_bfd, input_section,
365 contents, rel->r_offset,
366 relocation, rel->r_addend);
367}
368\f
369/* Set the howto pointer for a IQ2000 ELF reloc. */
370
371static void
58852c27
NC		 372iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
373 arelent * cache_ptr,
374 Elf_Internal_Rela * dst)
a75473eb
SC		 375{
376 unsigned int r_type;
377
378 r_type = ELF32_R_TYPE (dst->r_info);
379 switch (r_type)
380 {
381 case R_IQ2000_GNU_VTINHERIT:
382 cache_ptr->howto = & iq2000_elf_vtinherit_howto;
383 break;
384
385 case R_IQ2000_GNU_VTENTRY:
386 cache_ptr->howto = & iq2000_elf_vtentry_howto;
387 break;
388
389 default:
390 cache_ptr->howto = & iq2000_elf_howto_table [r_type];
391 break;
392 }
393}
394
395/* Look through the relocs for a section during the first phase.
396 Since we don't do .gots or .plts, we just need to consider the
397 virtual table relocs for gc. */
398
399static bfd_boolean
58852c27
NC		 400iq2000_elf_check_relocs (bfd *abfd,
401 struct bfd_link_info *info,
402 asection *sec,
403 const Elf_Internal_Rela *relocs)
a75473eb
SC		 404{
405 Elf_Internal_Shdr *symtab_hdr;
406 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
60d8b524
AM		 407 const Elf_Internal_Rela *rel;
408 const Elf_Internal_Rela *rel_end;
409 bfd_boolean changed = FALSE;
a75473eb 410
1049f94e 411 if (info->relocatable)
a75473eb
SC		 412 return TRUE;
413
414 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
415 sym_hashes = elf_sym_hashes (abfd);
58852c27 416 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
a75473eb
SC		 417 if (!elf_bad_symtab (abfd))
418 sym_hashes_end -= symtab_hdr->sh_info;
419
420 rel_end = relocs + sec->reloc_count;
421 for (rel = relocs; rel < rel_end; rel++)
422 {
423 struct elf_link_hash_entry *h;
424 unsigned long r_symndx;
425
426 r_symndx = ELF32_R_SYM (rel->r_info);
427 if (r_symndx < symtab_hdr->sh_info)
428 h = NULL;
429 else
430 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
431
432 switch (ELF32_R_TYPE (rel->r_info))
433 {
58852c27
NC		 434 /* This relocation describes the C++ object vtable
435 hierarchy. Reconstruct it for later use during GC. */
a75473eb 436 case R_IQ2000_GNU_VTINHERIT:
c152c796 437 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
a75473eb
SC		 438 return FALSE;
439 break;
440
58852c27
NC		 441 /* This relocation describes which C++ vtable entries
442 are actually used. Record for later use during GC. */
a75473eb 443 case R_IQ2000_GNU_VTENTRY:
c152c796 444 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
a75473eb
SC		 445 return FALSE;
446 break;
447
448 case R_IQ2000_32:
58852c27 449 /* For debug section, change to special harvard-aware relocations. */
a75473eb
SC		 450 if (memcmp (sec->name, ".debug", 6) == 0
451 || memcmp (sec->name, ".stab", 5) == 0
452 || memcmp (sec->name, ".eh_frame", 9) == 0)
60d8b524
AM		 453 {
454 ((Elf_Internal_Rela *) rel)->r_info
455 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
456 changed = TRUE;
457 }
a75473eb
SC		 458 break;
459 }
460 }
60d8b524
AM		 461
462 if (changed)
463 /* Note that we've changed relocs, otherwise if !info->keep_memory
464 we'll free the relocs and lose our changes. */
d5cb4bb8 465 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
60d8b524 466
a75473eb
SC		 467 return TRUE;
468}
469
470\f
471/* Relocate a IQ2000 ELF section.
472 There is some attempt to make this function usable for many architectures,
473 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
474 if only to serve as a learning tool.
475
476 The RELOCATE_SECTION function is called by the new ELF backend linker
477 to handle the relocations for a section.
478
479 The relocs are always passed as Rela structures; if the section
480 actually uses Rel structures, the r_addend field will always be
481 zero.
482
483 This function is responsible for adjusting the section contents as
1049f94e 484 necessary, and (if using Rela relocs and generating a relocatable
a75473eb
SC		 485 output file) adjusting the reloc addend as necessary.
486
487 This function does not have to worry about setting the reloc
488 address or the reloc symbol index.
489
490 LOCAL_SYMS is a pointer to the swapped in local symbols.
491
492 LOCAL_SECTIONS is an array giving the section in the input file
493 corresponding to the st_shndx field of each local symbol.
494
495 The global hash table entry for the global symbols can be found
496 via elf_sym_hashes (input_bfd).
497
1049f94e 498 When generating relocatable output, this function must handle
a75473eb
SC		 499 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
500 going to be the section symbol corresponding to the output
501 section, which means that the addend must be adjusted
502 accordingly. */
503
504static bfd_boolean
58852c27
NC		 505iq2000_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
506 struct bfd_link_info * info,
507 bfd * input_bfd,
508 asection * input_section,
509 bfd_byte * contents,
510 Elf_Internal_Rela * relocs,
511 Elf_Internal_Sym * local_syms,
512 asection ** local_sections)
a75473eb
SC		 513{
514 Elf_Internal_Shdr * symtab_hdr;
515 struct elf_link_hash_entry ** sym_hashes;
516 Elf_Internal_Rela * rel;
517 Elf_Internal_Rela * relend;
518
d5cb4bb8
NC		 519 if (info->relocatable)
520 return TRUE;
521
a75473eb
SC		 522 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
523 sym_hashes = elf_sym_hashes (input_bfd);
524 relend = relocs + input_section->reloc_count;
525
526 for (rel = relocs; rel < relend; rel ++)
527 {
528 reloc_howto_type * howto;
529 unsigned long r_symndx;
530 Elf_Internal_Sym * sym;
531 asection * sec;
532 struct elf_link_hash_entry * h;
533 bfd_vma relocation;
534 bfd_reloc_status_type r;
535 const char * name = NULL;
536 int r_type;
537
538 r_type = ELF32_R_TYPE (rel->r_info);
539
540 if ( r_type == R_IQ2000_GNU_VTINHERIT
541 || r_type == R_IQ2000_GNU_VTENTRY)
542 continue;
543
544 r_symndx = ELF32_R_SYM (rel->r_info);
545
546 /* This is a final link. */
547 howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
548 h = NULL;
549 sym = NULL;
550 sec = NULL;
551
552 if (r_symndx < symtab_hdr->sh_info)
553 {
554 sym = local_syms + r_symndx;
555 sec = local_sections [r_symndx];
556 relocation = (sec->output_section->vma
557 + sec->output_offset
558 + sym->st_value);
559
560 name = bfd_elf_string_from_elf_section
561 (input_bfd, symtab_hdr->sh_link, sym->st_name);
562 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
a75473eb
SC		 563 }
564 else
565 {
560e09e9
NC		 566 bfd_boolean unresolved_reloc;
567 bfd_boolean warned;
568
b2a8e766
AM		 569 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
570 r_symndx, symtab_hdr, sym_hashes,
571 h, sec, relocation,
572 unresolved_reloc, warned);
a75473eb
SC		 573
574 name = h->root.root.string;
a75473eb
SC		 575 }
576
577 switch (r_type)
578 {
579 case R_IQ2000_HI16:
580 r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
581 break;
582
583 case R_IQ2000_PC16:
584 rel->r_addend -= 4;
585 /* Fall through. */
586
587 default:
588 r = iq2000_final_link_relocate (howto, input_bfd, input_section,
589 contents, rel, relocation);
590 break;
591 }
592
593 if (r != bfd_reloc_ok)
594 {
595 const char * msg = (const char *) NULL;
596
597 switch (r)
598 {
599 case bfd_reloc_overflow:
600 r = info->callbacks->reloc_overflow
dfeffb9f
L		 601 (info, (h ? &h->root : NULL), name, howto->name,
602 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
a75473eb
SC		 603 break;
604
605 case bfd_reloc_undefined:
606 r = info->callbacks->undefined_symbol
607 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
608 break;
609
610 case bfd_reloc_outofrange:
611 msg = _("internal error: out of range error");
612 break;
613
614 case bfd_reloc_notsupported:
615 msg = _("internal error: unsupported relocation error");
616 break;
617
618 case bfd_reloc_dangerous:
619 msg = _("internal error: dangerous relocation");
620 break;
621
622 default:
623 msg = _("internal error: unknown error");
624 break;
625 }
626
627 if (msg)
628 r = info->callbacks->warning
629 (info, msg, name, input_bfd, input_section, rel->r_offset);
630
631 if (! r)
632 return FALSE;
633 }
634 }
635
636 return TRUE;
637}
638\f
639
640/* Update the got entry reference counts for the section being
641 removed. */
642
643static bfd_boolean
58852c27
NC		 644iq2000_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
645 struct bfd_link_info * info ATTRIBUTE_UNUSED,
646 asection * sec ATTRIBUTE_UNUSED,
647 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
a75473eb
SC		 648{
649 return TRUE;
650}
651
652/* Return the section that should be marked against GC for a given
653 relocation. */
654
655static asection *
58852c27
NC		 656iq2000_elf_gc_mark_hook (asection * sec,
657 struct bfd_link_info * info ATTRIBUTE_UNUSED,
658 Elf_Internal_Rela * rel,
659 struct elf_link_hash_entry * h,
660 Elf_Internal_Sym * sym)
a75473eb 661{
58852c27
NC		 662 if (h == NULL)
663 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
664
665 switch (ELF32_R_TYPE (rel->r_info))
a75473eb 666 {
58852c27
NC		 667 case R_IQ2000_GNU_VTINHERIT:
668 case R_IQ2000_GNU_VTENTRY:
669 break;
a75473eb 670
58852c27
NC		 671 default:
672 switch (h->root.type)
673 {
674 case bfd_link_hash_defined:
675 case bfd_link_hash_defweak:
676 return h->root.u.def.section;
a75473eb 677
58852c27
NC		 678 case bfd_link_hash_common:
679 return h->root.u.c.p->section;
a75473eb 680
58852c27
NC		 681 default:
682 break;
a75473eb
SC		 683 }
684 }
a75473eb
SC		 685
686 return NULL;
687}
688
689\f
690/* Return the MACH for an e_flags value. */
691
692static int
58852c27 693elf32_iq2000_machine (bfd *abfd)
a75473eb
SC		 694{
695 switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
696 {
58852c27
NC		 697 case EF_IQ2000_CPU_IQ10:
698 return bfd_mach_iq10;
a75473eb 699
58852c27
NC		 700 case EF_IQ2000_CPU_IQ2000:
701 default:
702 return bfd_mach_iq2000;
703 }
a75473eb
SC		 704}
705
706\f
707/* Function to set the ELF flag bits. */
708
709static bfd_boolean
58852c27 710iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
a75473eb
SC		 711{
712 elf_elfheader (abfd)->e_flags = flags;
713 elf_flags_init (abfd) = TRUE;
714 return TRUE;
715}
716
717/* Copy backend specific data from one object module to another. */
718
719static bfd_boolean
58852c27 720iq2000_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
a75473eb
SC		 721{
722 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
723 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
724 return TRUE;
725
726 BFD_ASSERT (!elf_flags_init (obfd)
727 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
728
729 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
730 elf_flags_init (obfd) = TRUE;
731 return TRUE;
732}
733
58852c27
NC		 734/* Merge backend specific data from an object
735 file to the output object file when linking. */
a75473eb
SC		 736
737static bfd_boolean
58852c27 738iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
a75473eb
SC		 739{
740 flagword old_flags, old_partial;
741 flagword new_flags, new_partial;
742 bfd_boolean error = FALSE;
743 char new_opt[80];
744 char old_opt[80];
745
746 new_opt[0] = old_opt[0] = '\0';
747 new_flags = elf_elfheader (ibfd)->e_flags;
748 old_flags = elf_elfheader (obfd)->e_flags;
749
a75473eb
SC		 750 if (!elf_flags_init (obfd))
751 {
752 /* First call, no flags set. */
753 elf_flags_init (obfd) = TRUE;
754 elf_elfheader (obfd)->e_flags = new_flags;
755 }
756
58852c27 757 else if (new_flags != old_flags)
a75473eb 758 {
58852c27
NC		 759 /* Warn if different cpu is used, but allow a
760 specific cpu to override the generic cpu. */
a75473eb
SC		 761 new_partial = (new_flags & EF_IQ2000_CPU_MASK);
762 old_partial = (old_flags & EF_IQ2000_CPU_MASK);
a75473eb 763
58852c27 764 if (new_partial != old_partial)
a75473eb
SC		 765 {
766 switch (new_partial)
767 {
58852c27
NC		 768 case EF_IQ2000_CPU_IQ10:
769 strcat (new_opt, " -m10");
770 break;
771
772 default:
773 case EF_IQ2000_CPU_IQ2000:
774 strcat (new_opt, " -m2000");
775 break;
a75473eb
SC		 776 }
777
778 switch (old_partial)
779 {
58852c27
NC		 780 case EF_IQ2000_CPU_IQ10:
781 strcat (old_opt, " -m10");
782 break;
783
784 default:
785 case EF_IQ2000_CPU_IQ2000:
786 strcat (old_opt, " -m2000");
787 break;
a75473eb
SC		 788 }
789 }
790
791 /* Print out any mismatches from above. */
792 if (new_opt[0])
793 {
794 error = TRUE;
58852c27 795 _bfd_error_handler
a75473eb
SC		 796 (_("%s: compiled with %s and linked with modules compiled with %s"),
797 bfd_get_filename (ibfd), new_opt, old_opt);
798 }
799
800 new_flags &= ~ EF_IQ2000_ALL_FLAGS;
801 old_flags &= ~ EF_IQ2000_ALL_FLAGS;
802
803 /* Warn about any other mismatches. */
804 if (new_flags != old_flags)
805 {
806 error = TRUE;
58852c27
NC		 807
808 _bfd_error_handler
a75473eb
SC		 809 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
810 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
811 }
812 }
813
814 if (error)
815 bfd_set_error (bfd_error_bad_value);
816
817 return !error;
818}
819
820\f
821static bfd_boolean
58852c27 822iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
a75473eb
SC		 823{
824 FILE *file = (FILE *) ptr;
825 flagword flags;
826
827 BFD_ASSERT (abfd != NULL && ptr != NULL);
828
829 /* Print normal ELF private data. */
830 _bfd_elf_print_private_bfd_data (abfd, ptr);
831
832 flags = elf_elfheader (abfd)->e_flags;
833 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
834
835 switch (flags & EF_IQ2000_CPU_MASK)
836 {
58852c27
NC		 837 case EF_IQ2000_CPU_IQ10:
838 fprintf (file, " -m10");
839 break;
840 case EF_IQ2000_CPU_IQ2000:
841 fprintf (file, " -m2000");
842 break;
843 default:
844 break;
a75473eb
SC		 845 }
846
847 fputc ('\n', file);
60d8b524 848 return TRUE;
a75473eb
SC		 849}
850
851static
852bfd_boolean
58852c27 853iq2000_elf_object_p (bfd *abfd)
a75473eb 854{
a75473eb
SC		 855 bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
856 elf32_iq2000_machine (abfd));
857 return TRUE;
858}
859
860\f
861#define ELF_ARCH bfd_arch_iq2000
862#define ELF_MACHINE_CODE EM_IQ2000
863#define ELF_MAXPAGESIZE 0x1000
864
865#define TARGET_BIG_SYM bfd_elf32_iq2000_vec
866#define TARGET_BIG_NAME "elf32-iq2000"
867
868#define elf_info_to_howto_rel NULL
869#define elf_info_to_howto iq2000_info_to_howto_rela
870#define elf_backend_relocate_section iq2000_elf_relocate_section
871#define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook
872#define elf_backend_gc_sweep_hook iq2000_elf_gc_sweep_hook
873#define elf_backend_check_relocs iq2000_elf_check_relocs
874#define elf_backend_object_p iq2000_elf_object_p
875#define elf_backend_rela_normal 1
876
877#define elf_backend_can_gc_sections 1
878
879#define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup
880#define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags
881#define bfd_elf32_bfd_copy_private_bfd_data iq2000_elf_copy_private_bfd_data
882#define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data
883#define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data
884
885#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.171325 seconds and 4 git commands to generate.