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_ARCH_MASK
) == EF_M68K_M68000
)
434 else if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
437 switch (eflags
& EF_M68K_CPU32_MASK
)
439 case EF_M68K_CPU32_FIDO_A
:
440 features
|= fido_a
; break;
445 switch (eflags
& EF_M68K_CF_ISA_MASK
)
447 case EF_M68K_CF_ISA_A_NODIV
:
448 features
|= mcfisa_a
;
450 case EF_M68K_CF_ISA_A
:
451 features
|= mcfisa_a
|mcfhwdiv
;
453 case EF_M68K_CF_ISA_A_PLUS
:
454 features
|= mcfisa_a
|mcfisa_aa
|mcfhwdiv
|mcfusp
;
456 case EF_M68K_CF_ISA_B_NOUSP
:
457 features
|= mcfisa_a
|mcfisa_b
|mcfhwdiv
;
459 case EF_M68K_CF_ISA_B
:
460 features
|= mcfisa_a
|mcfisa_b
|mcfhwdiv
|mcfusp
;
463 switch (eflags
& EF_M68K_CF_MAC_MASK
)
468 case EF_M68K_CF_EMAC
:
472 if (eflags
& EF_M68K_CF_FLOAT
)
476 mach
= bfd_m68k_features_to_mach (features
);
477 bfd_default_set_arch_mach (abfd
, bfd_arch_m68k
, mach
);
482 /* Keep m68k-specific flags in the ELF header. */
484 elf32_m68k_set_private_flags (abfd
, flags
)
488 elf_elfheader (abfd
)->e_flags
= flags
;
489 elf_flags_init (abfd
) = TRUE
;
493 /* Merge backend specific data from an object file to the output
494 object file when linking. */
496 elf32_m68k_merge_private_bfd_data (ibfd
, obfd
)
504 const bfd_arch_info_type
*arch_info
;
506 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
507 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
510 /* Get the merged machine. This checks for incompatibility between
511 Coldfire & non-Coldfire flags, incompability between different
512 Coldfire ISAs, and incompability between different MAC types. */
513 arch_info
= bfd_arch_get_compatible (ibfd
, obfd
, FALSE
);
517 bfd_set_arch_mach (obfd
, bfd_arch_m68k
, arch_info
->mach
);
519 in_flags
= elf_elfheader (ibfd
)->e_flags
;
520 if (!elf_flags_init (obfd
))
522 elf_flags_init (obfd
) = TRUE
;
523 out_flags
= in_flags
;
527 out_flags
= elf_elfheader (obfd
)->e_flags
;
528 unsigned int variant_mask
;
530 if ((in_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
532 else if ((in_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
533 variant_mask
= EF_M68K_CPU32_MASK
;
535 variant_mask
= EF_M68K_CF_ISA_MASK
;
537 in_isa
= (in_flags
& variant_mask
);
538 out_isa
= (out_flags
& variant_mask
);
539 if (in_isa
> out_isa
)
540 out_flags
^= in_isa
^ out_isa
;
541 out_flags
|= in_flags
^ in_isa
;
543 elf_elfheader (obfd
)->e_flags
= out_flags
;
548 /* Display the flags field. */
550 elf32_m68k_print_private_bfd_data (abfd
, ptr
)
554 FILE *file
= (FILE *) ptr
;
555 flagword eflags
= elf_elfheader (abfd
)->e_flags
;
557 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
559 /* Print normal ELF private data. */
560 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
562 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
564 /* xgettext:c-format */
565 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
567 if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
568 fprintf (file
, " [m68000]");
569 else if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
571 fprintf (file
, " [cpu32]");
572 if (eflags
& EF_M68K_CPU32_FIDO_A
)
573 fprintf (file
, " [fido]");
577 if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_CFV4E
)
578 fprintf (file
, " [cfv4e]");
580 if (eflags
& EF_M68K_CF_ISA_MASK
)
582 char const *isa
= _("unknown");
583 char const *mac
= _("unknown");
584 char const *additional
= "";
586 switch (eflags
& EF_M68K_CF_ISA_MASK
)
588 case EF_M68K_CF_ISA_A_NODIV
:
590 additional
= " [nodiv]";
592 case EF_M68K_CF_ISA_A
:
595 case EF_M68K_CF_ISA_A_PLUS
:
598 case EF_M68K_CF_ISA_B_NOUSP
:
600 additional
= " [nousp]";
602 case EF_M68K_CF_ISA_B
:
606 fprintf (file
, " [isa %s]%s", isa
, additional
);
607 if (eflags
& EF_M68K_CF_FLOAT
)
608 fprintf (file
, " [float]");
609 switch (eflags
& EF_M68K_CF_MAC_MASK
)
617 case EF_M68K_CF_EMAC
:
622 fprintf (file
, " [%s]", mac
);
630 /* Look through the relocs for a section during the first phase, and
631 allocate space in the global offset table or procedure linkage
635 elf_m68k_check_relocs (abfd
, info
, sec
, relocs
)
637 struct bfd_link_info
*info
;
639 const Elf_Internal_Rela
*relocs
;
642 Elf_Internal_Shdr
*symtab_hdr
;
643 struct elf_link_hash_entry
**sym_hashes
;
644 bfd_signed_vma
*local_got_refcounts
;
645 const Elf_Internal_Rela
*rel
;
646 const Elf_Internal_Rela
*rel_end
;
651 if (info
->relocatable
)
654 dynobj
= elf_hash_table (info
)->dynobj
;
655 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
656 sym_hashes
= elf_sym_hashes (abfd
);
657 local_got_refcounts
= elf_local_got_refcounts (abfd
);
663 rel_end
= relocs
+ sec
->reloc_count
;
664 for (rel
= relocs
; rel
< rel_end
; rel
++)
666 unsigned long r_symndx
;
667 struct elf_link_hash_entry
*h
;
669 r_symndx
= ELF32_R_SYM (rel
->r_info
);
671 if (r_symndx
< symtab_hdr
->sh_info
)
675 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
676 while (h
->root
.type
== bfd_link_hash_indirect
677 || h
->root
.type
== bfd_link_hash_warning
)
678 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
681 switch (ELF32_R_TYPE (rel
->r_info
))
687 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
693 /* This symbol requires a global offset table entry. */
697 /* Create the .got section. */
698 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
699 if (!_bfd_elf_create_got_section (dynobj
, info
))
705 sgot
= bfd_get_section_by_name (dynobj
, ".got");
706 BFD_ASSERT (sgot
!= NULL
);
710 && (h
!= NULL
|| info
->shared
))
712 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
715 srelgot
= bfd_make_section_with_flags (dynobj
,
724 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
731 if (h
->got
.refcount
== 0)
733 /* Make sure this symbol is output as a dynamic symbol. */
737 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
741 /* Allocate space in the .got section. */
743 /* Allocate relocation space. */
744 srelgot
->size
+= sizeof (Elf32_External_Rela
);
750 /* This is a global offset table entry for a local symbol. */
751 if (local_got_refcounts
== NULL
)
755 size
= symtab_hdr
->sh_info
;
756 size
*= sizeof (bfd_signed_vma
);
757 local_got_refcounts
= ((bfd_signed_vma
*)
758 bfd_zalloc (abfd
, size
));
759 if (local_got_refcounts
== NULL
)
761 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
763 if (local_got_refcounts
[r_symndx
] == 0)
768 /* If we are generating a shared object, we need to
769 output a R_68K_RELATIVE reloc so that the dynamic
770 linker can adjust this GOT entry. */
771 srelgot
->size
+= sizeof (Elf32_External_Rela
);
774 local_got_refcounts
[r_symndx
]++;
781 /* This symbol requires a procedure linkage table entry. We
782 actually build the entry in adjust_dynamic_symbol,
783 because this might be a case of linking PIC code which is
784 never referenced by a dynamic object, in which case we
785 don't need to generate a procedure linkage table entry
788 /* If this is a local symbol, we resolve it directly without
789 creating a procedure linkage table entry. */
800 /* This symbol requires a procedure linkage table entry. */
804 /* It does not make sense to have this relocation for a
805 local symbol. FIXME: does it? How to handle it if
806 it does make sense? */
807 bfd_set_error (bfd_error_bad_value
);
811 /* Make sure this symbol is output as a dynamic symbol. */
815 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
826 /* If we are creating a shared library and this is not a local
827 symbol, we need to copy the reloc into the shared library.
828 However when linking with -Bsymbolic and this is a global
829 symbol which is defined in an object we are including in the
830 link (i.e., DEF_REGULAR is set), then we can resolve the
831 reloc directly. At this point we have not seen all the input
832 files, so it is possible that DEF_REGULAR is not set now but
833 will be set later (it is never cleared). We account for that
834 possibility below by storing information in the
835 pcrel_relocs_copied field of the hash table entry. */
837 && (sec
->flags
& SEC_ALLOC
) != 0
840 || h
->root
.type
== bfd_link_hash_defweak
841 || !h
->def_regular
)))
845 /* Make sure a plt entry is created for this symbol if
846 it turns out to be a function defined by a dynamic
858 /* Make sure a plt entry is created for this symbol if it
859 turns out to be a function defined by a dynamic object. */
863 /* If we are creating a shared library, we need to copy the
864 reloc into the shared library. */
866 && (sec
->flags
& SEC_ALLOC
) != 0)
868 /* When creating a shared object, we must copy these
869 reloc types into the output file. We create a reloc
870 section in dynobj and make room for this reloc. */
875 name
= (bfd_elf_string_from_elf_section
877 elf_elfheader (abfd
)->e_shstrndx
,
878 elf_section_data (sec
)->rel_hdr
.sh_name
));
882 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
883 && strcmp (bfd_get_section_name (abfd
, sec
),
886 sreloc
= bfd_get_section_by_name (dynobj
, name
);
889 sreloc
= bfd_make_section_with_flags (dynobj
,
898 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
901 elf_section_data (sec
)->sreloc
= sreloc
;
904 if (sec
->flags
& SEC_READONLY
905 /* Don't set DF_TEXTREL yet for PC relative
906 relocations, they might be discarded later. */
907 && !(ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
908 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
909 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
))
910 info
->flags
|= DF_TEXTREL
;
912 sreloc
->size
+= sizeof (Elf32_External_Rela
);
914 /* We count the number of PC relative relocations we have
915 entered for this symbol, so that we can discard them
916 again if, in the -Bsymbolic case, the symbol is later
917 defined by a regular object, or, in the normal shared
918 case, the symbol is forced to be local. Note that this
919 function is only called if we are using an m68kelf linker
920 hash table, which means that h is really a pointer to an
921 elf_m68k_link_hash_entry. */
922 if (ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
923 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
924 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
)
926 struct elf_m68k_pcrel_relocs_copied
*p
;
927 struct elf_m68k_pcrel_relocs_copied
**head
;
931 struct elf_m68k_link_hash_entry
*eh
932 = elf_m68k_hash_entry (h
);
933 head
= &eh
->pcrel_relocs_copied
;
940 s
= (bfd_section_from_r_symndx
941 (abfd
, &elf_m68k_hash_table (info
)->sym_sec
,
946 vpp
= &elf_section_data (s
)->local_dynrel
;
947 head
= (struct elf_m68k_pcrel_relocs_copied
**) vpp
;
950 for (p
= *head
; p
!= NULL
; p
= p
->next
)
951 if (p
->section
== sreloc
)
956 p
= ((struct elf_m68k_pcrel_relocs_copied
*)
957 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
972 /* This relocation describes the C++ object vtable hierarchy.
973 Reconstruct it for later use during GC. */
974 case R_68K_GNU_VTINHERIT
:
975 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
979 /* This relocation describes which C++ vtable entries are actually
980 used. Record for later use during GC. */
981 case R_68K_GNU_VTENTRY
:
982 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
994 /* Return the section that should be marked against GC for a given
998 elf_m68k_gc_mark_hook (asection
*sec
,
999 struct bfd_link_info
*info
,
1000 Elf_Internal_Rela
*rel
,
1001 struct elf_link_hash_entry
*h
,
1002 Elf_Internal_Sym
*sym
)
1005 switch (ELF32_R_TYPE (rel
->r_info
))
1007 case R_68K_GNU_VTINHERIT
:
1008 case R_68K_GNU_VTENTRY
:
1012 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1015 /* Update the got entry reference counts for the section being removed. */
1018 elf_m68k_gc_sweep_hook (bfd
*abfd
,
1019 struct bfd_link_info
*info
,
1021 const Elf_Internal_Rela
*relocs
)
1023 Elf_Internal_Shdr
*symtab_hdr
;
1024 struct elf_link_hash_entry
**sym_hashes
;
1025 bfd_signed_vma
*local_got_refcounts
;
1026 const Elf_Internal_Rela
*rel
, *relend
;
1031 dynobj
= elf_hash_table (info
)->dynobj
;
1035 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1036 sym_hashes
= elf_sym_hashes (abfd
);
1037 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1039 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1040 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1042 relend
= relocs
+ sec
->reloc_count
;
1043 for (rel
= relocs
; rel
< relend
; rel
++)
1045 unsigned long r_symndx
;
1046 struct elf_link_hash_entry
*h
= NULL
;
1048 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1049 if (r_symndx
>= symtab_hdr
->sh_info
)
1051 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1052 while (h
->root
.type
== bfd_link_hash_indirect
1053 || h
->root
.type
== bfd_link_hash_warning
)
1054 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1057 switch (ELF32_R_TYPE (rel
->r_info
))
1067 if (h
->got
.refcount
> 0)
1070 if (h
->got
.refcount
== 0)
1072 /* We don't need the .got entry any more. */
1074 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1078 else if (local_got_refcounts
!= NULL
)
1080 if (local_got_refcounts
[r_symndx
] > 0)
1082 --local_got_refcounts
[r_symndx
];
1083 if (local_got_refcounts
[r_symndx
] == 0)
1085 /* We don't need the .got entry any more. */
1088 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1108 if (h
->plt
.refcount
> 0)
1121 /* Return the type of PLT associated with OUTPUT_BFD. */
1123 static const struct elf_m68k_plt_info
*
1124 elf_m68k_get_plt_info (bfd
*output_bfd
)
1126 unsigned int features
;
1128 features
= bfd_m68k_mach_to_features (bfd_get_mach (output_bfd
));
1129 if (features
& cpu32
)
1130 return &elf_cpu32_plt_info
;
1131 if (features
& mcfisa_b
)
1132 return &elf_isab_plt_info
;
1133 return &elf_m68k_plt_info
;
1136 /* This function is called after all the input files have been read,
1137 and the input sections have been assigned to output sections.
1138 It's a convenient place to determine the PLT style. */
1141 elf_m68k_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1143 elf_m68k_hash_table (info
)->plt_info
= elf_m68k_get_plt_info (output_bfd
);
1147 /* Adjust a symbol defined by a dynamic object and referenced by a
1148 regular object. The current definition is in some section of the
1149 dynamic object, but we're not including those sections. We have to
1150 change the definition to something the rest of the link can
1154 elf_m68k_adjust_dynamic_symbol (info
, h
)
1155 struct bfd_link_info
*info
;
1156 struct elf_link_hash_entry
*h
;
1158 struct elf_m68k_link_hash_table
*htab
;
1161 unsigned int power_of_two
;
1163 htab
= elf_m68k_hash_table (info
);
1164 dynobj
= elf_hash_table (info
)->dynobj
;
1166 /* Make sure we know what is going on here. */
1167 BFD_ASSERT (dynobj
!= NULL
1169 || h
->u
.weakdef
!= NULL
1172 && !h
->def_regular
)));
1174 /* If this is a function, put it in the procedure linkage table. We
1175 will fill in the contents of the procedure linkage table later,
1176 when we know the address of the .got section. */
1177 if (h
->type
== STT_FUNC
1180 if ((h
->plt
.refcount
<= 0
1181 || SYMBOL_CALLS_LOCAL (info
, h
)
1182 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1183 && h
->root
.type
== bfd_link_hash_undefweak
))
1184 /* We must always create the plt entry if it was referenced
1185 by a PLTxxO relocation. In this case we already recorded
1186 it as a dynamic symbol. */
1187 && h
->dynindx
== -1)
1189 /* This case can occur if we saw a PLTxx reloc in an input
1190 file, but the symbol was never referred to by a dynamic
1191 object, or if all references were garbage collected. In
1192 such a case, we don't actually need to build a procedure
1193 linkage table, and we can just do a PCxx reloc instead. */
1194 h
->plt
.offset
= (bfd_vma
) -1;
1199 /* Make sure this symbol is output as a dynamic symbol. */
1200 if (h
->dynindx
== -1
1201 && !h
->forced_local
)
1203 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1207 s
= bfd_get_section_by_name (dynobj
, ".plt");
1208 BFD_ASSERT (s
!= NULL
);
1210 /* If this is the first .plt entry, make room for the special
1213 s
->size
= htab
->plt_info
->size
;
1215 /* If this symbol is not defined in a regular file, and we are
1216 not generating a shared library, then set the symbol to this
1217 location in the .plt. This is required to make function
1218 pointers compare as equal between the normal executable and
1219 the shared library. */
1223 h
->root
.u
.def
.section
= s
;
1224 h
->root
.u
.def
.value
= s
->size
;
1227 h
->plt
.offset
= s
->size
;
1229 /* Make room for this entry. */
1230 s
->size
+= htab
->plt_info
->size
;
1232 /* We also need to make an entry in the .got.plt section, which
1233 will be placed in the .got section by the linker script. */
1234 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
1235 BFD_ASSERT (s
!= NULL
);
1238 /* We also need to make an entry in the .rela.plt section. */
1239 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1240 BFD_ASSERT (s
!= NULL
);
1241 s
->size
+= sizeof (Elf32_External_Rela
);
1246 /* Reinitialize the plt offset now that it is not used as a reference
1248 h
->plt
.offset
= (bfd_vma
) -1;
1250 /* If this is a weak symbol, and there is a real definition, the
1251 processor independent code will have arranged for us to see the
1252 real definition first, and we can just use the same value. */
1253 if (h
->u
.weakdef
!= NULL
)
1255 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1256 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1257 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1258 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1262 /* This is a reference to a symbol defined by a dynamic object which
1263 is not a function. */
1265 /* If we are creating a shared library, we must presume that the
1266 only references to the symbol are via the global offset table.
1267 For such cases we need not do anything here; the relocations will
1268 be handled correctly by relocate_section. */
1274 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1275 h
->root
.root
.string
);
1279 /* We must allocate the symbol in our .dynbss section, which will
1280 become part of the .bss section of the executable. There will be
1281 an entry for this symbol in the .dynsym section. The dynamic
1282 object will contain position independent code, so all references
1283 from the dynamic object to this symbol will go through the global
1284 offset table. The dynamic linker will use the .dynsym entry to
1285 determine the address it must put in the global offset table, so
1286 both the dynamic object and the regular object will refer to the
1287 same memory location for the variable. */
1289 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1290 BFD_ASSERT (s
!= NULL
);
1292 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1293 copy the initial value out of the dynamic object and into the
1294 runtime process image. We need to remember the offset into the
1295 .rela.bss section we are going to use. */
1296 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1300 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
1301 BFD_ASSERT (srel
!= NULL
);
1302 srel
->size
+= sizeof (Elf32_External_Rela
);
1306 /* We need to figure out the alignment required for this symbol. I
1307 have no idea how ELF linkers handle this. */
1308 power_of_two
= bfd_log2 (h
->size
);
1309 if (power_of_two
> 3)
1312 /* Apply the required alignment. */
1313 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1314 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1316 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1320 /* Define the symbol as being at this point in the section. */
1321 h
->root
.u
.def
.section
= s
;
1322 h
->root
.u
.def
.value
= s
->size
;
1324 /* Increment the section size to make room for the symbol. */
1330 /* Set the sizes of the dynamic sections. */
1333 elf_m68k_size_dynamic_sections (output_bfd
, info
)
1334 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1335 struct bfd_link_info
*info
;
1342 dynobj
= elf_hash_table (info
)->dynobj
;
1343 BFD_ASSERT (dynobj
!= NULL
);
1345 if (elf_hash_table (info
)->dynamic_sections_created
)
1347 /* Set the contents of the .interp section to the interpreter. */
1348 if (info
->executable
)
1350 s
= bfd_get_section_by_name (dynobj
, ".interp");
1351 BFD_ASSERT (s
!= NULL
);
1352 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1353 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1358 /* We may have created entries in the .rela.got section.
1359 However, if we are not creating the dynamic sections, we will
1360 not actually use these entries. Reset the size of .rela.got,
1361 which will cause it to get stripped from the output file
1363 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1368 /* If this is a -Bsymbolic shared link, then we need to discard all
1369 PC relative relocs against symbols defined in a regular object.
1370 For the normal shared case we discard the PC relative relocs
1371 against symbols that have become local due to visibility changes.
1372 We allocated space for them in the check_relocs routine, but we
1373 will not fill them in in the relocate_section routine. */
1375 elf_link_hash_traverse (elf_hash_table (info
),
1376 elf_m68k_discard_copies
,
1379 /* The check_relocs and adjust_dynamic_symbol entry points have
1380 determined the sizes of the various dynamic sections. Allocate
1384 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1388 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1391 /* It's OK to base decisions on the section name, because none
1392 of the dynobj section names depend upon the input files. */
1393 name
= bfd_get_section_name (dynobj
, s
);
1395 if (strcmp (name
, ".plt") == 0)
1397 /* Remember whether there is a PLT. */
1400 else if (CONST_STRNEQ (name
, ".rela"))
1406 /* We use the reloc_count field as a counter if we need
1407 to copy relocs into the output file. */
1411 else if (! CONST_STRNEQ (name
, ".got")
1412 && strcmp (name
, ".dynbss") != 0)
1414 /* It's not one of our sections, so don't allocate space. */
1420 /* If we don't need this section, strip it from the
1421 output file. This is mostly to handle .rela.bss and
1422 .rela.plt. We must create both sections in
1423 create_dynamic_sections, because they must be created
1424 before the linker maps input sections to output
1425 sections. The linker does that before
1426 adjust_dynamic_symbol is called, and it is that
1427 function which decides whether anything needs to go
1428 into these sections. */
1429 s
->flags
|= SEC_EXCLUDE
;
1433 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1436 /* Allocate memory for the section contents. */
1437 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1438 Unused entries should be reclaimed before the section's contents
1439 are written out, but at the moment this does not happen. Thus in
1440 order to prevent writing out garbage, we initialise the section's
1441 contents to zero. */
1442 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1443 if (s
->contents
== NULL
)
1447 if (elf_hash_table (info
)->dynamic_sections_created
)
1449 /* Add some entries to the .dynamic section. We fill in the
1450 values later, in elf_m68k_finish_dynamic_sections, but we
1451 must add the entries now so that we get the correct size for
1452 the .dynamic section. The DT_DEBUG entry is filled in by the
1453 dynamic linker and used by the debugger. */
1454 #define add_dynamic_entry(TAG, VAL) \
1455 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1459 if (!add_dynamic_entry (DT_DEBUG
, 0))
1465 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1466 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1467 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1468 || !add_dynamic_entry (DT_JMPREL
, 0))
1474 if (!add_dynamic_entry (DT_RELA
, 0)
1475 || !add_dynamic_entry (DT_RELASZ
, 0)
1476 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1480 if ((info
->flags
& DF_TEXTREL
) != 0)
1482 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1486 #undef add_dynamic_entry
1491 /* This function is called via elf_link_hash_traverse if we are
1492 creating a shared object. In the -Bsymbolic case it discards the
1493 space allocated to copy PC relative relocs against symbols which
1494 are defined in regular objects. For the normal shared case, it
1495 discards space for pc-relative relocs that have become local due to
1496 symbol visibility changes. We allocated space for them in the
1497 check_relocs routine, but we won't fill them in in the
1498 relocate_section routine.
1500 We also check whether any of the remaining relocations apply
1501 against a readonly section, and set the DF_TEXTREL flag in this
1505 elf_m68k_discard_copies (h
, inf
)
1506 struct elf_link_hash_entry
*h
;
1509 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1510 struct elf_m68k_pcrel_relocs_copied
*s
;
1512 if (h
->root
.type
== bfd_link_hash_warning
)
1513 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1517 && !h
->forced_local
))
1519 if ((info
->flags
& DF_TEXTREL
) == 0)
1521 /* Look for relocations against read-only sections. */
1522 for (s
= elf_m68k_hash_entry (h
)->pcrel_relocs_copied
;
1525 if ((s
->section
->flags
& SEC_READONLY
) != 0)
1527 info
->flags
|= DF_TEXTREL
;
1535 for (s
= elf_m68k_hash_entry (h
)->pcrel_relocs_copied
;
1538 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
1543 /* Relocate an M68K ELF section. */
1546 elf_m68k_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1547 contents
, relocs
, local_syms
, local_sections
)
1549 struct bfd_link_info
*info
;
1551 asection
*input_section
;
1553 Elf_Internal_Rela
*relocs
;
1554 Elf_Internal_Sym
*local_syms
;
1555 asection
**local_sections
;
1558 Elf_Internal_Shdr
*symtab_hdr
;
1559 struct elf_link_hash_entry
**sym_hashes
;
1560 bfd_vma
*local_got_offsets
;
1564 Elf_Internal_Rela
*rel
;
1565 Elf_Internal_Rela
*relend
;
1567 if (info
->relocatable
)
1570 dynobj
= elf_hash_table (info
)->dynobj
;
1571 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1572 sym_hashes
= elf_sym_hashes (input_bfd
);
1573 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1580 relend
= relocs
+ input_section
->reloc_count
;
1581 for (; rel
< relend
; rel
++)
1584 reloc_howto_type
*howto
;
1585 unsigned long r_symndx
;
1586 struct elf_link_hash_entry
*h
;
1587 Elf_Internal_Sym
*sym
;
1590 bfd_boolean unresolved_reloc
;
1591 bfd_reloc_status_type r
;
1593 r_type
= ELF32_R_TYPE (rel
->r_info
);
1594 if (r_type
< 0 || r_type
>= (int) R_68K_max
)
1596 bfd_set_error (bfd_error_bad_value
);
1599 howto
= howto_table
+ r_type
;
1601 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1606 unresolved_reloc
= FALSE
;
1608 if (r_symndx
< symtab_hdr
->sh_info
)
1610 sym
= local_syms
+ r_symndx
;
1611 sec
= local_sections
[r_symndx
];
1612 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1618 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1619 r_symndx
, symtab_hdr
, sym_hashes
,
1621 unresolved_reloc
, warned
);
1629 /* Relocation is to the address of the entry for this symbol
1630 in the global offset table. */
1632 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1638 /* Relocation is the offset of the entry for this symbol in
1639 the global offset table. */
1646 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1647 BFD_ASSERT (sgot
!= NULL
);
1654 off
= h
->got
.offset
;
1655 BFD_ASSERT (off
!= (bfd_vma
) -1);
1657 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1658 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1665 /* This is actually a static link, or it is a
1666 -Bsymbolic link and the symbol is defined
1667 locally, or the symbol was forced to be local
1668 because of a version file.. We must initialize
1669 this entry in the global offset table. Since
1670 the offset must always be a multiple of 4, we
1671 use the least significant bit to record whether
1672 we have initialized it already.
1674 When doing a dynamic link, we create a .rela.got
1675 relocation entry to initialize the value. This
1676 is done in the finish_dynamic_symbol routine. */
1681 bfd_put_32 (output_bfd
, relocation
,
1682 sgot
->contents
+ off
);
1687 unresolved_reloc
= FALSE
;
1691 BFD_ASSERT (local_got_offsets
!= NULL
1692 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1694 off
= local_got_offsets
[r_symndx
];
1696 /* The offset must always be a multiple of 4. We use
1697 the least significant bit to record whether we have
1698 already generated the necessary reloc. */
1703 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1708 Elf_Internal_Rela outrel
;
1711 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1712 BFD_ASSERT (s
!= NULL
);
1714 outrel
.r_offset
= (sgot
->output_section
->vma
1715 + sgot
->output_offset
1717 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1718 outrel
.r_addend
= relocation
;
1720 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1721 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1724 local_got_offsets
[r_symndx
] |= 1;
1728 relocation
= sgot
->output_offset
+ off
;
1729 if (r_type
== R_68K_GOT8O
1730 || r_type
== R_68K_GOT16O
1731 || r_type
== R_68K_GOT32O
)
1733 /* This relocation does not use the addend. */
1737 relocation
+= sgot
->output_section
->vma
;
1744 /* Relocation is to the entry for this symbol in the
1745 procedure linkage table. */
1747 /* Resolve a PLTxx reloc against a local symbol directly,
1748 without using the procedure linkage table. */
1752 if (h
->plt
.offset
== (bfd_vma
) -1
1753 || !elf_hash_table (info
)->dynamic_sections_created
)
1755 /* We didn't make a PLT entry for this symbol. This
1756 happens when statically linking PIC code, or when
1757 using -Bsymbolic. */
1763 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1764 BFD_ASSERT (splt
!= NULL
);
1767 relocation
= (splt
->output_section
->vma
1768 + splt
->output_offset
1770 unresolved_reloc
= FALSE
;
1776 /* Relocation is the offset of the entry for this symbol in
1777 the procedure linkage table. */
1778 BFD_ASSERT (h
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1);
1782 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1783 BFD_ASSERT (splt
!= NULL
);
1786 relocation
= h
->plt
.offset
;
1787 unresolved_reloc
= FALSE
;
1789 /* This relocation does not use the addend. */
1799 && h
->forced_local
))
1807 && (input_section
->flags
& SEC_ALLOC
) != 0
1809 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1810 || h
->root
.type
!= bfd_link_hash_undefweak
)
1811 && ((r_type
!= R_68K_PC8
1812 && r_type
!= R_68K_PC16
1813 && r_type
!= R_68K_PC32
)
1817 || !h
->def_regular
))))
1819 Elf_Internal_Rela outrel
;
1821 bfd_boolean skip
, relocate
;
1823 /* When generating a shared object, these relocations
1824 are copied into the output file to be resolved at run
1831 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1833 if (outrel
.r_offset
== (bfd_vma
) -1)
1835 else if (outrel
.r_offset
== (bfd_vma
) -2)
1836 skip
= TRUE
, relocate
= TRUE
;
1837 outrel
.r_offset
+= (input_section
->output_section
->vma
1838 + input_section
->output_offset
);
1841 memset (&outrel
, 0, sizeof outrel
);
1844 && (r_type
== R_68K_PC8
1845 || r_type
== R_68K_PC16
1846 || r_type
== R_68K_PC32
1849 || !h
->def_regular
))
1851 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1852 outrel
.r_addend
= rel
->r_addend
;
1856 /* This symbol is local, or marked to become local. */
1857 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1859 if (r_type
== R_68K_32
)
1862 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1868 if (bfd_is_abs_section (sec
))
1870 else if (sec
== NULL
|| sec
->owner
== NULL
)
1872 bfd_set_error (bfd_error_bad_value
);
1879 /* We are turning this relocation into one
1880 against a section symbol. It would be
1881 proper to subtract the symbol's value,
1882 osec->vma, from the emitted reloc addend,
1883 but ld.so expects buggy relocs. */
1884 osec
= sec
->output_section
;
1885 indx
= elf_section_data (osec
)->dynindx
;
1888 struct elf_link_hash_table
*htab
;
1889 htab
= elf_hash_table (info
);
1890 osec
= htab
->text_index_section
;
1891 indx
= elf_section_data (osec
)->dynindx
;
1893 BFD_ASSERT (indx
!= 0);
1896 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1900 sreloc
= elf_section_data (input_section
)->sreloc
;
1904 loc
= sreloc
->contents
;
1905 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1906 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1908 /* This reloc will be computed at runtime, so there's no
1909 need to do anything now, except for R_68K_32
1910 relocations that have been turned into
1918 case R_68K_GNU_VTINHERIT
:
1919 case R_68K_GNU_VTENTRY
:
1920 /* These are no-ops in the end. */
1927 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1928 because such sections are not SEC_ALLOC and thus ld.so will
1929 not process them. */
1930 if (unresolved_reloc
1931 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
1934 (*_bfd_error_handler
)
1935 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1938 (long) rel
->r_offset
,
1940 h
->root
.root
.string
);
1944 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1945 contents
, rel
->r_offset
,
1946 relocation
, rel
->r_addend
);
1948 if (r
!= bfd_reloc_ok
)
1953 name
= h
->root
.root
.string
;
1956 name
= bfd_elf_string_from_elf_section (input_bfd
,
1957 symtab_hdr
->sh_link
,
1962 name
= bfd_section_name (input_bfd
, sec
);
1965 if (r
== bfd_reloc_overflow
)
1967 if (!(info
->callbacks
->reloc_overflow
1968 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1969 (bfd_vma
) 0, input_bfd
, input_section
,
1975 (*_bfd_error_handler
)
1976 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1977 input_bfd
, input_section
,
1978 (long) rel
->r_offset
, name
, (int) r
);
1987 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
1988 into section SEC. */
1991 elf_m68k_install_pc32 (asection
*sec
, bfd_vma offset
, bfd_vma value
)
1993 /* Make VALUE PC-relative. */
1994 value
-= sec
->output_section
->vma
+ offset
;
1996 /* Apply any in-place addend. */
1997 value
+= bfd_get_32 (sec
->owner
, sec
->contents
+ offset
);
1999 bfd_put_32 (sec
->owner
, value
, sec
->contents
+ offset
);
2002 /* Finish up dynamic symbol handling. We set the contents of various
2003 dynamic sections here. */
2006 elf_m68k_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2008 struct bfd_link_info
*info
;
2009 struct elf_link_hash_entry
*h
;
2010 Elf_Internal_Sym
*sym
;
2014 dynobj
= elf_hash_table (info
)->dynobj
;
2016 if (h
->plt
.offset
!= (bfd_vma
) -1)
2018 const struct elf_m68k_plt_info
*plt_info
;
2024 Elf_Internal_Rela rela
;
2027 /* This symbol has an entry in the procedure linkage table. Set
2030 BFD_ASSERT (h
->dynindx
!= -1);
2032 plt_info
= elf_m68k_hash_table (info
)->plt_info
;
2033 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2034 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2035 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2036 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
2038 /* Get the index in the procedure linkage table which
2039 corresponds to this symbol. This is the index of this symbol
2040 in all the symbols for which we are making plt entries. The
2041 first entry in the procedure linkage table is reserved. */
2042 plt_index
= (h
->plt
.offset
/ plt_info
->size
) - 1;
2044 /* Get the offset into the .got table of the entry that
2045 corresponds to this function. Each .got entry is 4 bytes.
2046 The first three are reserved. */
2047 got_offset
= (plt_index
+ 3) * 4;
2049 memcpy (splt
->contents
+ h
->plt
.offset
,
2050 plt_info
->symbol_entry
,
2053 elf_m68k_install_pc32 (splt
, h
->plt
.offset
+ plt_info
->symbol_relocs
.got
,
2054 (sgot
->output_section
->vma
2055 + sgot
->output_offset
2058 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
2061 + plt_info
->symbol_resolve_entry
+ 2);
2063 elf_m68k_install_pc32 (splt
, h
->plt
.offset
+ plt_info
->symbol_relocs
.plt
,
2064 splt
->output_section
->vma
);
2066 /* Fill in the entry in the global offset table. */
2067 bfd_put_32 (output_bfd
,
2068 (splt
->output_section
->vma
2069 + splt
->output_offset
2071 + plt_info
->symbol_resolve_entry
),
2072 sgot
->contents
+ got_offset
);
2074 /* Fill in the entry in the .rela.plt section. */
2075 rela
.r_offset
= (sgot
->output_section
->vma
2076 + sgot
->output_offset
2078 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_JMP_SLOT
);
2080 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
2081 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2083 if (!h
->def_regular
)
2085 /* Mark the symbol as undefined, rather than as defined in
2086 the .plt section. Leave the value alone. */
2087 sym
->st_shndx
= SHN_UNDEF
;
2091 if (h
->got
.offset
!= (bfd_vma
) -1)
2095 Elf_Internal_Rela rela
;
2098 /* This symbol has an entry in the global offset table. Set it
2101 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2102 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
2103 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2105 rela
.r_offset
= (sgot
->output_section
->vma
2106 + sgot
->output_offset
2107 + (h
->got
.offset
&~ (bfd_vma
) 1));
2109 /* If this is a -Bsymbolic link, and the symbol is defined
2110 locally, we just want to emit a RELATIVE reloc. Likewise if
2111 the symbol was forced to be local because of a version file.
2112 The entry in the global offset table will already have been
2113 initialized in the relocate_section function. */
2120 rela
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
2121 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
2123 + (h
->got
.offset
&~ (bfd_vma
) 1)));
2127 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2128 sgot
->contents
+ (h
->got
.offset
&~ (bfd_vma
) 1));
2129 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_GLOB_DAT
);
2133 loc
= srela
->contents
;
2134 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2135 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2141 Elf_Internal_Rela rela
;
2144 /* This symbol needs a copy reloc. Set it up. */
2146 BFD_ASSERT (h
->dynindx
!= -1
2147 && (h
->root
.type
== bfd_link_hash_defined
2148 || h
->root
.type
== bfd_link_hash_defweak
));
2150 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2152 BFD_ASSERT (s
!= NULL
);
2154 rela
.r_offset
= (h
->root
.u
.def
.value
2155 + h
->root
.u
.def
.section
->output_section
->vma
2156 + h
->root
.u
.def
.section
->output_offset
);
2157 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_COPY
);
2159 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2160 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2163 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2164 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2165 || h
== elf_hash_table (info
)->hgot
)
2166 sym
->st_shndx
= SHN_ABS
;
2171 /* Finish up the dynamic sections. */
2174 elf_m68k_finish_dynamic_sections (output_bfd
, info
)
2176 struct bfd_link_info
*info
;
2182 dynobj
= elf_hash_table (info
)->dynobj
;
2184 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2185 BFD_ASSERT (sgot
!= NULL
);
2186 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2188 if (elf_hash_table (info
)->dynamic_sections_created
)
2191 Elf32_External_Dyn
*dyncon
, *dynconend
;
2193 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2194 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2196 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2197 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2198 for (; dyncon
< dynconend
; dyncon
++)
2200 Elf_Internal_Dyn dyn
;
2204 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2217 s
= bfd_get_section_by_name (output_bfd
, name
);
2218 BFD_ASSERT (s
!= NULL
);
2219 dyn
.d_un
.d_ptr
= s
->vma
;
2220 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2224 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2225 BFD_ASSERT (s
!= NULL
);
2226 dyn
.d_un
.d_val
= s
->size
;
2227 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2231 /* The procedure linkage table relocs (DT_JMPREL) should
2232 not be included in the overall relocs (DT_RELA).
2233 Therefore, we override the DT_RELASZ entry here to
2234 make it not include the JMPREL relocs. Since the
2235 linker script arranges for .rela.plt to follow all
2236 other relocation sections, we don't have to worry
2237 about changing the DT_RELA entry. */
2238 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2240 dyn
.d_un
.d_val
-= s
->size
;
2241 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2246 /* Fill in the first entry in the procedure linkage table. */
2249 const struct elf_m68k_plt_info
*plt_info
;
2251 plt_info
= elf_m68k_hash_table (info
)->plt_info
;
2252 memcpy (splt
->contents
, plt_info
->plt0_entry
, plt_info
->size
);
2254 elf_m68k_install_pc32 (splt
, plt_info
->plt0_relocs
.got4
,
2255 (sgot
->output_section
->vma
2256 + sgot
->output_offset
2259 elf_m68k_install_pc32 (splt
, plt_info
->plt0_relocs
.got8
,
2260 (sgot
->output_section
->vma
2261 + sgot
->output_offset
2264 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2269 /* Fill in the first three entries in the global offset table. */
2273 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2275 bfd_put_32 (output_bfd
,
2276 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2278 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
2279 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
2282 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2287 /* Given a .data section and a .emreloc in-memory section, store
2288 relocation information into the .emreloc section which can be
2289 used at runtime to relocate the section. This is called by the
2290 linker when the --embedded-relocs switch is used. This is called
2291 after the add_symbols entry point has been called for all the
2292 objects, and before the final_link entry point is called. */
2295 bfd_m68k_elf32_create_embedded_relocs (abfd
, info
, datasec
, relsec
, errmsg
)
2297 struct bfd_link_info
*info
;
2302 Elf_Internal_Shdr
*symtab_hdr
;
2303 Elf_Internal_Sym
*isymbuf
= NULL
;
2304 Elf_Internal_Rela
*internal_relocs
= NULL
;
2305 Elf_Internal_Rela
*irel
, *irelend
;
2309 BFD_ASSERT (! info
->relocatable
);
2313 if (datasec
->reloc_count
== 0)
2316 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2318 /* Get a copy of the native relocations. */
2319 internal_relocs
= (_bfd_elf_link_read_relocs
2320 (abfd
, datasec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
2321 info
->keep_memory
));
2322 if (internal_relocs
== NULL
)
2325 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
2326 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2327 if (relsec
->contents
== NULL
)
2330 p
= relsec
->contents
;
2332 irelend
= internal_relocs
+ datasec
->reloc_count
;
2333 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
2335 asection
*targetsec
;
2337 /* We are going to write a four byte longword into the runtime
2338 reloc section. The longword will be the address in the data
2339 section which must be relocated. It is followed by the name
2340 of the target section NUL-padded or truncated to 8
2343 /* We can only relocate absolute longword relocs at run time. */
2344 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_68K_32
)
2346 *errmsg
= _("unsupported reloc type");
2347 bfd_set_error (bfd_error_bad_value
);
2351 /* Get the target section referred to by the reloc. */
2352 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2354 /* A local symbol. */
2355 Elf_Internal_Sym
*isym
;
2357 /* Read this BFD's local symbols if we haven't done so already. */
2358 if (isymbuf
== NULL
)
2360 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2361 if (isymbuf
== NULL
)
2362 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2363 symtab_hdr
->sh_info
, 0,
2365 if (isymbuf
== NULL
)
2369 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2370 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2375 struct elf_link_hash_entry
*h
;
2377 /* An external symbol. */
2378 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2379 h
= elf_sym_hashes (abfd
)[indx
];
2380 BFD_ASSERT (h
!= NULL
);
2381 if (h
->root
.type
== bfd_link_hash_defined
2382 || h
->root
.type
== bfd_link_hash_defweak
)
2383 targetsec
= h
->root
.u
.def
.section
;
2388 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2389 memset (p
+ 4, 0, 8);
2390 if (targetsec
!= NULL
)
2391 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
2394 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2396 if (internal_relocs
!= NULL
2397 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2398 free (internal_relocs
);
2402 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2404 if (internal_relocs
!= NULL
2405 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2406 free (internal_relocs
);
2410 static enum elf_reloc_type_class
2411 elf32_m68k_reloc_type_class (rela
)
2412 const Elf_Internal_Rela
*rela
;
2414 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2416 case R_68K_RELATIVE
:
2417 return reloc_class_relative
;
2418 case R_68K_JMP_SLOT
:
2419 return reloc_class_plt
;
2421 return reloc_class_copy
;
2423 return reloc_class_normal
;
2427 /* Return address for Ith PLT stub in section PLT, for relocation REL
2428 or (bfd_vma) -1 if it should not be included. */
2431 elf_m68k_plt_sym_val (bfd_vma i
, const asection
*plt
,
2432 const arelent
*rel ATTRIBUTE_UNUSED
)
2434 return plt
->vma
+ (i
+ 1) * elf_m68k_get_plt_info (plt
->owner
)->size
;
2437 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2438 #define TARGET_BIG_NAME "elf32-m68k"
2439 #define ELF_MACHINE_CODE EM_68K
2440 #define ELF_MAXPAGESIZE 0x2000
2441 #define elf_backend_create_dynamic_sections \
2442 _bfd_elf_create_dynamic_sections
2443 #define bfd_elf32_bfd_link_hash_table_create \
2444 elf_m68k_link_hash_table_create
2445 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2447 #define elf_backend_check_relocs elf_m68k_check_relocs
2448 #define elf_backend_always_size_sections \
2449 elf_m68k_always_size_sections
2450 #define elf_backend_adjust_dynamic_symbol \
2451 elf_m68k_adjust_dynamic_symbol
2452 #define elf_backend_size_dynamic_sections \
2453 elf_m68k_size_dynamic_sections
2454 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
2455 #define elf_backend_relocate_section elf_m68k_relocate_section
2456 #define elf_backend_finish_dynamic_symbol \
2457 elf_m68k_finish_dynamic_symbol
2458 #define elf_backend_finish_dynamic_sections \
2459 elf_m68k_finish_dynamic_sections
2460 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2461 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2462 #define bfd_elf32_bfd_merge_private_bfd_data \
2463 elf32_m68k_merge_private_bfd_data
2464 #define bfd_elf32_bfd_set_private_flags \
2465 elf32_m68k_set_private_flags
2466 #define bfd_elf32_bfd_print_private_bfd_data \
2467 elf32_m68k_print_private_bfd_data
2468 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2469 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2470 #define elf_backend_object_p elf32_m68k_object_p
2472 #define elf_backend_can_gc_sections 1
2473 #define elf_backend_can_refcount 1
2474 #define elf_backend_want_got_plt 1
2475 #define elf_backend_plt_readonly 1
2476 #define elf_backend_want_plt_sym 0
2477 #define elf_backend_got_header_size 12
2478 #define elf_backend_rela_normal 1
2480 #include "elf32-target.h"