2005-12-14 Paolo Bonzini <bonzini@gnu.org>
[binutils.git] / bfd / elf32-xstormy16.c
blob1341a4405ec9bf5bb99dbcec9ccce4daf27d635f
1 /* Xstormy16-specific support for 32-bit ELF.
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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,
19 USA. */
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/xstormy16.h"
26 #include "libiberty.h"
28 /* Handle the R_XSTORMY16_24 reloc, which has an odd bit arrangement. */
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)
39 bfd_vma relocation, x;
41 if (output_bfd != NULL)
43 reloc_entry->address += input_section->output_offset;
44 return bfd_reloc_ok;
47 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
48 return bfd_reloc_outofrange;
50 if (bfd_is_com_section (symbol->section))
51 relocation = 0;
52 else
53 relocation = symbol->value;
55 relocation += symbol->section->output_section->vma;
56 relocation += symbol->section->output_offset;
57 relocation += reloc_entry->addend;
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);
65 if (relocation & ~ (bfd_vma) 0xffffff)
66 return bfd_reloc_overflow;
68 return bfd_reloc_ok;
71 static reloc_howto_type xstormy16_elf_howto_table [] =
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
269 static reloc_howto_type xstormy16_elf_howto_table2 [] =
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 */
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 */
303 /* Map BFD reloc types to XSTORMY16 ELF reloc types. */
305 typedef struct xstormy16_reloc_map
307 bfd_reloc_code_real_type bfd_reloc_val;
308 unsigned int xstormy16_reloc_val;
309 reloc_howto_type * table;
310 } reloc_map;
312 static const reloc_map xstormy16_reloc_map [] =
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 },
331 static reloc_howto_type *
332 xstormy16_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
333 bfd_reloc_code_real_type code)
335 unsigned int i;
337 for (i = ARRAY_SIZE (xstormy16_reloc_map); --i;)
339 const reloc_map * entry;
341 entry = xstormy16_reloc_map + i;
343 if (entry->bfd_reloc_val == code)
344 return entry->table + (entry->xstormy16_reloc_val
345 - entry->table[0].type);
348 return NULL;
351 /* Set the howto pointer for an XSTORMY16 ELF reloc. */
353 static void
354 xstormy16_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
355 arelent * cache_ptr,
356 Elf_Internal_Rela * dst)
358 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
360 if (r_type <= (unsigned int) R_XSTORMY16_12)
361 cache_ptr->howto = &xstormy16_elf_howto_table [r_type];
362 else if (r_type - R_XSTORMY16_GNU_VTINHERIT
363 <= (unsigned int) R_XSTORMY16_GNU_VTENTRY)
364 cache_ptr->howto
365 = &xstormy16_elf_howto_table2 [r_type - R_XSTORMY16_GNU_VTINHERIT];
366 else
367 abort ();
370 /* We support 16-bit pointers to code above 64k by generating a thunk
371 below 64k containing a JMPF instruction to the final address. We
372 cannot, unfortunately, minimize the number of thunks unless the
373 -relax switch is given, as otherwise we have no idea where the
374 sections will fall in the address space. */
376 static bfd_boolean
377 xstormy16_elf_check_relocs (bfd *abfd,
378 struct bfd_link_info *info,
379 asection *sec,
380 const Elf_Internal_Rela *relocs)
382 const Elf_Internal_Rela *rel, *relend;
383 struct elf_link_hash_entry **sym_hashes;
384 Elf_Internal_Shdr *symtab_hdr;
385 bfd_vma *local_plt_offsets;
386 asection *splt;
387 bfd *dynobj;
389 if (info->relocatable)
390 return TRUE;
392 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
393 sym_hashes = elf_sym_hashes (abfd);
394 local_plt_offsets = elf_local_got_offsets (abfd);
395 splt = NULL;
396 dynobj = elf_hash_table(info)->dynobj;
398 relend = relocs + sec->reloc_count;
399 for (rel = relocs; rel < relend; ++rel)
401 unsigned long r_symndx;
402 struct elf_link_hash_entry *h;
403 bfd_vma *offset;
405 r_symndx = ELF32_R_SYM (rel->r_info);
406 if (r_symndx < symtab_hdr->sh_info)
407 h = NULL;
408 else
410 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
411 while (h->root.type == bfd_link_hash_indirect
412 || h->root.type == bfd_link_hash_warning)
413 h = (struct elf_link_hash_entry *) h->root.u.i.link;
416 switch (ELF32_R_TYPE (rel->r_info))
418 /* This relocation describes a 16-bit pointer to a function.
419 We may need to allocate a thunk in low memory; reserve memory
420 for it now. */
421 case R_XSTORMY16_FPTR16:
422 if (rel->r_addend != 0)
424 (*info->callbacks->warning)
425 (info, _("non-zero addend in @fptr reloc"), 0,
426 abfd, 0, 0);
429 if (dynobj == NULL)
430 elf_hash_table (info)->dynobj = dynobj = abfd;
431 if (splt == NULL)
433 splt = bfd_get_section_by_name (dynobj, ".plt");
434 if (splt == NULL)
436 splt = bfd_make_section_with_flags (dynobj, ".plt",
437 (SEC_ALLOC
438 | SEC_LOAD
439 | SEC_HAS_CONTENTS
440 | SEC_IN_MEMORY
441 | SEC_LINKER_CREATED
442 | SEC_READONLY
443 | SEC_CODE));
445 if (splt == NULL
446 || ! bfd_set_section_alignment (dynobj, splt, 1))
447 return FALSE;
451 if (h != NULL)
452 offset = &h->plt.offset;
453 else
455 if (local_plt_offsets == NULL)
457 size_t size;
458 unsigned int i;
460 size = symtab_hdr->sh_info * sizeof (bfd_vma);
461 local_plt_offsets = bfd_alloc (abfd, size);
462 if (local_plt_offsets == NULL)
463 return FALSE;
464 elf_local_got_offsets (abfd) = local_plt_offsets;
466 for (i = 0; i < symtab_hdr->sh_info; i++)
467 local_plt_offsets[i] = (bfd_vma) -1;
469 offset = &local_plt_offsets[r_symndx];
472 if (*offset == (bfd_vma) -1)
474 *offset = splt->size;
475 splt->size += 4;
477 break;
479 /* This relocation describes the C++ object vtable hierarchy.
480 Reconstruct it for later use during GC. */
481 case R_XSTORMY16_GNU_VTINHERIT:
482 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
483 return FALSE;
484 break;
486 /* This relocation describes which C++ vtable entries are actually
487 used. Record for later use during GC. */
488 case R_XSTORMY16_GNU_VTENTRY:
489 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
490 return FALSE;
491 break;
495 return TRUE;
498 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H
499 is within the low 64k, remove any entry for it in the plt. */
501 struct relax_plt_data
503 asection *splt;
504 bfd_boolean *again;
507 static bfd_boolean
508 xstormy16_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
510 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
512 if (h->root.type == bfd_link_hash_warning)
513 h = (struct elf_link_hash_entry *) h->root.u.i.link;
515 if (h->plt.offset != (bfd_vma) -1)
517 bfd_vma address;
519 if (h->root.type == bfd_link_hash_undefined
520 || h->root.type == bfd_link_hash_undefweak)
521 address = 0;
522 else
523 address = (h->root.u.def.section->output_section->vma
524 + h->root.u.def.section->output_offset
525 + h->root.u.def.value);
527 if (address <= 0xffff)
529 h->plt.offset = -1;
530 data->splt->size -= 4;
531 *data->again = TRUE;
535 return TRUE;
538 /* A subroutine of xstormy16_elf_relax_section. If the global symbol H
539 previously had a plt entry, give it a new entry offset. */
541 static bfd_boolean
542 xstormy16_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
544 bfd_vma *entry = (bfd_vma *) xdata;
546 if (h->root.type == bfd_link_hash_warning)
547 h = (struct elf_link_hash_entry *) h->root.u.i.link;
549 if (h->plt.offset != (bfd_vma) -1)
551 h->plt.offset = *entry;
552 *entry += 4;
555 return TRUE;
558 static bfd_boolean
559 xstormy16_elf_relax_section (bfd *dynobj,
560 asection *splt,
561 struct bfd_link_info *info,
562 bfd_boolean *again)
564 struct relax_plt_data relax_plt_data;
565 bfd *ibfd;
567 /* Assume nothing changes. */
568 *again = FALSE;
570 if (info->relocatable)
571 return TRUE;
573 /* We only relax the .plt section at the moment. */
574 if (dynobj != elf_hash_table (info)->dynobj
575 || strcmp (splt->name, ".plt") != 0)
576 return TRUE;
578 /* Quick check for an empty plt. */
579 if (splt->size == 0)
580 return TRUE;
582 /* Map across all global symbols; see which ones happen to
583 fall in the low 64k. */
584 relax_plt_data.splt = splt;
585 relax_plt_data.again = again;
586 elf_link_hash_traverse (elf_hash_table (info), xstormy16_relax_plt_check,
587 &relax_plt_data);
589 /* Likewise for local symbols, though that's somewhat less convenient
590 as we have to walk the list of input bfds and swap in symbol data. */
591 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
593 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
594 Elf_Internal_Shdr *symtab_hdr;
595 Elf_Internal_Sym *isymbuf = NULL;
596 unsigned int idx;
598 if (! local_plt_offsets)
599 continue;
601 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
602 if (symtab_hdr->sh_info != 0)
604 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
605 if (isymbuf == NULL)
606 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
607 symtab_hdr->sh_info, 0,
608 NULL, NULL, NULL);
609 if (isymbuf == NULL)
610 return FALSE;
613 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
615 Elf_Internal_Sym *isym;
616 asection *tsec;
617 bfd_vma address;
619 if (local_plt_offsets[idx] == (bfd_vma) -1)
620 continue;
622 isym = &isymbuf[idx];
623 if (isym->st_shndx == SHN_UNDEF)
624 continue;
625 else if (isym->st_shndx == SHN_ABS)
626 tsec = bfd_abs_section_ptr;
627 else if (isym->st_shndx == SHN_COMMON)
628 tsec = bfd_com_section_ptr;
629 else
630 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
632 address = (tsec->output_section->vma
633 + tsec->output_offset
634 + isym->st_value);
635 if (address <= 0xffff)
637 local_plt_offsets[idx] = -1;
638 splt->size -= 4;
639 *again = TRUE;
643 if (isymbuf != NULL
644 && symtab_hdr->contents != (unsigned char *) isymbuf)
646 if (! info->keep_memory)
647 free (isymbuf);
648 else
650 /* Cache the symbols for elf_link_input_bfd. */
651 symtab_hdr->contents = (unsigned char *) isymbuf;
656 /* If we changed anything, walk the symbols again to reallocate
657 .plt entry addresses. */
658 if (*again && splt->size > 0)
660 bfd_vma entry = 0;
662 elf_link_hash_traverse (elf_hash_table (info),
663 xstormy16_relax_plt_realloc, &entry);
665 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
667 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
668 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
669 unsigned int idx;
671 if (! local_plt_offsets)
672 continue;
674 for (idx = 0; idx < nlocals; ++idx)
675 if (local_plt_offsets[idx] != (bfd_vma) -1)
677 local_plt_offsets[idx] = entry;
678 entry += 4;
683 return TRUE;
686 static bfd_boolean
687 xstormy16_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
688 struct bfd_link_info *info)
690 bfd *dynobj;
691 asection *splt;
693 if (info->relocatable)
694 return TRUE;
696 dynobj = elf_hash_table (info)->dynobj;
697 if (dynobj == NULL)
698 return TRUE;
700 splt = bfd_get_section_by_name (dynobj, ".plt");
701 BFD_ASSERT (splt != NULL);
703 splt->contents = bfd_zalloc (dynobj, splt->size);
704 if (splt->contents == NULL)
705 return FALSE;
707 return TRUE;
710 /* Relocate an XSTORMY16 ELF section.
712 The RELOCATE_SECTION function is called by the new ELF backend linker
713 to handle the relocations for a section.
715 The relocs are always passed as Rela structures; if the section
716 actually uses Rel structures, the r_addend field will always be
717 zero.
719 This function is responsible for adjusting the section contents as
720 necessary, and (if using Rela relocs and generating a relocatable
721 output file) adjusting the reloc addend as necessary.
723 This function does not have to worry about setting the reloc
724 address or the reloc symbol index.
726 LOCAL_SYMS is a pointer to the swapped in local symbols.
728 LOCAL_SECTIONS is an array giving the section in the input file
729 corresponding to the st_shndx field of each local symbol.
731 The global hash table entry for the global symbols can be found
732 via elf_sym_hashes (input_bfd).
734 When generating relocatable output, this function must handle
735 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
736 going to be the section symbol corresponding to the output
737 section, which means that the addend must be adjusted
738 accordingly. */
740 static bfd_boolean
741 xstormy16_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
742 struct bfd_link_info * info,
743 bfd * input_bfd,
744 asection * input_section,
745 bfd_byte * contents,
746 Elf_Internal_Rela * relocs,
747 Elf_Internal_Sym * local_syms,
748 asection ** local_sections)
750 Elf_Internal_Shdr * symtab_hdr;
751 struct elf_link_hash_entry ** sym_hashes;
752 Elf_Internal_Rela * rel;
753 Elf_Internal_Rela * relend;
754 bfd *dynobj;
755 asection *splt;
757 if (info->relocatable)
758 return TRUE;
760 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
761 sym_hashes = elf_sym_hashes (input_bfd);
762 relend = relocs + input_section->reloc_count;
764 dynobj = elf_hash_table (info)->dynobj;
765 splt = NULL;
766 if (dynobj != NULL)
767 splt = bfd_get_section_by_name (dynobj, ".plt");
769 for (rel = relocs; rel < relend; rel ++)
771 reloc_howto_type * howto;
772 unsigned long r_symndx;
773 Elf_Internal_Sym * sym;
774 asection * sec;
775 struct elf_link_hash_entry * h;
776 bfd_vma relocation;
777 bfd_reloc_status_type r;
778 const char * name = NULL;
779 int r_type;
781 r_type = ELF32_R_TYPE (rel->r_info);
783 if ( r_type == R_XSTORMY16_GNU_VTINHERIT
784 || r_type == R_XSTORMY16_GNU_VTENTRY)
785 continue;
787 r_symndx = ELF32_R_SYM (rel->r_info);
788 howto = xstormy16_elf_howto_table + ELF32_R_TYPE (rel->r_info);
789 h = NULL;
790 sym = NULL;
791 sec = NULL;
793 if (r_symndx < symtab_hdr->sh_info)
795 sym = local_syms + r_symndx;
796 sec = local_sections [r_symndx];
797 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
799 else
801 bfd_boolean unresolved_reloc, warned;
803 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
804 r_symndx, symtab_hdr, sym_hashes,
805 h, sec, relocation,
806 unresolved_reloc, warned);
809 if (h != NULL)
810 name = h->root.root.string;
811 else
813 name = (bfd_elf_string_from_elf_section
814 (input_bfd, symtab_hdr->sh_link, sym->st_name));
815 if (name == NULL || *name == '\0')
816 name = bfd_section_name (input_bfd, sec);
819 switch (ELF32_R_TYPE (rel->r_info))
821 case R_XSTORMY16_24:
823 bfd_vma reloc = relocation + rel->r_addend;
824 unsigned int x;
826 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
827 x &= 0x0000ff00;
828 x |= reloc & 0xff;
829 x |= (reloc << 8) & 0xffff0000;
830 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
832 if (reloc & ~0xffffff)
833 r = bfd_reloc_overflow;
834 else
835 r = bfd_reloc_ok;
836 break;
839 case R_XSTORMY16_FPTR16:
841 bfd_vma *plt_offset;
843 if (h != NULL)
844 plt_offset = &h->plt.offset;
845 else
846 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
848 if (relocation <= 0xffff)
850 /* If the symbol is in range for a 16-bit address, we should
851 have deallocated the plt entry in relax_section. */
852 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
854 else
856 /* If the symbol is out of range for a 16-bit address,
857 we must have allocated a plt entry. */
858 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
860 /* If this is the first time we've processed this symbol,
861 fill in the plt entry with the correct symbol address. */
862 if ((*plt_offset & 1) == 0)
864 unsigned int x;
866 x = 0x00000200; /* jmpf */
867 x |= relocation & 0xff;
868 x |= (relocation << 8) & 0xffff0000;
869 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
870 *plt_offset |= 1;
873 relocation = (splt->output_section->vma
874 + splt->output_offset
875 + (*plt_offset & -2));
877 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
878 contents, rel->r_offset,
879 relocation, 0);
880 break;
883 default:
884 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
885 contents, rel->r_offset,
886 relocation, rel->r_addend);
887 break;
890 if (r != bfd_reloc_ok)
892 const char * msg = NULL;
894 switch (r)
896 case bfd_reloc_overflow:
897 r = info->callbacks->reloc_overflow
898 (info, (h ? &h->root : NULL), name, howto->name,
899 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
900 break;
902 case bfd_reloc_undefined:
903 r = info->callbacks->undefined_symbol
904 (info, name, input_bfd, input_section, rel->r_offset,
905 TRUE);
906 break;
908 case bfd_reloc_outofrange:
909 msg = _("internal error: out of range error");
910 break;
912 case bfd_reloc_notsupported:
913 msg = _("internal error: unsupported relocation error");
914 break;
916 case bfd_reloc_dangerous:
917 msg = _("internal error: dangerous relocation");
918 break;
920 default:
921 msg = _("internal error: unknown error");
922 break;
925 if (msg)
926 r = info->callbacks->warning
927 (info, msg, name, input_bfd, input_section, rel->r_offset);
929 if (! r)
930 return FALSE;
934 return TRUE;
937 /* This must exist if dynobj is ever set. */
939 static bfd_boolean
940 xstormy16_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
941 struct bfd_link_info *info)
943 bfd *dynobj;
944 asection *splt;
946 /* As an extra sanity check, verify that all plt entries have
947 been filled in. */
949 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
950 && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
952 bfd_byte *contents = splt->contents;
953 unsigned int i, size = splt->size;
955 for (i = 0; i < size; i += 4)
957 unsigned int x = bfd_get_32 (dynobj, contents + i);
959 BFD_ASSERT (x != 0);
963 return TRUE;
966 /* Return the section that should be marked against GC for a given
967 relocation. */
969 static asection *
970 xstormy16_elf_gc_mark_hook (asection * sec,
971 struct bfd_link_info * info ATTRIBUTE_UNUSED,
972 Elf_Internal_Rela * rel,
973 struct elf_link_hash_entry * h,
974 Elf_Internal_Sym * sym)
976 if (h != NULL)
978 switch (ELF32_R_TYPE (rel->r_info))
980 case R_XSTORMY16_GNU_VTINHERIT:
981 case R_XSTORMY16_GNU_VTENTRY:
982 break;
984 default:
985 switch (h->root.type)
987 case bfd_link_hash_defined:
988 case bfd_link_hash_defweak:
989 return h->root.u.def.section;
991 case bfd_link_hash_common:
992 return h->root.u.c.p->section;
994 default:
995 break;
999 else
1000 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1002 return NULL;
1005 /* Update the got entry reference counts for the section being removed. */
1007 static bfd_boolean
1008 xstormy16_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
1009 struct bfd_link_info * info ATTRIBUTE_UNUSED,
1010 asection * sec ATTRIBUTE_UNUSED,
1011 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
1013 return TRUE;
1016 #define ELF_ARCH bfd_arch_xstormy16
1017 #define ELF_MACHINE_CODE EM_XSTORMY16
1018 #define ELF_MAXPAGESIZE 0x100
1020 #define TARGET_LITTLE_SYM bfd_elf32_xstormy16_vec
1021 #define TARGET_LITTLE_NAME "elf32-xstormy16"
1023 #define elf_info_to_howto_rel NULL
1024 #define elf_info_to_howto xstormy16_info_to_howto_rela
1025 #define elf_backend_relocate_section xstormy16_elf_relocate_section
1026 #define elf_backend_gc_mark_hook xstormy16_elf_gc_mark_hook
1027 #define elf_backend_gc_sweep_hook xstormy16_elf_gc_sweep_hook
1028 #define elf_backend_check_relocs xstormy16_elf_check_relocs
1029 #define elf_backend_always_size_sections \
1030 xstormy16_elf_always_size_sections
1031 #define elf_backend_finish_dynamic_sections \
1032 xstormy16_elf_finish_dynamic_sections
1034 #define elf_backend_can_gc_sections 1
1035 #define elf_backend_rela_normal 1
1037 #define bfd_elf32_bfd_reloc_type_lookup xstormy16_reloc_type_lookup
1038 #define bfd_elf32_bfd_relax_section xstormy16_elf_relax_section
1040 #include "elf32-target.h"