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