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