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