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
)
438 switch (eflags
& EF_M68K_CF_ISA_MASK
)
440 case EF_M68K_CF_ISA_A_NODIV
:
441 features
|= mcfisa_a
;
443 case EF_M68K_CF_ISA_A
:
444 features
|= mcfisa_a
|mcfhwdiv
;
446 case EF_M68K_CF_ISA_A_PLUS
:
447 features
|= mcfisa_a
|mcfisa_aa
|mcfhwdiv
|mcfusp
;
449 case EF_M68K_CF_ISA_B_NOUSP
:
450 features
|= mcfisa_a
|mcfisa_b
|mcfhwdiv
;
452 case EF_M68K_CF_ISA_B
:
453 features
|= mcfisa_a
|mcfisa_b
|mcfhwdiv
|mcfusp
;
456 switch (eflags
& EF_M68K_CF_MAC_MASK
)
461 case EF_M68K_CF_EMAC
:
465 if (eflags
& EF_M68K_CF_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 unsigned int variant_mask
;
523 if ((in_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
525 else if ((in_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
528 variant_mask
= EF_M68K_CF_ISA_MASK
;
530 in_isa
= (in_flags
& variant_mask
);
531 out_isa
= (out_flags
& variant_mask
);
532 if (in_isa
> out_isa
)
533 out_flags
^= in_isa
^ out_isa
;
534 out_flags
|= in_flags
^ in_isa
;
536 elf_elfheader (obfd
)->e_flags
= out_flags
;
541 /* Display the flags field. */
543 elf32_m68k_print_private_bfd_data (abfd
, ptr
)
547 FILE *file
= (FILE *) ptr
;
548 flagword eflags
= elf_elfheader (abfd
)->e_flags
;
550 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
552 /* Print normal ELF private data. */
553 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
555 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
557 /* xgettext:c-format */
558 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
560 if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
561 fprintf (file
, " [m68000]");
562 else if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
563 fprintf (file
, " [cpu32]");
566 if ((eflags
& EF_M68K_ARCH_MASK
) == EF_M68K_CFV4E
)
567 fprintf (file
, " [cfv4e]");
569 if (eflags
& EF_M68K_CF_ISA_MASK
)
571 char const *isa
= _("unknown");
572 char const *mac
= _("unknown");
573 char const *additional
= "";
575 switch (eflags
& EF_M68K_CF_ISA_MASK
)
577 case EF_M68K_CF_ISA_A_NODIV
:
579 additional
= " [nodiv]";
581 case EF_M68K_CF_ISA_A
:
584 case EF_M68K_CF_ISA_A_PLUS
:
587 case EF_M68K_CF_ISA_B_NOUSP
:
589 additional
= " [nousp]";
591 case EF_M68K_CF_ISA_B
:
595 fprintf (file
, " [isa %s]%s", isa
, additional
);
596 if (eflags
& EF_M68K_CF_FLOAT
)
597 fprintf (file
, " [float]");
598 switch (eflags
& EF_M68K_CF_MAC_MASK
)
606 case EF_M68K_CF_EMAC
:
611 fprintf (file
, " [%s]", mac
);
619 /* Look through the relocs for a section during the first phase, and
620 allocate space in the global offset table or procedure linkage
624 elf_m68k_check_relocs (abfd
, info
, sec
, relocs
)
626 struct bfd_link_info
*info
;
628 const Elf_Internal_Rela
*relocs
;
631 Elf_Internal_Shdr
*symtab_hdr
;
632 struct elf_link_hash_entry
**sym_hashes
;
633 bfd_signed_vma
*local_got_refcounts
;
634 const Elf_Internal_Rela
*rel
;
635 const Elf_Internal_Rela
*rel_end
;
640 if (info
->relocatable
)
643 dynobj
= elf_hash_table (info
)->dynobj
;
644 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
645 sym_hashes
= elf_sym_hashes (abfd
);
646 local_got_refcounts
= elf_local_got_refcounts (abfd
);
652 rel_end
= relocs
+ sec
->reloc_count
;
653 for (rel
= relocs
; rel
< rel_end
; rel
++)
655 unsigned long r_symndx
;
656 struct elf_link_hash_entry
*h
;
658 r_symndx
= ELF32_R_SYM (rel
->r_info
);
660 if (r_symndx
< symtab_hdr
->sh_info
)
664 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
665 while (h
->root
.type
== bfd_link_hash_indirect
666 || h
->root
.type
== bfd_link_hash_warning
)
667 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
670 switch (ELF32_R_TYPE (rel
->r_info
))
676 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
682 /* This symbol requires a global offset table entry. */
686 /* Create the .got section. */
687 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
688 if (!_bfd_elf_create_got_section (dynobj
, info
))
694 sgot
= bfd_get_section_by_name (dynobj
, ".got");
695 BFD_ASSERT (sgot
!= NULL
);
699 && (h
!= NULL
|| info
->shared
))
701 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
704 srelgot
= bfd_make_section_with_flags (dynobj
,
713 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
720 if (h
->got
.refcount
== 0)
722 /* Make sure this symbol is output as a dynamic symbol. */
726 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
730 /* Allocate space in the .got section. */
732 /* Allocate relocation space. */
733 srelgot
->size
+= sizeof (Elf32_External_Rela
);
739 /* This is a global offset table entry for a local symbol. */
740 if (local_got_refcounts
== NULL
)
744 size
= symtab_hdr
->sh_info
;
745 size
*= sizeof (bfd_signed_vma
);
746 local_got_refcounts
= ((bfd_signed_vma
*)
747 bfd_zalloc (abfd
, size
));
748 if (local_got_refcounts
== NULL
)
750 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
752 if (local_got_refcounts
[r_symndx
] == 0)
757 /* If we are generating a shared object, we need to
758 output a R_68K_RELATIVE reloc so that the dynamic
759 linker can adjust this GOT entry. */
760 srelgot
->size
+= sizeof (Elf32_External_Rela
);
763 local_got_refcounts
[r_symndx
]++;
770 /* This symbol requires a procedure linkage table entry. We
771 actually build the entry in adjust_dynamic_symbol,
772 because this might be a case of linking PIC code which is
773 never referenced by a dynamic object, in which case we
774 don't need to generate a procedure linkage table entry
777 /* If this is a local symbol, we resolve it directly without
778 creating a procedure linkage table entry. */
789 /* This symbol requires a procedure linkage table entry. */
793 /* It does not make sense to have this relocation for a
794 local symbol. FIXME: does it? How to handle it if
795 it does make sense? */
796 bfd_set_error (bfd_error_bad_value
);
800 /* Make sure this symbol is output as a dynamic symbol. */
804 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
815 /* If we are creating a shared library and this is not a local
816 symbol, we need to copy the reloc into the shared library.
817 However when linking with -Bsymbolic and this is a global
818 symbol which is defined in an object we are including in the
819 link (i.e., DEF_REGULAR is set), then we can resolve the
820 reloc directly. At this point we have not seen all the input
821 files, so it is possible that DEF_REGULAR is not set now but
822 will be set later (it is never cleared). We account for that
823 possibility below by storing information in the
824 pcrel_relocs_copied field of the hash table entry. */
826 && (sec
->flags
& SEC_ALLOC
) != 0
829 || h
->root
.type
== bfd_link_hash_defweak
830 || !h
->def_regular
)))
834 /* Make sure a plt entry is created for this symbol if
835 it turns out to be a function defined by a dynamic
847 /* Make sure a plt entry is created for this symbol if it
848 turns out to be a function defined by a dynamic object. */
852 /* If we are creating a shared library, we need to copy the
853 reloc into the shared library. */
855 && (sec
->flags
& SEC_ALLOC
) != 0)
857 /* When creating a shared object, we must copy these
858 reloc types into the output file. We create a reloc
859 section in dynobj and make room for this reloc. */
864 name
= (bfd_elf_string_from_elf_section
866 elf_elfheader (abfd
)->e_shstrndx
,
867 elf_section_data (sec
)->rel_hdr
.sh_name
));
871 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
872 && strcmp (bfd_get_section_name (abfd
, sec
),
875 sreloc
= bfd_get_section_by_name (dynobj
, name
);
878 sreloc
= bfd_make_section_with_flags (dynobj
,
887 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
890 elf_section_data (sec
)->sreloc
= sreloc
;
893 if (sec
->flags
& SEC_READONLY
894 /* Don't set DF_TEXTREL yet for PC relative
895 relocations, they might be discarded later. */
896 && !(ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
897 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
898 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
))
899 info
->flags
|= DF_TEXTREL
;
901 sreloc
->size
+= sizeof (Elf32_External_Rela
);
903 /* We count the number of PC relative relocations we have
904 entered for this symbol, so that we can discard them
905 again if, in the -Bsymbolic case, the symbol is later
906 defined by a regular object, or, in the normal shared
907 case, the symbol is forced to be local. Note that this
908 function is only called if we are using an m68kelf linker
909 hash table, which means that h is really a pointer to an
910 elf_m68k_link_hash_entry. */
911 if (ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
912 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
913 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
)
915 struct elf_m68k_pcrel_relocs_copied
*p
;
916 struct elf_m68k_pcrel_relocs_copied
**head
;
920 struct elf_m68k_link_hash_entry
*eh
921 = elf_m68k_hash_entry (h
);
922 head
= &eh
->pcrel_relocs_copied
;
929 s
= (bfd_section_from_r_symndx
930 (abfd
, &elf_m68k_hash_table (info
)->sym_sec
,
935 vpp
= &elf_section_data (s
)->local_dynrel
;
936 head
= (struct elf_m68k_pcrel_relocs_copied
**) vpp
;
939 for (p
= *head
; p
!= NULL
; p
= p
->next
)
940 if (p
->section
== sreloc
)
945 p
= ((struct elf_m68k_pcrel_relocs_copied
*)
946 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
961 /* This relocation describes the C++ object vtable hierarchy.
962 Reconstruct it for later use during GC. */
963 case R_68K_GNU_VTINHERIT
:
964 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
968 /* This relocation describes which C++ vtable entries are actually
969 used. Record for later use during GC. */
970 case R_68K_GNU_VTENTRY
:
971 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
983 /* Return the section that should be marked against GC for a given
987 elf_m68k_gc_mark_hook (asection
*sec
,
988 struct bfd_link_info
*info
,
989 Elf_Internal_Rela
*rel
,
990 struct elf_link_hash_entry
*h
,
991 Elf_Internal_Sym
*sym
)
994 switch (ELF32_R_TYPE (rel
->r_info
))
996 case R_68K_GNU_VTINHERIT
:
997 case R_68K_GNU_VTENTRY
:
1001 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1004 /* Update the got entry reference counts for the section being removed. */
1007 elf_m68k_gc_sweep_hook (bfd
*abfd
,
1008 struct bfd_link_info
*info
,
1010 const Elf_Internal_Rela
*relocs
)
1012 Elf_Internal_Shdr
*symtab_hdr
;
1013 struct elf_link_hash_entry
**sym_hashes
;
1014 bfd_signed_vma
*local_got_refcounts
;
1015 const Elf_Internal_Rela
*rel
, *relend
;
1020 dynobj
= elf_hash_table (info
)->dynobj
;
1024 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1025 sym_hashes
= elf_sym_hashes (abfd
);
1026 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1028 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1029 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1031 relend
= relocs
+ sec
->reloc_count
;
1032 for (rel
= relocs
; rel
< relend
; rel
++)
1034 unsigned long r_symndx
;
1035 struct elf_link_hash_entry
*h
= NULL
;
1037 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1038 if (r_symndx
>= symtab_hdr
->sh_info
)
1040 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1041 while (h
->root
.type
== bfd_link_hash_indirect
1042 || h
->root
.type
== bfd_link_hash_warning
)
1043 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1046 switch (ELF32_R_TYPE (rel
->r_info
))
1056 if (h
->got
.refcount
> 0)
1059 if (h
->got
.refcount
== 0)
1061 /* We don't need the .got entry any more. */
1063 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1067 else if (local_got_refcounts
!= NULL
)
1069 if (local_got_refcounts
[r_symndx
] > 0)
1071 --local_got_refcounts
[r_symndx
];
1072 if (local_got_refcounts
[r_symndx
] == 0)
1074 /* We don't need the .got entry any more. */
1077 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1097 if (h
->plt
.refcount
> 0)
1110 /* Return the type of PLT associated with OUTPUT_BFD. */
1112 static const struct elf_m68k_plt_info
*
1113 elf_m68k_get_plt_info (bfd
*output_bfd
)
1115 unsigned int features
;
1117 features
= bfd_m68k_mach_to_features (bfd_get_mach (output_bfd
));
1118 if (features
& cpu32
)
1119 return &elf_cpu32_plt_info
;
1120 if (features
& mcfisa_b
)
1121 return &elf_isab_plt_info
;
1122 return &elf_m68k_plt_info
;
1125 /* This function is called after all the input files have been read,
1126 and the input sections have been assigned to output sections.
1127 It's a convenient place to determine the PLT style. */
1130 elf_m68k_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1132 elf_m68k_hash_table (info
)->plt_info
= elf_m68k_get_plt_info (output_bfd
);
1136 /* Adjust a symbol defined by a dynamic object and referenced by a
1137 regular object. The current definition is in some section of the
1138 dynamic object, but we're not including those sections. We have to
1139 change the definition to something the rest of the link can
1143 elf_m68k_adjust_dynamic_symbol (info
, h
)
1144 struct bfd_link_info
*info
;
1145 struct elf_link_hash_entry
*h
;
1147 struct elf_m68k_link_hash_table
*htab
;
1150 unsigned int power_of_two
;
1152 htab
= elf_m68k_hash_table (info
);
1153 dynobj
= elf_hash_table (info
)->dynobj
;
1155 /* Make sure we know what is going on here. */
1156 BFD_ASSERT (dynobj
!= NULL
1158 || h
->u
.weakdef
!= NULL
1161 && !h
->def_regular
)));
1163 /* If this is a function, put it in the procedure linkage table. We
1164 will fill in the contents of the procedure linkage table later,
1165 when we know the address of the .got section. */
1166 if (h
->type
== STT_FUNC
1169 if ((h
->plt
.refcount
<= 0
1170 || SYMBOL_CALLS_LOCAL (info
, h
)
1171 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1172 && h
->root
.type
== bfd_link_hash_undefweak
))
1173 /* We must always create the plt entry if it was referenced
1174 by a PLTxxO relocation. In this case we already recorded
1175 it as a dynamic symbol. */
1176 && h
->dynindx
== -1)
1178 /* This case can occur if we saw a PLTxx reloc in an input
1179 file, but the symbol was never referred to by a dynamic
1180 object, or if all references were garbage collected. In
1181 such a case, we don't actually need to build a procedure
1182 linkage table, and we can just do a PCxx reloc instead. */
1183 h
->plt
.offset
= (bfd_vma
) -1;
1188 /* Make sure this symbol is output as a dynamic symbol. */
1189 if (h
->dynindx
== -1
1190 && !h
->forced_local
)
1192 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1196 s
= bfd_get_section_by_name (dynobj
, ".plt");
1197 BFD_ASSERT (s
!= NULL
);
1199 /* If this is the first .plt entry, make room for the special
1202 s
->size
= htab
->plt_info
->size
;
1204 /* If this symbol is not defined in a regular file, and we are
1205 not generating a shared library, then set the symbol to this
1206 location in the .plt. This is required to make function
1207 pointers compare as equal between the normal executable and
1208 the shared library. */
1212 h
->root
.u
.def
.section
= s
;
1213 h
->root
.u
.def
.value
= s
->size
;
1216 h
->plt
.offset
= s
->size
;
1218 /* Make room for this entry. */
1219 s
->size
+= htab
->plt_info
->size
;
1221 /* We also need to make an entry in the .got.plt section, which
1222 will be placed in the .got section by the linker script. */
1223 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
1224 BFD_ASSERT (s
!= NULL
);
1227 /* We also need to make an entry in the .rela.plt section. */
1228 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1229 BFD_ASSERT (s
!= NULL
);
1230 s
->size
+= sizeof (Elf32_External_Rela
);
1235 /* Reinitialize the plt offset now that it is not used as a reference
1237 h
->plt
.offset
= (bfd_vma
) -1;
1239 /* If this is a weak symbol, and there is a real definition, the
1240 processor independent code will have arranged for us to see the
1241 real definition first, and we can just use the same value. */
1242 if (h
->u
.weakdef
!= NULL
)
1244 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1245 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1246 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1247 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1251 /* This is a reference to a symbol defined by a dynamic object which
1252 is not a function. */
1254 /* If we are creating a shared library, we must presume that the
1255 only references to the symbol are via the global offset table.
1256 For such cases we need not do anything here; the relocations will
1257 be handled correctly by relocate_section. */
1263 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1264 h
->root
.root
.string
);
1268 /* We must allocate the symbol in our .dynbss section, which will
1269 become part of the .bss section of the executable. There will be
1270 an entry for this symbol in the .dynsym section. The dynamic
1271 object will contain position independent code, so all references
1272 from the dynamic object to this symbol will go through the global
1273 offset table. The dynamic linker will use the .dynsym entry to
1274 determine the address it must put in the global offset table, so
1275 both the dynamic object and the regular object will refer to the
1276 same memory location for the variable. */
1278 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1279 BFD_ASSERT (s
!= NULL
);
1281 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1282 copy the initial value out of the dynamic object and into the
1283 runtime process image. We need to remember the offset into the
1284 .rela.bss section we are going to use. */
1285 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1289 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
1290 BFD_ASSERT (srel
!= NULL
);
1291 srel
->size
+= sizeof (Elf32_External_Rela
);
1295 /* We need to figure out the alignment required for this symbol. I
1296 have no idea how ELF linkers handle this. */
1297 power_of_two
= bfd_log2 (h
->size
);
1298 if (power_of_two
> 3)
1301 /* Apply the required alignment. */
1302 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1303 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1305 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1309 /* Define the symbol as being at this point in the section. */
1310 h
->root
.u
.def
.section
= s
;
1311 h
->root
.u
.def
.value
= s
->size
;
1313 /* Increment the section size to make room for the symbol. */
1319 /* Set the sizes of the dynamic sections. */
1322 elf_m68k_size_dynamic_sections (output_bfd
, info
)
1323 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1324 struct bfd_link_info
*info
;
1331 dynobj
= elf_hash_table (info
)->dynobj
;
1332 BFD_ASSERT (dynobj
!= NULL
);
1334 if (elf_hash_table (info
)->dynamic_sections_created
)
1336 /* Set the contents of the .interp section to the interpreter. */
1337 if (info
->executable
)
1339 s
= bfd_get_section_by_name (dynobj
, ".interp");
1340 BFD_ASSERT (s
!= NULL
);
1341 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1342 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1347 /* We may have created entries in the .rela.got section.
1348 However, if we are not creating the dynamic sections, we will
1349 not actually use these entries. Reset the size of .rela.got,
1350 which will cause it to get stripped from the output file
1352 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1357 /* If this is a -Bsymbolic shared link, then we need to discard all
1358 PC relative relocs against symbols defined in a regular object.
1359 For the normal shared case we discard the PC relative relocs
1360 against symbols that have become local due to visibility changes.
1361 We allocated space for them in the check_relocs routine, but we
1362 will not fill them in in the relocate_section routine. */
1364 elf_link_hash_traverse (elf_hash_table (info
),
1365 elf_m68k_discard_copies
,
1368 /* The check_relocs and adjust_dynamic_symbol entry points have
1369 determined the sizes of the various dynamic sections. Allocate
1373 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1377 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1380 /* It's OK to base decisions on the section name, because none
1381 of the dynobj section names depend upon the input files. */
1382 name
= bfd_get_section_name (dynobj
, s
);
1384 if (strcmp (name
, ".plt") == 0)
1386 /* Remember whether there is a PLT. */
1389 else if (CONST_STRNEQ (name
, ".rela"))
1395 /* We use the reloc_count field as a counter if we need
1396 to copy relocs into the output file. */
1400 else if (! CONST_STRNEQ (name
, ".got")
1401 && strcmp (name
, ".dynbss") != 0)
1403 /* It's not one of our sections, so don't allocate space. */
1409 /* If we don't need this section, strip it from the
1410 output file. This is mostly to handle .rela.bss and
1411 .rela.plt. We must create both sections in
1412 create_dynamic_sections, because they must be created
1413 before the linker maps input sections to output
1414 sections. The linker does that before
1415 adjust_dynamic_symbol is called, and it is that
1416 function which decides whether anything needs to go
1417 into these sections. */
1418 s
->flags
|= SEC_EXCLUDE
;
1422 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1425 /* Allocate memory for the section contents. */
1426 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1427 Unused entries should be reclaimed before the section's contents
1428 are written out, but at the moment this does not happen. Thus in
1429 order to prevent writing out garbage, we initialise the section's
1430 contents to zero. */
1431 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1432 if (s
->contents
== NULL
)
1436 if (elf_hash_table (info
)->dynamic_sections_created
)
1438 /* Add some entries to the .dynamic section. We fill in the
1439 values later, in elf_m68k_finish_dynamic_sections, but we
1440 must add the entries now so that we get the correct size for
1441 the .dynamic section. The DT_DEBUG entry is filled in by the
1442 dynamic linker and used by the debugger. */
1443 #define add_dynamic_entry(TAG, VAL) \
1444 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1448 if (!add_dynamic_entry (DT_DEBUG
, 0))
1454 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1455 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1456 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1457 || !add_dynamic_entry (DT_JMPREL
, 0))
1463 if (!add_dynamic_entry (DT_RELA
, 0)
1464 || !add_dynamic_entry (DT_RELASZ
, 0)
1465 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1469 if ((info
->flags
& DF_TEXTREL
) != 0)
1471 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1475 #undef add_dynamic_entry
1480 /* This function is called via elf_link_hash_traverse if we are
1481 creating a shared object. In the -Bsymbolic case it discards the
1482 space allocated to copy PC relative relocs against symbols which
1483 are defined in regular objects. For the normal shared case, it
1484 discards space for pc-relative relocs that have become local due to
1485 symbol visibility changes. We allocated space for them in the
1486 check_relocs routine, but we won't fill them in in the
1487 relocate_section routine.
1489 We also check whether any of the remaining relocations apply
1490 against a readonly section, and set the DF_TEXTREL flag in this
1494 elf_m68k_discard_copies (h
, inf
)
1495 struct elf_link_hash_entry
*h
;
1498 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1499 struct elf_m68k_pcrel_relocs_copied
*s
;
1501 if (h
->root
.type
== bfd_link_hash_warning
)
1502 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1506 && !h
->forced_local
))
1508 if ((info
->flags
& DF_TEXTREL
) == 0)
1510 /* Look for relocations against read-only sections. */
1511 for (s
= elf_m68k_hash_entry (h
)->pcrel_relocs_copied
;
1514 if ((s
->section
->flags
& SEC_READONLY
) != 0)
1516 info
->flags
|= DF_TEXTREL
;
1524 for (s
= elf_m68k_hash_entry (h
)->pcrel_relocs_copied
;
1527 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
1532 /* Relocate an M68K ELF section. */
1535 elf_m68k_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1536 contents
, relocs
, local_syms
, local_sections
)
1538 struct bfd_link_info
*info
;
1540 asection
*input_section
;
1542 Elf_Internal_Rela
*relocs
;
1543 Elf_Internal_Sym
*local_syms
;
1544 asection
**local_sections
;
1547 Elf_Internal_Shdr
*symtab_hdr
;
1548 struct elf_link_hash_entry
**sym_hashes
;
1549 bfd_vma
*local_got_offsets
;
1553 Elf_Internal_Rela
*rel
;
1554 Elf_Internal_Rela
*relend
;
1556 if (info
->relocatable
)
1559 dynobj
= elf_hash_table (info
)->dynobj
;
1560 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1561 sym_hashes
= elf_sym_hashes (input_bfd
);
1562 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1569 relend
= relocs
+ input_section
->reloc_count
;
1570 for (; rel
< relend
; rel
++)
1573 reloc_howto_type
*howto
;
1574 unsigned long r_symndx
;
1575 struct elf_link_hash_entry
*h
;
1576 Elf_Internal_Sym
*sym
;
1579 bfd_boolean unresolved_reloc
;
1580 bfd_reloc_status_type r
;
1582 r_type
= ELF32_R_TYPE (rel
->r_info
);
1583 if (r_type
< 0 || r_type
>= (int) R_68K_max
)
1585 bfd_set_error (bfd_error_bad_value
);
1588 howto
= howto_table
+ r_type
;
1590 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1595 unresolved_reloc
= FALSE
;
1597 if (r_symndx
< symtab_hdr
->sh_info
)
1599 sym
= local_syms
+ r_symndx
;
1600 sec
= local_sections
[r_symndx
];
1601 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1607 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1608 r_symndx
, symtab_hdr
, sym_hashes
,
1610 unresolved_reloc
, warned
);
1618 /* Relocation is to the address of the entry for this symbol
1619 in the global offset table. */
1621 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1627 /* Relocation is the offset of the entry for this symbol in
1628 the global offset table. */
1635 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1636 BFD_ASSERT (sgot
!= NULL
);
1643 off
= h
->got
.offset
;
1644 BFD_ASSERT (off
!= (bfd_vma
) -1);
1646 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1647 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1654 /* This is actually a static link, or it is a
1655 -Bsymbolic link and the symbol is defined
1656 locally, or the symbol was forced to be local
1657 because of a version file.. We must initialize
1658 this entry in the global offset table. Since
1659 the offset must always be a multiple of 4, we
1660 use the least significant bit to record whether
1661 we have initialized it already.
1663 When doing a dynamic link, we create a .rela.got
1664 relocation entry to initialize the value. This
1665 is done in the finish_dynamic_symbol routine. */
1670 bfd_put_32 (output_bfd
, relocation
,
1671 sgot
->contents
+ off
);
1676 unresolved_reloc
= FALSE
;
1680 BFD_ASSERT (local_got_offsets
!= NULL
1681 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1683 off
= local_got_offsets
[r_symndx
];
1685 /* The offset must always be a multiple of 4. We use
1686 the least significant bit to record whether we have
1687 already generated the necessary reloc. */
1692 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1697 Elf_Internal_Rela outrel
;
1700 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1701 BFD_ASSERT (s
!= NULL
);
1703 outrel
.r_offset
= (sgot
->output_section
->vma
1704 + sgot
->output_offset
1706 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1707 outrel
.r_addend
= relocation
;
1709 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1710 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1713 local_got_offsets
[r_symndx
] |= 1;
1717 relocation
= sgot
->output_offset
+ off
;
1718 if (r_type
== R_68K_GOT8O
1719 || r_type
== R_68K_GOT16O
1720 || r_type
== R_68K_GOT32O
)
1722 /* This relocation does not use the addend. */
1726 relocation
+= sgot
->output_section
->vma
;
1733 /* Relocation is to the entry for this symbol in the
1734 procedure linkage table. */
1736 /* Resolve a PLTxx reloc against a local symbol directly,
1737 without using the procedure linkage table. */
1741 if (h
->plt
.offset
== (bfd_vma
) -1
1742 || !elf_hash_table (info
)->dynamic_sections_created
)
1744 /* We didn't make a PLT entry for this symbol. This
1745 happens when statically linking PIC code, or when
1746 using -Bsymbolic. */
1752 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1753 BFD_ASSERT (splt
!= NULL
);
1756 relocation
= (splt
->output_section
->vma
1757 + splt
->output_offset
1759 unresolved_reloc
= FALSE
;
1765 /* Relocation is the offset of the entry for this symbol in
1766 the procedure linkage table. */
1767 BFD_ASSERT (h
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1);
1771 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1772 BFD_ASSERT (splt
!= NULL
);
1775 relocation
= h
->plt
.offset
;
1776 unresolved_reloc
= FALSE
;
1778 /* This relocation does not use the addend. */
1788 && h
->forced_local
))
1796 && (input_section
->flags
& SEC_ALLOC
) != 0
1798 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1799 || h
->root
.type
!= bfd_link_hash_undefweak
)
1800 && ((r_type
!= R_68K_PC8
1801 && r_type
!= R_68K_PC16
1802 && r_type
!= R_68K_PC32
)
1806 || !h
->def_regular
))))
1808 Elf_Internal_Rela outrel
;
1810 bfd_boolean skip
, relocate
;
1812 /* When generating a shared object, these relocations
1813 are copied into the output file to be resolved at run
1820 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1822 if (outrel
.r_offset
== (bfd_vma
) -1)
1824 else if (outrel
.r_offset
== (bfd_vma
) -2)
1825 skip
= TRUE
, relocate
= TRUE
;
1826 outrel
.r_offset
+= (input_section
->output_section
->vma
1827 + input_section
->output_offset
);
1830 memset (&outrel
, 0, sizeof outrel
);
1833 && (r_type
== R_68K_PC8
1834 || r_type
== R_68K_PC16
1835 || r_type
== R_68K_PC32
1838 || !h
->def_regular
))
1840 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1841 outrel
.r_addend
= rel
->r_addend
;
1845 /* This symbol is local, or marked to become local. */
1846 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1848 if (r_type
== R_68K_32
)
1851 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1857 if (bfd_is_abs_section (sec
))
1859 else if (sec
== NULL
|| sec
->owner
== NULL
)
1861 bfd_set_error (bfd_error_bad_value
);
1868 /* We are turning this relocation into one
1869 against a section symbol. It would be
1870 proper to subtract the symbol's value,
1871 osec->vma, from the emitted reloc addend,
1872 but ld.so expects buggy relocs. */
1873 osec
= sec
->output_section
;
1874 indx
= elf_section_data (osec
)->dynindx
;
1877 struct elf_link_hash_table
*htab
;
1878 htab
= elf_hash_table (info
);
1879 osec
= htab
->text_index_section
;
1880 indx
= elf_section_data (osec
)->dynindx
;
1882 BFD_ASSERT (indx
!= 0);
1885 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1889 sreloc
= elf_section_data (input_section
)->sreloc
;
1893 loc
= sreloc
->contents
;
1894 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1895 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1897 /* This reloc will be computed at runtime, so there's no
1898 need to do anything now, except for R_68K_32
1899 relocations that have been turned into
1907 case R_68K_GNU_VTINHERIT
:
1908 case R_68K_GNU_VTENTRY
:
1909 /* These are no-ops in the end. */
1916 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1917 because such sections are not SEC_ALLOC and thus ld.so will
1918 not process them. */
1919 if (unresolved_reloc
1920 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
1923 (*_bfd_error_handler
)
1924 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1927 (long) rel
->r_offset
,
1929 h
->root
.root
.string
);
1933 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1934 contents
, rel
->r_offset
,
1935 relocation
, rel
->r_addend
);
1937 if (r
!= bfd_reloc_ok
)
1942 name
= h
->root
.root
.string
;
1945 name
= bfd_elf_string_from_elf_section (input_bfd
,
1946 symtab_hdr
->sh_link
,
1951 name
= bfd_section_name (input_bfd
, sec
);
1954 if (r
== bfd_reloc_overflow
)
1956 if (!(info
->callbacks
->reloc_overflow
1957 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1958 (bfd_vma
) 0, input_bfd
, input_section
,
1964 (*_bfd_error_handler
)
1965 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1966 input_bfd
, input_section
,
1967 (long) rel
->r_offset
, name
, (int) r
);
1976 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
1977 into section SEC. */
1980 elf_m68k_install_pc32 (asection
*sec
, bfd_vma offset
, bfd_vma value
)
1982 /* Make VALUE PC-relative. */
1983 value
-= sec
->output_section
->vma
+ offset
;
1985 /* Apply any in-place addend. */
1986 value
+= bfd_get_32 (sec
->owner
, sec
->contents
+ offset
);
1988 bfd_put_32 (sec
->owner
, value
, sec
->contents
+ offset
);
1991 /* Finish up dynamic symbol handling. We set the contents of various
1992 dynamic sections here. */
1995 elf_m68k_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1997 struct bfd_link_info
*info
;
1998 struct elf_link_hash_entry
*h
;
1999 Elf_Internal_Sym
*sym
;
2003 dynobj
= elf_hash_table (info
)->dynobj
;
2005 if (h
->plt
.offset
!= (bfd_vma
) -1)
2007 const struct elf_m68k_plt_info
*plt_info
;
2013 Elf_Internal_Rela rela
;
2016 /* This symbol has an entry in the procedure linkage table. Set
2019 BFD_ASSERT (h
->dynindx
!= -1);
2021 plt_info
= elf_m68k_hash_table (info
)->plt_info
;
2022 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2023 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2024 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2025 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
2027 /* Get the index in the procedure linkage table which
2028 corresponds to this symbol. This is the index of this symbol
2029 in all the symbols for which we are making plt entries. The
2030 first entry in the procedure linkage table is reserved. */
2031 plt_index
= (h
->plt
.offset
/ plt_info
->size
) - 1;
2033 /* Get the offset into the .got table of the entry that
2034 corresponds to this function. Each .got entry is 4 bytes.
2035 The first three are reserved. */
2036 got_offset
= (plt_index
+ 3) * 4;
2038 memcpy (splt
->contents
+ h
->plt
.offset
,
2039 plt_info
->symbol_entry
,
2042 elf_m68k_install_pc32 (splt
, h
->plt
.offset
+ plt_info
->symbol_relocs
.got
,
2043 (sgot
->output_section
->vma
2044 + sgot
->output_offset
2047 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
2050 + plt_info
->symbol_resolve_entry
+ 2);
2052 elf_m68k_install_pc32 (splt
, h
->plt
.offset
+ plt_info
->symbol_relocs
.plt
,
2053 splt
->output_section
->vma
);
2055 /* Fill in the entry in the global offset table. */
2056 bfd_put_32 (output_bfd
,
2057 (splt
->output_section
->vma
2058 + splt
->output_offset
2060 + plt_info
->symbol_resolve_entry
),
2061 sgot
->contents
+ got_offset
);
2063 /* Fill in the entry in the .rela.plt section. */
2064 rela
.r_offset
= (sgot
->output_section
->vma
2065 + sgot
->output_offset
2067 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_JMP_SLOT
);
2069 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
2070 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2072 if (!h
->def_regular
)
2074 /* Mark the symbol as undefined, rather than as defined in
2075 the .plt section. Leave the value alone. */
2076 sym
->st_shndx
= SHN_UNDEF
;
2080 if (h
->got
.offset
!= (bfd_vma
) -1)
2084 Elf_Internal_Rela rela
;
2087 /* This symbol has an entry in the global offset table. Set it
2090 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2091 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
2092 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2094 rela
.r_offset
= (sgot
->output_section
->vma
2095 + sgot
->output_offset
2096 + (h
->got
.offset
&~ (bfd_vma
) 1));
2098 /* If this is a -Bsymbolic link, and the symbol is defined
2099 locally, we just want to emit a RELATIVE reloc. Likewise if
2100 the symbol was forced to be local because of a version file.
2101 The entry in the global offset table will already have been
2102 initialized in the relocate_section function. */
2109 rela
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
2110 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
2112 + (h
->got
.offset
&~ (bfd_vma
) 1)));
2116 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2117 sgot
->contents
+ (h
->got
.offset
&~ (bfd_vma
) 1));
2118 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_GLOB_DAT
);
2122 loc
= srela
->contents
;
2123 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2124 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2130 Elf_Internal_Rela rela
;
2133 /* This symbol needs a copy reloc. Set it up. */
2135 BFD_ASSERT (h
->dynindx
!= -1
2136 && (h
->root
.type
== bfd_link_hash_defined
2137 || h
->root
.type
== bfd_link_hash_defweak
));
2139 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2141 BFD_ASSERT (s
!= NULL
);
2143 rela
.r_offset
= (h
->root
.u
.def
.value
2144 + h
->root
.u
.def
.section
->output_section
->vma
2145 + h
->root
.u
.def
.section
->output_offset
);
2146 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_COPY
);
2148 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2149 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2152 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2153 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2154 || h
== elf_hash_table (info
)->hgot
)
2155 sym
->st_shndx
= SHN_ABS
;
2160 /* Finish up the dynamic sections. */
2163 elf_m68k_finish_dynamic_sections (output_bfd
, info
)
2165 struct bfd_link_info
*info
;
2171 dynobj
= elf_hash_table (info
)->dynobj
;
2173 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2174 BFD_ASSERT (sgot
!= NULL
);
2175 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2177 if (elf_hash_table (info
)->dynamic_sections_created
)
2180 Elf32_External_Dyn
*dyncon
, *dynconend
;
2182 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2183 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2185 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2186 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2187 for (; dyncon
< dynconend
; dyncon
++)
2189 Elf_Internal_Dyn dyn
;
2193 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2206 s
= bfd_get_section_by_name (output_bfd
, name
);
2207 BFD_ASSERT (s
!= NULL
);
2208 dyn
.d_un
.d_ptr
= s
->vma
;
2209 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2213 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2214 BFD_ASSERT (s
!= NULL
);
2215 dyn
.d_un
.d_val
= s
->size
;
2216 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2220 /* The procedure linkage table relocs (DT_JMPREL) should
2221 not be included in the overall relocs (DT_RELA).
2222 Therefore, we override the DT_RELASZ entry here to
2223 make it not include the JMPREL relocs. Since the
2224 linker script arranges for .rela.plt to follow all
2225 other relocation sections, we don't have to worry
2226 about changing the DT_RELA entry. */
2227 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2229 dyn
.d_un
.d_val
-= s
->size
;
2230 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2235 /* Fill in the first entry in the procedure linkage table. */
2238 const struct elf_m68k_plt_info
*plt_info
;
2240 plt_info
= elf_m68k_hash_table (info
)->plt_info
;
2241 memcpy (splt
->contents
, plt_info
->plt0_entry
, plt_info
->size
);
2243 elf_m68k_install_pc32 (splt
, plt_info
->plt0_relocs
.got4
,
2244 (sgot
->output_section
->vma
2245 + sgot
->output_offset
2248 elf_m68k_install_pc32 (splt
, plt_info
->plt0_relocs
.got8
,
2249 (sgot
->output_section
->vma
2250 + sgot
->output_offset
2253 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2258 /* Fill in the first three entries in the global offset table. */
2262 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2264 bfd_put_32 (output_bfd
,
2265 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2267 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
2268 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
2271 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2276 /* Given a .data section and a .emreloc in-memory section, store
2277 relocation information into the .emreloc section which can be
2278 used at runtime to relocate the section. This is called by the
2279 linker when the --embedded-relocs switch is used. This is called
2280 after the add_symbols entry point has been called for all the
2281 objects, and before the final_link entry point is called. */
2284 bfd_m68k_elf32_create_embedded_relocs (abfd
, info
, datasec
, relsec
, errmsg
)
2286 struct bfd_link_info
*info
;
2291 Elf_Internal_Shdr
*symtab_hdr
;
2292 Elf_Internal_Sym
*isymbuf
= NULL
;
2293 Elf_Internal_Rela
*internal_relocs
= NULL
;
2294 Elf_Internal_Rela
*irel
, *irelend
;
2298 BFD_ASSERT (! info
->relocatable
);
2302 if (datasec
->reloc_count
== 0)
2305 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2307 /* Get a copy of the native relocations. */
2308 internal_relocs
= (_bfd_elf_link_read_relocs
2309 (abfd
, datasec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
2310 info
->keep_memory
));
2311 if (internal_relocs
== NULL
)
2314 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
2315 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2316 if (relsec
->contents
== NULL
)
2319 p
= relsec
->contents
;
2321 irelend
= internal_relocs
+ datasec
->reloc_count
;
2322 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
2324 asection
*targetsec
;
2326 /* We are going to write a four byte longword into the runtime
2327 reloc section. The longword will be the address in the data
2328 section which must be relocated. It is followed by the name
2329 of the target section NUL-padded or truncated to 8
2332 /* We can only relocate absolute longword relocs at run time. */
2333 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_68K_32
)
2335 *errmsg
= _("unsupported reloc type");
2336 bfd_set_error (bfd_error_bad_value
);
2340 /* Get the target section referred to by the reloc. */
2341 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2343 /* A local symbol. */
2344 Elf_Internal_Sym
*isym
;
2346 /* Read this BFD's local symbols if we haven't done so already. */
2347 if (isymbuf
== NULL
)
2349 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2350 if (isymbuf
== NULL
)
2351 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2352 symtab_hdr
->sh_info
, 0,
2354 if (isymbuf
== NULL
)
2358 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2359 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2364 struct elf_link_hash_entry
*h
;
2366 /* An external symbol. */
2367 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2368 h
= elf_sym_hashes (abfd
)[indx
];
2369 BFD_ASSERT (h
!= NULL
);
2370 if (h
->root
.type
== bfd_link_hash_defined
2371 || h
->root
.type
== bfd_link_hash_defweak
)
2372 targetsec
= h
->root
.u
.def
.section
;
2377 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2378 memset (p
+ 4, 0, 8);
2379 if (targetsec
!= NULL
)
2380 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
2383 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2385 if (internal_relocs
!= NULL
2386 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2387 free (internal_relocs
);
2391 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2393 if (internal_relocs
!= NULL
2394 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2395 free (internal_relocs
);
2399 static enum elf_reloc_type_class
2400 elf32_m68k_reloc_type_class (rela
)
2401 const Elf_Internal_Rela
*rela
;
2403 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2405 case R_68K_RELATIVE
:
2406 return reloc_class_relative
;
2407 case R_68K_JMP_SLOT
:
2408 return reloc_class_plt
;
2410 return reloc_class_copy
;
2412 return reloc_class_normal
;
2416 /* Return address for Ith PLT stub in section PLT, for relocation REL
2417 or (bfd_vma) -1 if it should not be included. */
2420 elf_m68k_plt_sym_val (bfd_vma i
, const asection
*plt
,
2421 const arelent
*rel ATTRIBUTE_UNUSED
)
2423 return plt
->vma
+ (i
+ 1) * elf_m68k_get_plt_info (plt
->owner
)->size
;
2426 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2427 #define TARGET_BIG_NAME "elf32-m68k"
2428 #define ELF_MACHINE_CODE EM_68K
2429 #define ELF_MAXPAGESIZE 0x2000
2430 #define elf_backend_create_dynamic_sections \
2431 _bfd_elf_create_dynamic_sections
2432 #define bfd_elf32_bfd_link_hash_table_create \
2433 elf_m68k_link_hash_table_create
2434 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2436 #define elf_backend_check_relocs elf_m68k_check_relocs
2437 #define elf_backend_always_size_sections \
2438 elf_m68k_always_size_sections
2439 #define elf_backend_adjust_dynamic_symbol \
2440 elf_m68k_adjust_dynamic_symbol
2441 #define elf_backend_size_dynamic_sections \
2442 elf_m68k_size_dynamic_sections
2443 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
2444 #define elf_backend_relocate_section elf_m68k_relocate_section
2445 #define elf_backend_finish_dynamic_symbol \
2446 elf_m68k_finish_dynamic_symbol
2447 #define elf_backend_finish_dynamic_sections \
2448 elf_m68k_finish_dynamic_sections
2449 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2450 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2451 #define bfd_elf32_bfd_merge_private_bfd_data \
2452 elf32_m68k_merge_private_bfd_data
2453 #define bfd_elf32_bfd_set_private_flags \
2454 elf32_m68k_set_private_flags
2455 #define bfd_elf32_bfd_print_private_bfd_data \
2456 elf32_m68k_print_private_bfd_data
2457 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2458 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2459 #define elf_backend_object_p elf32_m68k_object_p
2461 #define elf_backend_can_gc_sections 1
2462 #define elf_backend_can_refcount 1
2463 #define elf_backend_want_got_plt 1
2464 #define elf_backend_plt_readonly 1
2465 #define elf_backend_want_plt_sym 0
2466 #define elf_backend_got_header_size 12
2467 #define elf_backend_rela_normal 1
2469 #include "elf32-target.h"