1 /* Motorola 68k series support for 32-bit ELF
2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
27 #include "opcode/m68k.h"
29 static reloc_howto_type *reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31 static void rtype_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static struct bfd_hash_entry *elf_m68k_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35 static struct bfd_link_hash_table *elf_m68k_link_hash_table_create
37 static bfd_boolean elf_m68k_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
40 static bfd_boolean elf_m68k_adjust_dynamic_symbol
41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
42 static bfd_boolean elf_m68k_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44 static bfd_boolean elf_m68k_discard_copies
45 PARAMS ((struct elf_link_hash_entry *, PTR));
46 static bfd_boolean elf_m68k_relocate_section
47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
49 static bfd_boolean elf_m68k_finish_dynamic_symbol
50 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
52 static bfd_boolean elf_m68k_finish_dynamic_sections
53 PARAMS ((bfd *, struct bfd_link_info *));
55 static bfd_boolean elf32_m68k_set_private_flags
56 PARAMS ((bfd *, flagword));
57 static bfd_boolean elf32_m68k_merge_private_bfd_data
58 PARAMS ((bfd *, bfd *));
59 static bfd_boolean elf32_m68k_print_private_bfd_data
60 PARAMS ((bfd *, PTR));
61 static enum elf_reloc_type_class elf32_m68k_reloc_type_class
62 PARAMS ((const Elf_Internal_Rela *));
64 static reloc_howto_type howto_table[] = {
65 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE),
66 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE),
67 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE),
68 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE),
69 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE),
70 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE),
71 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE),
72 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE),
73 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE),
74 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE),
75 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE),
76 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE),
77 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE),
78 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE),
79 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE),
80 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE),
81 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE),
82 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE),
83 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE),
84 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE),
85 HOWTO(R_68K_GLOB_DAT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_GLOB_DAT", FALSE, 0, 0xffffffff,FALSE),
86 HOWTO(R_68K_JMP_SLOT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_JMP_SLOT", FALSE, 0, 0xffffffff,FALSE),
87 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE),
88 /* GNU extension to record C++ vtable hierarchy. */
89 HOWTO (R_68K_GNU_VTINHERIT, /* type */
91 2, /* size (0 = byte, 1 = short, 2 = long) */
93 FALSE, /* pc_relative */
95 complain_overflow_dont, /* complain_on_overflow */
96 NULL, /* special_function */
97 "R_68K_GNU_VTINHERIT", /* name */
98 FALSE, /* partial_inplace */
102 /* GNU extension to record C++ vtable member usage. */
103 HOWTO (R_68K_GNU_VTENTRY, /* type */
105 2, /* size (0 = byte, 1 = short, 2 = long) */
107 FALSE, /* pc_relative */
109 complain_overflow_dont, /* complain_on_overflow */
110 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
111 "R_68K_GNU_VTENTRY", /* name */
112 FALSE, /* partial_inplace */
119 rtype_to_howto (abfd, cache_ptr, dst)
120 bfd *abfd ATTRIBUTE_UNUSED;
122 Elf_Internal_Rela *dst;
124 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_68K_max);
125 cache_ptr->howto = &howto_table[ELF32_R_TYPE(dst->r_info)];
128 #define elf_info_to_howto rtype_to_howto
132 bfd_reloc_code_real_type bfd_val;
135 { BFD_RELOC_NONE, R_68K_NONE },
136 { BFD_RELOC_32, R_68K_32 },
137 { BFD_RELOC_16, R_68K_16 },
138 { BFD_RELOC_8, R_68K_8 },
139 { BFD_RELOC_32_PCREL, R_68K_PC32 },
140 { BFD_RELOC_16_PCREL, R_68K_PC16 },
141 { BFD_RELOC_8_PCREL, R_68K_PC8 },
142 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
143 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
144 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
145 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
146 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
147 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
148 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
149 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
150 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
151 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
152 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
153 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
154 { BFD_RELOC_NONE, R_68K_COPY },
155 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
156 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
157 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
158 { BFD_RELOC_CTOR, R_68K_32 },
159 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
160 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
163 static reloc_howto_type *
164 reloc_type_lookup (abfd, code)
165 bfd *abfd ATTRIBUTE_UNUSED;
166 bfd_reloc_code_real_type code;
169 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
171 if (reloc_map[i].bfd_val == code)
172 return &howto_table[reloc_map[i].elf_val];
177 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
178 #define ELF_ARCH bfd_arch_m68k
180 /* Functions for the m68k ELF linker. */
182 /* The name of the dynamic interpreter. This is put in the .interp
185 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
187 /* Describes one of the various PLT styles. */
189 struct elf_m68k_plt_info
191 /* The size of each PLT entry. */
194 /* The template for the first PLT entry. */
195 const bfd_byte *plt0_entry;
197 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
198 The comments by each member indicate the value that the relocation
201 unsigned int got4; /* .got + 4 */
202 unsigned int got8; /* .got + 8 */
205 /* The template for a symbol's PLT entry. */
206 const bfd_byte *symbol_entry;
208 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
209 The comments by each member indicate the value that the relocation
212 unsigned int got; /* the symbol's .got.plt entry */
213 unsigned int plt; /* .plt */
216 /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
217 The stub starts with "move.l #relocoffset,%d0". */
218 bfd_vma symbol_resolve_entry;
221 /* The size in bytes of an entry in the procedure linkage table. */
223 #define PLT_ENTRY_SIZE 20
225 /* The first entry in a procedure linkage table looks like this. See
226 the SVR4 ABI m68k supplement to see how this works. */
228 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
230 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
231 0, 0, 0, 2, /* + (.got + 4) - . */
232 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
233 0, 0, 0, 2, /* + (.got + 8) - . */
234 0, 0, 0, 0 /* pad out to 20 bytes. */
237 /* Subsequent entries in a procedure linkage table look like this. */
239 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
241 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
242 0, 0, 0, 2, /* + (.got.plt entry) - . */
243 0x2f, 0x3c, /* move.l #offset,-(%sp) */
244 0, 0, 0, 0, /* + reloc index */
245 0x60, 0xff, /* bra.l .plt */
246 0, 0, 0, 0 /* + .plt - . */
249 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
251 elf_m68k_plt0_entry, { 4, 12 },
252 elf_m68k_plt_entry, { 4, 16 }, 8
255 #define ISAB_PLT_ENTRY_SIZE 24
257 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
259 0x20, 0x3c, /* move.l #offset,%d0 */
260 0, 0, 0, 0, /* + (.got + 4) - . */
261 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
262 0x20, 0x3c, /* move.l #offset,%d0 */
263 0, 0, 0, 0, /* + (.got + 8) - . */
264 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
265 0x4e, 0xd0, /* jmp (%a0) */
269 /* Subsequent entries in a procedure linkage table look like this. */
271 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
273 0x20, 0x3c, /* move.l #offset,%d0 */
274 0, 0, 0, 0, /* + (.got.plt entry) - . */
275 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
276 0x4e, 0xd0, /* jmp (%a0) */
277 0x2f, 0x3c, /* move.l #offset,-(%sp) */
278 0, 0, 0, 0, /* + reloc index */
279 0x60, 0xff, /* bra.l .plt */
280 0, 0, 0, 0 /* + .plt - . */
283 static const struct elf_m68k_plt_info elf_isab_plt_info = {
285 elf_isab_plt0_entry, { 2, 12 },
286 elf_isab_plt_entry, { 2, 20 }, 12
289 #define CPU32_PLT_ENTRY_SIZE 24
290 /* Procedure linkage table entries for the cpu32 */
291 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
293 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
294 0, 0, 0, 2, /* + (.got + 4) - . */
295 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
296 0, 0, 0, 2, /* + (.got + 8) - . */
297 0x4e, 0xd1, /* jmp %a1@ */
298 0, 0, 0, 0, /* pad out to 24 bytes. */
302 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
304 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
305 0, 0, 0, 2, /* + (.got.plt entry) - . */
306 0x4e, 0xd1, /* jmp %a1@ */
307 0x2f, 0x3c, /* move.l #offset,-(%sp) */
308 0, 0, 0, 0, /* + reloc index */
309 0x60, 0xff, /* bra.l .plt */
310 0, 0, 0, 0, /* + .plt - . */
314 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
315 CPU32_PLT_ENTRY_SIZE,
316 elf_cpu32_plt0_entry, { 4, 12 },
317 elf_cpu32_plt_entry, { 4, 18 }, 10
320 /* The m68k linker needs to keep track of the number of relocs that it
321 decides to copy in check_relocs for each symbol. This is so that it
322 can discard PC relative relocs if it doesn't need them when linking
323 with -Bsymbolic. We store the information in a field extending the
324 regular ELF linker hash table. */
326 /* This structure keeps track of the number of PC relative relocs we have
327 copied for a given symbol. */
329 struct elf_m68k_pcrel_relocs_copied
332 struct elf_m68k_pcrel_relocs_copied *next;
333 /* A section in dynobj. */
335 /* Number of relocs copied in this section. */
339 /* m68k ELF linker hash entry. */
341 struct elf_m68k_link_hash_entry
343 struct elf_link_hash_entry root;
345 /* Number of PC relative relocs copied for this symbol. */
346 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
349 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
351 /* m68k ELF linker hash table. */
353 struct elf_m68k_link_hash_table
355 struct elf_link_hash_table root;
357 /* Small local sym to section mapping cache. */
358 struct sym_sec_cache sym_sec;
360 /* The PLT format used by this link, or NULL if the format has not
362 const struct elf_m68k_plt_info *plt_info;
365 /* Get the m68k ELF linker hash table from a link_info structure. */
367 #define elf_m68k_hash_table(p) \
368 ((struct elf_m68k_link_hash_table *) (p)->hash)
370 /* Create an entry in an m68k ELF linker hash table. */
372 static struct bfd_hash_entry *
373 elf_m68k_link_hash_newfunc (entry, table, string)
374 struct bfd_hash_entry *entry;
375 struct bfd_hash_table *table;
378 struct bfd_hash_entry *ret = entry;
380 /* Allocate the structure if it has not already been allocated by a
383 ret = bfd_hash_allocate (table,
384 sizeof (struct elf_m68k_link_hash_entry));
388 /* Call the allocation method of the superclass. */
389 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
391 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
396 /* Create an m68k ELF linker hash table. */
398 static struct bfd_link_hash_table *
399 elf_m68k_link_hash_table_create (abfd)
402 struct elf_m68k_link_hash_table *ret;
403 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
405 ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
406 if (ret == (struct elf_m68k_link_hash_table *) NULL)
409 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
410 elf_m68k_link_hash_newfunc,
411 sizeof (struct elf_m68k_link_hash_entry)))
417 ret->sym_sec.abfd = NULL;
418 ret->plt_info = NULL;
420 return &ret->root.root;
423 /* Set the right machine number. */
426 elf32_m68k_object_p (bfd *abfd)
428 unsigned int mach = 0;
429 unsigned features = 0;
430 flagword eflags = elf_elfheader (abfd)->e_flags;
432 if (eflags & EF_M68K_M68000)
434 else if (eflags & EF_M68K_CPU32)
436 else if (eflags & EF_M68K_ISA_MASK)
438 switch (eflags & EF_M68K_ISA_MASK)
440 case EF_M68K_ISA_A_NODIV:
441 features |= mcfisa_a;
444 features |= mcfisa_a|mcfhwdiv;
446 case EF_M68K_ISA_A_PLUS:
447 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
449 case EF_M68K_ISA_B_NOUSP:
450 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
453 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
456 switch (eflags & EF_M68K_MAC_MASK)
465 if (eflags & EF_M68K_FLOAT)
469 mach = bfd_m68k_features_to_mach (features);
470 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
475 /* Keep m68k-specific flags in the ELF header. */
477 elf32_m68k_set_private_flags (abfd, flags)
481 elf_elfheader (abfd)->e_flags = flags;
482 elf_flags_init (abfd) = TRUE;
486 /* Merge backend specific data from an object file to the output
487 object file when linking. */
489 elf32_m68k_merge_private_bfd_data (ibfd, obfd)
497 const bfd_arch_info_type *arch_info;
499 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
500 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
503 /* Get the merged machine. This checks for incompatibility between
504 Coldfire & non-Coldfire flags, incompability between different
505 Coldfire ISAs, and incompability between different MAC types. */
506 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
510 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
512 in_flags = elf_elfheader (ibfd)->e_flags;
513 if (!elf_flags_init (obfd))
515 elf_flags_init (obfd) = TRUE;
516 out_flags = in_flags;
520 out_flags = elf_elfheader (obfd)->e_flags;
521 in_isa = (in_flags & EF_M68K_ISA_MASK);
522 out_isa = (out_flags & EF_M68K_ISA_MASK);
523 if (in_isa > out_isa)
524 out_flags ^= in_isa ^ out_isa;
525 out_flags |= in_flags ^ in_isa;
527 elf_elfheader (obfd)->e_flags = out_flags;
532 /* Display the flags field. */
534 elf32_m68k_print_private_bfd_data (abfd, ptr)
538 FILE *file = (FILE *) ptr;
539 flagword eflags = elf_elfheader (abfd)->e_flags;
541 BFD_ASSERT (abfd != NULL && ptr != NULL);
543 /* Print normal ELF private data. */
544 _bfd_elf_print_private_bfd_data (abfd, ptr);
546 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
548 /* xgettext:c-format */
549 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
551 if (eflags & EF_M68K_CPU32)
552 fprintf (file, " [cpu32]");
554 if (eflags & EF_M68K_M68000)
555 fprintf (file, " [m68000]");
557 if (eflags & EF_M68K_CFV4E)
558 fprintf (file, " [cfv4e]");
560 if (eflags & EF_M68K_ISA_MASK)
562 char const *isa = _("unknown");
563 char const *mac = _("unknown");
564 char const *additional = "";
566 switch (eflags & EF_M68K_ISA_MASK)
568 case EF_M68K_ISA_A_NODIV:
570 additional = " [nodiv]";
575 case EF_M68K_ISA_A_PLUS:
578 case EF_M68K_ISA_B_NOUSP:
580 additional = " [nousp]";
586 fprintf (file, " [isa %s]%s", isa, additional);
587 if (eflags & EF_M68K_FLOAT)
588 fprintf (file, " [float]");
589 switch (eflags & EF_M68K_MAC_MASK)
602 fprintf (file, " [%s]", mac);
609 /* Look through the relocs for a section during the first phase, and
610 allocate space in the global offset table or procedure linkage
614 elf_m68k_check_relocs (abfd, info, sec, relocs)
616 struct bfd_link_info *info;
618 const Elf_Internal_Rela *relocs;
621 Elf_Internal_Shdr *symtab_hdr;
622 struct elf_link_hash_entry **sym_hashes;
623 bfd_signed_vma *local_got_refcounts;
624 const Elf_Internal_Rela *rel;
625 const Elf_Internal_Rela *rel_end;
630 if (info->relocatable)
633 dynobj = elf_hash_table (info)->dynobj;
634 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
635 sym_hashes = elf_sym_hashes (abfd);
636 local_got_refcounts = elf_local_got_refcounts (abfd);
642 rel_end = relocs + sec->reloc_count;
643 for (rel = relocs; rel < rel_end; rel++)
645 unsigned long r_symndx;
646 struct elf_link_hash_entry *h;
648 r_symndx = ELF32_R_SYM (rel->r_info);
650 if (r_symndx < symtab_hdr->sh_info)
654 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
655 while (h->root.type == bfd_link_hash_indirect
656 || h->root.type == bfd_link_hash_warning)
657 h = (struct elf_link_hash_entry *) h->root.u.i.link;
660 switch (ELF32_R_TYPE (rel->r_info))
666 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
672 /* This symbol requires a global offset table entry. */
676 /* Create the .got section. */
677 elf_hash_table (info)->dynobj = dynobj = abfd;
678 if (!_bfd_elf_create_got_section (dynobj, info))
684 sgot = bfd_get_section_by_name (dynobj, ".got");
685 BFD_ASSERT (sgot != NULL);
689 && (h != NULL || info->shared))
691 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
694 srelgot = bfd_make_section_with_flags (dynobj,
703 || !bfd_set_section_alignment (dynobj, srelgot, 2))
710 if (h->got.refcount == 0)
712 /* Make sure this symbol is output as a dynamic symbol. */
716 if (!bfd_elf_link_record_dynamic_symbol (info, h))
720 /* Allocate space in the .got section. */
722 /* Allocate relocation space. */
723 srelgot->size += sizeof (Elf32_External_Rela);
729 /* This is a global offset table entry for a local symbol. */
730 if (local_got_refcounts == NULL)
734 size = symtab_hdr->sh_info;
735 size *= sizeof (bfd_signed_vma);
736 local_got_refcounts = ((bfd_signed_vma *)
737 bfd_zalloc (abfd, size));
738 if (local_got_refcounts == NULL)
740 elf_local_got_refcounts (abfd) = local_got_refcounts;
742 if (local_got_refcounts[r_symndx] == 0)
747 /* If we are generating a shared object, we need to
748 output a R_68K_RELATIVE reloc so that the dynamic
749 linker can adjust this GOT entry. */
750 srelgot->size += sizeof (Elf32_External_Rela);
753 local_got_refcounts[r_symndx]++;
760 /* This symbol requires a procedure linkage table entry. We
761 actually build the entry in adjust_dynamic_symbol,
762 because this might be a case of linking PIC code which is
763 never referenced by a dynamic object, in which case we
764 don't need to generate a procedure linkage table entry
767 /* If this is a local symbol, we resolve it directly without
768 creating a procedure linkage table entry. */
779 /* This symbol requires a procedure linkage table entry. */
783 /* It does not make sense to have this relocation for a
784 local symbol. FIXME: does it? How to handle it if
785 it does make sense? */
786 bfd_set_error (bfd_error_bad_value);
790 /* Make sure this symbol is output as a dynamic symbol. */
794 if (!bfd_elf_link_record_dynamic_symbol (info, h))
805 /* If we are creating a shared library and this is not a local
806 symbol, we need to copy the reloc into the shared library.
807 However when linking with -Bsymbolic and this is a global
808 symbol which is defined in an object we are including in the
809 link (i.e., DEF_REGULAR is set), then we can resolve the
810 reloc directly. At this point we have not seen all the input
811 files, so it is possible that DEF_REGULAR is not set now but
812 will be set later (it is never cleared). We account for that
813 possibility below by storing information in the
814 pcrel_relocs_copied field of the hash table entry. */
816 && (sec->flags & SEC_ALLOC) != 0
819 || h->root.type == bfd_link_hash_defweak
820 || !h->def_regular)))
824 /* Make sure a plt entry is created for this symbol if
825 it turns out to be a function defined by a dynamic
837 /* Make sure a plt entry is created for this symbol if it
838 turns out to be a function defined by a dynamic object. */
842 /* If we are creating a shared library, we need to copy the
843 reloc into the shared library. */
845 && (sec->flags & SEC_ALLOC) != 0)
847 /* When creating a shared object, we must copy these
848 reloc types into the output file. We create a reloc
849 section in dynobj and make room for this reloc. */
854 name = (bfd_elf_string_from_elf_section
856 elf_elfheader (abfd)->e_shstrndx,
857 elf_section_data (sec)->rel_hdr.sh_name));
861 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
862 && strcmp (bfd_get_section_name (abfd, sec),
865 sreloc = bfd_get_section_by_name (dynobj, name);
868 sreloc = bfd_make_section_with_flags (dynobj,
877 || !bfd_set_section_alignment (dynobj, sreloc, 2))
880 elf_section_data (sec)->sreloc = sreloc;
883 if (sec->flags & SEC_READONLY
884 /* Don't set DF_TEXTREL yet for PC relative
885 relocations, they might be discarded later. */
886 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
887 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
888 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
889 info->flags |= DF_TEXTREL;
891 sreloc->size += sizeof (Elf32_External_Rela);
893 /* We count the number of PC relative relocations we have
894 entered for this symbol, so that we can discard them
895 again if, in the -Bsymbolic case, the symbol is later
896 defined by a regular object, or, in the normal shared
897 case, the symbol is forced to be local. Note that this
898 function is only called if we are using an m68kelf linker
899 hash table, which means that h is really a pointer to an
900 elf_m68k_link_hash_entry. */
901 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
902 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
903 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
905 struct elf_m68k_pcrel_relocs_copied *p;
906 struct elf_m68k_pcrel_relocs_copied **head;
910 struct elf_m68k_link_hash_entry *eh
911 = elf_m68k_hash_entry (h);
912 head = &eh->pcrel_relocs_copied;
919 s = (bfd_section_from_r_symndx
920 (abfd, &elf_m68k_hash_table (info)->sym_sec,
925 vpp = &elf_section_data (s)->local_dynrel;
926 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
929 for (p = *head; p != NULL; p = p->next)
930 if (p->section == sreloc)
935 p = ((struct elf_m68k_pcrel_relocs_copied *)
936 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
951 /* This relocation describes the C++ object vtable hierarchy.
952 Reconstruct it for later use during GC. */
953 case R_68K_GNU_VTINHERIT:
954 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
958 /* This relocation describes which C++ vtable entries are actually
959 used. Record for later use during GC. */
960 case R_68K_GNU_VTENTRY:
961 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
973 /* Return the section that should be marked against GC for a given
977 elf_m68k_gc_mark_hook (asection *sec,
978 struct bfd_link_info *info,
979 Elf_Internal_Rela *rel,
980 struct elf_link_hash_entry *h,
981 Elf_Internal_Sym *sym)
984 switch (ELF32_R_TYPE (rel->r_info))
986 case R_68K_GNU_VTINHERIT:
987 case R_68K_GNU_VTENTRY:
991 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
994 /* Update the got entry reference counts for the section being removed. */
997 elf_m68k_gc_sweep_hook (bfd *abfd,
998 struct bfd_link_info *info,
1000 const Elf_Internal_Rela *relocs)
1002 Elf_Internal_Shdr *symtab_hdr;
1003 struct elf_link_hash_entry **sym_hashes;
1004 bfd_signed_vma *local_got_refcounts;
1005 const Elf_Internal_Rela *rel, *relend;
1010 dynobj = elf_hash_table (info)->dynobj;
1014 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1015 sym_hashes = elf_sym_hashes (abfd);
1016 local_got_refcounts = elf_local_got_refcounts (abfd);
1018 sgot = bfd_get_section_by_name (dynobj, ".got");
1019 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1021 relend = relocs + sec->reloc_count;
1022 for (rel = relocs; rel < relend; rel++)
1024 unsigned long r_symndx;
1025 struct elf_link_hash_entry *h = NULL;
1027 r_symndx = ELF32_R_SYM (rel->r_info);
1028 if (r_symndx >= symtab_hdr->sh_info)
1030 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1031 while (h->root.type == bfd_link_hash_indirect
1032 || h->root.type == bfd_link_hash_warning)
1033 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1036 switch (ELF32_R_TYPE (rel->r_info))
1046 if (h->got.refcount > 0)
1049 if (h->got.refcount == 0)
1051 /* We don't need the .got entry any more. */
1053 srelgot->size -= sizeof (Elf32_External_Rela);
1057 else if (local_got_refcounts != NULL)
1059 if (local_got_refcounts[r_symndx] > 0)
1061 --local_got_refcounts[r_symndx];
1062 if (local_got_refcounts[r_symndx] == 0)
1064 /* We don't need the .got entry any more. */
1067 srelgot->size -= sizeof (Elf32_External_Rela);
1087 if (h->plt.refcount > 0)
1100 /* Return the type of PLT associated with OUTPUT_BFD. */
1102 static const struct elf_m68k_plt_info *
1103 elf_m68k_get_plt_info (bfd *output_bfd)
1105 unsigned int features;
1107 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
1108 if (features & cpu32)
1109 return &elf_cpu32_plt_info;
1110 if (features & mcfisa_b)
1111 return &elf_isab_plt_info;
1112 return &elf_m68k_plt_info;
1115 /* This function is called after all the input files have been read,
1116 and the input sections have been assigned to output sections.
1117 It's a convenient place to determine the PLT style. */
1120 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1122 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
1126 /* Adjust a symbol defined by a dynamic object and referenced by a
1127 regular object. The current definition is in some section of the
1128 dynamic object, but we're not including those sections. We have to
1129 change the definition to something the rest of the link can
1133 elf_m68k_adjust_dynamic_symbol (info, h)
1134 struct bfd_link_info *info;
1135 struct elf_link_hash_entry *h;
1137 struct elf_m68k_link_hash_table *htab;
1140 unsigned int power_of_two;
1142 htab = elf_m68k_hash_table (info);
1143 dynobj = elf_hash_table (info)->dynobj;
1145 /* Make sure we know what is going on here. */
1146 BFD_ASSERT (dynobj != NULL
1148 || h->u.weakdef != NULL
1151 && !h->def_regular)));
1153 /* If this is a function, put it in the procedure linkage table. We
1154 will fill in the contents of the procedure linkage table later,
1155 when we know the address of the .got section. */
1156 if (h->type == STT_FUNC
1159 if ((h->plt.refcount <= 0
1160 || SYMBOL_CALLS_LOCAL (info, h)
1161 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1162 && h->root.type == bfd_link_hash_undefweak))
1163 /* We must always create the plt entry if it was referenced
1164 by a PLTxxO relocation. In this case we already recorded
1165 it as a dynamic symbol. */
1166 && h->dynindx == -1)
1168 /* This case can occur if we saw a PLTxx reloc in an input
1169 file, but the symbol was never referred to by a dynamic
1170 object, or if all references were garbage collected. In
1171 such a case, we don't actually need to build a procedure
1172 linkage table, and we can just do a PCxx reloc instead. */
1173 h->plt.offset = (bfd_vma) -1;
1178 /* Make sure this symbol is output as a dynamic symbol. */
1179 if (h->dynindx == -1
1180 && !h->forced_local)
1182 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1186 s = bfd_get_section_by_name (dynobj, ".plt");
1187 BFD_ASSERT (s != NULL);
1189 /* If this is the first .plt entry, make room for the special
1192 s->size = htab->plt_info->size;
1194 /* If this symbol is not defined in a regular file, and we are
1195 not generating a shared library, then set the symbol to this
1196 location in the .plt. This is required to make function
1197 pointers compare as equal between the normal executable and
1198 the shared library. */
1202 h->root.u.def.section = s;
1203 h->root.u.def.value = s->size;
1206 h->plt.offset = s->size;
1208 /* Make room for this entry. */
1209 s->size += htab->plt_info->size;
1211 /* We also need to make an entry in the .got.plt section, which
1212 will be placed in the .got section by the linker script. */
1213 s = bfd_get_section_by_name (dynobj, ".got.plt");
1214 BFD_ASSERT (s != NULL);
1217 /* We also need to make an entry in the .rela.plt section. */
1218 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1219 BFD_ASSERT (s != NULL);
1220 s->size += sizeof (Elf32_External_Rela);
1225 /* Reinitialize the plt offset now that it is not used as a reference
1227 h->plt.offset = (bfd_vma) -1;
1229 /* If this is a weak symbol, and there is a real definition, the
1230 processor independent code will have arranged for us to see the
1231 real definition first, and we can just use the same value. */
1232 if (h->u.weakdef != NULL)
1234 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1235 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1236 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1237 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1241 /* This is a reference to a symbol defined by a dynamic object which
1242 is not a function. */
1244 /* If we are creating a shared library, we must presume that the
1245 only references to the symbol are via the global offset table.
1246 For such cases we need not do anything here; the relocations will
1247 be handled correctly by relocate_section. */
1253 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1254 h->root.root.string);
1258 /* We must allocate the symbol in our .dynbss section, which will
1259 become part of the .bss section of the executable. There will be
1260 an entry for this symbol in the .dynsym section. The dynamic
1261 object will contain position independent code, so all references
1262 from the dynamic object to this symbol will go through the global
1263 offset table. The dynamic linker will use the .dynsym entry to
1264 determine the address it must put in the global offset table, so
1265 both the dynamic object and the regular object will refer to the
1266 same memory location for the variable. */
1268 s = bfd_get_section_by_name (dynobj, ".dynbss");
1269 BFD_ASSERT (s != NULL);
1271 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1272 copy the initial value out of the dynamic object and into the
1273 runtime process image. We need to remember the offset into the
1274 .rela.bss section we are going to use. */
1275 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1279 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1280 BFD_ASSERT (srel != NULL);
1281 srel->size += sizeof (Elf32_External_Rela);
1285 /* We need to figure out the alignment required for this symbol. I
1286 have no idea how ELF linkers handle this. */
1287 power_of_two = bfd_log2 (h->size);
1288 if (power_of_two > 3)
1291 /* Apply the required alignment. */
1292 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1293 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1295 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1299 /* Define the symbol as being at this point in the section. */
1300 h->root.u.def.section = s;
1301 h->root.u.def.value = s->size;
1303 /* Increment the section size to make room for the symbol. */
1309 /* Set the sizes of the dynamic sections. */
1312 elf_m68k_size_dynamic_sections (output_bfd, info)
1313 bfd *output_bfd ATTRIBUTE_UNUSED;
1314 struct bfd_link_info *info;
1321 dynobj = elf_hash_table (info)->dynobj;
1322 BFD_ASSERT (dynobj != NULL);
1324 if (elf_hash_table (info)->dynamic_sections_created)
1326 /* Set the contents of the .interp section to the interpreter. */
1327 if (info->executable)
1329 s = bfd_get_section_by_name (dynobj, ".interp");
1330 BFD_ASSERT (s != NULL);
1331 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1332 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1337 /* We may have created entries in the .rela.got section.
1338 However, if we are not creating the dynamic sections, we will
1339 not actually use these entries. Reset the size of .rela.got,
1340 which will cause it to get stripped from the output file
1342 s = bfd_get_section_by_name (dynobj, ".rela.got");
1347 /* If this is a -Bsymbolic shared link, then we need to discard all
1348 PC relative relocs against symbols defined in a regular object.
1349 For the normal shared case we discard the PC relative relocs
1350 against symbols that have become local due to visibility changes.
1351 We allocated space for them in the check_relocs routine, but we
1352 will not fill them in in the relocate_section routine. */
1354 elf_link_hash_traverse (elf_hash_table (info),
1355 elf_m68k_discard_copies,
1358 /* The check_relocs and adjust_dynamic_symbol entry points have
1359 determined the sizes of the various dynamic sections. Allocate
1363 for (s = dynobj->sections; s != NULL; s = s->next)
1367 if ((s->flags & SEC_LINKER_CREATED) == 0)
1370 /* It's OK to base decisions on the section name, because none
1371 of the dynobj section names depend upon the input files. */
1372 name = bfd_get_section_name (dynobj, s);
1374 if (strcmp (name, ".plt") == 0)
1376 /* Remember whether there is a PLT. */
1379 else if (CONST_STRNEQ (name, ".rela"))
1385 /* We use the reloc_count field as a counter if we need
1386 to copy relocs into the output file. */
1390 else if (! CONST_STRNEQ (name, ".got")
1391 && strcmp (name, ".dynbss") != 0)
1393 /* It's not one of our sections, so don't allocate space. */
1399 /* If we don't need this section, strip it from the
1400 output file. This is mostly to handle .rela.bss and
1401 .rela.plt. We must create both sections in
1402 create_dynamic_sections, because they must be created
1403 before the linker maps input sections to output
1404 sections. The linker does that before
1405 adjust_dynamic_symbol is called, and it is that
1406 function which decides whether anything needs to go
1407 into these sections. */
1408 s->flags |= SEC_EXCLUDE;
1412 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1415 /* Allocate memory for the section contents. */
1416 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1417 Unused entries should be reclaimed before the section's contents
1418 are written out, but at the moment this does not happen. Thus in
1419 order to prevent writing out garbage, we initialise the section's
1420 contents to zero. */
1421 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1422 if (s->contents == NULL)
1426 if (elf_hash_table (info)->dynamic_sections_created)
1428 /* Add some entries to the .dynamic section. We fill in the
1429 values later, in elf_m68k_finish_dynamic_sections, but we
1430 must add the entries now so that we get the correct size for
1431 the .dynamic section. The DT_DEBUG entry is filled in by the
1432 dynamic linker and used by the debugger. */
1433 #define add_dynamic_entry(TAG, VAL) \
1434 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1438 if (!add_dynamic_entry (DT_DEBUG, 0))
1444 if (!add_dynamic_entry (DT_PLTGOT, 0)
1445 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1446 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1447 || !add_dynamic_entry (DT_JMPREL, 0))
1453 if (!add_dynamic_entry (DT_RELA, 0)
1454 || !add_dynamic_entry (DT_RELASZ, 0)
1455 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1459 if ((info->flags & DF_TEXTREL) != 0)
1461 if (!add_dynamic_entry (DT_TEXTREL, 0))
1465 #undef add_dynamic_entry
1470 /* This function is called via elf_link_hash_traverse if we are
1471 creating a shared object. In the -Bsymbolic case it discards the
1472 space allocated to copy PC relative relocs against symbols which
1473 are defined in regular objects. For the normal shared case, it
1474 discards space for pc-relative relocs that have become local due to
1475 symbol visibility changes. We allocated space for them in the
1476 check_relocs routine, but we won't fill them in in the
1477 relocate_section routine.
1479 We also check whether any of the remaining relocations apply
1480 against a readonly section, and set the DF_TEXTREL flag in this
1484 elf_m68k_discard_copies (h, inf)
1485 struct elf_link_hash_entry *h;
1488 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1489 struct elf_m68k_pcrel_relocs_copied *s;
1491 if (h->root.type == bfd_link_hash_warning)
1492 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1496 && !h->forced_local))
1498 if ((info->flags & DF_TEXTREL) == 0)
1500 /* Look for relocations against read-only sections. */
1501 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1504 if ((s->section->flags & SEC_READONLY) != 0)
1506 info->flags |= DF_TEXTREL;
1514 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1517 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1522 /* Relocate an M68K ELF section. */
1525 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1526 contents, relocs, local_syms, local_sections)
1528 struct bfd_link_info *info;
1530 asection *input_section;
1532 Elf_Internal_Rela *relocs;
1533 Elf_Internal_Sym *local_syms;
1534 asection **local_sections;
1537 Elf_Internal_Shdr *symtab_hdr;
1538 struct elf_link_hash_entry **sym_hashes;
1539 bfd_vma *local_got_offsets;
1543 Elf_Internal_Rela *rel;
1544 Elf_Internal_Rela *relend;
1546 if (info->relocatable)
1549 dynobj = elf_hash_table (info)->dynobj;
1550 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1551 sym_hashes = elf_sym_hashes (input_bfd);
1552 local_got_offsets = elf_local_got_offsets (input_bfd);
1559 relend = relocs + input_section->reloc_count;
1560 for (; rel < relend; rel++)
1563 reloc_howto_type *howto;
1564 unsigned long r_symndx;
1565 struct elf_link_hash_entry *h;
1566 Elf_Internal_Sym *sym;
1569 bfd_boolean unresolved_reloc;
1570 bfd_reloc_status_type r;
1572 r_type = ELF32_R_TYPE (rel->r_info);
1573 if (r_type < 0 || r_type >= (int) R_68K_max)
1575 bfd_set_error (bfd_error_bad_value);
1578 howto = howto_table + r_type;
1580 r_symndx = ELF32_R_SYM (rel->r_info);
1585 unresolved_reloc = FALSE;
1587 if (r_symndx < symtab_hdr->sh_info)
1589 sym = local_syms + r_symndx;
1590 sec = local_sections[r_symndx];
1591 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1597 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1598 r_symndx, symtab_hdr, sym_hashes,
1600 unresolved_reloc, warned);
1608 /* Relocation is to the address of the entry for this symbol
1609 in the global offset table. */
1611 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1617 /* Relocation is the offset of the entry for this symbol in
1618 the global offset table. */
1625 sgot = bfd_get_section_by_name (dynobj, ".got");
1626 BFD_ASSERT (sgot != NULL);
1633 off = h->got.offset;
1634 BFD_ASSERT (off != (bfd_vma) -1);
1636 dyn = elf_hash_table (info)->dynamic_sections_created;
1637 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1644 /* This is actually a static link, or it is a
1645 -Bsymbolic link and the symbol is defined
1646 locally, or the symbol was forced to be local
1647 because of a version file.. We must initialize
1648 this entry in the global offset table. Since
1649 the offset must always be a multiple of 4, we
1650 use the least significant bit to record whether
1651 we have initialized it already.
1653 When doing a dynamic link, we create a .rela.got
1654 relocation entry to initialize the value. This
1655 is done in the finish_dynamic_symbol routine. */
1660 bfd_put_32 (output_bfd, relocation,
1661 sgot->contents + off);
1666 unresolved_reloc = FALSE;
1670 BFD_ASSERT (local_got_offsets != NULL
1671 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1673 off = local_got_offsets[r_symndx];
1675 /* The offset must always be a multiple of 4. We use
1676 the least significant bit to record whether we have
1677 already generated the necessary reloc. */
1682 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1687 Elf_Internal_Rela outrel;
1690 s = bfd_get_section_by_name (dynobj, ".rela.got");
1691 BFD_ASSERT (s != NULL);
1693 outrel.r_offset = (sgot->output_section->vma
1694 + sgot->output_offset
1696 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1697 outrel.r_addend = relocation;
1699 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1700 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1703 local_got_offsets[r_symndx] |= 1;
1707 relocation = sgot->output_offset + off;
1708 if (r_type == R_68K_GOT8O
1709 || r_type == R_68K_GOT16O
1710 || r_type == R_68K_GOT32O)
1712 /* This relocation does not use the addend. */
1716 relocation += sgot->output_section->vma;
1723 /* Relocation is to the entry for this symbol in the
1724 procedure linkage table. */
1726 /* Resolve a PLTxx reloc against a local symbol directly,
1727 without using the procedure linkage table. */
1731 if (h->plt.offset == (bfd_vma) -1
1732 || !elf_hash_table (info)->dynamic_sections_created)
1734 /* We didn't make a PLT entry for this symbol. This
1735 happens when statically linking PIC code, or when
1736 using -Bsymbolic. */
1742 splt = bfd_get_section_by_name (dynobj, ".plt");
1743 BFD_ASSERT (splt != NULL);
1746 relocation = (splt->output_section->vma
1747 + splt->output_offset
1749 unresolved_reloc = FALSE;
1755 /* Relocation is the offset of the entry for this symbol in
1756 the procedure linkage table. */
1757 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1761 splt = bfd_get_section_by_name (dynobj, ".plt");
1762 BFD_ASSERT (splt != NULL);
1765 relocation = h->plt.offset;
1766 unresolved_reloc = FALSE;
1768 /* This relocation does not use the addend. */
1778 && h->forced_local))
1786 && (input_section->flags & SEC_ALLOC) != 0
1788 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1789 || h->root.type != bfd_link_hash_undefweak)
1790 && ((r_type != R_68K_PC8
1791 && r_type != R_68K_PC16
1792 && r_type != R_68K_PC32)
1796 || !h->def_regular))))
1798 Elf_Internal_Rela outrel;
1800 bfd_boolean skip, relocate;
1802 /* When generating a shared object, these relocations
1803 are copied into the output file to be resolved at run
1810 _bfd_elf_section_offset (output_bfd, info, input_section,
1812 if (outrel.r_offset == (bfd_vma) -1)
1814 else if (outrel.r_offset == (bfd_vma) -2)
1815 skip = TRUE, relocate = TRUE;
1816 outrel.r_offset += (input_section->output_section->vma
1817 + input_section->output_offset);
1820 memset (&outrel, 0, sizeof outrel);
1823 && (r_type == R_68K_PC8
1824 || r_type == R_68K_PC16
1825 || r_type == R_68K_PC32
1828 || !h->def_regular))
1830 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1831 outrel.r_addend = rel->r_addend;
1835 /* This symbol is local, or marked to become local. */
1836 if (r_type == R_68K_32)
1839 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1840 outrel.r_addend = relocation + rel->r_addend;
1846 if (bfd_is_abs_section (sec))
1848 else if (sec == NULL || sec->owner == NULL)
1850 bfd_set_error (bfd_error_bad_value);
1857 osec = sec->output_section;
1858 indx = elf_section_data (osec)->dynindx;
1859 BFD_ASSERT (indx > 0);
1862 outrel.r_info = ELF32_R_INFO (indx, r_type);
1863 outrel.r_addend = relocation + rel->r_addend;
1867 sreloc = elf_section_data (input_section)->sreloc;
1871 loc = sreloc->contents;
1872 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1873 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1875 /* This reloc will be computed at runtime, so there's no
1876 need to do anything now, except for R_68K_32
1877 relocations that have been turned into
1885 case R_68K_GNU_VTINHERIT:
1886 case R_68K_GNU_VTENTRY:
1887 /* These are no-ops in the end. */
1894 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1895 because such sections are not SEC_ALLOC and thus ld.so will
1896 not process them. */
1897 if (unresolved_reloc
1898 && !((input_section->flags & SEC_DEBUGGING) != 0
1901 (*_bfd_error_handler)
1902 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1905 (long) rel->r_offset,
1907 h->root.root.string);
1911 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1912 contents, rel->r_offset,
1913 relocation, rel->r_addend);
1915 if (r != bfd_reloc_ok)
1920 name = h->root.root.string;
1923 name = bfd_elf_string_from_elf_section (input_bfd,
1924 symtab_hdr->sh_link,
1929 name = bfd_section_name (input_bfd, sec);
1932 if (r == bfd_reloc_overflow)
1934 if (!(info->callbacks->reloc_overflow
1935 (info, (h ? &h->root : NULL), name, howto->name,
1936 (bfd_vma) 0, input_bfd, input_section,
1942 (*_bfd_error_handler)
1943 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1944 input_bfd, input_section,
1945 (long) rel->r_offset, name, (int) r);
1954 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
1955 into section SEC. */
1958 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
1960 /* Make VALUE PC-relative. */
1961 value -= sec->output_section->vma + offset;
1963 /* Apply any in-place addend. */
1964 value += bfd_get_32 (sec->owner, sec->contents + offset);
1966 bfd_put_32 (sec->owner, value, sec->contents + offset);
1969 /* Finish up dynamic symbol handling. We set the contents of various
1970 dynamic sections here. */
1973 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
1975 struct bfd_link_info *info;
1976 struct elf_link_hash_entry *h;
1977 Elf_Internal_Sym *sym;
1981 dynobj = elf_hash_table (info)->dynobj;
1983 if (h->plt.offset != (bfd_vma) -1)
1985 const struct elf_m68k_plt_info *plt_info;
1991 Elf_Internal_Rela rela;
1994 /* This symbol has an entry in the procedure linkage table. Set
1997 BFD_ASSERT (h->dynindx != -1);
1999 plt_info = elf_m68k_hash_table (info)->plt_info;
2000 splt = bfd_get_section_by_name (dynobj, ".plt");
2001 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2002 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2003 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2005 /* Get the index in the procedure linkage table which
2006 corresponds to this symbol. This is the index of this symbol
2007 in all the symbols for which we are making plt entries. The
2008 first entry in the procedure linkage table is reserved. */
2009 plt_index = (h->plt.offset / plt_info->size) - 1;
2011 /* Get the offset into the .got table of the entry that
2012 corresponds to this function. Each .got entry is 4 bytes.
2013 The first three are reserved. */
2014 got_offset = (plt_index + 3) * 4;
2016 memcpy (splt->contents + h->plt.offset,
2017 plt_info->symbol_entry,
2020 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2021 (sgot->output_section->vma
2022 + sgot->output_offset
2025 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2028 + plt_info->symbol_resolve_entry + 2);
2030 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2031 splt->output_section->vma);
2033 /* Fill in the entry in the global offset table. */
2034 bfd_put_32 (output_bfd,
2035 (splt->output_section->vma
2036 + splt->output_offset
2038 + plt_info->symbol_resolve_entry),
2039 sgot->contents + got_offset);
2041 /* Fill in the entry in the .rela.plt section. */
2042 rela.r_offset = (sgot->output_section->vma
2043 + sgot->output_offset
2045 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2047 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2048 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2050 if (!h->def_regular)
2052 /* Mark the symbol as undefined, rather than as defined in
2053 the .plt section. Leave the value alone. */
2054 sym->st_shndx = SHN_UNDEF;
2058 if (h->got.offset != (bfd_vma) -1)
2062 Elf_Internal_Rela rela;
2065 /* This symbol has an entry in the global offset table. Set it
2068 sgot = bfd_get_section_by_name (dynobj, ".got");
2069 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2070 BFD_ASSERT (sgot != NULL && srela != NULL);
2072 rela.r_offset = (sgot->output_section->vma
2073 + sgot->output_offset
2074 + (h->got.offset &~ (bfd_vma) 1));
2076 /* If this is a -Bsymbolic link, and the symbol is defined
2077 locally, we just want to emit a RELATIVE reloc. Likewise if
2078 the symbol was forced to be local because of a version file.
2079 The entry in the global offset table will already have been
2080 initialized in the relocate_section function. */
2087 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2088 rela.r_addend = bfd_get_signed_32 (output_bfd,
2090 + (h->got.offset &~ (bfd_vma) 1)));
2094 bfd_put_32 (output_bfd, (bfd_vma) 0,
2095 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2096 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2100 loc = srela->contents;
2101 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2102 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2108 Elf_Internal_Rela rela;
2111 /* This symbol needs a copy reloc. Set it up. */
2113 BFD_ASSERT (h->dynindx != -1
2114 && (h->root.type == bfd_link_hash_defined
2115 || h->root.type == bfd_link_hash_defweak));
2117 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2119 BFD_ASSERT (s != NULL);
2121 rela.r_offset = (h->root.u.def.value
2122 + h->root.u.def.section->output_section->vma
2123 + h->root.u.def.section->output_offset);
2124 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2126 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2127 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2130 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2131 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2132 || h == elf_hash_table (info)->hgot)
2133 sym->st_shndx = SHN_ABS;
2138 /* Finish up the dynamic sections. */
2141 elf_m68k_finish_dynamic_sections (output_bfd, info)
2143 struct bfd_link_info *info;
2149 dynobj = elf_hash_table (info)->dynobj;
2151 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2152 BFD_ASSERT (sgot != NULL);
2153 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2155 if (elf_hash_table (info)->dynamic_sections_created)
2158 Elf32_External_Dyn *dyncon, *dynconend;
2160 splt = bfd_get_section_by_name (dynobj, ".plt");
2161 BFD_ASSERT (splt != NULL && sdyn != NULL);
2163 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2164 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2165 for (; dyncon < dynconend; dyncon++)
2167 Elf_Internal_Dyn dyn;
2171 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2184 s = bfd_get_section_by_name (output_bfd, name);
2185 BFD_ASSERT (s != NULL);
2186 dyn.d_un.d_ptr = s->vma;
2187 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2191 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2192 BFD_ASSERT (s != NULL);
2193 dyn.d_un.d_val = s->size;
2194 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2198 /* The procedure linkage table relocs (DT_JMPREL) should
2199 not be included in the overall relocs (DT_RELA).
2200 Therefore, we override the DT_RELASZ entry here to
2201 make it not include the JMPREL relocs. Since the
2202 linker script arranges for .rela.plt to follow all
2203 other relocation sections, we don't have to worry
2204 about changing the DT_RELA entry. */
2205 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2207 dyn.d_un.d_val -= s->size;
2208 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2213 /* Fill in the first entry in the procedure linkage table. */
2216 const struct elf_m68k_plt_info *plt_info;
2218 plt_info = elf_m68k_hash_table (info)->plt_info;
2219 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2221 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2222 (sgot->output_section->vma
2223 + sgot->output_offset
2226 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2227 (sgot->output_section->vma
2228 + sgot->output_offset
2231 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2236 /* Fill in the first three entries in the global offset table. */
2240 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2242 bfd_put_32 (output_bfd,
2243 sdyn->output_section->vma + sdyn->output_offset,
2245 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2246 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2249 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2254 /* Given a .data section and a .emreloc in-memory section, store
2255 relocation information into the .emreloc section which can be
2256 used at runtime to relocate the section. This is called by the
2257 linker when the --embedded-relocs switch is used. This is called
2258 after the add_symbols entry point has been called for all the
2259 objects, and before the final_link entry point is called. */
2262 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2264 struct bfd_link_info *info;
2269 Elf_Internal_Shdr *symtab_hdr;
2270 Elf_Internal_Sym *isymbuf = NULL;
2271 Elf_Internal_Rela *internal_relocs = NULL;
2272 Elf_Internal_Rela *irel, *irelend;
2276 BFD_ASSERT (! info->relocatable);
2280 if (datasec->reloc_count == 0)
2283 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2285 /* Get a copy of the native relocations. */
2286 internal_relocs = (_bfd_elf_link_read_relocs
2287 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2288 info->keep_memory));
2289 if (internal_relocs == NULL)
2292 amt = (bfd_size_type) datasec->reloc_count * 12;
2293 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2294 if (relsec->contents == NULL)
2297 p = relsec->contents;
2299 irelend = internal_relocs + datasec->reloc_count;
2300 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2302 asection *targetsec;
2304 /* We are going to write a four byte longword into the runtime
2305 reloc section. The longword will be the address in the data
2306 section which must be relocated. It is followed by the name
2307 of the target section NUL-padded or truncated to 8
2310 /* We can only relocate absolute longword relocs at run time. */
2311 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2313 *errmsg = _("unsupported reloc type");
2314 bfd_set_error (bfd_error_bad_value);
2318 /* Get the target section referred to by the reloc. */
2319 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2321 /* A local symbol. */
2322 Elf_Internal_Sym *isym;
2324 /* Read this BFD's local symbols if we haven't done so already. */
2325 if (isymbuf == NULL)
2327 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2328 if (isymbuf == NULL)
2329 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2330 symtab_hdr->sh_info, 0,
2332 if (isymbuf == NULL)
2336 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2337 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2342 struct elf_link_hash_entry *h;
2344 /* An external symbol. */
2345 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2346 h = elf_sym_hashes (abfd)[indx];
2347 BFD_ASSERT (h != NULL);
2348 if (h->root.type == bfd_link_hash_defined
2349 || h->root.type == bfd_link_hash_defweak)
2350 targetsec = h->root.u.def.section;
2355 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2356 memset (p + 4, 0, 8);
2357 if (targetsec != NULL)
2358 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2361 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2363 if (internal_relocs != NULL
2364 && elf_section_data (datasec)->relocs != internal_relocs)
2365 free (internal_relocs);
2369 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2371 if (internal_relocs != NULL
2372 && elf_section_data (datasec)->relocs != internal_relocs)
2373 free (internal_relocs);
2377 static enum elf_reloc_type_class
2378 elf32_m68k_reloc_type_class (rela)
2379 const Elf_Internal_Rela *rela;
2381 switch ((int) ELF32_R_TYPE (rela->r_info))
2383 case R_68K_RELATIVE:
2384 return reloc_class_relative;
2385 case R_68K_JMP_SLOT:
2386 return reloc_class_plt;
2388 return reloc_class_copy;
2390 return reloc_class_normal;
2394 /* Return address for Ith PLT stub in section PLT, for relocation REL
2395 or (bfd_vma) -1 if it should not be included. */
2398 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2399 const arelent *rel ATTRIBUTE_UNUSED)
2401 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2404 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2405 #define TARGET_BIG_NAME "elf32-m68k"
2406 #define ELF_MACHINE_CODE EM_68K
2407 #define ELF_MAXPAGESIZE 0x2000
2408 #define elf_backend_create_dynamic_sections \
2409 _bfd_elf_create_dynamic_sections
2410 #define bfd_elf32_bfd_link_hash_table_create \
2411 elf_m68k_link_hash_table_create
2412 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2414 #define elf_backend_check_relocs elf_m68k_check_relocs
2415 #define elf_backend_always_size_sections \
2416 elf_m68k_always_size_sections
2417 #define elf_backend_adjust_dynamic_symbol \
2418 elf_m68k_adjust_dynamic_symbol
2419 #define elf_backend_size_dynamic_sections \
2420 elf_m68k_size_dynamic_sections
2421 #define elf_backend_relocate_section elf_m68k_relocate_section
2422 #define elf_backend_finish_dynamic_symbol \
2423 elf_m68k_finish_dynamic_symbol
2424 #define elf_backend_finish_dynamic_sections \
2425 elf_m68k_finish_dynamic_sections
2426 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2427 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2428 #define bfd_elf32_bfd_merge_private_bfd_data \
2429 elf32_m68k_merge_private_bfd_data
2430 #define bfd_elf32_bfd_set_private_flags \
2431 elf32_m68k_set_private_flags
2432 #define bfd_elf32_bfd_print_private_bfd_data \
2433 elf32_m68k_print_private_bfd_data
2434 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2435 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2436 #define elf_backend_object_p elf32_m68k_object_p
2438 #define elf_backend_can_gc_sections 1
2439 #define elf_backend_can_refcount 1
2440 #define elf_backend_want_got_plt 1
2441 #define elf_backend_plt_readonly 1
2442 #define elf_backend_want_plt_sym 0
2443 #define elf_backend_got_header_size 12
2444 #define elf_backend_rela_normal 1
2446 #include "elf32-target.h"