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, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
29 #include "opcode/m68k.h"
32 elf_m68k_discard_copies (struct elf_link_hash_entry *, void *);
34 static reloc_howto_type howto_table[] =
36 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE),
37 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE),
38 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE),
39 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE),
40 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE),
41 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE),
42 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE),
43 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE),
44 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE),
45 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE),
46 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE),
47 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE),
48 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE),
49 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE),
50 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE),
51 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE),
52 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE),
53 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE),
54 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE),
55 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE),
56 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),
57 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),
58 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE),
59 /* GNU extension to record C++ vtable hierarchy. */
60 HOWTO (R_68K_GNU_VTINHERIT, /* type */
62 2, /* size (0 = byte, 1 = short, 2 = long) */
64 FALSE, /* pc_relative */
66 complain_overflow_dont, /* complain_on_overflow */
67 NULL, /* special_function */
68 "R_68K_GNU_VTINHERIT", /* name */
69 FALSE, /* partial_inplace */
73 /* GNU extension to record C++ vtable member usage. */
74 HOWTO (R_68K_GNU_VTENTRY, /* type */
76 2, /* size (0 = byte, 1 = short, 2 = long) */
78 FALSE, /* pc_relative */
80 complain_overflow_dont, /* complain_on_overflow */
81 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
82 "R_68K_GNU_VTENTRY", /* name */
83 FALSE, /* partial_inplace */
88 /* TLS general dynamic variable reference. */
89 HOWTO (R_68K_TLS_GD32, /* type */
91 2, /* size (0 = byte, 1 = short, 2 = long) */
93 FALSE, /* pc_relative */
95 complain_overflow_bitfield, /* complain_on_overflow */
96 bfd_elf_generic_reloc, /* special_function */
97 "R_68K_TLS_GD32", /* name */
98 FALSE, /* partial_inplace */
100 0xffffffff, /* dst_mask */
101 FALSE), /* pcrel_offset */
103 HOWTO (R_68K_TLS_GD16, /* type */
105 1, /* size (0 = byte, 1 = short, 2 = long) */
107 FALSE, /* pc_relative */
109 complain_overflow_signed, /* complain_on_overflow */
110 bfd_elf_generic_reloc, /* special_function */
111 "R_68K_TLS_GD16", /* name */
112 FALSE, /* partial_inplace */
114 0x0000ffff, /* dst_mask */
115 FALSE), /* pcrel_offset */
117 HOWTO (R_68K_TLS_GD8, /* type */
119 0, /* size (0 = byte, 1 = short, 2 = long) */
121 FALSE, /* pc_relative */
123 complain_overflow_signed, /* complain_on_overflow */
124 bfd_elf_generic_reloc, /* special_function */
125 "R_68K_TLS_GD8", /* name */
126 FALSE, /* partial_inplace */
128 0x000000ff, /* dst_mask */
129 FALSE), /* pcrel_offset */
131 /* TLS local dynamic variable reference. */
132 HOWTO (R_68K_TLS_LDM32, /* type */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
136 FALSE, /* pc_relative */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 bfd_elf_generic_reloc, /* special_function */
140 "R_68K_TLS_LDM32", /* name */
141 FALSE, /* partial_inplace */
143 0xffffffff, /* dst_mask */
144 FALSE), /* pcrel_offset */
146 HOWTO (R_68K_TLS_LDM16, /* type */
148 1, /* size (0 = byte, 1 = short, 2 = long) */
150 FALSE, /* pc_relative */
152 complain_overflow_signed, /* complain_on_overflow */
153 bfd_elf_generic_reloc, /* special_function */
154 "R_68K_TLS_LDM16", /* name */
155 FALSE, /* partial_inplace */
157 0x0000ffff, /* dst_mask */
158 FALSE), /* pcrel_offset */
160 HOWTO (R_68K_TLS_LDM8, /* type */
162 0, /* size (0 = byte, 1 = short, 2 = long) */
164 FALSE, /* pc_relative */
166 complain_overflow_signed, /* complain_on_overflow */
167 bfd_elf_generic_reloc, /* special_function */
168 "R_68K_TLS_LDM8", /* name */
169 FALSE, /* partial_inplace */
171 0x000000ff, /* dst_mask */
172 FALSE), /* pcrel_offset */
174 HOWTO (R_68K_TLS_LDO32, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE, /* pc_relative */
180 complain_overflow_bitfield, /* complain_on_overflow */
181 bfd_elf_generic_reloc, /* special_function */
182 "R_68K_TLS_LDO32", /* name */
183 FALSE, /* partial_inplace */
185 0xffffffff, /* dst_mask */
186 FALSE), /* pcrel_offset */
188 HOWTO (R_68K_TLS_LDO16, /* type */
190 1, /* size (0 = byte, 1 = short, 2 = long) */
192 FALSE, /* pc_relative */
194 complain_overflow_signed, /* complain_on_overflow */
195 bfd_elf_generic_reloc, /* special_function */
196 "R_68K_TLS_LDO16", /* name */
197 FALSE, /* partial_inplace */
199 0x0000ffff, /* dst_mask */
200 FALSE), /* pcrel_offset */
202 HOWTO (R_68K_TLS_LDO8, /* type */
204 0, /* size (0 = byte, 1 = short, 2 = long) */
206 FALSE, /* pc_relative */
208 complain_overflow_signed, /* complain_on_overflow */
209 bfd_elf_generic_reloc, /* special_function */
210 "R_68K_TLS_LDO8", /* name */
211 FALSE, /* partial_inplace */
213 0x000000ff, /* dst_mask */
214 FALSE), /* pcrel_offset */
216 /* TLS initial execution variable reference. */
217 HOWTO (R_68K_TLS_IE32, /* type */
219 2, /* size (0 = byte, 1 = short, 2 = long) */
221 FALSE, /* pc_relative */
223 complain_overflow_bitfield, /* complain_on_overflow */
224 bfd_elf_generic_reloc, /* special_function */
225 "R_68K_TLS_IE32", /* name */
226 FALSE, /* partial_inplace */
228 0xffffffff, /* dst_mask */
229 FALSE), /* pcrel_offset */
231 HOWTO (R_68K_TLS_IE16, /* type */
233 1, /* size (0 = byte, 1 = short, 2 = long) */
235 FALSE, /* pc_relative */
237 complain_overflow_signed, /* complain_on_overflow */
238 bfd_elf_generic_reloc, /* special_function */
239 "R_68K_TLS_IE16", /* name */
240 FALSE, /* partial_inplace */
242 0x0000ffff, /* dst_mask */
243 FALSE), /* pcrel_offset */
245 HOWTO (R_68K_TLS_IE8, /* type */
247 0, /* size (0 = byte, 1 = short, 2 = long) */
249 FALSE, /* pc_relative */
251 complain_overflow_signed, /* complain_on_overflow */
252 bfd_elf_generic_reloc, /* special_function */
253 "R_68K_TLS_IE8", /* name */
254 FALSE, /* partial_inplace */
256 0x000000ff, /* dst_mask */
257 FALSE), /* pcrel_offset */
259 /* TLS local execution variable reference. */
260 HOWTO (R_68K_TLS_LE32, /* type */
262 2, /* size (0 = byte, 1 = short, 2 = long) */
264 FALSE, /* pc_relative */
266 complain_overflow_bitfield, /* complain_on_overflow */
267 bfd_elf_generic_reloc, /* special_function */
268 "R_68K_TLS_LE32", /* name */
269 FALSE, /* partial_inplace */
271 0xffffffff, /* dst_mask */
272 FALSE), /* pcrel_offset */
274 HOWTO (R_68K_TLS_LE16, /* type */
276 1, /* size (0 = byte, 1 = short, 2 = long) */
278 FALSE, /* pc_relative */
280 complain_overflow_signed, /* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_68K_TLS_LE16", /* name */
283 FALSE, /* partial_inplace */
285 0x0000ffff, /* dst_mask */
286 FALSE), /* pcrel_offset */
288 HOWTO (R_68K_TLS_LE8, /* type */
290 0, /* size (0 = byte, 1 = short, 2 = long) */
292 FALSE, /* pc_relative */
294 complain_overflow_signed, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_68K_TLS_LE8", /* name */
297 FALSE, /* partial_inplace */
299 0x000000ff, /* dst_mask */
300 FALSE), /* pcrel_offset */
302 /* TLS GD/LD dynamic relocations. */
303 HOWTO (R_68K_TLS_DTPMOD32, /* type */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
307 FALSE, /* pc_relative */
309 complain_overflow_dont, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_68K_TLS_DTPMOD32", /* name */
312 FALSE, /* partial_inplace */
314 0xffffffff, /* dst_mask */
315 FALSE), /* pcrel_offset */
317 HOWTO (R_68K_TLS_DTPREL32, /* type */
319 2, /* size (0 = byte, 1 = short, 2 = long) */
321 FALSE, /* pc_relative */
323 complain_overflow_dont, /* complain_on_overflow */
324 bfd_elf_generic_reloc, /* special_function */
325 "R_68K_TLS_DTPREL32", /* name */
326 FALSE, /* partial_inplace */
328 0xffffffff, /* dst_mask */
329 FALSE), /* pcrel_offset */
331 HOWTO (R_68K_TLS_TPREL32, /* type */
333 2, /* size (0 = byte, 1 = short, 2 = long) */
335 FALSE, /* pc_relative */
337 complain_overflow_dont, /* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_68K_TLS_TPREL32", /* name */
340 FALSE, /* partial_inplace */
342 0xffffffff, /* dst_mask */
343 FALSE), /* pcrel_offset */
347 rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
349 unsigned int indx = ELF32_R_TYPE (dst->r_info);
351 if (indx >= (unsigned int) R_68K_max)
353 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
357 cache_ptr->howto = &howto_table[indx];
360 #define elf_info_to_howto rtype_to_howto
364 bfd_reloc_code_real_type bfd_val;
369 { BFD_RELOC_NONE, R_68K_NONE },
370 { BFD_RELOC_32, R_68K_32 },
371 { BFD_RELOC_16, R_68K_16 },
372 { BFD_RELOC_8, R_68K_8 },
373 { BFD_RELOC_32_PCREL, R_68K_PC32 },
374 { BFD_RELOC_16_PCREL, R_68K_PC16 },
375 { BFD_RELOC_8_PCREL, R_68K_PC8 },
376 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
377 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
378 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
379 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
380 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
381 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
382 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
383 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
384 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
385 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
386 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
387 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
388 { BFD_RELOC_NONE, R_68K_COPY },
389 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
390 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
391 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
392 { BFD_RELOC_CTOR, R_68K_32 },
393 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
394 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
395 { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 },
396 { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 },
397 { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 },
398 { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 },
399 { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 },
400 { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 },
401 { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 },
402 { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 },
403 { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 },
404 { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 },
405 { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 },
406 { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 },
407 { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 },
408 { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 },
409 { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 },
412 static reloc_howto_type *
413 reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
414 bfd_reloc_code_real_type code)
417 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
419 if (reloc_map[i].bfd_val == code)
420 return &howto_table[reloc_map[i].elf_val];
425 static reloc_howto_type *
426 reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
430 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
431 if (howto_table[i].name != NULL
432 && strcasecmp (howto_table[i].name, r_name) == 0)
433 return &howto_table[i];
438 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
439 #define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
440 #define ELF_ARCH bfd_arch_m68k
441 #define ELF_TARGET_ID M68K_ELF_DATA
443 /* Functions for the m68k ELF linker. */
445 /* The name of the dynamic interpreter. This is put in the .interp
448 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
450 /* Describes one of the various PLT styles. */
452 struct elf_m68k_plt_info
454 /* The size of each PLT entry. */
457 /* The template for the first PLT entry. */
458 const bfd_byte *plt0_entry;
460 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
461 The comments by each member indicate the value that the relocation
464 unsigned int got4; /* .got + 4 */
465 unsigned int got8; /* .got + 8 */
468 /* The template for a symbol's PLT entry. */
469 const bfd_byte *symbol_entry;
471 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
472 The comments by each member indicate the value that the relocation
475 unsigned int got; /* the symbol's .got.plt entry */
476 unsigned int plt; /* .plt */
479 /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
480 The stub starts with "move.l #relocoffset,%d0". */
481 bfd_vma symbol_resolve_entry;
484 /* The size in bytes of an entry in the procedure linkage table. */
486 #define PLT_ENTRY_SIZE 20
488 /* The first entry in a procedure linkage table looks like this. See
489 the SVR4 ABI m68k supplement to see how this works. */
491 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
493 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
494 0, 0, 0, 2, /* + (.got + 4) - . */
495 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
496 0, 0, 0, 2, /* + (.got + 8) - . */
497 0, 0, 0, 0 /* pad out to 20 bytes. */
500 /* Subsequent entries in a procedure linkage table look like this. */
502 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
504 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
505 0, 0, 0, 2, /* + (.got.plt entry) - . */
506 0x2f, 0x3c, /* move.l #offset,-(%sp) */
507 0, 0, 0, 0, /* + reloc index */
508 0x60, 0xff, /* bra.l .plt */
509 0, 0, 0, 0 /* + .plt - . */
512 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
514 elf_m68k_plt0_entry, { 4, 12 },
515 elf_m68k_plt_entry, { 4, 16 }, 8
518 #define ISAB_PLT_ENTRY_SIZE 24
520 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
522 0x20, 0x3c, /* move.l #offset,%d0 */
523 0, 0, 0, 0, /* + (.got + 4) - . */
524 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
525 0x20, 0x3c, /* move.l #offset,%d0 */
526 0, 0, 0, 0, /* + (.got + 8) - . */
527 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
528 0x4e, 0xd0, /* jmp (%a0) */
532 /* Subsequent entries in a procedure linkage table look like this. */
534 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
536 0x20, 0x3c, /* move.l #offset,%d0 */
537 0, 0, 0, 0, /* + (.got.plt entry) - . */
538 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
539 0x4e, 0xd0, /* jmp (%a0) */
540 0x2f, 0x3c, /* move.l #offset,-(%sp) */
541 0, 0, 0, 0, /* + reloc index */
542 0x60, 0xff, /* bra.l .plt */
543 0, 0, 0, 0 /* + .plt - . */
546 static const struct elf_m68k_plt_info elf_isab_plt_info = {
548 elf_isab_plt0_entry, { 2, 12 },
549 elf_isab_plt_entry, { 2, 20 }, 12
552 #define ISAC_PLT_ENTRY_SIZE 24
554 static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
556 0x20, 0x3c, /* move.l #offset,%d0 */
557 0, 0, 0, 0, /* replaced with .got + 4 - . */
558 0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
559 0x20, 0x3c, /* move.l #offset,%d0 */
560 0, 0, 0, 0, /* replaced with .got + 8 - . */
561 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
562 0x4e, 0xd0, /* jmp (%a0) */
566 /* Subsequent entries in a procedure linkage table look like this. */
568 static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
570 0x20, 0x3c, /* move.l #offset,%d0 */
571 0, 0, 0, 0, /* replaced with (.got entry) - . */
572 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
573 0x4e, 0xd0, /* jmp (%a0) */
574 0x2f, 0x3c, /* move.l #offset,-(%sp) */
575 0, 0, 0, 0, /* replaced with offset into relocation table */
576 0x61, 0xff, /* bsr.l .plt */
577 0, 0, 0, 0 /* replaced with .plt - . */
580 static const struct elf_m68k_plt_info elf_isac_plt_info = {
582 elf_isac_plt0_entry, { 2, 12},
583 elf_isac_plt_entry, { 2, 20 }, 12
586 #define CPU32_PLT_ENTRY_SIZE 24
587 /* Procedure linkage table entries for the cpu32 */
588 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
590 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
591 0, 0, 0, 2, /* + (.got + 4) - . */
592 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
593 0, 0, 0, 2, /* + (.got + 8) - . */
594 0x4e, 0xd1, /* jmp %a1@ */
595 0, 0, 0, 0, /* pad out to 24 bytes. */
599 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
601 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
602 0, 0, 0, 2, /* + (.got.plt entry) - . */
603 0x4e, 0xd1, /* jmp %a1@ */
604 0x2f, 0x3c, /* move.l #offset,-(%sp) */
605 0, 0, 0, 0, /* + reloc index */
606 0x60, 0xff, /* bra.l .plt */
607 0, 0, 0, 0, /* + .plt - . */
611 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
612 CPU32_PLT_ENTRY_SIZE,
613 elf_cpu32_plt0_entry, { 4, 12 },
614 elf_cpu32_plt_entry, { 4, 18 }, 10
617 /* The m68k linker needs to keep track of the number of relocs that it
618 decides to copy in check_relocs for each symbol. This is so that it
619 can discard PC relative relocs if it doesn't need them when linking
620 with -Bsymbolic. We store the information in a field extending the
621 regular ELF linker hash table. */
623 /* This structure keeps track of the number of PC relative relocs we have
624 copied for a given symbol. */
626 struct elf_m68k_pcrel_relocs_copied
629 struct elf_m68k_pcrel_relocs_copied *next;
630 /* A section in dynobj. */
632 /* Number of relocs copied in this section. */
636 /* Forward declaration. */
637 struct elf_m68k_got_entry;
639 /* m68k ELF linker hash entry. */
641 struct elf_m68k_link_hash_entry
643 struct elf_link_hash_entry root;
645 /* Number of PC relative relocs copied for this symbol. */
646 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
648 /* Key to got_entries. */
649 unsigned long got_entry_key;
651 /* List of GOT entries for this symbol. This list is build during
652 offset finalization and is used within elf_m68k_finish_dynamic_symbol
653 to traverse all GOT entries for a particular symbol.
655 ??? We could've used root.got.glist field instead, but having
656 a separate field is cleaner. */
657 struct elf_m68k_got_entry *glist;
660 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
662 /* Key part of GOT entry in hashtable. */
663 struct elf_m68k_got_entry_key
665 /* BFD in which this symbol was defined. NULL for global symbols. */
668 /* Symbol index. Either local symbol index or h->got_entry_key. */
669 unsigned long symndx;
671 /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32},
672 R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}.
674 From perspective of hashtable key, only elf_m68k_got_reloc_type (type)
675 matters. That is, we distinguish between, say, R_68K_GOT16O
676 and R_68K_GOT32O when allocating offsets, but they are considered to be
677 the same when searching got->entries. */
678 enum elf_m68k_reloc_type type;
681 /* Size of the GOT offset suitable for relocation. */
682 enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST };
684 /* Entry of the GOT. */
685 struct elf_m68k_got_entry
687 /* GOT entries are put into a got->entries hashtable. This is the key. */
688 struct elf_m68k_got_entry_key key_;
690 /* GOT entry data. We need s1 before offset finalization and s2 after. */
695 /* Number of times this entry is referenced. It is used to
696 filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook. */
702 /* Offset from the start of .got section. To calculate offset relative
703 to GOT pointer one should substract got->offset from this value. */
706 /* Pointer to the next GOT entry for this global symbol.
707 Symbols have at most one entry in one GOT, but might
708 have entries in more than one GOT.
709 Root of this list is h->glist.
710 NULL for local symbols. */
711 struct elf_m68k_got_entry *next;
716 /* Return representative type for relocation R_TYPE.
717 This is used to avoid enumerating many relocations in comparisons,
720 static enum elf_m68k_reloc_type
721 elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type)
725 /* In most cases R_68K_GOTx relocations require the very same
726 handling as R_68K_GOT32O relocation. In cases when we need
727 to distinguish between the two, we use explicitly compare against
740 return R_68K_TLS_GD32;
742 case R_68K_TLS_LDM32:
743 case R_68K_TLS_LDM16:
745 return R_68K_TLS_LDM32;
750 return R_68K_TLS_IE32;
758 /* Return size of the GOT entry offset for relocation R_TYPE. */
760 static enum elf_m68k_got_offset_size
761 elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type)
765 case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8:
766 case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32:
770 case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16:
774 case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8:
784 /* Return number of GOT entries we need to allocate in GOT for
785 relocation R_TYPE. */
788 elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type)
790 switch (elf_m68k_reloc_got_type (r_type))
797 case R_68K_TLS_LDM32:
806 /* Return TRUE if relocation R_TYPE is a TLS one. */
809 elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type)
813 case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8:
814 case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8:
815 case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8:
816 case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8:
817 case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8:
818 case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32:
826 /* Data structure representing a single GOT. */
829 /* Hashtable of 'struct elf_m68k_got_entry's.
830 Starting size of this table is the maximum number of
831 R_68K_GOT8O entries. */
834 /* Number of R_x slots in this GOT. Some (e.g., TLS) entries require
837 n_slots[R_8] is the count of R_8 slots in this GOT.
838 n_slots[R_16] is the cumulative count of R_8 and R_16 slots
840 n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots
841 in this GOT. This is the total number of slots. */
842 bfd_vma n_slots[R_LAST];
844 /* Number of local (entry->key_.h == NULL) slots in this GOT.
845 This is only used to properly calculate size of .rela.got section;
846 see elf_m68k_partition_multi_got. */
847 bfd_vma local_n_slots;
849 /* Offset of this GOT relative to beginning of .got section. */
853 /* BFD and its GOT. This is an entry in multi_got->bfd2got hashtable. */
854 struct elf_m68k_bfd2got_entry
859 /* Assigned GOT. Before partitioning multi-GOT each BFD has its own
860 GOT structure. After partitioning several BFD's might [and often do]
861 share a single GOT. */
862 struct elf_m68k_got *got;
865 /* The main data structure holding all the pieces. */
866 struct elf_m68k_multi_got
868 /* Hashtable mapping each BFD to its GOT. If a BFD doesn't have an entry
869 here, then it doesn't need a GOT (this includes the case of a BFD
870 having an empty GOT).
872 ??? This hashtable can be replaced by an array indexed by bfd->id. */
875 /* Next symndx to assign a global symbol.
876 h->got_entry_key is initialized from this counter. */
877 unsigned long global_symndx;
880 /* m68k ELF linker hash table. */
882 struct elf_m68k_link_hash_table
884 struct elf_link_hash_table root;
886 /* Small local sym cache. */
887 struct sym_cache sym_cache;
889 /* The PLT format used by this link, or NULL if the format has not
891 const struct elf_m68k_plt_info *plt_info;
893 /* True, if GP is loaded within each function which uses it.
894 Set to TRUE when GOT negative offsets or multi-GOT is enabled. */
895 bfd_boolean local_gp_p;
897 /* Switch controlling use of negative offsets to double the size of GOTs. */
898 bfd_boolean use_neg_got_offsets_p;
900 /* Switch controlling generation of multiple GOTs. */
901 bfd_boolean allow_multigot_p;
903 /* Multi-GOT data structure. */
904 struct elf_m68k_multi_got multi_got_;
907 /* Get the m68k ELF linker hash table from a link_info structure. */
909 #define elf_m68k_hash_table(p) \
910 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
911 == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL)
913 /* Shortcut to multi-GOT data. */
914 #define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_)
916 /* Create an entry in an m68k ELF linker hash table. */
918 static struct bfd_hash_entry *
919 elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry,
920 struct bfd_hash_table *table,
923 struct bfd_hash_entry *ret = entry;
925 /* Allocate the structure if it has not already been allocated by a
928 ret = bfd_hash_allocate (table,
929 sizeof (struct elf_m68k_link_hash_entry));
933 /* Call the allocation method of the superclass. */
934 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
937 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
938 elf_m68k_hash_entry (ret)->got_entry_key = 0;
939 elf_m68k_hash_entry (ret)->glist = NULL;
945 /* Create an m68k ELF linker hash table. */
947 static struct bfd_link_hash_table *
948 elf_m68k_link_hash_table_create (bfd *abfd)
950 struct elf_m68k_link_hash_table *ret;
951 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
953 ret = (struct elf_m68k_link_hash_table *) bfd_zmalloc (amt);
954 if (ret == (struct elf_m68k_link_hash_table *) NULL)
957 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
958 elf_m68k_link_hash_newfunc,
959 sizeof (struct elf_m68k_link_hash_entry),
966 ret->multi_got_.global_symndx = 1;
968 return &ret->root.root;
971 /* Destruct local data. */
974 elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab)
976 struct elf_m68k_link_hash_table *htab;
978 htab = (struct elf_m68k_link_hash_table *) _htab;
980 if (htab->multi_got_.bfd2got != NULL)
982 htab_delete (htab->multi_got_.bfd2got);
983 htab->multi_got_.bfd2got = NULL;
987 /* Set the right machine number. */
990 elf32_m68k_object_p (bfd *abfd)
992 unsigned int mach = 0;
993 unsigned features = 0;
994 flagword eflags = elf_elfheader (abfd)->e_flags;
996 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
998 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1000 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1004 switch (eflags & EF_M68K_CF_ISA_MASK)
1006 case EF_M68K_CF_ISA_A_NODIV:
1007 features |= mcfisa_a;
1009 case EF_M68K_CF_ISA_A:
1010 features |= mcfisa_a|mcfhwdiv;
1012 case EF_M68K_CF_ISA_A_PLUS:
1013 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1015 case EF_M68K_CF_ISA_B_NOUSP:
1016 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1018 case EF_M68K_CF_ISA_B:
1019 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1021 case EF_M68K_CF_ISA_C:
1022 features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1024 case EF_M68K_CF_ISA_C_NODIV:
1025 features |= mcfisa_a|mcfisa_c|mcfusp;
1028 switch (eflags & EF_M68K_CF_MAC_MASK)
1030 case EF_M68K_CF_MAC:
1033 case EF_M68K_CF_EMAC:
1034 features |= mcfemac;
1037 if (eflags & EF_M68K_CF_FLOAT)
1041 mach = bfd_m68k_features_to_mach (features);
1042 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1047 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1048 field based on the machine number. */
1051 elf_m68k_final_write_processing (bfd *abfd,
1052 bfd_boolean linker ATTRIBUTE_UNUSED)
1054 int mach = bfd_get_mach (abfd);
1055 unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1059 unsigned int arch_mask;
1061 arch_mask = bfd_m68k_mach_to_features (mach);
1063 if (arch_mask & m68000)
1064 e_flags = EF_M68K_M68000;
1065 else if (arch_mask & cpu32)
1066 e_flags = EF_M68K_CPU32;
1067 else if (arch_mask & fido_a)
1068 e_flags = EF_M68K_FIDO;
1072 & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1075 e_flags |= EF_M68K_CF_ISA_A_NODIV;
1077 case mcfisa_a | mcfhwdiv:
1078 e_flags |= EF_M68K_CF_ISA_A;
1080 case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1081 e_flags |= EF_M68K_CF_ISA_A_PLUS;
1083 case mcfisa_a | mcfisa_b | mcfhwdiv:
1084 e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1086 case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1087 e_flags |= EF_M68K_CF_ISA_B;
1089 case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1090 e_flags |= EF_M68K_CF_ISA_C;
1092 case mcfisa_a | mcfisa_c | mcfusp:
1093 e_flags |= EF_M68K_CF_ISA_C_NODIV;
1096 if (arch_mask & mcfmac)
1097 e_flags |= EF_M68K_CF_MAC;
1098 else if (arch_mask & mcfemac)
1099 e_flags |= EF_M68K_CF_EMAC;
1100 if (arch_mask & cfloat)
1101 e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1103 elf_elfheader (abfd)->e_flags = e_flags;
1107 /* Keep m68k-specific flags in the ELF header. */
1110 elf32_m68k_set_private_flags (bfd *abfd, flagword flags)
1112 elf_elfheader (abfd)->e_flags = flags;
1113 elf_flags_init (abfd) = TRUE;
1117 /* Merge backend specific data from an object file to the output
1118 object file when linking. */
1120 elf32_m68k_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1126 const bfd_arch_info_type *arch_info;
1128 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1129 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1132 /* Get the merged machine. This checks for incompatibility between
1133 Coldfire & non-Coldfire flags, incompability between different
1134 Coldfire ISAs, and incompability between different MAC types. */
1135 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
1139 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
1141 in_flags = elf_elfheader (ibfd)->e_flags;
1142 if (!elf_flags_init (obfd))
1144 elf_flags_init (obfd) = TRUE;
1145 out_flags = in_flags;
1149 out_flags = elf_elfheader (obfd)->e_flags;
1150 unsigned int variant_mask;
1152 if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1154 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1156 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1159 variant_mask = EF_M68K_CF_ISA_MASK;
1161 in_isa = (in_flags & variant_mask);
1162 out_isa = (out_flags & variant_mask);
1163 if (in_isa > out_isa)
1164 out_flags ^= in_isa ^ out_isa;
1165 if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
1166 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1167 || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
1168 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
1169 out_flags = EF_M68K_FIDO;
1171 out_flags |= in_flags ^ in_isa;
1173 elf_elfheader (obfd)->e_flags = out_flags;
1178 /* Display the flags field. */
1181 elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr)
1183 FILE *file = (FILE *) ptr;
1184 flagword eflags = elf_elfheader (abfd)->e_flags;
1186 BFD_ASSERT (abfd != NULL && ptr != NULL);
1188 /* Print normal ELF private data. */
1189 _bfd_elf_print_private_bfd_data (abfd, ptr);
1191 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
1193 /* xgettext:c-format */
1194 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1196 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1197 fprintf (file, " [m68000]");
1198 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1199 fprintf (file, " [cpu32]");
1200 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1201 fprintf (file, " [fido]");
1204 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
1205 fprintf (file, " [cfv4e]");
1207 if (eflags & EF_M68K_CF_ISA_MASK)
1209 char const *isa = _("unknown");
1210 char const *mac = _("unknown");
1211 char const *additional = "";
1213 switch (eflags & EF_M68K_CF_ISA_MASK)
1215 case EF_M68K_CF_ISA_A_NODIV:
1217 additional = " [nodiv]";
1219 case EF_M68K_CF_ISA_A:
1222 case EF_M68K_CF_ISA_A_PLUS:
1225 case EF_M68K_CF_ISA_B_NOUSP:
1227 additional = " [nousp]";
1229 case EF_M68K_CF_ISA_B:
1232 case EF_M68K_CF_ISA_C:
1235 case EF_M68K_CF_ISA_C_NODIV:
1237 additional = " [nodiv]";
1240 fprintf (file, " [isa %s]%s", isa, additional);
1242 if (eflags & EF_M68K_CF_FLOAT)
1243 fprintf (file, " [float]");
1245 switch (eflags & EF_M68K_CF_MAC_MASK)
1250 case EF_M68K_CF_MAC:
1253 case EF_M68K_CF_EMAC:
1256 case EF_M68K_CF_EMAC_B:
1261 fprintf (file, " [%s]", mac);
1270 /* Multi-GOT support implementation design:
1272 Multi-GOT starts in check_relocs hook. There we scan all
1273 relocations of a BFD and build a local GOT (struct elf_m68k_got)
1274 for it. If a single BFD appears to require too many GOT slots with
1275 R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification
1277 After check_relocs has been invoked for each input BFD, we have
1278 constructed a GOT for each input BFD.
1280 To minimize total number of GOTs required for a particular output BFD
1281 (as some environments support only 1 GOT per output object) we try
1282 to merge some of the GOTs to share an offset space. Ideally [and in most
1283 cases] we end up with a single GOT. In cases when there are too many
1284 restricted relocations (e.g., R_68K_GOT16O relocations) we end up with
1285 several GOTs, assuming the environment can handle them.
1287 Partitioning is done in elf_m68k_partition_multi_got. We start with
1288 an empty GOT and traverse bfd2got hashtable putting got_entries from
1289 local GOTs to the new 'big' one. We do that by constructing an
1290 intermediate GOT holding all the entries the local GOT has and the big
1291 GOT lacks. Then we check if there is room in the big GOT to accomodate
1292 all the entries from diff. On success we add those entries to the big
1293 GOT; on failure we start the new 'big' GOT and retry the adding of
1294 entries from the local GOT. Note that this retry will always succeed as
1295 each local GOT doesn't overflow the limits. After partitioning we
1296 end up with each bfd assigned one of the big GOTs. GOT entries in the
1297 big GOTs are initialized with GOT offsets. Note that big GOTs are
1298 positioned consequently in program space and represent a single huge GOT
1299 to the outside world.
1301 After that we get to elf_m68k_relocate_section. There we
1302 adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol
1303 relocations to refer to appropriate [assigned to current input_bfd]
1308 GOT entry type: We have several types of GOT entries.
1309 * R_8 type is used in entries for symbols that have at least one
1310 R_68K_GOT8O or R_68K_TLS_*8 relocation. We can have at most 0x40
1311 such entries in one GOT.
1312 * R_16 type is used in entries for symbols that have at least one
1313 R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations.
1314 We can have at most 0x4000 such entries in one GOT.
1315 * R_32 type is used in all other cases. We can have as many
1316 such entries in one GOT as we'd like.
1317 When counting relocations we have to include the count of the smaller
1318 ranged relocations in the counts of the larger ranged ones in order
1319 to correctly detect overflow.
1321 Sorting the GOT: In each GOT starting offsets are assigned to
1322 R_8 entries, which are followed by R_16 entries, and
1323 R_32 entries go at the end. See finalize_got_offsets for details.
1325 Negative GOT offsets: To double usable offset range of GOTs we use
1326 negative offsets. As we assign entries with GOT offsets relative to
1327 start of .got section, the offset values are positive. They become
1328 negative only in relocate_section where got->offset value is
1329 subtracted from them.
1331 3 special GOT entries: There are 3 special GOT entries used internally
1332 by loader. These entries happen to be placed to .got.plt section,
1333 so we don't do anything about them in multi-GOT support.
1335 Memory management: All data except for hashtables
1336 multi_got->bfd2got and got->entries are allocated on
1337 elf_hash_table (info)->dynobj bfd (for this reason we pass 'info'
1338 to most functions), so we don't need to care to free them. At the
1339 moment of allocation hashtables are being linked into main data
1340 structure (multi_got), all pieces of which are reachable from
1341 elf_m68k_multi_got (info). We deallocate them in
1342 elf_m68k_link_hash_table_free. */
1344 /* Initialize GOT. */
1347 elf_m68k_init_got (struct elf_m68k_got *got)
1349 got->entries = NULL;
1350 got->n_slots[R_8] = 0;
1351 got->n_slots[R_16] = 0;
1352 got->n_slots[R_32] = 0;
1353 got->local_n_slots = 0;
1354 got->offset = (bfd_vma) -1;
1360 elf_m68k_clear_got (struct elf_m68k_got *got)
1362 if (got->entries != NULL)
1364 htab_delete (got->entries);
1365 got->entries = NULL;
1369 /* Create and empty GOT structure. INFO is the context where memory
1370 should be allocated. */
1372 static struct elf_m68k_got *
1373 elf_m68k_create_empty_got (struct bfd_link_info *info)
1375 struct elf_m68k_got *got;
1377 got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got));
1381 elf_m68k_init_got (got);
1386 /* Initialize KEY. */
1389 elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key,
1390 struct elf_link_hash_entry *h,
1391 const bfd *abfd, unsigned long symndx,
1392 enum elf_m68k_reloc_type reloc_type)
1394 if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32)
1395 /* All TLS_LDM relocations share a single GOT entry. */
1401 /* Global symbols are identified with their got_entry_key. */
1404 key->symndx = elf_m68k_hash_entry (h)->got_entry_key;
1405 BFD_ASSERT (key->symndx != 0);
1408 /* Local symbols are identified by BFD they appear in and symndx. */
1411 key->symndx = symndx;
1414 key->type = reloc_type;
1417 /* Calculate hash of got_entry.
1421 elf_m68k_got_entry_hash (const void *_entry)
1423 const struct elf_m68k_got_entry_key *key;
1425 key = &((const struct elf_m68k_got_entry *) _entry)->key_;
1428 + (key->bfd != NULL ? (int) key->bfd->id : -1)
1429 + elf_m68k_reloc_got_type (key->type));
1432 /* Check if two got entries are equal. */
1435 elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2)
1437 const struct elf_m68k_got_entry_key *key1;
1438 const struct elf_m68k_got_entry_key *key2;
1440 key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_;
1441 key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_;
1443 return (key1->bfd == key2->bfd
1444 && key1->symndx == key2->symndx
1445 && (elf_m68k_reloc_got_type (key1->type)
1446 == elf_m68k_reloc_got_type (key2->type)));
1449 /* When using negative offsets, we allocate one extra R_8, one extra R_16
1450 and one extra R_32 slots to simplify handling of 2-slot entries during
1451 offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots. */
1453 /* Maximal number of R_8 slots in a single GOT. */
1454 #define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO) \
1455 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \
1459 /* Maximal number of R_8 and R_16 slots in a single GOT. */
1460 #define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO) \
1461 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \
1465 /* SEARCH - simply search the hashtable, don't insert new entries or fail when
1466 the entry cannot be found.
1467 FIND_OR_CREATE - search for an existing entry, but create new if there's
1469 MUST_FIND - search for an existing entry and assert that it exist.
1470 MUST_CREATE - assert that there's no such entry and create new one. */
1471 enum elf_m68k_get_entry_howto
1479 /* Get or create (depending on HOWTO) entry with KEY in GOT.
1480 INFO is context in which memory should be allocated (can be NULL if
1481 HOWTO is SEARCH or MUST_FIND). */
1483 static struct elf_m68k_got_entry *
1484 elf_m68k_get_got_entry (struct elf_m68k_got *got,
1485 const struct elf_m68k_got_entry_key *key,
1486 enum elf_m68k_get_entry_howto howto,
1487 struct bfd_link_info *info)
1489 struct elf_m68k_got_entry entry_;
1490 struct elf_m68k_got_entry *entry;
1493 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1495 if (got->entries == NULL)
1496 /* This is the first entry in ABFD. Initialize hashtable. */
1498 if (howto == SEARCH)
1501 got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT
1503 elf_m68k_got_entry_hash,
1504 elf_m68k_got_entry_eq, NULL);
1505 if (got->entries == NULL)
1507 bfd_set_error (bfd_error_no_memory);
1513 ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH
1514 ? INSERT : NO_INSERT));
1517 if (howto == SEARCH)
1518 /* Entry not found. */
1521 /* We're out of memory. */
1522 bfd_set_error (bfd_error_no_memory);
1527 /* We didn't find the entry and we're asked to create a new one. */
1529 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1531 entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry));
1535 /* Initialize new entry. */
1538 entry->u.s1.refcount = 0;
1540 /* Mark the entry as not initialized. */
1541 entry->key_.type = R_68K_max;
1546 /* We found the entry. */
1548 BFD_ASSERT (howto != MUST_CREATE);
1556 /* Update GOT counters when merging entry of WAS type with entry of NEW type.
1557 Return the value to which ENTRY's type should be set. */
1559 static enum elf_m68k_reloc_type
1560 elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
1561 enum elf_m68k_reloc_type was,
1562 enum elf_m68k_reloc_type new_reloc)
1564 enum elf_m68k_got_offset_size was_size;
1565 enum elf_m68k_got_offset_size new_size;
1568 if (was == R_68K_max)
1569 /* The type of the entry is not initialized yet. */
1571 /* Update all got->n_slots counters, including n_slots[R_32]. */
1578 /* !!! We, probably, should emit an error rather then fail on assert
1580 BFD_ASSERT (elf_m68k_reloc_got_type (was)
1581 == elf_m68k_reloc_got_type (new_reloc));
1583 was_size = elf_m68k_reloc_got_offset_size (was);
1586 new_size = elf_m68k_reloc_got_offset_size (new_reloc);
1587 n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
1589 while (was_size > new_size)
1592 got->n_slots[was_size] += n_slots;
1595 if (new_reloc > was)
1596 /* Relocations are ordered from bigger got offset size to lesser,
1597 so choose the relocation type with lesser offset size. */
1603 /* Update GOT counters when removing an entry of type TYPE. */
1606 elf_m68k_remove_got_entry_type (struct elf_m68k_got *got,
1607 enum elf_m68k_reloc_type type)
1609 enum elf_m68k_got_offset_size os;
1612 n_slots = elf_m68k_reloc_got_n_slots (type);
1614 /* Decrese counter of slots with offset size corresponding to TYPE
1615 and all greater offset sizes. */
1616 for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os)
1618 BFD_ASSERT (got->n_slots[os] >= n_slots);
1620 got->n_slots[os] -= n_slots;
1624 /* Add new or update existing entry to GOT.
1625 H, ABFD, TYPE and SYMNDX is data for the entry.
1626 INFO is a context where memory should be allocated. */
1628 static struct elf_m68k_got_entry *
1629 elf_m68k_add_entry_to_got (struct elf_m68k_got *got,
1630 struct elf_link_hash_entry *h,
1632 enum elf_m68k_reloc_type reloc_type,
1633 unsigned long symndx,
1634 struct bfd_link_info *info)
1636 struct elf_m68k_got_entry_key key_;
1637 struct elf_m68k_got_entry *entry;
1639 if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0)
1640 elf_m68k_hash_entry (h)->got_entry_key
1641 = elf_m68k_multi_got (info)->global_symndx++;
1643 elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type);
1645 entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info);
1649 /* Determine entry's type and update got->n_slots counters. */
1650 entry->key_.type = elf_m68k_update_got_entry_type (got,
1654 /* Update refcount. */
1655 ++entry->u.s1.refcount;
1657 if (entry->u.s1.refcount == 1)
1658 /* We see this entry for the first time. */
1660 if (entry->key_.bfd != NULL)
1661 got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type);
1664 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
1666 if ((got->n_slots[R_8]
1667 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1668 || (got->n_slots[R_16]
1669 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1670 /* This BFD has too many relocation. */
1672 if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1673 (*_bfd_error_handler) (_("%B: GOT overflow: "
1674 "Number of relocations with 8-bit "
1677 ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
1679 (*_bfd_error_handler) (_("%B: GOT overflow: "
1680 "Number of relocations with 8- or 16-bit "
1683 ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
1691 /* Compute the hash value of the bfd in a bfd2got hash entry. */
1694 elf_m68k_bfd2got_entry_hash (const void *entry)
1696 const struct elf_m68k_bfd2got_entry *e;
1698 e = (const struct elf_m68k_bfd2got_entry *) entry;
1703 /* Check whether two hash entries have the same bfd. */
1706 elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2)
1708 const struct elf_m68k_bfd2got_entry *e1;
1709 const struct elf_m68k_bfd2got_entry *e2;
1711 e1 = (const struct elf_m68k_bfd2got_entry *) entry1;
1712 e2 = (const struct elf_m68k_bfd2got_entry *) entry2;
1714 return e1->bfd == e2->bfd;
1717 /* Destruct a bfd2got entry. */
1720 elf_m68k_bfd2got_entry_del (void *_entry)
1722 struct elf_m68k_bfd2got_entry *entry;
1724 entry = (struct elf_m68k_bfd2got_entry *) _entry;
1726 BFD_ASSERT (entry->got != NULL);
1727 elf_m68k_clear_got (entry->got);
1730 /* Find existing or create new (depending on HOWTO) bfd2got entry in
1731 MULTI_GOT. ABFD is the bfd we need a GOT for. INFO is a context where
1732 memory should be allocated. */
1734 static struct elf_m68k_bfd2got_entry *
1735 elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got,
1737 enum elf_m68k_get_entry_howto howto,
1738 struct bfd_link_info *info)
1740 struct elf_m68k_bfd2got_entry entry_;
1742 struct elf_m68k_bfd2got_entry *entry;
1744 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1746 if (multi_got->bfd2got == NULL)
1747 /* This is the first GOT. Initialize bfd2got. */
1749 if (howto == SEARCH)
1752 multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash,
1753 elf_m68k_bfd2got_entry_eq,
1754 elf_m68k_bfd2got_entry_del);
1755 if (multi_got->bfd2got == NULL)
1757 bfd_set_error (bfd_error_no_memory);
1763 ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH
1764 ? INSERT : NO_INSERT));
1767 if (howto == SEARCH)
1768 /* Entry not found. */
1771 /* We're out of memory. */
1772 bfd_set_error (bfd_error_no_memory);
1777 /* Entry was not found. Create new one. */
1779 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1781 entry = ((struct elf_m68k_bfd2got_entry *)
1782 bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)));
1788 entry->got = elf_m68k_create_empty_got (info);
1789 if (entry->got == NULL)
1796 BFD_ASSERT (howto != MUST_CREATE);
1798 /* Return existing entry. */
1805 struct elf_m68k_can_merge_gots_arg
1807 /* A current_got that we constructing a DIFF against. */
1808 struct elf_m68k_got *big;
1810 /* GOT holding entries not present or that should be changed in
1812 struct elf_m68k_got *diff;
1814 /* Context where to allocate memory. */
1815 struct bfd_link_info *info;
1818 bfd_boolean error_p;
1821 /* Process a single entry from the small GOT to see if it should be added
1822 or updated in the big GOT. */
1825 elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg)
1827 const struct elf_m68k_got_entry *entry1;
1828 struct elf_m68k_can_merge_gots_arg *arg;
1829 const struct elf_m68k_got_entry *entry2;
1830 enum elf_m68k_reloc_type type;
1832 entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr;
1833 arg = (struct elf_m68k_can_merge_gots_arg *) _arg;
1835 entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL);
1838 /* We found an existing entry. Check if we should update it. */
1840 type = elf_m68k_update_got_entry_type (arg->diff,
1844 if (type == entry2->key_.type)
1845 /* ENTRY1 doesn't update data in ENTRY2. Skip it.
1846 To skip creation of difference entry we use the type,
1847 which we won't see in GOT entries for sure. */
1851 /* We didn't find the entry. Add entry1 to DIFF. */
1853 BFD_ASSERT (entry1->key_.type != R_68K_max);
1855 type = elf_m68k_update_got_entry_type (arg->diff,
1856 R_68K_max, entry1->key_.type);
1858 if (entry1->key_.bfd != NULL)
1859 arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type);
1862 if (type != R_68K_max)
1863 /* Create an entry in DIFF. */
1865 struct elf_m68k_got_entry *entry;
1867 entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE,
1871 arg->error_p = TRUE;
1875 entry->key_.type = type;
1881 /* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it.
1882 Construct DIFF GOT holding the entries which should be added or updated
1883 in BIG GOT to accumulate information from SMALL.
1884 INFO is the context where memory should be allocated. */
1887 elf_m68k_can_merge_gots (struct elf_m68k_got *big,
1888 const struct elf_m68k_got *small,
1889 struct bfd_link_info *info,
1890 struct elf_m68k_got *diff)
1892 struct elf_m68k_can_merge_gots_arg arg_;
1894 BFD_ASSERT (small->offset == (bfd_vma) -1);
1899 arg_.error_p = FALSE;
1900 htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_);
1907 /* Check for overflow. */
1908 if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8]
1909 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1910 || (big->n_slots[R_16] + arg_.diff->n_slots[R_16]
1911 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1917 struct elf_m68k_merge_gots_arg
1920 struct elf_m68k_got *big;
1922 /* Context where memory should be allocated. */
1923 struct bfd_link_info *info;
1926 bfd_boolean error_p;
1929 /* Process a single entry from DIFF got. Add or update corresponding
1930 entry in the BIG got. */
1933 elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg)
1935 const struct elf_m68k_got_entry *from;
1936 struct elf_m68k_merge_gots_arg *arg;
1937 struct elf_m68k_got_entry *to;
1939 from = (const struct elf_m68k_got_entry *) *entry_ptr;
1940 arg = (struct elf_m68k_merge_gots_arg *) _arg;
1942 to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE,
1946 arg->error_p = TRUE;
1950 BFD_ASSERT (to->u.s1.refcount == 0);
1951 /* All we need to merge is TYPE. */
1952 to->key_.type = from->key_.type;
1957 /* Merge data from DIFF to BIG. INFO is context where memory should be
1961 elf_m68k_merge_gots (struct elf_m68k_got *big,
1962 struct elf_m68k_got *diff,
1963 struct bfd_link_info *info)
1965 if (diff->entries != NULL)
1966 /* DIFF is not empty. Merge it into BIG GOT. */
1968 struct elf_m68k_merge_gots_arg arg_;
1970 /* Merge entries. */
1973 arg_.error_p = FALSE;
1974 htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_);
1978 /* Merge counters. */
1979 big->n_slots[R_8] += diff->n_slots[R_8];
1980 big->n_slots[R_16] += diff->n_slots[R_16];
1981 big->n_slots[R_32] += diff->n_slots[R_32];
1982 big->local_n_slots += diff->local_n_slots;
1985 /* DIFF is empty. */
1987 BFD_ASSERT (diff->n_slots[R_8] == 0);
1988 BFD_ASSERT (diff->n_slots[R_16] == 0);
1989 BFD_ASSERT (diff->n_slots[R_32] == 0);
1990 BFD_ASSERT (diff->local_n_slots == 0);
1993 BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p
1994 || ((big->n_slots[R_8]
1995 <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1996 && (big->n_slots[R_16]
1997 <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))));
2002 struct elf_m68k_finalize_got_offsets_arg
2004 /* Ranges of the offsets for GOT entries.
2005 R_x entries receive offsets between offset1[R_x] and offset2[R_x].
2006 R_x is R_8, R_16 and R_32. */
2010 /* Mapping from global symndx to global symbols.
2011 This is used to build lists of got entries for global symbols. */
2012 struct elf_m68k_link_hash_entry **symndx2h;
2014 bfd_vma n_ldm_entries;
2017 /* Assign ENTRY an offset. Build list of GOT entries for global symbols
2021 elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg)
2023 struct elf_m68k_got_entry *entry;
2024 struct elf_m68k_finalize_got_offsets_arg *arg;
2026 enum elf_m68k_got_offset_size got_offset_size;
2029 entry = (struct elf_m68k_got_entry *) *entry_ptr;
2030 arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg;
2032 /* This should be a fresh entry created in elf_m68k_can_merge_gots. */
2033 BFD_ASSERT (entry->u.s1.refcount == 0);
2035 /* Get GOT offset size for the entry . */
2036 got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type);
2038 /* Calculate entry size in bytes. */
2039 entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type);
2041 /* Check if we should switch to negative range of the offsets. */
2042 if (arg->offset1[got_offset_size] + entry_size
2043 > arg->offset2[got_offset_size])
2045 /* Verify that this is the only switch to negative range for
2046 got_offset_size. If this assertion fails, then we've miscalculated
2047 range for got_offset_size entries in
2048 elf_m68k_finalize_got_offsets. */
2049 BFD_ASSERT (arg->offset2[got_offset_size]
2050 != arg->offset2[-(int) got_offset_size - 1]);
2053 arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1];
2054 arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1];
2056 /* Verify that now we have enough room for the entry. */
2057 BFD_ASSERT (arg->offset1[got_offset_size] + entry_size
2058 <= arg->offset2[got_offset_size]);
2061 /* Assign offset to entry. */
2062 entry->u.s2.offset = arg->offset1[got_offset_size];
2063 arg->offset1[got_offset_size] += entry_size;
2065 if (entry->key_.bfd == NULL)
2066 /* Hook up this entry into the list of got_entries of H. */
2068 struct elf_m68k_link_hash_entry *h;
2070 h = arg->symndx2h[entry->key_.symndx];
2073 entry->u.s2.next = h->glist;
2077 /* This should be the entry for TLS_LDM relocation then. */
2079 BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type)
2081 && entry->key_.symndx == 0);
2083 ++arg->n_ldm_entries;
2087 /* This entry is for local symbol. */
2088 entry->u.s2.next = NULL;
2093 /* Assign offsets within GOT. USE_NEG_GOT_OFFSETS_P indicates if we
2094 should use negative offsets.
2095 Build list of GOT entries for global symbols along the way.
2096 SYMNDX2H is mapping from global symbol indices to actual
2098 Return offset at which next GOT should start. */
2101 elf_m68k_finalize_got_offsets (struct elf_m68k_got *got,
2102 bfd_boolean use_neg_got_offsets_p,
2103 struct elf_m68k_link_hash_entry **symndx2h,
2104 bfd_vma *final_offset, bfd_vma *n_ldm_entries)
2106 struct elf_m68k_finalize_got_offsets_arg arg_;
2107 bfd_vma offset1_[2 * R_LAST];
2108 bfd_vma offset2_[2 * R_LAST];
2110 bfd_vma start_offset;
2112 BFD_ASSERT (got->offset != (bfd_vma) -1);
2114 /* We set entry offsets relative to the .got section (and not the
2115 start of a particular GOT), so that we can use them in
2116 finish_dynamic_symbol without needing to know the GOT which they come
2119 /* Put offset1 in the middle of offset1_, same for offset2. */
2120 arg_.offset1 = offset1_ + R_LAST;
2121 arg_.offset2 = offset2_ + R_LAST;
2123 start_offset = got->offset;
2125 if (use_neg_got_offsets_p)
2126 /* Setup both negative and positive ranges for R_8, R_16 and R_32. */
2127 i = -(int) R_32 - 1;
2129 /* Setup positives ranges for R_8, R_16 and R_32. */
2132 for (; i <= (int) R_32; ++i)
2137 /* Set beginning of the range of offsets I. */
2138 arg_.offset1[i] = start_offset;
2140 /* Calculate number of slots that require I offsets. */
2141 j = (i >= 0) ? i : -i - 1;
2142 n = (j >= 1) ? got->n_slots[j - 1] : 0;
2143 n = got->n_slots[j] - n;
2145 if (use_neg_got_offsets_p && n != 0)
2148 /* We first fill the positive side of the range, so we might
2149 end up with one empty slot at that side when we can't fit
2150 whole 2-slot entry. Account for that at negative side of
2151 the interval with one additional entry. */
2154 /* When the number of slots is odd, make positive side of the
2155 range one entry bigger. */
2159 /* N is the number of slots that require I offsets.
2160 Calculate length of the range for I offsets. */
2163 /* Set end of the range. */
2164 arg_.offset2[i] = start_offset + n;
2166 start_offset = arg_.offset2[i];
2169 if (!use_neg_got_offsets_p)
2170 /* Make sure that if we try to switch to negative offsets in
2171 elf_m68k_finalize_got_offsets_1, the assert therein will catch
2173 for (i = R_8; i <= R_32; ++i)
2174 arg_.offset2[-i - 1] = arg_.offset2[i];
2176 /* Setup got->offset. offset1[R_8] is either in the middle or at the
2177 beginning of GOT depending on use_neg_got_offsets_p. */
2178 got->offset = arg_.offset1[R_8];
2180 arg_.symndx2h = symndx2h;
2181 arg_.n_ldm_entries = 0;
2183 /* Assign offsets. */
2184 htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_);
2186 /* Check offset ranges we have actually assigned. */
2187 for (i = (int) R_8; i <= (int) R_32; ++i)
2188 BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4);
2190 *final_offset = start_offset;
2191 *n_ldm_entries = arg_.n_ldm_entries;
2194 struct elf_m68k_partition_multi_got_arg
2196 /* The GOT we are adding entries to. Aka big got. */
2197 struct elf_m68k_got *current_got;
2199 /* Offset to assign the next CURRENT_GOT. */
2202 /* Context where memory should be allocated. */
2203 struct bfd_link_info *info;
2205 /* Total number of slots in the .got section.
2206 This is used to calculate size of the .got and .rela.got sections. */
2209 /* Difference in numbers of allocated slots in the .got section
2210 and necessary relocations in the .rela.got section.
2211 This is used to calculate size of the .rela.got section. */
2212 bfd_vma slots_relas_diff;
2215 bfd_boolean error_p;
2217 /* Mapping from global symndx to global symbols.
2218 This is used to build lists of got entries for global symbols. */
2219 struct elf_m68k_link_hash_entry **symndx2h;
2223 elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg)
2225 bfd_vma n_ldm_entries;
2227 elf_m68k_finalize_got_offsets (arg->current_got,
2228 (elf_m68k_hash_table (arg->info)
2229 ->use_neg_got_offsets_p),
2231 &arg->offset, &n_ldm_entries);
2233 arg->n_slots += arg->current_got->n_slots[R_32];
2235 if (!arg->info->shared)
2236 /* If we are generating a shared object, we need to
2237 output a R_68K_RELATIVE reloc so that the dynamic
2238 linker can adjust this GOT entry. Overwise we
2239 don't need space in .rela.got for local symbols. */
2240 arg->slots_relas_diff += arg->current_got->local_n_slots;
2242 /* @LDM relocations require a 2-slot GOT entry, but only
2243 one relocation. Account for that. */
2244 arg->slots_relas_diff += n_ldm_entries;
2246 BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots);
2250 /* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT
2251 or start a new CURRENT_GOT. */
2254 elf_m68k_partition_multi_got_1 (void **_entry, void *_arg)
2256 struct elf_m68k_bfd2got_entry *entry;
2257 struct elf_m68k_partition_multi_got_arg *arg;
2258 struct elf_m68k_got *got;
2259 struct elf_m68k_got diff_;
2260 struct elf_m68k_got *diff;
2262 entry = (struct elf_m68k_bfd2got_entry *) *_entry;
2263 arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2266 BFD_ASSERT (got != NULL);
2267 BFD_ASSERT (got->offset == (bfd_vma) -1);
2271 if (arg->current_got != NULL)
2272 /* Construct diff. */
2275 elf_m68k_init_got (diff);
2277 if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff))
2279 if (diff->offset == 0)
2280 /* Offset set to 0 in the diff_ indicates an error. */
2282 arg->error_p = TRUE;
2286 if (elf_m68k_hash_table (arg->info)->allow_multigot_p)
2288 elf_m68k_clear_got (diff);
2289 /* Schedule to finish up current_got and start new one. */
2293 Merge GOTs no matter what. If big GOT overflows,
2294 we'll fail in relocate_section due to truncated relocations.
2296 ??? May be fail earlier? E.g., in can_merge_gots. */
2300 /* Diff of got against empty current_got is got itself. */
2302 /* Create empty current_got to put subsequent GOTs to. */
2303 arg->current_got = elf_m68k_create_empty_got (arg->info);
2304 if (arg->current_got == NULL)
2306 arg->error_p = TRUE;
2310 arg->current_got->offset = arg->offset;
2317 if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info))
2319 arg->error_p = TRUE;
2323 /* Now we can free GOT. */
2324 elf_m68k_clear_got (got);
2326 entry->got = arg->current_got;
2330 /* Finish up current_got. */
2331 elf_m68k_partition_multi_got_2 (arg);
2333 /* Schedule to start a new current_got. */
2334 arg->current_got = NULL;
2337 if (!elf_m68k_partition_multi_got_1 (_entry, _arg))
2339 BFD_ASSERT (arg->error_p);
2346 elf_m68k_clear_got (diff);
2348 return arg->error_p == FALSE ? 1 : 0;
2351 /* Helper function to build symndx2h mapping. */
2354 elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h,
2357 struct elf_m68k_link_hash_entry *h;
2359 h = elf_m68k_hash_entry (_h);
2361 if (h->got_entry_key != 0)
2362 /* H has at least one entry in the GOT. */
2364 struct elf_m68k_partition_multi_got_arg *arg;
2366 arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2368 BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL);
2369 arg->symndx2h[h->got_entry_key] = h;
2375 /* Merge GOTs of some BFDs, assign offsets to GOT entries and build
2376 lists of GOT entries for global symbols.
2377 Calculate sizes of .got and .rela.got sections. */
2380 elf_m68k_partition_multi_got (struct bfd_link_info *info)
2382 struct elf_m68k_multi_got *multi_got;
2383 struct elf_m68k_partition_multi_got_arg arg_;
2385 multi_got = elf_m68k_multi_got (info);
2387 arg_.current_got = NULL;
2391 arg_.slots_relas_diff = 0;
2392 arg_.error_p = FALSE;
2394 if (multi_got->bfd2got != NULL)
2396 /* Initialize symndx2h mapping. */
2398 arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx
2399 * sizeof (*arg_.symndx2h));
2400 if (arg_.symndx2h == NULL)
2403 elf_link_hash_traverse (elf_hash_table (info),
2404 elf_m68k_init_symndx2h_1, &arg_);
2408 htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1,
2412 free (arg_.symndx2h);
2413 arg_.symndx2h = NULL;
2418 /* Finish up last current_got. */
2419 elf_m68k_partition_multi_got_2 (&arg_);
2421 free (arg_.symndx2h);
2424 if (elf_hash_table (info)->dynobj != NULL)
2425 /* Set sizes of .got and .rela.got sections. */
2429 s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".got");
2431 s->size = arg_.offset;
2433 BFD_ASSERT (arg_.offset == 0);
2435 BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots);
2436 arg_.n_slots -= arg_.slots_relas_diff;
2438 s = bfd_get_linker_section (elf_hash_table (info)->dynobj, ".rela.got");
2440 s->size = arg_.n_slots * sizeof (Elf32_External_Rela);
2442 BFD_ASSERT (arg_.n_slots == 0);
2445 BFD_ASSERT (multi_got->bfd2got == NULL);
2450 /* Specialized version of elf_m68k_get_got_entry that returns pointer
2451 to hashtable slot, thus allowing removal of entry via
2452 elf_m68k_remove_got_entry. */
2454 static struct elf_m68k_got_entry **
2455 elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got,
2456 struct elf_m68k_got_entry_key *key)
2459 struct elf_m68k_got_entry entry_;
2460 struct elf_m68k_got_entry **entry_ptr;
2463 ptr = htab_find_slot (got->entries, &entry_, NO_INSERT);
2464 BFD_ASSERT (ptr != NULL);
2466 entry_ptr = (struct elf_m68k_got_entry **) ptr;
2471 /* Remove entry pointed to by ENTRY_PTR from GOT. */
2474 elf_m68k_remove_got_entry (struct elf_m68k_got *got,
2475 struct elf_m68k_got_entry **entry_ptr)
2477 struct elf_m68k_got_entry *entry;
2481 /* Check that offsets have not been finalized yet. */
2482 BFD_ASSERT (got->offset == (bfd_vma) -1);
2483 /* Check that this entry is indeed unused. */
2484 BFD_ASSERT (entry->u.s1.refcount == 0);
2486 elf_m68k_remove_got_entry_type (got, entry->key_.type);
2488 if (entry->key_.bfd != NULL)
2489 got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type);
2491 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
2493 htab_clear_slot (got->entries, (void **) entry_ptr);
2496 /* Copy any information related to dynamic linking from a pre-existing
2497 symbol to a newly created symbol. Also called to copy flags and
2498 other back-end info to a weakdef, in which case the symbol is not
2499 newly created and plt/got refcounts and dynamic indices should not
2503 elf_m68k_copy_indirect_symbol (struct bfd_link_info *info,
2504 struct elf_link_hash_entry *_dir,
2505 struct elf_link_hash_entry *_ind)
2507 struct elf_m68k_link_hash_entry *dir;
2508 struct elf_m68k_link_hash_entry *ind;
2510 _bfd_elf_link_hash_copy_indirect (info, _dir, _ind);
2512 if (_ind->root.type != bfd_link_hash_indirect)
2515 dir = elf_m68k_hash_entry (_dir);
2516 ind = elf_m68k_hash_entry (_ind);
2518 /* Any absolute non-dynamic relocations against an indirect or weak
2519 definition will be against the target symbol. */
2520 _dir->non_got_ref |= _ind->non_got_ref;
2522 /* We might have a direct symbol already having entries in the GOTs.
2523 Update its key only in case indirect symbol has GOT entries and
2524 assert that both indirect and direct symbols don't have GOT entries
2525 at the same time. */
2526 if (ind->got_entry_key != 0)
2528 BFD_ASSERT (dir->got_entry_key == 0);
2529 /* Assert that GOTs aren't partioned yet. */
2530 BFD_ASSERT (ind->glist == NULL);
2532 dir->got_entry_key = ind->got_entry_key;
2533 ind->got_entry_key = 0;
2537 /* Look through the relocs for a section during the first phase, and
2538 allocate space in the global offset table or procedure linkage
2542 elf_m68k_check_relocs (bfd *abfd,
2543 struct bfd_link_info *info,
2545 const Elf_Internal_Rela *relocs)
2548 Elf_Internal_Shdr *symtab_hdr;
2549 struct elf_link_hash_entry **sym_hashes;
2550 const Elf_Internal_Rela *rel;
2551 const Elf_Internal_Rela *rel_end;
2555 struct elf_m68k_got *got;
2557 if (info->relocatable)
2560 dynobj = elf_hash_table (info)->dynobj;
2561 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2562 sym_hashes = elf_sym_hashes (abfd);
2570 rel_end = relocs + sec->reloc_count;
2571 for (rel = relocs; rel < rel_end; rel++)
2573 unsigned long r_symndx;
2574 struct elf_link_hash_entry *h;
2576 r_symndx = ELF32_R_SYM (rel->r_info);
2578 if (r_symndx < symtab_hdr->sh_info)
2582 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2583 while (h->root.type == bfd_link_hash_indirect
2584 || h->root.type == bfd_link_hash_warning)
2585 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2588 switch (ELF32_R_TYPE (rel->r_info))
2594 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2598 /* Relative GOT relocations. */
2604 /* TLS relocations. */
2606 case R_68K_TLS_GD16:
2607 case R_68K_TLS_GD32:
2608 case R_68K_TLS_LDM8:
2609 case R_68K_TLS_LDM16:
2610 case R_68K_TLS_LDM32:
2612 case R_68K_TLS_IE16:
2613 case R_68K_TLS_IE32:
2615 case R_68K_TLS_TPREL32:
2616 case R_68K_TLS_DTPREL32:
2618 if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2620 /* Do the special chorus for libraries with static TLS. */
2621 info->flags |= DF_STATIC_TLS;
2623 /* This symbol requires a global offset table entry. */
2627 /* Create the .got section. */
2628 elf_hash_table (info)->dynobj = dynobj = abfd;
2629 if (!_bfd_elf_create_got_section (dynobj, info))
2635 sgot = bfd_get_linker_section (dynobj, ".got");
2636 BFD_ASSERT (sgot != NULL);
2640 && (h != NULL || info->shared))
2642 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2643 if (srelgot == NULL)
2645 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2646 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2648 srelgot = bfd_make_section_anyway_with_flags (dynobj,
2652 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2659 struct elf_m68k_bfd2got_entry *bfd2got_entry;
2662 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2663 abfd, FIND_OR_CREATE, info);
2664 if (bfd2got_entry == NULL)
2667 got = bfd2got_entry->got;
2668 BFD_ASSERT (got != NULL);
2672 struct elf_m68k_got_entry *got_entry;
2674 /* Add entry to got. */
2675 got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2676 ELF32_R_TYPE (rel->r_info),
2678 if (got_entry == NULL)
2681 if (got_entry->u.s1.refcount == 1)
2683 /* Make sure this symbol is output as a dynamic symbol. */
2686 && !h->forced_local)
2688 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2699 /* This symbol requires a procedure linkage table entry. We
2700 actually build the entry in adjust_dynamic_symbol,
2701 because this might be a case of linking PIC code which is
2702 never referenced by a dynamic object, in which case we
2703 don't need to generate a procedure linkage table entry
2706 /* If this is a local symbol, we resolve it directly without
2707 creating a procedure linkage table entry. */
2718 /* This symbol requires a procedure linkage table entry. */
2722 /* It does not make sense to have this relocation for a
2723 local symbol. FIXME: does it? How to handle it if
2724 it does make sense? */
2725 bfd_set_error (bfd_error_bad_value);
2729 /* Make sure this symbol is output as a dynamic symbol. */
2730 if (h->dynindx == -1
2731 && !h->forced_local)
2733 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2744 /* If we are creating a shared library and this is not a local
2745 symbol, we need to copy the reloc into the shared library.
2746 However when linking with -Bsymbolic and this is a global
2747 symbol which is defined in an object we are including in the
2748 link (i.e., DEF_REGULAR is set), then we can resolve the
2749 reloc directly. At this point we have not seen all the input
2750 files, so it is possible that DEF_REGULAR is not set now but
2751 will be set later (it is never cleared). We account for that
2752 possibility below by storing information in the
2753 pcrel_relocs_copied field of the hash table entry. */
2755 && (sec->flags & SEC_ALLOC) != 0
2758 || h->root.type == bfd_link_hash_defweak
2759 || !h->def_regular)))
2763 /* Make sure a plt entry is created for this symbol if
2764 it turns out to be a function defined by a dynamic
2774 /* We don't need to handle relocs into sections not going into
2775 the "real" output. */
2776 if ((sec->flags & SEC_ALLOC) == 0)
2781 /* Make sure a plt entry is created for this symbol if it
2782 turns out to be a function defined by a dynamic object. */
2785 if (info->executable)
2786 /* This symbol needs a non-GOT reference. */
2790 /* If we are creating a shared library, we need to copy the
2791 reloc into the shared library. */
2794 /* When creating a shared object, we must copy these
2795 reloc types into the output file. We create a reloc
2796 section in dynobj and make room for this reloc. */
2799 sreloc = _bfd_elf_make_dynamic_reloc_section
2800 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2806 if (sec->flags & SEC_READONLY
2807 /* Don't set DF_TEXTREL yet for PC relative
2808 relocations, they might be discarded later. */
2809 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2810 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2811 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2812 info->flags |= DF_TEXTREL;
2814 sreloc->size += sizeof (Elf32_External_Rela);
2816 /* We count the number of PC relative relocations we have
2817 entered for this symbol, so that we can discard them
2818 again if, in the -Bsymbolic case, the symbol is later
2819 defined by a regular object, or, in the normal shared
2820 case, the symbol is forced to be local. Note that this
2821 function is only called if we are using an m68kelf linker
2822 hash table, which means that h is really a pointer to an
2823 elf_m68k_link_hash_entry. */
2824 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2825 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2826 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2828 struct elf_m68k_pcrel_relocs_copied *p;
2829 struct elf_m68k_pcrel_relocs_copied **head;
2833 struct elf_m68k_link_hash_entry *eh
2834 = elf_m68k_hash_entry (h);
2835 head = &eh->pcrel_relocs_copied;
2841 Elf_Internal_Sym *isym;
2843 isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2848 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2852 vpp = &elf_section_data (s)->local_dynrel;
2853 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2856 for (p = *head; p != NULL; p = p->next)
2857 if (p->section == sreloc)
2862 p = ((struct elf_m68k_pcrel_relocs_copied *)
2863 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2868 p->section = sreloc;
2878 /* This relocation describes the C++ object vtable hierarchy.
2879 Reconstruct it for later use during GC. */
2880 case R_68K_GNU_VTINHERIT:
2881 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2885 /* This relocation describes which C++ vtable entries are actually
2886 used. Record for later use during GC. */
2887 case R_68K_GNU_VTENTRY:
2888 BFD_ASSERT (h != NULL);
2890 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2902 /* Return the section that should be marked against GC for a given
2906 elf_m68k_gc_mark_hook (asection *sec,
2907 struct bfd_link_info *info,
2908 Elf_Internal_Rela *rel,
2909 struct elf_link_hash_entry *h,
2910 Elf_Internal_Sym *sym)
2913 switch (ELF32_R_TYPE (rel->r_info))
2915 case R_68K_GNU_VTINHERIT:
2916 case R_68K_GNU_VTENTRY:
2920 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2923 /* Update the got entry reference counts for the section being removed. */
2926 elf_m68k_gc_sweep_hook (bfd *abfd,
2927 struct bfd_link_info *info,
2929 const Elf_Internal_Rela *relocs)
2931 Elf_Internal_Shdr *symtab_hdr;
2932 struct elf_link_hash_entry **sym_hashes;
2933 const Elf_Internal_Rela *rel, *relend;
2935 struct elf_m68k_got *got;
2937 if (info->relocatable)
2940 dynobj = elf_hash_table (info)->dynobj;
2944 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2945 sym_hashes = elf_sym_hashes (abfd);
2948 relend = relocs + sec->reloc_count;
2949 for (rel = relocs; rel < relend; rel++)
2951 unsigned long r_symndx;
2952 struct elf_link_hash_entry *h = NULL;
2954 r_symndx = ELF32_R_SYM (rel->r_info);
2955 if (r_symndx >= symtab_hdr->sh_info)
2957 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2958 while (h->root.type == bfd_link_hash_indirect
2959 || h->root.type == bfd_link_hash_warning)
2960 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2963 switch (ELF32_R_TYPE (rel->r_info))
2969 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2978 /* TLS relocations. */
2980 case R_68K_TLS_GD16:
2981 case R_68K_TLS_GD32:
2982 case R_68K_TLS_LDM8:
2983 case R_68K_TLS_LDM16:
2984 case R_68K_TLS_LDM32:
2986 case R_68K_TLS_IE16:
2987 case R_68K_TLS_IE32:
2989 case R_68K_TLS_TPREL32:
2990 case R_68K_TLS_DTPREL32:
2994 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2995 abfd, MUST_FIND, NULL)->got;
2996 BFD_ASSERT (got != NULL);
3000 struct elf_m68k_got_entry_key key_;
3001 struct elf_m68k_got_entry **got_entry_ptr;
3002 struct elf_m68k_got_entry *got_entry;
3004 elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3005 ELF32_R_TYPE (rel->r_info));
3006 got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3008 got_entry = *got_entry_ptr;
3010 if (got_entry->u.s1.refcount > 0)
3012 --got_entry->u.s1.refcount;
3014 if (got_entry->u.s1.refcount == 0)
3015 /* We don't need the .got entry any more. */
3016 elf_m68k_remove_got_entry (got, got_entry_ptr);
3035 if (h->plt.refcount > 0)
3048 /* Return the type of PLT associated with OUTPUT_BFD. */
3050 static const struct elf_m68k_plt_info *
3051 elf_m68k_get_plt_info (bfd *output_bfd)
3053 unsigned int features;
3055 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3056 if (features & cpu32)
3057 return &elf_cpu32_plt_info;
3058 if (features & mcfisa_b)
3059 return &elf_isab_plt_info;
3060 if (features & mcfisa_c)
3061 return &elf_isac_plt_info;
3062 return &elf_m68k_plt_info;
3065 /* This function is called after all the input files have been read,
3066 and the input sections have been assigned to output sections.
3067 It's a convenient place to determine the PLT style. */
3070 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3072 /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3074 if (!elf_m68k_partition_multi_got (info))
3077 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3081 /* Adjust a symbol defined by a dynamic object and referenced by a
3082 regular object. The current definition is in some section of the
3083 dynamic object, but we're not including those sections. We have to
3084 change the definition to something the rest of the link can
3088 elf_m68k_adjust_dynamic_symbol (struct bfd_link_info *info,
3089 struct elf_link_hash_entry *h)
3091 struct elf_m68k_link_hash_table *htab;
3095 htab = elf_m68k_hash_table (info);
3096 dynobj = elf_hash_table (info)->dynobj;
3098 /* Make sure we know what is going on here. */
3099 BFD_ASSERT (dynobj != NULL
3101 || h->u.weakdef != NULL
3104 && !h->def_regular)));
3106 /* If this is a function, put it in the procedure linkage table. We
3107 will fill in the contents of the procedure linkage table later,
3108 when we know the address of the .got section. */
3109 if (h->type == STT_FUNC
3112 if ((h->plt.refcount <= 0
3113 || SYMBOL_CALLS_LOCAL (info, h)
3114 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3115 && h->root.type == bfd_link_hash_undefweak))
3116 /* We must always create the plt entry if it was referenced
3117 by a PLTxxO relocation. In this case we already recorded
3118 it as a dynamic symbol. */
3119 && h->dynindx == -1)
3121 /* This case can occur if we saw a PLTxx reloc in an input
3122 file, but the symbol was never referred to by a dynamic
3123 object, or if all references were garbage collected. In
3124 such a case, we don't actually need to build a procedure
3125 linkage table, and we can just do a PCxx reloc instead. */
3126 h->plt.offset = (bfd_vma) -1;
3131 /* Make sure this symbol is output as a dynamic symbol. */
3132 if (h->dynindx == -1
3133 && !h->forced_local)
3135 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3139 s = bfd_get_linker_section (dynobj, ".plt");
3140 BFD_ASSERT (s != NULL);
3142 /* If this is the first .plt entry, make room for the special
3145 s->size = htab->plt_info->size;
3147 /* If this symbol is not defined in a regular file, and we are
3148 not generating a shared library, then set the symbol to this
3149 location in the .plt. This is required to make function
3150 pointers compare as equal between the normal executable and
3151 the shared library. */
3155 h->root.u.def.section = s;
3156 h->root.u.def.value = s->size;
3159 h->plt.offset = s->size;
3161 /* Make room for this entry. */
3162 s->size += htab->plt_info->size;
3164 /* We also need to make an entry in the .got.plt section, which
3165 will be placed in the .got section by the linker script. */
3166 s = bfd_get_linker_section (dynobj, ".got.plt");
3167 BFD_ASSERT (s != NULL);
3170 /* We also need to make an entry in the .rela.plt section. */
3171 s = bfd_get_linker_section (dynobj, ".rela.plt");
3172 BFD_ASSERT (s != NULL);
3173 s->size += sizeof (Elf32_External_Rela);
3178 /* Reinitialize the plt offset now that it is not used as a reference
3180 h->plt.offset = (bfd_vma) -1;
3182 /* If this is a weak symbol, and there is a real definition, the
3183 processor independent code will have arranged for us to see the
3184 real definition first, and we can just use the same value. */
3185 if (h->u.weakdef != NULL)
3187 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3188 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3189 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3190 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3194 /* This is a reference to a symbol defined by a dynamic object which
3195 is not a function. */
3197 /* If we are creating a shared library, we must presume that the
3198 only references to the symbol are via the global offset table.
3199 For such cases we need not do anything here; the relocations will
3200 be handled correctly by relocate_section. */
3204 /* If there are no references to this symbol that do not use the
3205 GOT, we don't need to generate a copy reloc. */
3206 if (!h->non_got_ref)
3209 /* We must allocate the symbol in our .dynbss section, which will
3210 become part of the .bss section of the executable. There will be
3211 an entry for this symbol in the .dynsym section. The dynamic
3212 object will contain position independent code, so all references
3213 from the dynamic object to this symbol will go through the global
3214 offset table. The dynamic linker will use the .dynsym entry to
3215 determine the address it must put in the global offset table, so
3216 both the dynamic object and the regular object will refer to the
3217 same memory location for the variable. */
3219 s = bfd_get_linker_section (dynobj, ".dynbss");
3220 BFD_ASSERT (s != NULL);
3222 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3223 copy the initial value out of the dynamic object and into the
3224 runtime process image. We need to remember the offset into the
3225 .rela.bss section we are going to use. */
3226 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3230 srel = bfd_get_linker_section (dynobj, ".rela.bss");
3231 BFD_ASSERT (srel != NULL);
3232 srel->size += sizeof (Elf32_External_Rela);
3236 return _bfd_elf_adjust_dynamic_copy (h, s);
3239 /* Set the sizes of the dynamic sections. */
3242 elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3243 struct bfd_link_info *info)
3250 dynobj = elf_hash_table (info)->dynobj;
3251 BFD_ASSERT (dynobj != NULL);
3253 if (elf_hash_table (info)->dynamic_sections_created)
3255 /* Set the contents of the .interp section to the interpreter. */
3256 if (info->executable)
3258 s = bfd_get_linker_section (dynobj, ".interp");
3259 BFD_ASSERT (s != NULL);
3260 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3261 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3266 /* We may have created entries in the .rela.got section.
3267 However, if we are not creating the dynamic sections, we will
3268 not actually use these entries. Reset the size of .rela.got,
3269 which will cause it to get stripped from the output file
3271 s = bfd_get_linker_section (dynobj, ".rela.got");
3276 /* If this is a -Bsymbolic shared link, then we need to discard all
3277 PC relative relocs against symbols defined in a regular object.
3278 For the normal shared case we discard the PC relative relocs
3279 against symbols that have become local due to visibility changes.
3280 We allocated space for them in the check_relocs routine, but we
3281 will not fill them in in the relocate_section routine. */
3283 elf_link_hash_traverse (elf_hash_table (info),
3284 elf_m68k_discard_copies,
3287 /* The check_relocs and adjust_dynamic_symbol entry points have
3288 determined the sizes of the various dynamic sections. Allocate
3292 for (s = dynobj->sections; s != NULL; s = s->next)
3296 if ((s->flags & SEC_LINKER_CREATED) == 0)
3299 /* It's OK to base decisions on the section name, because none
3300 of the dynobj section names depend upon the input files. */
3301 name = bfd_get_section_name (dynobj, s);
3303 if (strcmp (name, ".plt") == 0)
3305 /* Remember whether there is a PLT. */
3308 else if (CONST_STRNEQ (name, ".rela"))
3314 /* We use the reloc_count field as a counter if we need
3315 to copy relocs into the output file. */
3319 else if (! CONST_STRNEQ (name, ".got")
3320 && strcmp (name, ".dynbss") != 0)
3322 /* It's not one of our sections, so don't allocate space. */
3328 /* If we don't need this section, strip it from the
3329 output file. This is mostly to handle .rela.bss and
3330 .rela.plt. We must create both sections in
3331 create_dynamic_sections, because they must be created
3332 before the linker maps input sections to output
3333 sections. The linker does that before
3334 adjust_dynamic_symbol is called, and it is that
3335 function which decides whether anything needs to go
3336 into these sections. */
3337 s->flags |= SEC_EXCLUDE;
3341 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3344 /* Allocate memory for the section contents. */
3345 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3346 Unused entries should be reclaimed before the section's contents
3347 are written out, but at the moment this does not happen. Thus in
3348 order to prevent writing out garbage, we initialise the section's
3349 contents to zero. */
3350 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3351 if (s->contents == NULL)
3355 if (elf_hash_table (info)->dynamic_sections_created)
3357 /* Add some entries to the .dynamic section. We fill in the
3358 values later, in elf_m68k_finish_dynamic_sections, but we
3359 must add the entries now so that we get the correct size for
3360 the .dynamic section. The DT_DEBUG entry is filled in by the
3361 dynamic linker and used by the debugger. */
3362 #define add_dynamic_entry(TAG, VAL) \
3363 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3367 if (!add_dynamic_entry (DT_DEBUG, 0))
3373 if (!add_dynamic_entry (DT_PLTGOT, 0)
3374 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3375 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3376 || !add_dynamic_entry (DT_JMPREL, 0))
3382 if (!add_dynamic_entry (DT_RELA, 0)
3383 || !add_dynamic_entry (DT_RELASZ, 0)
3384 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3388 if ((info->flags & DF_TEXTREL) != 0)
3390 if (!add_dynamic_entry (DT_TEXTREL, 0))
3394 #undef add_dynamic_entry
3399 /* This function is called via elf_link_hash_traverse if we are
3400 creating a shared object. In the -Bsymbolic case it discards the
3401 space allocated to copy PC relative relocs against symbols which
3402 are defined in regular objects. For the normal shared case, it
3403 discards space for pc-relative relocs that have become local due to
3404 symbol visibility changes. We allocated space for them in the
3405 check_relocs routine, but we won't fill them in in the
3406 relocate_section routine.
3408 We also check whether any of the remaining relocations apply
3409 against a readonly section, and set the DF_TEXTREL flag in this
3413 elf_m68k_discard_copies (struct elf_link_hash_entry *h,
3416 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3417 struct elf_m68k_pcrel_relocs_copied *s;
3419 if (!SYMBOL_CALLS_LOCAL (info, h))
3421 if ((info->flags & DF_TEXTREL) == 0)
3423 /* Look for relocations against read-only sections. */
3424 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3427 if ((s->section->flags & SEC_READONLY) != 0)
3429 info->flags |= DF_TEXTREL;
3434 /* Make sure undefined weak symbols are output as a dynamic symbol
3437 && h->root.type == bfd_link_hash_undefweak
3438 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3440 && !h->forced_local)
3442 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3449 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3452 s->section->size -= s->count * sizeof (Elf32_External_Rela);
3458 /* Install relocation RELA. */
3461 elf_m68k_install_rela (bfd *output_bfd,
3463 Elf_Internal_Rela *rela)
3467 loc = srela->contents;
3468 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3469 bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3472 /* Find the base offsets for thread-local storage in this object,
3473 for GD/LD and IE/LE respectively. */
3475 #define DTP_OFFSET 0x8000
3476 #define TP_OFFSET 0x7000
3479 dtpoff_base (struct bfd_link_info *info)
3481 /* If tls_sec is NULL, we should have signalled an error already. */
3482 if (elf_hash_table (info)->tls_sec == NULL)
3484 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3488 tpoff_base (struct bfd_link_info *info)
3490 /* If tls_sec is NULL, we should have signalled an error already. */
3491 if (elf_hash_table (info)->tls_sec == NULL)
3493 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3496 /* Output necessary relocation to handle a symbol during static link.
3497 This function is called from elf_m68k_relocate_section. */
3500 elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3502 enum elf_m68k_reloc_type r_type,
3504 bfd_vma got_entry_offset,
3507 switch (elf_m68k_reloc_got_type (r_type))
3510 bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3513 case R_68K_TLS_GD32:
3514 /* We know the offset within the module,
3515 put it into the second GOT slot. */
3516 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3517 sgot->contents + got_entry_offset + 4);
3520 case R_68K_TLS_LDM32:
3521 /* Mark it as belonging to module 1, the executable. */
3522 bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3525 case R_68K_TLS_IE32:
3526 bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3527 sgot->contents + got_entry_offset);
3535 /* Output necessary relocation to handle a local symbol
3536 during dynamic link.
3537 This function is called either from elf_m68k_relocate_section
3538 or from elf_m68k_finish_dynamic_symbol. */
3541 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3543 enum elf_m68k_reloc_type r_type,
3545 bfd_vma got_entry_offset,
3549 Elf_Internal_Rela outrel;
3551 switch (elf_m68k_reloc_got_type (r_type))
3554 /* Emit RELATIVE relocation to initialize GOT slot
3556 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3557 outrel.r_addend = relocation;
3560 case R_68K_TLS_GD32:
3561 /* We know the offset within the module,
3562 put it into the second GOT slot. */
3563 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3564 sgot->contents + got_entry_offset + 4);
3567 case R_68K_TLS_LDM32:
3568 /* We don't know the module number,
3569 create a relocation for it. */
3570 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3571 outrel.r_addend = 0;
3574 case R_68K_TLS_IE32:
3575 /* Emit TPREL relocation to initialize GOT slot
3577 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3578 outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3585 /* Offset of the GOT entry. */
3586 outrel.r_offset = (sgot->output_section->vma
3587 + sgot->output_offset
3588 + got_entry_offset);
3590 /* Install one of the above relocations. */
3591 elf_m68k_install_rela (output_bfd, srela, &outrel);
3593 bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3596 /* Relocate an M68K ELF section. */
3599 elf_m68k_relocate_section (bfd *output_bfd,
3600 struct bfd_link_info *info,
3602 asection *input_section,
3604 Elf_Internal_Rela *relocs,
3605 Elf_Internal_Sym *local_syms,
3606 asection **local_sections)
3609 Elf_Internal_Shdr *symtab_hdr;
3610 struct elf_link_hash_entry **sym_hashes;
3615 struct elf_m68k_got *got;
3616 Elf_Internal_Rela *rel;
3617 Elf_Internal_Rela *relend;
3619 dynobj = elf_hash_table (info)->dynobj;
3620 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3621 sym_hashes = elf_sym_hashes (input_bfd);
3631 relend = relocs + input_section->reloc_count;
3632 for (; rel < relend; rel++)
3635 reloc_howto_type *howto;
3636 unsigned long r_symndx;
3637 struct elf_link_hash_entry *h;
3638 Elf_Internal_Sym *sym;
3641 bfd_boolean unresolved_reloc;
3642 bfd_reloc_status_type r;
3644 r_type = ELF32_R_TYPE (rel->r_info);
3645 if (r_type < 0 || r_type >= (int) R_68K_max)
3647 bfd_set_error (bfd_error_bad_value);
3650 howto = howto_table + r_type;
3652 r_symndx = ELF32_R_SYM (rel->r_info);
3657 unresolved_reloc = FALSE;
3659 if (r_symndx < symtab_hdr->sh_info)
3661 sym = local_syms + r_symndx;
3662 sec = local_sections[r_symndx];
3663 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3669 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3670 r_symndx, symtab_hdr, sym_hashes,
3672 unresolved_reloc, warned);
3675 if (sec != NULL && discarded_section (sec))
3676 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3677 rel, 1, relend, howto, 0, contents);
3679 if (info->relocatable)
3687 /* Relocation is to the address of the entry for this symbol
3688 in the global offset table. */
3690 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3692 if (elf_m68k_hash_table (info)->local_gp_p)
3694 bfd_vma sgot_output_offset;
3699 sgot = bfd_get_linker_section (dynobj, ".got");
3702 sgot_output_offset = sgot->output_offset;
3704 /* In this case we have a reference to
3705 _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3707 ??? Issue a warning? */
3708 sgot_output_offset = 0;
3711 sgot_output_offset = sgot->output_offset;
3715 struct elf_m68k_bfd2got_entry *bfd2got_entry;
3718 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3719 input_bfd, SEARCH, NULL);
3721 if (bfd2got_entry != NULL)
3723 got = bfd2got_entry->got;
3724 BFD_ASSERT (got != NULL);
3726 got_offset = got->offset;
3729 /* In this case we have a reference to
3730 _GLOBAL_OFFSET_TABLE_, but no other references
3731 accessing any GOT entries.
3732 ??? Issue a warning? */
3736 got_offset = got->offset;
3738 /* Adjust GOT pointer to point to the GOT
3739 assigned to input_bfd. */
3740 rel->r_addend += sgot_output_offset + got_offset;
3743 BFD_ASSERT (got == NULL || got->offset == 0);
3752 case R_68K_TLS_LDM32:
3753 case R_68K_TLS_LDM16:
3754 case R_68K_TLS_LDM8:
3757 case R_68K_TLS_GD16:
3758 case R_68K_TLS_GD32:
3761 case R_68K_TLS_IE16:
3762 case R_68K_TLS_IE32:
3764 /* Relocation is the offset of the entry for this symbol in
3765 the global offset table. */
3768 struct elf_m68k_got_entry_key key_;
3774 sgot = bfd_get_linker_section (dynobj, ".got");
3775 BFD_ASSERT (sgot != NULL);
3780 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3781 input_bfd, MUST_FIND,
3783 BFD_ASSERT (got != NULL);
3786 /* Get GOT offset for this symbol. */
3787 elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3789 off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3793 /* The offset must always be a multiple of 4. We use
3794 the least significant bit to record whether we have
3795 already generated the necessary reloc. */
3801 /* @TLSLDM relocations are bounded to the module, in
3802 which the symbol is defined -- not to the symbol
3804 && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3808 dyn = elf_hash_table (info)->dynamic_sections_created;
3809 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3811 && SYMBOL_REFERENCES_LOCAL (info, h))
3812 || (ELF_ST_VISIBILITY (h->other)
3813 && h->root.type == bfd_link_hash_undefweak))
3815 /* This is actually a static link, or it is a
3816 -Bsymbolic link and the symbol is defined
3817 locally, or the symbol was forced to be local
3818 because of a version file. We must initialize
3819 this entry in the global offset table. Since
3820 the offset must always be a multiple of 4, we
3821 use the least significant bit to record whether
3822 we have initialized it already.
3824 When doing a dynamic link, we create a .rela.got
3825 relocation entry to initialize the value. This
3826 is done in the finish_dynamic_symbol routine. */
3828 elf_m68k_init_got_entry_static (info,
3838 unresolved_reloc = FALSE;
3840 else if (info->shared) /* && h == NULL */
3841 /* Process local symbol during dynamic link. */
3845 srela = bfd_get_linker_section (dynobj, ".rela.got");
3846 BFD_ASSERT (srela != NULL);
3849 elf_m68k_init_got_entry_local_shared (info,
3859 else /* h == NULL && !info->shared */
3861 elf_m68k_init_got_entry_static (info,
3872 /* We don't use elf_m68k_reloc_got_type in the condition below
3873 because this is the only place where difference between
3874 R_68K_GOTx and R_68K_GOTxO relocations matters. */
3875 if (r_type == R_68K_GOT32O
3876 || r_type == R_68K_GOT16O
3877 || r_type == R_68K_GOT8O
3878 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3879 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3880 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3882 /* GOT pointer is adjusted to point to the start/middle
3883 of local GOT. Adjust the offset accordingly. */
3884 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3885 || off >= got->offset);
3887 if (elf_m68k_hash_table (info)->local_gp_p)
3888 relocation = off - got->offset;
3891 BFD_ASSERT (got->offset == 0);
3892 relocation = sgot->output_offset + off;
3895 /* This relocation does not use the addend. */
3899 relocation = (sgot->output_section->vma + sgot->output_offset
3904 case R_68K_TLS_LDO32:
3905 case R_68K_TLS_LDO16:
3906 case R_68K_TLS_LDO8:
3907 relocation -= dtpoff_base (info);
3910 case R_68K_TLS_LE32:
3911 case R_68K_TLS_LE16:
3913 if (info->shared && !info->pie)
3915 (*_bfd_error_handler)
3916 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3917 "in shared object"),
3918 input_bfd, input_section, (long) rel->r_offset, howto->name);
3923 relocation -= tpoff_base (info);
3930 /* Relocation is to the entry for this symbol in the
3931 procedure linkage table. */
3933 /* Resolve a PLTxx reloc against a local symbol directly,
3934 without using the procedure linkage table. */
3938 if (h->plt.offset == (bfd_vma) -1
3939 || !elf_hash_table (info)->dynamic_sections_created)
3941 /* We didn't make a PLT entry for this symbol. This
3942 happens when statically linking PIC code, or when
3943 using -Bsymbolic. */
3949 splt = bfd_get_linker_section (dynobj, ".plt");
3950 BFD_ASSERT (splt != NULL);
3953 relocation = (splt->output_section->vma
3954 + splt->output_offset
3956 unresolved_reloc = FALSE;
3962 /* Relocation is the offset of the entry for this symbol in
3963 the procedure linkage table. */
3964 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
3968 splt = bfd_get_linker_section (dynobj, ".plt");
3969 BFD_ASSERT (splt != NULL);
3972 relocation = h->plt.offset;
3973 unresolved_reloc = FALSE;
3975 /* This relocation does not use the addend. */
3987 && r_symndx != STN_UNDEF
3988 && (input_section->flags & SEC_ALLOC) != 0
3990 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3991 || h->root.type != bfd_link_hash_undefweak)
3992 && ((r_type != R_68K_PC8
3993 && r_type != R_68K_PC16
3994 && r_type != R_68K_PC32)
3995 || !SYMBOL_CALLS_LOCAL (info, h)))
3997 Elf_Internal_Rela outrel;
3999 bfd_boolean skip, relocate;
4001 /* When generating a shared object, these relocations
4002 are copied into the output file to be resolved at run
4009 _bfd_elf_section_offset (output_bfd, info, input_section,
4011 if (outrel.r_offset == (bfd_vma) -1)
4013 else if (outrel.r_offset == (bfd_vma) -2)
4014 skip = TRUE, relocate = TRUE;
4015 outrel.r_offset += (input_section->output_section->vma
4016 + input_section->output_offset);
4019 memset (&outrel, 0, sizeof outrel);
4022 && (r_type == R_68K_PC8
4023 || r_type == R_68K_PC16
4024 || r_type == R_68K_PC32
4027 || !h->def_regular))
4029 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4030 outrel.r_addend = rel->r_addend;
4034 /* This symbol is local, or marked to become local. */
4035 outrel.r_addend = relocation + rel->r_addend;
4037 if (r_type == R_68K_32)
4040 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4046 if (bfd_is_abs_section (sec))
4048 else if (sec == NULL || sec->owner == NULL)
4050 bfd_set_error (bfd_error_bad_value);
4057 /* We are turning this relocation into one
4058 against a section symbol. It would be
4059 proper to subtract the symbol's value,
4060 osec->vma, from the emitted reloc addend,
4061 but ld.so expects buggy relocs. */
4062 osec = sec->output_section;
4063 indx = elf_section_data (osec)->dynindx;
4066 struct elf_link_hash_table *htab;
4067 htab = elf_hash_table (info);
4068 osec = htab->text_index_section;
4069 indx = elf_section_data (osec)->dynindx;
4071 BFD_ASSERT (indx != 0);
4074 outrel.r_info = ELF32_R_INFO (indx, r_type);
4078 sreloc = elf_section_data (input_section)->sreloc;
4082 loc = sreloc->contents;
4083 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4084 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4086 /* This reloc will be computed at runtime, so there's no
4087 need to do anything now, except for R_68K_32
4088 relocations that have been turned into
4096 case R_68K_GNU_VTINHERIT:
4097 case R_68K_GNU_VTENTRY:
4098 /* These are no-ops in the end. */
4105 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4106 because such sections are not SEC_ALLOC and thus ld.so will
4107 not process them. */
4108 if (unresolved_reloc
4109 && !((input_section->flags & SEC_DEBUGGING) != 0
4111 && _bfd_elf_section_offset (output_bfd, info, input_section,
4112 rel->r_offset) != (bfd_vma) -1)
4114 (*_bfd_error_handler)
4115 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4118 (long) rel->r_offset,
4120 h->root.root.string);
4124 if (r_symndx != STN_UNDEF
4125 && r_type != R_68K_NONE
4127 || h->root.type == bfd_link_hash_defined
4128 || h->root.type == bfd_link_hash_defweak))
4132 sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4134 if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4139 name = h->root.root.string;
4142 name = (bfd_elf_string_from_elf_section
4143 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4144 if (name == NULL || *name == '\0')
4145 name = bfd_section_name (input_bfd, sec);
4148 (*_bfd_error_handler)
4149 ((sym_type == STT_TLS
4150 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4151 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4154 (long) rel->r_offset,
4160 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4161 contents, rel->r_offset,
4162 relocation, rel->r_addend);
4164 if (r != bfd_reloc_ok)
4169 name = h->root.root.string;
4172 name = bfd_elf_string_from_elf_section (input_bfd,
4173 symtab_hdr->sh_link,
4178 name = bfd_section_name (input_bfd, sec);
4181 if (r == bfd_reloc_overflow)
4183 if (!(info->callbacks->reloc_overflow
4184 (info, (h ? &h->root : NULL), name, howto->name,
4185 (bfd_vma) 0, input_bfd, input_section,
4191 (*_bfd_error_handler)
4192 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4193 input_bfd, input_section,
4194 (long) rel->r_offset, name, (int) r);
4203 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
4204 into section SEC. */
4207 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
4209 /* Make VALUE PC-relative. */
4210 value -= sec->output_section->vma + offset;
4212 /* Apply any in-place addend. */
4213 value += bfd_get_32 (sec->owner, sec->contents + offset);
4215 bfd_put_32 (sec->owner, value, sec->contents + offset);
4218 /* Finish up dynamic symbol handling. We set the contents of various
4219 dynamic sections here. */
4222 elf_m68k_finish_dynamic_symbol (bfd *output_bfd,
4223 struct bfd_link_info *info,
4224 struct elf_link_hash_entry *h,
4225 Elf_Internal_Sym *sym)
4229 dynobj = elf_hash_table (info)->dynobj;
4231 if (h->plt.offset != (bfd_vma) -1)
4233 const struct elf_m68k_plt_info *plt_info;
4239 Elf_Internal_Rela rela;
4242 /* This symbol has an entry in the procedure linkage table. Set
4245 BFD_ASSERT (h->dynindx != -1);
4247 plt_info = elf_m68k_hash_table (info)->plt_info;
4248 splt = bfd_get_linker_section (dynobj, ".plt");
4249 sgot = bfd_get_linker_section (dynobj, ".got.plt");
4250 srela = bfd_get_linker_section (dynobj, ".rela.plt");
4251 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
4253 /* Get the index in the procedure linkage table which
4254 corresponds to this symbol. This is the index of this symbol
4255 in all the symbols for which we are making plt entries. The
4256 first entry in the procedure linkage table is reserved. */
4257 plt_index = (h->plt.offset / plt_info->size) - 1;
4259 /* Get the offset into the .got table of the entry that
4260 corresponds to this function. Each .got entry is 4 bytes.
4261 The first three are reserved. */
4262 got_offset = (plt_index + 3) * 4;
4264 memcpy (splt->contents + h->plt.offset,
4265 plt_info->symbol_entry,
4268 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
4269 (sgot->output_section->vma
4270 + sgot->output_offset
4273 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4276 + plt_info->symbol_resolve_entry + 2);
4278 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
4279 splt->output_section->vma);
4281 /* Fill in the entry in the global offset table. */
4282 bfd_put_32 (output_bfd,
4283 (splt->output_section->vma
4284 + splt->output_offset
4286 + plt_info->symbol_resolve_entry),
4287 sgot->contents + got_offset);
4289 /* Fill in the entry in the .rela.plt section. */
4290 rela.r_offset = (sgot->output_section->vma
4291 + sgot->output_offset
4293 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
4295 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
4296 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4298 if (!h->def_regular)
4300 /* Mark the symbol as undefined, rather than as defined in
4301 the .plt section. Leave the value alone. */
4302 sym->st_shndx = SHN_UNDEF;
4306 if (elf_m68k_hash_entry (h)->glist != NULL)
4310 struct elf_m68k_got_entry *got_entry;
4312 /* This symbol has an entry in the global offset table. Set it
4315 sgot = bfd_get_linker_section (dynobj, ".got");
4316 srela = bfd_get_linker_section (dynobj, ".rela.got");
4317 BFD_ASSERT (sgot != NULL && srela != NULL);
4319 got_entry = elf_m68k_hash_entry (h)->glist;
4321 while (got_entry != NULL)
4323 enum elf_m68k_reloc_type r_type;
4324 bfd_vma got_entry_offset;
4326 r_type = got_entry->key_.type;
4327 got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1;
4329 /* If this is a -Bsymbolic link, and the symbol is defined
4330 locally, we just want to emit a RELATIVE reloc. Likewise if
4331 the symbol was forced to be local because of a version file.
4332 The entry in the global offset table already have been
4333 initialized in the relocate_section function. */
4335 && SYMBOL_REFERENCES_LOCAL (info, h))
4339 relocation = bfd_get_signed_32 (output_bfd,
4341 + got_entry_offset));
4344 switch (elf_m68k_reloc_got_type (r_type))
4347 case R_68K_TLS_LDM32:
4350 case R_68K_TLS_GD32:
4351 /* The value for this relocation is actually put in
4352 the second GOT slot. */
4353 relocation = bfd_get_signed_32 (output_bfd,
4355 + got_entry_offset + 4));
4356 relocation += dtpoff_base (info);
4359 case R_68K_TLS_IE32:
4360 relocation += tpoff_base (info);
4367 elf_m68k_init_got_entry_local_shared (info,
4377 Elf_Internal_Rela rela;
4379 /* Put zeros to GOT slots that will be initialized
4384 n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type);
4386 bfd_put_32 (output_bfd, (bfd_vma) 0,
4387 (sgot->contents + got_entry_offset
4392 rela.r_offset = (sgot->output_section->vma
4393 + sgot->output_offset
4394 + got_entry_offset);
4396 switch (elf_m68k_reloc_got_type (r_type))
4399 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
4400 elf_m68k_install_rela (output_bfd, srela, &rela);
4403 case R_68K_TLS_GD32:
4404 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32);
4405 elf_m68k_install_rela (output_bfd, srela, &rela);
4408 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32);
4409 elf_m68k_install_rela (output_bfd, srela, &rela);
4412 case R_68K_TLS_IE32:
4413 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32);
4414 elf_m68k_install_rela (output_bfd, srela, &rela);
4423 got_entry = got_entry->u.s2.next;
4430 Elf_Internal_Rela rela;
4433 /* This symbol needs a copy reloc. Set it up. */
4435 BFD_ASSERT (h->dynindx != -1
4436 && (h->root.type == bfd_link_hash_defined
4437 || h->root.type == bfd_link_hash_defweak));
4439 s = bfd_get_linker_section (dynobj, ".rela.bss");
4440 BFD_ASSERT (s != NULL);
4442 rela.r_offset = (h->root.u.def.value
4443 + h->root.u.def.section->output_section->vma
4444 + h->root.u.def.section->output_offset);
4445 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
4447 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4448 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4454 /* Finish up the dynamic sections. */
4457 elf_m68k_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4463 dynobj = elf_hash_table (info)->dynobj;
4465 sgot = bfd_get_linker_section (dynobj, ".got.plt");
4466 BFD_ASSERT (sgot != NULL);
4467 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4469 if (elf_hash_table (info)->dynamic_sections_created)
4472 Elf32_External_Dyn *dyncon, *dynconend;
4474 splt = bfd_get_linker_section (dynobj, ".plt");
4475 BFD_ASSERT (splt != NULL && sdyn != NULL);
4477 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4478 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4479 for (; dyncon < dynconend; dyncon++)
4481 Elf_Internal_Dyn dyn;
4485 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4498 s = bfd_get_section_by_name (output_bfd, name);
4499 BFD_ASSERT (s != NULL);
4500 dyn.d_un.d_ptr = s->vma;
4501 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4505 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4506 BFD_ASSERT (s != NULL);
4507 dyn.d_un.d_val = s->size;
4508 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4512 /* The procedure linkage table relocs (DT_JMPREL) should
4513 not be included in the overall relocs (DT_RELA).
4514 Therefore, we override the DT_RELASZ entry here to
4515 make it not include the JMPREL relocs. Since the
4516 linker script arranges for .rela.plt to follow all
4517 other relocation sections, we don't have to worry
4518 about changing the DT_RELA entry. */
4519 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4521 dyn.d_un.d_val -= s->size;
4522 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4527 /* Fill in the first entry in the procedure linkage table. */
4530 const struct elf_m68k_plt_info *plt_info;
4532 plt_info = elf_m68k_hash_table (info)->plt_info;
4533 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
4535 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
4536 (sgot->output_section->vma
4537 + sgot->output_offset
4540 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
4541 (sgot->output_section->vma
4542 + sgot->output_offset
4545 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4550 /* Fill in the first three entries in the global offset table. */
4554 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4556 bfd_put_32 (output_bfd,
4557 sdyn->output_section->vma + sdyn->output_offset,
4559 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4560 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4563 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4568 /* Given a .data section and a .emreloc in-memory section, store
4569 relocation information into the .emreloc section which can be
4570 used at runtime to relocate the section. This is called by the
4571 linker when the --embedded-relocs switch is used. This is called
4572 after the add_symbols entry point has been called for all the
4573 objects, and before the final_link entry point is called. */
4576 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
4578 struct bfd_link_info *info;
4583 Elf_Internal_Shdr *symtab_hdr;
4584 Elf_Internal_Sym *isymbuf = NULL;
4585 Elf_Internal_Rela *internal_relocs = NULL;
4586 Elf_Internal_Rela *irel, *irelend;
4590 BFD_ASSERT (! info->relocatable);
4594 if (datasec->reloc_count == 0)
4597 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4599 /* Get a copy of the native relocations. */
4600 internal_relocs = (_bfd_elf_link_read_relocs
4601 (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
4602 info->keep_memory));
4603 if (internal_relocs == NULL)
4606 amt = (bfd_size_type) datasec->reloc_count * 12;
4607 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4608 if (relsec->contents == NULL)
4611 p = relsec->contents;
4613 irelend = internal_relocs + datasec->reloc_count;
4614 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4616 asection *targetsec;
4618 /* We are going to write a four byte longword into the runtime
4619 reloc section. The longword will be the address in the data
4620 section which must be relocated. It is followed by the name
4621 of the target section NUL-padded or truncated to 8
4624 /* We can only relocate absolute longword relocs at run time. */
4625 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4627 *errmsg = _("unsupported reloc type");
4628 bfd_set_error (bfd_error_bad_value);
4632 /* Get the target section referred to by the reloc. */
4633 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4635 /* A local symbol. */
4636 Elf_Internal_Sym *isym;
4638 /* Read this BFD's local symbols if we haven't done so already. */
4639 if (isymbuf == NULL)
4641 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4642 if (isymbuf == NULL)
4643 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4644 symtab_hdr->sh_info, 0,
4646 if (isymbuf == NULL)
4650 isym = isymbuf + ELF32_R_SYM (irel->r_info);
4651 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4656 struct elf_link_hash_entry *h;
4658 /* An external symbol. */
4659 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4660 h = elf_sym_hashes (abfd)[indx];
4661 BFD_ASSERT (h != NULL);
4662 if (h->root.type == bfd_link_hash_defined
4663 || h->root.type == bfd_link_hash_defweak)
4664 targetsec = h->root.u.def.section;
4669 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4670 memset (p + 4, 0, 8);
4671 if (targetsec != NULL)
4672 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4675 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4677 if (internal_relocs != NULL
4678 && elf_section_data (datasec)->relocs != internal_relocs)
4679 free (internal_relocs);
4683 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4685 if (internal_relocs != NULL
4686 && elf_section_data (datasec)->relocs != internal_relocs)
4687 free (internal_relocs);
4691 /* Set target options. */
4694 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4696 struct elf_m68k_link_hash_table *htab;
4697 bfd_boolean use_neg_got_offsets_p;
4698 bfd_boolean allow_multigot_p;
4699 bfd_boolean local_gp_p;
4701 switch (got_handling)
4706 use_neg_got_offsets_p = FALSE;
4707 allow_multigot_p = FALSE;
4711 /* --got=negative. */
4713 use_neg_got_offsets_p = TRUE;
4714 allow_multigot_p = FALSE;
4718 /* --got=multigot. */
4720 use_neg_got_offsets_p = TRUE;
4721 allow_multigot_p = TRUE;
4729 htab = elf_m68k_hash_table (info);
4732 htab->local_gp_p = local_gp_p;
4733 htab->use_neg_got_offsets_p = use_neg_got_offsets_p;
4734 htab->allow_multigot_p = allow_multigot_p;
4738 static enum elf_reloc_type_class
4739 elf32_m68k_reloc_type_class (const Elf_Internal_Rela *rela)
4741 switch ((int) ELF32_R_TYPE (rela->r_info))
4743 case R_68K_RELATIVE:
4744 return reloc_class_relative;
4745 case R_68K_JMP_SLOT:
4746 return reloc_class_plt;
4748 return reloc_class_copy;
4750 return reloc_class_normal;
4754 /* Return address for Ith PLT stub in section PLT, for relocation REL
4755 or (bfd_vma) -1 if it should not be included. */
4758 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4759 const arelent *rel ATTRIBUTE_UNUSED)
4761 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4764 /* Support for core dump NOTE sections. */
4767 elf_m68k_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4772 switch (note->descsz)
4777 case 154: /* Linux/m68k */
4779 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
4782 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 22);
4791 /* Make a ".reg/999" section. */
4792 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
4793 size, note->descpos + offset);
4797 elf_m68k_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4799 switch (note->descsz)
4804 case 124: /* Linux/m68k elf_prpsinfo. */
4805 elf_tdata (abfd)->core_pid
4806 = bfd_get_32 (abfd, note->descdata + 12);
4807 elf_tdata (abfd)->core_program
4808 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
4809 elf_tdata (abfd)->core_command
4810 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
4813 /* Note that for some reason, a spurious space is tacked
4814 onto the end of the args in some (at least one anyway)
4815 implementations, so strip it off if it exists. */
4817 char *command = elf_tdata (abfd)->core_command;
4818 int n = strlen (command);
4820 if (n > 0 && command[n - 1] == ' ')
4821 command[n - 1] = '\0';
4827 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
4828 #define TARGET_BIG_NAME "elf32-m68k"
4829 #define ELF_MACHINE_CODE EM_68K
4830 #define ELF_MAXPAGESIZE 0x2000
4831 #define elf_backend_create_dynamic_sections \
4832 _bfd_elf_create_dynamic_sections
4833 #define bfd_elf32_bfd_link_hash_table_create \
4834 elf_m68k_link_hash_table_create
4835 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create? */
4836 #define bfd_elf32_bfd_link_hash_table_free \
4837 elf_m68k_link_hash_table_free
4838 #define bfd_elf32_bfd_final_link bfd_elf_final_link
4840 #define elf_backend_check_relocs elf_m68k_check_relocs
4841 #define elf_backend_always_size_sections \
4842 elf_m68k_always_size_sections
4843 #define elf_backend_adjust_dynamic_symbol \
4844 elf_m68k_adjust_dynamic_symbol
4845 #define elf_backend_size_dynamic_sections \
4846 elf_m68k_size_dynamic_sections
4847 #define elf_backend_final_write_processing elf_m68k_final_write_processing
4848 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4849 #define elf_backend_relocate_section elf_m68k_relocate_section
4850 #define elf_backend_finish_dynamic_symbol \
4851 elf_m68k_finish_dynamic_symbol
4852 #define elf_backend_finish_dynamic_sections \
4853 elf_m68k_finish_dynamic_sections
4854 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
4855 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
4856 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4857 #define bfd_elf32_bfd_merge_private_bfd_data \
4858 elf32_m68k_merge_private_bfd_data
4859 #define bfd_elf32_bfd_set_private_flags \
4860 elf32_m68k_set_private_flags
4861 #define bfd_elf32_bfd_print_private_bfd_data \
4862 elf32_m68k_print_private_bfd_data
4863 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
4864 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
4865 #define elf_backend_object_p elf32_m68k_object_p
4866 #define elf_backend_grok_prstatus elf_m68k_grok_prstatus
4867 #define elf_backend_grok_psinfo elf_m68k_grok_psinfo
4869 #define elf_backend_can_gc_sections 1
4870 #define elf_backend_can_refcount 1
4871 #define elf_backend_want_got_plt 1
4872 #define elf_backend_plt_readonly 1
4873 #define elf_backend_want_plt_sym 0
4874 #define elf_backend_got_header_size 12
4875 #define elf_backend_rela_normal 1
4877 #include "elf32-target.h"