projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Define bfd_elf32_get_synthetic_symtab for x32
[deliverable/binutils-gdb.git] / bfd / elf32-xstormy16.c
1 /* Xstormy16-specific support for 32-bit ELF.
2 Copyright (C) 2000-2014 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,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/xstormy16.h"
26 #include "libiberty.h"
27
28 /* Handle the R_XSTORMY16_24 reloc, which has an odd bit arrangement. */
29
30 static bfd_reloc_status_type
31 xstormy16_elf_24_reloc (bfd *abfd,
32 arelent *reloc_entry,
33 asymbol *symbol,
34 void * data,
35 asection *input_section,
36 bfd *output_bfd,
37 char **error_message ATTRIBUTE_UNUSED)
38 {
39 bfd_vma relocation, x;
40
41 if (output_bfd != NULL)
42 {
43 reloc_entry->address += input_section->output_offset;
44 return bfd_reloc_ok;
45 }
46
47 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
48 return bfd_reloc_outofrange;
49
50 if (bfd_is_com_section (symbol->section))
51 relocation = 0;
52 else
53 relocation = symbol->value;
54
55 relocation += symbol->section->output_section->vma;
56 relocation += symbol->section->output_offset;
57 relocation += reloc_entry->addend;
58
59 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
60 x &= 0x0000ff00;
61 x |= relocation & 0xff;
62 x |= (relocation << 8) & 0xffff0000;
63 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
64
65 if (relocation & ~ (bfd_vma) 0xffffff)
66 return bfd_reloc_overflow;
67
68 return bfd_reloc_ok;
69 }
70
71 static reloc_howto_type xstormy16_elf_howto_table [] =
72 {
73 /* This reloc does nothing. */
74 HOWTO (R_XSTORMY16_NONE, /* type */
75 0, /* rightshift */
76 2, /* size (0 = byte, 1 = short, 2 = long) */
77 32, /* bitsize */
78 FALSE, /* pc_relative */
79 0, /* bitpos */
80 complain_overflow_bitfield, /* complain_on_overflow */
81 bfd_elf_generic_reloc, /* special_function */
82 "R_XSTORMY16_NONE", /* name */
83 FALSE, /* partial_inplace */
84 0, /* src_mask */
85 0, /* dst_mask */
86 FALSE), /* pcrel_offset */
87
88 /* A 32 bit absolute relocation. */
89 HOWTO (R_XSTORMY16_32, /* type */
90 0, /* rightshift */
91 2, /* size (0 = byte, 1 = short, 2 = long) */
92 32, /* bitsize */
93 FALSE, /* pc_relative */
94 0, /* bitpos */
95 complain_overflow_dont, /* complain_on_overflow */
96 bfd_elf_generic_reloc, /* special_function */
97 "R_XSTORMY16_32", /* name */
98 FALSE, /* partial_inplace */
99 0, /* src_mask */
100 0xffffffff, /* dst_mask */
101 FALSE), /* pcrel_offset */
102
103 /* A 16 bit absolute relocation. */
104 HOWTO (R_XSTORMY16_16, /* type */
105 0, /* rightshift */
106 1, /* size (0 = byte, 1 = short, 2 = long) */
107 16, /* bitsize */
108 FALSE, /* pc_relative */
109 0, /* bitpos */
110 complain_overflow_bitfield, /* complain_on_overflow */
111 bfd_elf_generic_reloc, /* special_function */
112 "R_XSTORMY16_16", /* name */
113 FALSE, /* partial_inplace */
114 0, /* src_mask */
115 0xffff, /* dst_mask */
116 FALSE), /* pcrel_offset */
117
118 /* An 8 bit absolute relocation. */
119 HOWTO (R_XSTORMY16_8, /* type */
120 0, /* rightshift */
121 0, /* size (0 = byte, 1 = short, 2 = long) */
122 8, /* bitsize */
123 FALSE, /* pc_relative */
124 0, /* bitpos */
125 complain_overflow_unsigned, /* complain_on_overflow */
126 bfd_elf_generic_reloc, /* special_function */
127 "R_XSTORMY16_8", /* name */
128 FALSE, /* partial_inplace */
129 0, /* src_mask */
130 0xff, /* dst_mask */
131 FALSE), /* pcrel_offset */
132
133 /* A 32 bit pc-relative relocation. */
134 HOWTO (R_XSTORMY16_PC32, /* type */
135 0, /* rightshift */
136 2, /* size (0 = byte, 1 = short, 2 = long) */
137 32, /* bitsize */
138 TRUE, /* pc_relative */
139 0, /* bitpos */
140 complain_overflow_dont, /* complain_on_overflow */
141 bfd_elf_generic_reloc, /* special_function */
142 "R_XSTORMY16_PC32", /* name */
143 FALSE, /* partial_inplace */
144 0, /* src_mask */
145 0xffffffff, /* dst_mask */
146 TRUE), /* pcrel_offset */
147
148 /* A 16 bit pc-relative relocation. */
149 HOWTO (R_XSTORMY16_PC16, /* type */
150 0, /* rightshift */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
152 16, /* bitsize */
153 TRUE, /* pc_relative */
154 0, /* bitpos */
155 complain_overflow_signed, /* complain_on_overflow */
156 bfd_elf_generic_reloc, /* special_function */
157 "R_XSTORMY16_PC16", /* name */
158 FALSE, /* partial_inplace */
159 0, /* src_mask */
160 0xffffffff, /* dst_mask */
161 TRUE), /* pcrel_offset */
162
163 /* An 8 bit pc-relative relocation. */
164 HOWTO (R_XSTORMY16_PC8, /* type */
165 0, /* rightshift */
166 0, /* size (0 = byte, 1 = short, 2 = long) */
167 8, /* bitsize */
168 TRUE, /* pc_relative */
169 0, /* bitpos */
170 complain_overflow_signed, /* complain_on_overflow */
171 bfd_elf_generic_reloc, /* special_function */
172 "R_XSTORMY16_PC8", /* name */
173 FALSE, /* partial_inplace */
174 0, /* src_mask */
175 0xffffffff, /* dst_mask */
176 TRUE), /* pcrel_offset */
177
178 /* A 12-bit pc-relative relocation suitable for the branch instructions. */
179 HOWTO (R_XSTORMY16_REL_12, /* type */
180 1, /* rightshift */
181 1, /* size (0 = byte, 1 = short, 2 = long) */
182 11, /* bitsize */
183 TRUE, /* pc_relative */
184 1, /* bitpos */
185 complain_overflow_signed, /* complain_on_overflow */
186 bfd_elf_generic_reloc, /* special_function */
187 "R_XSTORMY16_REL_12", /* name */
188 FALSE, /* partial_inplace */
189 0, /* src_mask */
190 0x0ffe, /* dst_mask */
191 TRUE), /* pcrel_offset */
192
193 /* A 24-bit absolute relocation suitable for the jump instructions. */
194 HOWTO (R_XSTORMY16_24, /* type */
195 0, /* rightshift */
196 2, /* size (0 = byte, 1 = short, 2 = long) */
197 24, /* bitsize */
198 FALSE, /* pc_relative */
199 0, /* bitpos */
200 complain_overflow_unsigned, /* complain_on_overflow */
201 xstormy16_elf_24_reloc, /* special_function */
202 "R_XSTORMY16_24", /* name */
203 TRUE, /* partial_inplace */
204 0, /* src_mask */
205 0xffff00ff, /* dst_mask */
206 TRUE), /* pcrel_offset */
207
208 /* A 16 bit absolute relocation to a function pointer. */
209 HOWTO (R_XSTORMY16_FPTR16, /* type */
210 0, /* rightshift */
211 1, /* size (0 = byte, 1 = short, 2 = long) */
212 16, /* bitsize */
213 FALSE, /* pc_relative */
214 0, /* bitpos */
215 complain_overflow_bitfield, /* complain_on_overflow */
216 bfd_elf_generic_reloc, /* special_function */
217 "R_XSTORMY16_FPTR16", /* name */
218 FALSE, /* partial_inplace */
219 0, /* src_mask */
220 0xffffffff, /* dst_mask */
221 FALSE), /* pcrel_offset */
222
223 /* Low order 16 bit value of a high memory address. */
224 HOWTO (R_XSTORMY16_LO16, /* type */
225 0, /* rightshift */
226 1, /* size (0 = byte, 1 = short, 2 = long) */
227 16, /* bitsize */
228 FALSE, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_dont, /* complain_on_overflow */
231 bfd_elf_generic_reloc, /* special_function */
232 "R_XSTORMY16_LO16", /* name */
233 FALSE, /* partial_inplace */
234 0, /* src_mask */
235 0xffff, /* dst_mask */
236 FALSE), /* pcrel_offset */
237
238 /* High order 16 bit value of a high memory address. */
239 HOWTO (R_XSTORMY16_HI16, /* type */
240 16, /* rightshift */
241 1, /* size (0 = byte, 1 = short, 2 = long) */
242 16, /* bitsize */
243 FALSE, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_dont, /* complain_on_overflow */
246 bfd_elf_generic_reloc, /* special_function */
247 "R_XSTORMY16_HI16", /* name */
248 FALSE, /* partial_inplace */
249 0, /* src_mask */
250 0xffff, /* dst_mask */
251 FALSE), /* pcrel_offset */
252
253 /* A 12 bit absolute relocation. */
254 HOWTO (R_XSTORMY16_12, /* type */
255 0, /* rightshift */
256 1, /* size (0 = byte, 1 = short, 2 = long) */
257 12, /* bitsize */
258 FALSE, /* pc_relative */
259 0, /* bitpos */
260 complain_overflow_signed, /* complain_on_overflow */
261 bfd_elf_generic_reloc, /* special_function */
262 "R_XSTORMY16_12", /* name */
263 FALSE, /* partial_inplace */
264 0x0000, /* src_mask */
265 0x0fff, /* dst_mask */
266 FALSE), /* pcrel_offset */
267 };
268
269 static reloc_howto_type xstormy16_elf_howto_table2 [] =
270 {
271 /* GNU extension to record C++ vtable hierarchy */
272 HOWTO (R_XSTORMY16_GNU_VTINHERIT, /* type */
273 0, /* rightshift */
274 2, /* size (0 = byte, 1 = short, 2 = long) */
275 0, /* bitsize */
276 FALSE, /* pc_relative */
277 0, /* bitpos */
278 complain_overflow_dont, /* complain_on_overflow */
279 NULL, /* special_function */
280 "R_XSTORMY16_GNU_VTINHERIT", /* name */
281 FALSE, /* partial_inplace */
282 0, /* src_mask */
283 0, /* dst_mask */
284 FALSE), /* pcrel_offset */
285
286 /* GNU extension to record C++ vtable member usage */
287 HOWTO (R_XSTORMY16_GNU_VTENTRY, /* type */
288 0, /* rightshift */
289 2, /* size (0 = byte, 1 = short, 2 = long) */
290 0, /* bitsize */
291 FALSE, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_dont, /* complain_on_overflow */
294 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
295 "R_XSTORMY16_GNU_VTENTRY", /* name */
296 FALSE, /* partial_inplace */
297 0, /* src_mask */
298 0, /* dst_mask */
299 FALSE), /* pcrel_offset */
300
301 };
302 \f
303 /* Map BFD reloc types to XSTORMY16 ELF reloc types. */
304
305 typedef struct xstormy16_reloc_map
306 {
307 bfd_reloc_code_real_type bfd_reloc_val;
308 unsigned int xstormy16_reloc_val;
309 reloc_howto_type * table;
310 } reloc_map;
311
312 static const reloc_map xstormy16_reloc_map [] =
313 {
314 { BFD_RELOC_NONE, R_XSTORMY16_NONE, xstormy16_elf_howto_table },
315 { BFD_RELOC_32, R_XSTORMY16_32, xstormy16_elf_howto_table },
316 { BFD_RELOC_16, R_XSTORMY16_16, xstormy16_elf_howto_table },
317 { BFD_RELOC_8, R_XSTORMY16_8, xstormy16_elf_howto_table },
318 { BFD_RELOC_32_PCREL, R_XSTORMY16_PC32, xstormy16_elf_howto_table },
319 { BFD_RELOC_16_PCREL, R_XSTORMY16_PC16, xstormy16_elf_howto_table },
320 { BFD_RELOC_8_PCREL, R_XSTORMY16_PC8, xstormy16_elf_howto_table },
321 { BFD_RELOC_XSTORMY16_REL_12, R_XSTORMY16_REL_12, xstormy16_elf_howto_table },
322 { BFD_RELOC_XSTORMY16_24, R_XSTORMY16_24, xstormy16_elf_howto_table },
323 { BFD_RELOC_XSTORMY16_FPTR16, R_XSTORMY16_FPTR16, xstormy16_elf_howto_table },
324 { BFD_RELOC_LO16, R_XSTORMY16_LO16, xstormy16_elf_howto_table },
325 { BFD_RELOC_HI16, R_XSTORMY16_HI16, xstormy16_elf_howto_table },
326 { BFD_RELOC_XSTORMY16_12, R_XSTORMY16_12, xstormy16_elf_howto_table },
327 { BFD_RELOC_VTABLE_INHERIT, R_XSTORMY16_GNU_VTINHERIT, xstormy16_elf_howto_table2 },
328 { BFD_RELOC_VTABLE_ENTRY, R_XSTORMY16_GNU_VTENTRY, xstormy16_elf_howto_table2 },
329 };
330
331 static reloc_howto_type *
332 xstormy16_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
333 bfd_reloc_code_real_type code)
334 {
335 unsigned int i;
336
337 for (i = ARRAY_SIZE (xstormy16_reloc_map); --i;)
338 {
339 const reloc_map * entry;
340
341 entry = xstormy16_reloc_map + i;
342
343 if (entry->bfd_reloc_val == code)
344 return entry->table + (entry->xstormy16_reloc_val
345 - entry->table[0].type);
346 }
347
348 return NULL;
349 }
350
351 static reloc_howto_type *
352 xstormy16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
353 const char *r_name)
354 {
355 unsigned int i;
356
357 for (i = 0;
358 i < (sizeof (xstormy16_elf_howto_table)
359 / sizeof (xstormy16_elf_howto_table[0]));
360 i++)
361 if (xstormy16_elf_howto_table[i].name != NULL
362 && strcasecmp (xstormy16_elf_howto_table[i].name, r_name) == 0)
363 return &xstormy16_elf_howto_table[i];
364
365 for (i = 0;
366 i < (sizeof (xstormy16_elf_howto_table2)
367 / sizeof (xstormy16_elf_howto_table2[0]));
368 i++)
369 if (xstormy16_elf_howto_table2[i].name != NULL
370 && strcasecmp (xstormy16_elf_howto_table2[i].name, r_name) == 0)
371 return &xstormy16_elf_howto_table2[i];
372
373 return NULL;
374 }
375
376 /* Set the howto pointer for an XSTORMY16 ELF reloc. */
377
378 static void
379 xstormy16_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
380 arelent * cache_ptr,
381 Elf_Internal_Rela * dst)
382 {
383 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
384
385 if (r_type <= (unsigned int) R_XSTORMY16_12)
386 cache_ptr->howto = &xstormy16_elf_howto_table [r_type];
387 else if (r_type - R_XSTORMY16_GNU_VTINHERIT
388 <= (unsigned int) R_XSTORMY16_GNU_VTENTRY)
389 cache_ptr->howto
390 = &xstormy16_elf_howto_table2 [r_type - R_XSTORMY16_GNU_VTINHERIT];
391 else
392 abort ();
393 }
394 \f
395 /* We support 16-bit pointers to code above 64k by generating a thunk
396 below 64k containing a JMPF instruction to the final address. We
397 cannot, unfortunately, minimize the number of thunks unless the
398 -relax switch is given, as otherwise we have no idea where the
399 sections will fall in the address space. */
400
401 static bfd_boolean
402 xstormy16_elf_check_relocs (bfd *abfd,
403 struct bfd_link_info *info,
404 asection *sec,
405 const Elf_Internal_Rela *relocs)
406 {
407 const Elf_Internal_Rela *rel, *relend;
408 struct elf_link_hash_entry **sym_hashes;
409 Elf_Internal_Shdr *symtab_hdr;
410 bfd_vma *local_plt_offsets;
411 asection *splt;
412 bfd *dynobj;
413
414 if (info->relocatable)
415 return TRUE;
416
417 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
418 sym_hashes = elf_sym_hashes (abfd);
419 local_plt_offsets = elf_local_got_offsets (abfd);
420 splt = NULL;
421 dynobj = elf_hash_table(info)->dynobj;
422
423 relend = relocs + sec->reloc_count;
424 for (rel = relocs; rel < relend; ++rel)
425 {
426 unsigned long r_symndx;
427 struct elf_link_hash_entry *h;
428 bfd_vma *offset;
429
430 r_symndx = ELF32_R_SYM (rel->r_info);
431 if (r_symndx < symtab_hdr->sh_info)
432 h = NULL;
433 else
434 {
435 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
436 while (h->root.type == bfd_link_hash_indirect
437 || h->root.type == bfd_link_hash_warning)
438 h = (struct elf_link_hash_entry *) h->root.u.i.link;
439
440 /* PR15323, ref flags aren't set for references in the same
441 object. */
442 h->root.non_ir_ref = 1;
443 }
444
445 switch (ELF32_R_TYPE (rel->r_info))
446 {
447 /* This relocation describes a 16-bit pointer to a function.
448 We may need to allocate a thunk in low memory; reserve memory
449 for it now. */
450 case R_XSTORMY16_FPTR16:
451 if (rel->r_addend != 0)
452 {
453 (*info->callbacks->warning)
454 (info, _("non-zero addend in @fptr reloc"), 0,
455 abfd, 0, 0);
456 }
457
458 if (dynobj == NULL)
459 elf_hash_table (info)->dynobj = dynobj = abfd;
460 if (splt == NULL)
461 {
462 splt = bfd_get_linker_section (dynobj, ".plt");
463 if (splt == NULL)
464 {
465 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
466 | SEC_IN_MEMORY | SEC_LINKER_CREATED
467 | SEC_READONLY | SEC_CODE);
468
469 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
470 flags);
471 if (splt == NULL
472 || ! bfd_set_section_alignment (dynobj, splt, 1))
473 return FALSE;
474 }
475 }
476
477 if (h != NULL)
478 offset = &h->plt.offset;
479 else
480 {
481 if (local_plt_offsets == NULL)
482 {
483 size_t size;
484 unsigned int i;
485
486 size = symtab_hdr->sh_info * sizeof (bfd_vma);
487 local_plt_offsets = bfd_alloc (abfd, size);
488 if (local_plt_offsets == NULL)
489 return FALSE;
490 elf_local_got_offsets (abfd) = local_plt_offsets;
491
492 for (i = 0; i < symtab_hdr->sh_info; i++)
493 local_plt_offsets[i] = (bfd_vma) -1;
494 }
495 offset = &local_plt_offsets[r_symndx];
496 }
497
498 if (*offset == (bfd_vma) -1)
499 {
500 *offset = splt->size;
501 splt->size += 4;
502 }
503 break;
504
505 /* This relocation describes the C++ object vtable hierarchy.
506 Reconstruct it for later use during GC. */
507 case R_XSTORMY16_GNU_VTINHERIT:
508 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
509 return FALSE;
510 break;
511
512 /* This relocation describes which C++ vtable entries are actually
513 used. Record for later use during GC. */
514 case R_XSTORMY16_GNU_VTENTRY:
515 BFD_ASSERT (h != NULL);
516 if (h != NULL
517 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
518 return FALSE;
519 break;
520 }
521 }
522
523 return TRUE;
524 }
525
526 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H
527 is within the low 64k, remove any entry for it in the plt. */
528
529 struct relax_plt_data
530 {
531 asection *splt;
532 bfd_boolean *again;
533 };
534
535 static bfd_boolean
536 xstormy16_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
537 {
538 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
539
540 if (h->plt.offset != (bfd_vma) -1)
541 {
542 bfd_vma address;
543
544 if (h->root.type == bfd_link_hash_undefined
545 || h->root.type == bfd_link_hash_undefweak)
546 address = 0;
547 else
548 address = (h->root.u.def.section->output_section->vma
549 + h->root.u.def.section->output_offset
550 + h->root.u.def.value);
551
552 if (address <= 0xffff)
553 {
554 h->plt.offset = -1;
555 data->splt->size -= 4;
556 *data->again = TRUE;
557 }
558 }
559
560 return TRUE;
561 }
562
563 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H
564 previously had a plt entry, give it a new entry offset. */
565
566 static bfd_boolean
567 xstormy16_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
568 {
569 bfd_vma *entry = (bfd_vma *) xdata;
570
571 if (h->plt.offset != (bfd_vma) -1)
572 {
573 h->plt.offset = *entry;
574 *entry += 4;
575 }
576
577 return TRUE;
578 }
579
580 static bfd_boolean
581 xstormy16_elf_relax_section (bfd *dynobj,
582 asection *splt,
583 struct bfd_link_info *info,
584 bfd_boolean *again)
585 {
586 struct relax_plt_data relax_plt_data;
587 bfd *ibfd;
588
589 /* Assume nothing changes. */
590 *again = FALSE;
591
592 if (info->relocatable)
593 return TRUE;
594
595 /* We only relax the .plt section at the moment. */
596 if (dynobj != elf_hash_table (info)->dynobj
597 || strcmp (splt->name, ".plt") != 0)
598 return TRUE;
599
600 /* Quick check for an empty plt. */
601 if (splt->size == 0)
602 return TRUE;
603
604 /* Map across all global symbols; see which ones happen to
605 fall in the low 64k. */
606 relax_plt_data.splt = splt;
607 relax_plt_data.again = again;
608 elf_link_hash_traverse (elf_hash_table (info), xstormy16_relax_plt_check,
609 &relax_plt_data);
610
611 /* Likewise for local symbols, though that's somewhat less convenient
612 as we have to walk the list of input bfds and swap in symbol data. */
613 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
614 {
615 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
616 Elf_Internal_Shdr *symtab_hdr;
617 Elf_Internal_Sym *isymbuf = NULL;
618 unsigned int idx;
619
620 if (! local_plt_offsets)
621 continue;
622
623 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
624 if (symtab_hdr->sh_info != 0)
625 {
626 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
627 if (isymbuf == NULL)
628 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
629 symtab_hdr->sh_info, 0,
630 NULL, NULL, NULL);
631 if (isymbuf == NULL)
632 return FALSE;
633 }
634
635 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
636 {
637 Elf_Internal_Sym *isym;
638 asection *tsec;
639 bfd_vma address;
640
641 if (local_plt_offsets[idx] == (bfd_vma) -1)
642 continue;
643
644 isym = &isymbuf[idx];
645 if (isym->st_shndx == SHN_UNDEF)
646 continue;
647 else if (isym->st_shndx == SHN_ABS)
648 tsec = bfd_abs_section_ptr;
649 else if (isym->st_shndx == SHN_COMMON)
650 tsec = bfd_com_section_ptr;
651 else
652 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
653
654 address = (tsec->output_section->vma
655 + tsec->output_offset
656 + isym->st_value);
657 if (address <= 0xffff)
658 {
659 local_plt_offsets[idx] = -1;
660 splt->size -= 4;
661 *again = TRUE;
662 }
663 }
664
665 if (isymbuf != NULL
666 && symtab_hdr->contents != (unsigned char *) isymbuf)
667 {
668 if (! info->keep_memory)
669 free (isymbuf);
670 else
671 {
672 /* Cache the symbols for elf_link_input_bfd. */
673 symtab_hdr->contents = (unsigned char *) isymbuf;
674 }
675 }
676 }
677
678 /* If we changed anything, walk the symbols again to reallocate
679 .plt entry addresses. */
680 if (*again && splt->size > 0)
681 {
682 bfd_vma entry = 0;
683
684 elf_link_hash_traverse (elf_hash_table (info),
685 xstormy16_relax_plt_realloc, &entry);
686
687 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
688 {
689 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
690 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
691 unsigned int idx;
692
693 if (! local_plt_offsets)
694 continue;
695
696 for (idx = 0; idx < nlocals; ++idx)
697 if (local_plt_offsets[idx] != (bfd_vma) -1)
698 {
699 local_plt_offsets[idx] = entry;
700 entry += 4;
701 }
702 }
703 }
704
705 return TRUE;
706 }
707
708 static bfd_boolean
709 xstormy16_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
710 struct bfd_link_info *info)
711 {
712 bfd *dynobj;
713 asection *splt;
714
715 if (info->relocatable)
716 return TRUE;
717
718 dynobj = elf_hash_table (info)->dynobj;
719 if (dynobj == NULL)
720 return TRUE;
721
722 splt = bfd_get_linker_section (dynobj, ".plt");
723 BFD_ASSERT (splt != NULL);
724
725 splt->contents = bfd_zalloc (dynobj, splt->size);
726 if (splt->contents == NULL)
727 return FALSE;
728
729 return TRUE;
730 }
731 \f
732 /* Relocate an XSTORMY16 ELF section.
733
734 The RELOCATE_SECTION function is called by the new ELF backend linker
735 to handle the relocations for a section.
736
737 The relocs are always passed as Rela structures; if the section
738 actually uses Rel structures, the r_addend field will always be
739 zero.
740
741 This function is responsible for adjusting the section contents as
742 necessary, and (if using Rela relocs and generating a relocatable
743 output file) adjusting the reloc addend as necessary.
744
745 This function does not have to worry about setting the reloc
746 address or the reloc symbol index.
747
748 LOCAL_SYMS is a pointer to the swapped in local symbols.
749
750 LOCAL_SECTIONS is an array giving the section in the input file
751 corresponding to the st_shndx field of each local symbol.
752
753 The global hash table entry for the global symbols can be found
754 via elf_sym_hashes (input_bfd).
755
756 When generating relocatable output, this function must handle
757 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
758 going to be the section symbol corresponding to the output
759 section, which means that the addend must be adjusted
760 accordingly. */
761
762 static bfd_boolean
763 xstormy16_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
764 struct bfd_link_info * info,
765 bfd * input_bfd,
766 asection * input_section,
767 bfd_byte * contents,
768 Elf_Internal_Rela * relocs,
769 Elf_Internal_Sym * local_syms,
770 asection ** local_sections)
771 {
772 Elf_Internal_Shdr * symtab_hdr;
773 struct elf_link_hash_entry ** sym_hashes;
774 Elf_Internal_Rela * rel;
775 Elf_Internal_Rela * relend;
776 bfd *dynobj;
777 asection *splt;
778
779 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
780 sym_hashes = elf_sym_hashes (input_bfd);
781 relend = relocs + input_section->reloc_count;
782
783 dynobj = elf_hash_table (info)->dynobj;
784 splt = NULL;
785 if (dynobj != NULL)
786 splt = bfd_get_linker_section (dynobj, ".plt");
787
788 for (rel = relocs; rel < relend; rel ++)
789 {
790 reloc_howto_type * howto;
791 unsigned long r_symndx;
792 Elf_Internal_Sym * sym;
793 asection * sec;
794 struct elf_link_hash_entry * h;
795 bfd_vma relocation;
796 bfd_reloc_status_type r;
797 const char * name = NULL;
798 int r_type;
799
800 r_type = ELF32_R_TYPE (rel->r_info);
801
802 if ( r_type == R_XSTORMY16_GNU_VTINHERIT
803 || r_type == R_XSTORMY16_GNU_VTENTRY)
804 continue;
805
806 r_symndx = ELF32_R_SYM (rel->r_info);
807 howto = xstormy16_elf_howto_table + ELF32_R_TYPE (rel->r_info);
808 h = NULL;
809 sym = NULL;
810 sec = NULL;
811
812 if (r_symndx < symtab_hdr->sh_info)
813 {
814 sym = local_syms + r_symndx;
815 sec = local_sections [r_symndx];
816 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
817 }
818 else
819 {
820 bfd_boolean unresolved_reloc, warned, ignored;
821
822 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
823 r_symndx, symtab_hdr, sym_hashes,
824 h, sec, relocation,
825 unresolved_reloc, warned, ignored);
826 }
827
828 if (sec != NULL && discarded_section (sec))
829 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
830 rel, 1, relend, howto, 0, contents);
831
832 if (info->relocatable)
833 continue;
834
835 if (h != NULL)
836 name = h->root.root.string;
837 else
838 {
839 name = (bfd_elf_string_from_elf_section
840 (input_bfd, symtab_hdr->sh_link, sym->st_name));
841 if (name == NULL || *name == '\0')
842 name = bfd_section_name (input_bfd, sec);
843 }
844
845 switch (ELF32_R_TYPE (rel->r_info))
846 {
847 case R_XSTORMY16_24:
848 {
849 bfd_vma reloc = relocation + rel->r_addend;
850 unsigned int x;
851
852 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
853 x &= 0x0000ff00;
854 x |= reloc & 0xff;
855 x |= (reloc << 8) & 0xffff0000;
856 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
857
858 if (reloc & ~0xffffff)
859 r = bfd_reloc_overflow;
860 else
861 r = bfd_reloc_ok;
862 break;
863 }
864
865 case R_XSTORMY16_FPTR16:
866 {
867 bfd_vma *plt_offset;
868
869 if (h != NULL)
870 plt_offset = &h->plt.offset;
871 else
872 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
873
874 if (relocation <= 0xffff)
875 {
876 /* If the symbol is in range for a 16-bit address, we should
877 have deallocated the plt entry in relax_section. */
878 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
879 }
880 else
881 {
882 /* If the symbol is out of range for a 16-bit address,
883 we must have allocated a plt entry. */
884 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
885
886 /* If this is the first time we've processed this symbol,
887 fill in the plt entry with the correct symbol address. */
888 if ((*plt_offset & 1) == 0)
889 {
890 unsigned int x;
891
892 x = 0x00000200; /* jmpf */
893 x |= relocation & 0xff;
894 x |= (relocation << 8) & 0xffff0000;
895 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
896 *plt_offset |= 1;
897 }
898
899 relocation = (splt->output_section->vma
900 + splt->output_offset
901 + (*plt_offset & -2));
902 }
903 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
904 contents, rel->r_offset,
905 relocation, 0);
906 break;
907 }
908
909 default:
910 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
911 contents, rel->r_offset,
912 relocation, rel->r_addend);
913 break;
914 }
915
916 if (r != bfd_reloc_ok)
917 {
918 const char * msg = NULL;
919
920 switch (r)
921 {
922 case bfd_reloc_overflow:
923 r = info->callbacks->reloc_overflow
924 (info, (h ? &h->root : NULL), name, howto->name,
925 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
926 break;
927
928 case bfd_reloc_undefined:
929 r = info->callbacks->undefined_symbol
930 (info, name, input_bfd, input_section, rel->r_offset,
931 TRUE);
932 break;
933
934 case bfd_reloc_outofrange:
935 msg = _("internal error: out of range error");
936 break;
937
938 case bfd_reloc_notsupported:
939 msg = _("internal error: unsupported relocation error");
940 break;
941
942 case bfd_reloc_dangerous:
943 msg = _("internal error: dangerous relocation");
944 break;
945
946 default:
947 msg = _("internal error: unknown error");
948 break;
949 }
950
951 if (msg)
952 r = info->callbacks->warning
953 (info, msg, name, input_bfd, input_section, rel->r_offset);
954
955 if (! r)
956 return FALSE;
957 }
958 }
959
960 return TRUE;
961 }
962
963 /* This must exist if dynobj is ever set. */
964
965 static bfd_boolean
966 xstormy16_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
967 struct bfd_link_info *info)
968 {
969 bfd *dynobj;
970 asection *splt;
971
972 /* As an extra sanity check, verify that all plt entries have
973 been filled in. */
974
975 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
976 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
977 {
978 bfd_byte *contents = splt->contents;
979 unsigned int i, size = splt->size;
980
981 for (i = 0; i < size; i += 4)
982 {
983 unsigned int x = bfd_get_32 (dynobj, contents + i);
984
985 BFD_ASSERT (x != 0);
986 }
987 }
988
989 return TRUE;
990 }
991 \f
992 /* Return the section that should be marked against GC for a given
993 relocation. */
994
995 static asection *
996 xstormy16_elf_gc_mark_hook (asection *sec,
997 struct bfd_link_info *info,
998 Elf_Internal_Rela *rel,
999 struct elf_link_hash_entry *h,
1000 Elf_Internal_Sym *sym)
1001 {
1002 if (h != NULL)
1003 switch (ELF32_R_TYPE (rel->r_info))
1004 {
1005 case R_XSTORMY16_GNU_VTINHERIT:
1006 case R_XSTORMY16_GNU_VTENTRY:
1007 return NULL;
1008 }
1009
1010 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1011 }
1012 \f
1013 #define ELF_ARCH bfd_arch_xstormy16
1014 #define ELF_MACHINE_CODE EM_XSTORMY16
1015 #define ELF_MAXPAGESIZE 0x100
1016
1017 #define TARGET_LITTLE_SYM xstormy16_elf32_vec
1018 #define TARGET_LITTLE_NAME "elf32-xstormy16"
1019
1020 #define elf_info_to_howto_rel NULL
1021 #define elf_info_to_howto xstormy16_info_to_howto_rela
1022 #define elf_backend_relocate_section xstormy16_elf_relocate_section
1023 #define elf_backend_gc_mark_hook xstormy16_elf_gc_mark_hook
1024 #define elf_backend_check_relocs xstormy16_elf_check_relocs
1025 #define elf_backend_always_size_sections \
1026 xstormy16_elf_always_size_sections
1027 #define elf_backend_omit_section_dynsym \
1028 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
1029 #define elf_backend_finish_dynamic_sections \
1030 xstormy16_elf_finish_dynamic_sections
1031
1032 #define elf_backend_can_gc_sections 1
1033 #define elf_backend_rela_normal 1
1034
1035 #define bfd_elf32_bfd_reloc_type_lookup xstormy16_reloc_type_lookup
1036 #define bfd_elf32_bfd_reloc_name_lookup \
1037 xstormy16_reloc_name_lookup
1038 #define bfd_elf32_bfd_relax_section xstormy16_elf_relax_section
1039
1040 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.0645 seconds and 4 git commands to generate.