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 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "bfd.h" 24#include "bfdlink.h" 25#include "libbfd.h" 26#include "elf-bfd.h" 27#include "elf/m68k.h" 28#include "opcode/m68k.h" 29 30static reloc_howto_type *reloc_type_lookup 31 PARAMS ((bfd *, bfd_reloc_code_real_type)); 32static void rtype_to_howto 33 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 34static struct bfd_hash_entry *elf_m68k_link_hash_newfunc 35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 36static struct bfd_link_hash_table *elf_m68k_link_hash_table_create 37 PARAMS ((bfd *)); 38static bfd_boolean elf_m68k_check_relocs 39 PARAMS ((bfd *, struct bfd_link_info *, asection *, 40 const Elf_Internal_Rela *)); 41static bfd_boolean elf_m68k_adjust_dynamic_symbol 42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 43static bfd_boolean elf_m68k_size_dynamic_sections 44 PARAMS ((bfd *, struct bfd_link_info *)); 45static bfd_boolean elf_m68k_discard_copies 46 PARAMS ((struct elf_link_hash_entry *, PTR)); 47static bfd_boolean elf_m68k_relocate_section 48 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 49 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 50static bfd_boolean elf_m68k_finish_dynamic_symbol 51 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 52 Elf_Internal_Sym *)); 53static bfd_boolean elf_m68k_finish_dynamic_sections 54 PARAMS ((bfd *, struct bfd_link_info *)); 55 56static bfd_boolean elf32_m68k_set_private_flags 57 PARAMS ((bfd *, flagword)); 58static bfd_boolean elf32_m68k_merge_private_bfd_data 59 PARAMS ((bfd *, bfd *)); 60static bfd_boolean elf32_m68k_print_private_bfd_data 61 PARAMS ((bfd *, PTR)); 62static enum elf_reloc_type_class elf32_m68k_reloc_type_class 63 PARAMS ((const Elf_Internal_Rela *)); 64 65static reloc_howto_type howto_table[] = { 66 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE), 67 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE), 68 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE), 69 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE), 70 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE), 71 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE), 72 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE), 73 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE), 74 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE), 75 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE), 76 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE), 77 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE), 78 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE), 79 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE), 80 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE), 81 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE), 82 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE), 83 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE), 84 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE), 85 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE), 86 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), 87 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), 88 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE), 89 /* GNU extension to record C++ vtable hierarchy. */ 90 HOWTO (R_68K_GNU_VTINHERIT, /* type */ 91 0, /* rightshift */ 92 2, /* size (0 = byte, 1 = short, 2 = long) */ 93 0, /* bitsize */ 94 FALSE, /* pc_relative */ 95 0, /* bitpos */ 96 complain_overflow_dont, /* complain_on_overflow */ 97 NULL, /* special_function */ 98 "R_68K_GNU_VTINHERIT", /* name */ 99 FALSE, /* partial_inplace */ 100 0, /* src_mask */ 101 0, /* dst_mask */ 102 FALSE), 103 /* GNU extension to record C++ vtable member usage. */ 104 HOWTO (R_68K_GNU_VTENTRY, /* type */ 105 0, /* rightshift */ 106 2, /* size (0 = byte, 1 = short, 2 = long) */ 107 0, /* bitsize */ 108 FALSE, /* pc_relative */ 109 0, /* bitpos */ 110 complain_overflow_dont, /* complain_on_overflow */ 111 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 112 "R_68K_GNU_VTENTRY", /* name */ 113 FALSE, /* partial_inplace */ 114 0, /* src_mask */ 115 0, /* dst_mask */ 116 FALSE), 117}; 118 119static void 120rtype_to_howto (abfd, cache_ptr, dst) 121 bfd *abfd ATTRIBUTE_UNUSED; 122 arelent *cache_ptr; 123 Elf_Internal_Rela *dst; 124{ 125 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_68K_max); 126 cache_ptr->howto = &howto_table[ELF32_R_TYPE(dst->r_info)]; 127} 128 129#define elf_info_to_howto rtype_to_howto 130 131static const struct 132{ 133 bfd_reloc_code_real_type bfd_val; 134 int elf_val; 135} reloc_map[] = { 136 { BFD_RELOC_NONE, R_68K_NONE }, 137 { BFD_RELOC_32, R_68K_32 }, 138 { BFD_RELOC_16, R_68K_16 }, 139 { BFD_RELOC_8, R_68K_8 }, 140 { BFD_RELOC_32_PCREL, R_68K_PC32 }, 141 { BFD_RELOC_16_PCREL, R_68K_PC16 }, 142 { BFD_RELOC_8_PCREL, R_68K_PC8 }, 143 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 }, 144 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 }, 145 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 }, 146 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O }, 147 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O }, 148 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O }, 149 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 }, 150 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 }, 151 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 }, 152 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O }, 153 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O }, 154 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O }, 155 { BFD_RELOC_NONE, R_68K_COPY }, 156 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT }, 157 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT }, 158 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE }, 159 { BFD_RELOC_CTOR, R_68K_32 }, 160 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT }, 161 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY }, 162}; 163 164static reloc_howto_type * 165reloc_type_lookup (abfd, code) 166 bfd *abfd ATTRIBUTE_UNUSED; 167 bfd_reloc_code_real_type code; 168{ 169 unsigned int i; 170 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++) 171 { 172 if (reloc_map[i].bfd_val == code) 173 return &howto_table[reloc_map[i].elf_val]; 174 } 175 return 0; 176} 177 178static reloc_howto_type * 179reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 180{ 181 unsigned int i; 182 183 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++) 184 if (howto_table[i].name != NULL 185 && strcasecmp (howto_table[i].name, r_name) == 0) 186 return &howto_table[i]; 187 188 return NULL; 189} 190 191#define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup 192#define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup 193#define ELF_ARCH bfd_arch_m68k 194 195/* Functions for the m68k ELF linker. */ 196 197/* The name of the dynamic interpreter. This is put in the .interp 198 section. */ 199 200#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 201 202/* Describes one of the various PLT styles. */ 203 204struct elf_m68k_plt_info 205{ 206 /* The size of each PLT entry. */ 207 bfd_vma size; 208 209 /* The template for the first PLT entry. */ 210 const bfd_byte *plt0_entry; 211 212 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations. 213 The comments by each member indicate the value that the relocation 214 is against. */ 215 struct { 216 unsigned int got4; /* .got + 4 */ 217 unsigned int got8; /* .got + 8 */ 218 } plt0_relocs; 219 220 /* The template for a symbol's PLT entry. */ 221 const bfd_byte *symbol_entry; 222 223 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations. 224 The comments by each member indicate the value that the relocation 225 is against. */ 226 struct { 227 unsigned int got; /* the symbol's .got.plt entry */ 228 unsigned int plt; /* .plt */ 229 } symbol_relocs; 230 231 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. 232 The stub starts with "move.l #relocoffset,%d0". */ 233 bfd_vma symbol_resolve_entry; 234}; 235 236/* The size in bytes of an entry in the procedure linkage table. */ 237 238#define PLT_ENTRY_SIZE 20 239 240/* The first entry in a procedure linkage table looks like this. See 241 the SVR4 ABI m68k supplement to see how this works. */ 242 243static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] = 244{ 245 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */ 246 0, 0, 0, 2, /* + (.got + 4) - . */ 247 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */ 248 0, 0, 0, 2, /* + (.got + 8) - . */ 249 0, 0, 0, 0 /* pad out to 20 bytes. */ 250}; 251 252/* Subsequent entries in a procedure linkage table look like this. */ 253 254static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] = 255{ 256 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */ 257 0, 0, 0, 2, /* + (.got.plt entry) - . */ 258 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 259 0, 0, 0, 0, /* + reloc index */ 260 0x60, 0xff, /* bra.l .plt */ 261 0, 0, 0, 0 /* + .plt - . */ 262}; 263 264static const struct elf_m68k_plt_info elf_m68k_plt_info = { 265 PLT_ENTRY_SIZE, 266 elf_m68k_plt0_entry, { 4, 12 }, 267 elf_m68k_plt_entry, { 4, 16 }, 8 268}; 269 270#define ISAB_PLT_ENTRY_SIZE 24 271 272static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] = 273{ 274 0x20, 0x3c, /* move.l #offset,%d0 */ 275 0, 0, 0, 0, /* + (.got + 4) - . */ 276 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */ 277 0x20, 0x3c, /* move.l #offset,%d0 */ 278 0, 0, 0, 0, /* + (.got + 8) - . */ 279 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 280 0x4e, 0xd0, /* jmp (%a0) */ 281 0x4e, 0x71 /* nop */ 282}; 283 284/* Subsequent entries in a procedure linkage table look like this. */ 285 286static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] = 287{ 288 0x20, 0x3c, /* move.l #offset,%d0 */ 289 0, 0, 0, 0, /* + (.got.plt entry) - . */ 290 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 291 0x4e, 0xd0, /* jmp (%a0) */ 292 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 293 0, 0, 0, 0, /* + reloc index */ 294 0x60, 0xff, /* bra.l .plt */ 295 0, 0, 0, 0 /* + .plt - . */ 296}; 297 298static const struct elf_m68k_plt_info elf_isab_plt_info = { 299 ISAB_PLT_ENTRY_SIZE, 300 elf_isab_plt0_entry, { 2, 12 }, 301 elf_isab_plt_entry, { 2, 20 }, 12 302}; 303 304#define ISAC_PLT_ENTRY_SIZE 24 305 306static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] = 307{ 308 0x20, 0x3c, /* move.l #offset,%d0 */ 309 0, 0, 0, 0, /* replaced with .got + 4 - . */ 310 0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */ 311 0x20, 0x3c, /* move.l #offset,%d0 */ 312 0, 0, 0, 0, /* replaced with .got + 8 - . */ 313 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 314 0x4e, 0xd0, /* jmp (%a0) */ 315 0x4e, 0x71 /* nop */ 316}; 317 318/* Subsequent entries in a procedure linkage table look like this. */ 319 320static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] = 321{ 322 0x20, 0x3c, /* move.l #offset,%d0 */ 323 0, 0, 0, 0, /* replaced with (.got entry) - . */ 324 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 325 0x4e, 0xd0, /* jmp (%a0) */ 326 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 327 0, 0, 0, 0, /* replaced with offset into relocation table */ 328 0x61, 0xff, /* bsr.l .plt */ 329 0, 0, 0, 0 /* replaced with .plt - . */ 330}; 331 332static const struct elf_m68k_plt_info elf_isac_plt_info = { 333 ISAC_PLT_ENTRY_SIZE, 334 elf_isac_plt0_entry, { 2, 12}, 335 elf_isac_plt_entry, { 2, 20 }, 12 336}; 337 338#define CPU32_PLT_ENTRY_SIZE 24 339/* Procedure linkage table entries for the cpu32 */ 340static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] = 341{ 342 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */ 343 0, 0, 0, 2, /* + (.got + 4) - . */ 344 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */ 345 0, 0, 0, 2, /* + (.got + 8) - . */ 346 0x4e, 0xd1, /* jmp %a1@ */ 347 0, 0, 0, 0, /* pad out to 24 bytes. */ 348 0, 0 349}; 350 351static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] = 352{ 353 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */ 354 0, 0, 0, 2, /* + (.got.plt entry) - . */ 355 0x4e, 0xd1, /* jmp %a1@ */ 356 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 357 0, 0, 0, 0, /* + reloc index */ 358 0x60, 0xff, /* bra.l .plt */ 359 0, 0, 0, 0, /* + .plt - . */ 360 0, 0 361}; 362 363static const struct elf_m68k_plt_info elf_cpu32_plt_info = { 364 CPU32_PLT_ENTRY_SIZE, 365 elf_cpu32_plt0_entry, { 4, 12 }, 366 elf_cpu32_plt_entry, { 4, 18 }, 10 367}; 368 369/* The m68k linker needs to keep track of the number of relocs that it 370 decides to copy in check_relocs for each symbol. This is so that it 371 can discard PC relative relocs if it doesn't need them when linking 372 with -Bsymbolic. We store the information in a field extending the 373 regular ELF linker hash table. */ 374 375/* This structure keeps track of the number of PC relative relocs we have 376 copied for a given symbol. */ 377 378struct elf_m68k_pcrel_relocs_copied 379{ 380 /* Next section. */ 381 struct elf_m68k_pcrel_relocs_copied *next; 382 /* A section in dynobj. */ 383 asection *section; 384 /* Number of relocs copied in this section. */ 385 bfd_size_type count; 386}; 387 388/* m68k ELF linker hash entry. */ 389 390struct elf_m68k_link_hash_entry 391{ 392 struct elf_link_hash_entry root; 393 394 /* Number of PC relative relocs copied for this symbol. */ 395 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied; 396}; 397 398#define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent)) 399 400/* m68k ELF linker hash table. */ 401 402struct elf_m68k_link_hash_table 403{ 404 struct elf_link_hash_table root; 405 406 /* Small local sym to section mapping cache. */ 407 struct sym_sec_cache sym_sec; 408 409 /* The PLT format used by this link, or NULL if the format has not 410 yet been chosen. */ 411 const struct elf_m68k_plt_info *plt_info; 412}; 413 414/* Get the m68k ELF linker hash table from a link_info structure. */ 415 416#define elf_m68k_hash_table(p) \ 417 ((struct elf_m68k_link_hash_table *) (p)->hash) 418 419/* Create an entry in an m68k ELF linker hash table. */ 420 421static struct bfd_hash_entry * 422elf_m68k_link_hash_newfunc (entry, table, string) 423 struct bfd_hash_entry *entry; 424 struct bfd_hash_table *table; 425 const char *string; 426{ 427 struct bfd_hash_entry *ret = entry; 428 429 /* Allocate the structure if it has not already been allocated by a 430 subclass. */ 431 if (ret == NULL) 432 ret = bfd_hash_allocate (table, 433 sizeof (struct elf_m68k_link_hash_entry)); 434 if (ret == NULL) 435 return ret; 436 437 /* Call the allocation method of the superclass. */ 438 ret = _bfd_elf_link_hash_newfunc (ret, table, string); 439 if (ret != NULL) 440 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL; 441 442 return ret; 443} 444 445/* Create an m68k ELF linker hash table. */ 446 447static struct bfd_link_hash_table * 448elf_m68k_link_hash_table_create (abfd) 449 bfd *abfd; 450{ 451 struct elf_m68k_link_hash_table *ret; 452 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table); 453 454 ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt); 455 if (ret == (struct elf_m68k_link_hash_table *) NULL) 456 return NULL; 457 458 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 459 elf_m68k_link_hash_newfunc, 460 sizeof (struct elf_m68k_link_hash_entry))) 461 { 462 free (ret); 463 return NULL; 464 } 465 466 ret->sym_sec.abfd = NULL; 467 ret->plt_info = NULL; 468 469 return &ret->root.root; 470} 471 472/* Set the right machine number. */ 473 474static bfd_boolean 475elf32_m68k_object_p (bfd *abfd) 476{ 477 unsigned int mach = 0; 478 unsigned features = 0; 479 flagword eflags = elf_elfheader (abfd)->e_flags; 480 481 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 482 features |= m68000; 483 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 484 features |= cpu32; 485 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 486 features |= fido_a; 487 else 488 { 489 switch (eflags & EF_M68K_CF_ISA_MASK) 490 { 491 case EF_M68K_CF_ISA_A_NODIV: 492 features |= mcfisa_a; 493 break; 494 case EF_M68K_CF_ISA_A: 495 features |= mcfisa_a|mcfhwdiv; 496 break; 497 case EF_M68K_CF_ISA_A_PLUS: 498 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp; 499 break; 500 case EF_M68K_CF_ISA_B_NOUSP: 501 features |= mcfisa_a|mcfisa_b|mcfhwdiv; 502 break; 503 case EF_M68K_CF_ISA_B: 504 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp; 505 break; 506 case EF_M68K_CF_ISA_C: 507 features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp; 508 break; 509 } 510 switch (eflags & EF_M68K_CF_MAC_MASK) 511 { 512 case EF_M68K_CF_MAC: 513 features |= mcfmac; 514 break; 515 case EF_M68K_CF_EMAC: 516 features |= mcfemac; 517 break; 518 } 519 if (eflags & EF_M68K_CF_FLOAT) 520 features |= cfloat; 521 } 522 523 mach = bfd_m68k_features_to_mach (features); 524 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach); 525 526 return TRUE; 527} 528 529/* Keep m68k-specific flags in the ELF header. */ 530static bfd_boolean 531elf32_m68k_set_private_flags (abfd, flags) 532 bfd *abfd; 533 flagword flags; 534{ 535 elf_elfheader (abfd)->e_flags = flags; 536 elf_flags_init (abfd) = TRUE; 537 return TRUE; 538} 539 540/* Merge backend specific data from an object file to the output 541 object file when linking. */ 542static bfd_boolean 543elf32_m68k_merge_private_bfd_data (ibfd, obfd) 544 bfd *ibfd; 545 bfd *obfd; 546{ 547 flagword out_flags; 548 flagword in_flags; 549 flagword out_isa; 550 flagword in_isa; 551 const bfd_arch_info_type *arch_info; 552 553 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 554 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 555 return FALSE; 556 557 /* Get the merged machine. This checks for incompatibility between 558 Coldfire & non-Coldfire flags, incompability between different 559 Coldfire ISAs, and incompability between different MAC types. */ 560 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE); 561 if (!arch_info) 562 return FALSE; 563 564 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach); 565 566 in_flags = elf_elfheader (ibfd)->e_flags; 567 if (!elf_flags_init (obfd)) 568 { 569 elf_flags_init (obfd) = TRUE; 570 out_flags = in_flags; 571 } 572 else 573 { 574 out_flags = elf_elfheader (obfd)->e_flags; 575 unsigned int variant_mask; 576 577 if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 578 variant_mask = 0; 579 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 580 variant_mask = 0; 581 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 582 variant_mask = 0; 583 else 584 variant_mask = EF_M68K_CF_ISA_MASK; 585 586 in_isa = (in_flags & variant_mask); 587 out_isa = (out_flags & variant_mask); 588 if (in_isa > out_isa) 589 out_flags ^= in_isa ^ out_isa; 590 if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32 591 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 592 || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO 593 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)) 594 out_flags = EF_M68K_FIDO; 595 else 596 out_flags |= in_flags ^ in_isa; 597 } 598 elf_elfheader (obfd)->e_flags = out_flags; 599 600 return TRUE; 601} 602 603/* Display the flags field. */ 604static bfd_boolean 605elf32_m68k_print_private_bfd_data (abfd, ptr) 606 bfd *abfd; 607 PTR ptr; 608{ 609 FILE *file = (FILE *) ptr; 610 flagword eflags = elf_elfheader (abfd)->e_flags; 611 612 BFD_ASSERT (abfd != NULL && ptr != NULL); 613 614 /* Print normal ELF private data. */ 615 _bfd_elf_print_private_bfd_data (abfd, ptr); 616 617 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */ 618 619 /* xgettext:c-format */ 620 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 621 622 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 623 fprintf (file, " [m68000]"); 624 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 625 fprintf (file, " [cpu32]"); 626 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 627 fprintf (file, " [fido]"); 628 else 629 { 630 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E) 631 fprintf (file, " [cfv4e]"); 632 633 if (eflags & EF_M68K_CF_ISA_MASK) 634 { 635 char const *isa = _("unknown"); 636 char const *mac = _("unknown"); 637 char const *additional = ""; 638 639 switch (eflags & EF_M68K_CF_ISA_MASK) 640 { 641 case EF_M68K_CF_ISA_A_NODIV: 642 isa = "A"; 643 additional = " [nodiv]"; 644 break; 645 case EF_M68K_CF_ISA_A: 646 isa = "A"; 647 break; 648 case EF_M68K_CF_ISA_A_PLUS: 649 isa = "A+"; 650 break; 651 case EF_M68K_CF_ISA_B_NOUSP: 652 isa = "B"; 653 additional = " [nousp]"; 654 break; 655 case EF_M68K_CF_ISA_B: 656 isa = "B"; 657 break; 658 case EF_M68K_CF_ISA_C: 659 isa = "C"; 660 break; 661 } 662 fprintf (file, " [isa %s]%s", isa, additional); 663 if (eflags & EF_M68K_CF_FLOAT) 664 fprintf (file, " [float]"); 665 switch (eflags & EF_M68K_CF_MAC_MASK) 666 { 667 case 0: 668 mac = NULL; 669 break; 670 case EF_M68K_CF_MAC: 671 mac = "mac"; 672 break; 673 case EF_M68K_CF_EMAC: 674 mac = "emac"; 675 break; 676 } 677 if (mac) 678 fprintf (file, " [%s]", mac); 679 } 680 } 681 682 fputc ('\n', file); 683 684 return TRUE; 685} 686/* Look through the relocs for a section during the first phase, and 687 allocate space in the global offset table or procedure linkage 688 table. */ 689 690static bfd_boolean 691elf_m68k_check_relocs (abfd, info, sec, relocs) 692 bfd *abfd; 693 struct bfd_link_info *info; 694 asection *sec; 695 const Elf_Internal_Rela *relocs; 696{ 697 bfd *dynobj; 698 Elf_Internal_Shdr *symtab_hdr; 699 struct elf_link_hash_entry **sym_hashes; 700 bfd_signed_vma *local_got_refcounts; 701 const Elf_Internal_Rela *rel; 702 const Elf_Internal_Rela *rel_end; 703 asection *sgot; 704 asection *srelgot; 705 asection *sreloc; 706 707 if (info->relocatable) 708 return TRUE; 709 710 dynobj = elf_hash_table (info)->dynobj; 711 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 712 sym_hashes = elf_sym_hashes (abfd); 713 local_got_refcounts = elf_local_got_refcounts (abfd); 714 715 sgot = NULL; 716 srelgot = NULL; 717 sreloc = NULL; 718 719 rel_end = relocs + sec->reloc_count; 720 for (rel = relocs; rel < rel_end; rel++) 721 { 722 unsigned long r_symndx; 723 struct elf_link_hash_entry *h; 724 725 r_symndx = ELF32_R_SYM (rel->r_info); 726 727 if (r_symndx < symtab_hdr->sh_info) 728 h = NULL; 729 else 730 { 731 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 732 while (h->root.type == bfd_link_hash_indirect 733 || h->root.type == bfd_link_hash_warning) 734 h = (struct elf_link_hash_entry *) h->root.u.i.link; 735 } 736 737 switch (ELF32_R_TYPE (rel->r_info)) 738 { 739 case R_68K_GOT8: 740 case R_68K_GOT16: 741 case R_68K_GOT32: 742 if (h != NULL 743 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 744 break; 745 /* Fall through. */ 746 case R_68K_GOT8O: 747 case R_68K_GOT16O: 748 case R_68K_GOT32O: 749 /* This symbol requires a global offset table entry. */ 750 751 if (dynobj == NULL) 752 { 753 /* Create the .got section. */ 754 elf_hash_table (info)->dynobj = dynobj = abfd; 755 if (!_bfd_elf_create_got_section (dynobj, info)) 756 return FALSE; 757 } 758 759 if (sgot == NULL) 760 { 761 sgot = bfd_get_section_by_name (dynobj, ".got"); 762 BFD_ASSERT (sgot != NULL); 763 } 764 765 if (srelgot == NULL 766 && (h != NULL || info->shared)) 767 { 768 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 769 if (srelgot == NULL) 770 { 771 srelgot = bfd_make_section_with_flags (dynobj, 772 ".rela.got", 773 (SEC_ALLOC 774 | SEC_LOAD 775 | SEC_HAS_CONTENTS 776 | SEC_IN_MEMORY 777 | SEC_LINKER_CREATED 778 | SEC_READONLY)); 779 if (srelgot == NULL 780 || !bfd_set_section_alignment (dynobj, srelgot, 2)) 781 return FALSE; 782 } 783 } 784 785 if (h != NULL) 786 { 787 if (h->got.refcount == 0) 788 { 789 /* Make sure this symbol is output as a dynamic symbol. */ 790 if (h->dynindx == -1 791 && !h->forced_local) 792 { 793 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 794 return FALSE; 795 } 796 797 /* Allocate space in the .got section. */ 798 sgot->size += 4; 799 /* Allocate relocation space. */ 800 srelgot->size += sizeof (Elf32_External_Rela); 801 } 802 h->got.refcount++; 803 } 804 else 805 { 806 /* This is a global offset table entry for a local symbol. */ 807 if (local_got_refcounts == NULL) 808 { 809 bfd_size_type size; 810 811 size = symtab_hdr->sh_info; 812 size *= sizeof (bfd_signed_vma); 813 local_got_refcounts = ((bfd_signed_vma *) 814 bfd_zalloc (abfd, size)); 815 if (local_got_refcounts == NULL) 816 return FALSE; 817 elf_local_got_refcounts (abfd) = local_got_refcounts; 818 } 819 if (local_got_refcounts[r_symndx] == 0) 820 { 821 sgot->size += 4; 822 if (info->shared) 823 { 824 /* If we are generating a shared object, we need to 825 output a R_68K_RELATIVE reloc so that the dynamic 826 linker can adjust this GOT entry. */ 827 srelgot->size += sizeof (Elf32_External_Rela); 828 } 829 } 830 local_got_refcounts[r_symndx]++; 831 } 832 break; 833 834 case R_68K_PLT8: 835 case R_68K_PLT16: 836 case R_68K_PLT32: 837 /* This symbol requires a procedure linkage table entry. We 838 actually build the entry in adjust_dynamic_symbol, 839 because this might be a case of linking PIC code which is 840 never referenced by a dynamic object, in which case we 841 don't need to generate a procedure linkage table entry 842 after all. */ 843 844 /* If this is a local symbol, we resolve it directly without 845 creating a procedure linkage table entry. */ 846 if (h == NULL) 847 continue; 848 849 h->needs_plt = 1; 850 h->plt.refcount++; 851 break; 852 853 case R_68K_PLT8O: 854 case R_68K_PLT16O: 855 case R_68K_PLT32O: 856 /* This symbol requires a procedure linkage table entry. */ 857 858 if (h == NULL) 859 { 860 /* It does not make sense to have this relocation for a 861 local symbol. FIXME: does it? How to handle it if 862 it does make sense? */ 863 bfd_set_error (bfd_error_bad_value); 864 return FALSE; 865 } 866 867 /* Make sure this symbol is output as a dynamic symbol. */ 868 if (h->dynindx == -1 869 && !h->forced_local) 870 { 871 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 872 return FALSE; 873 } 874 875 h->needs_plt = 1; 876 h->plt.refcount++; 877 break; 878 879 case R_68K_PC8: 880 case R_68K_PC16: 881 case R_68K_PC32: 882 /* If we are creating a shared library and this is not a local 883 symbol, we need to copy the reloc into the shared library. 884 However when linking with -Bsymbolic and this is a global 885 symbol which is defined in an object we are including in the 886 link (i.e., DEF_REGULAR is set), then we can resolve the 887 reloc directly. At this point we have not seen all the input 888 files, so it is possible that DEF_REGULAR is not set now but 889 will be set later (it is never cleared). We account for that 890 possibility below by storing information in the 891 pcrel_relocs_copied field of the hash table entry. */ 892 if (!(info->shared 893 && (sec->flags & SEC_ALLOC) != 0 894 && h != NULL 895 && (!info->symbolic 896 || h->root.type == bfd_link_hash_defweak 897 || !h->def_regular))) 898 { 899 if (h != NULL) 900 { 901 /* Make sure a plt entry is created for this symbol if 902 it turns out to be a function defined by a dynamic 903 object. */ 904 h->plt.refcount++; 905 } 906 break; 907 } 908 /* Fall through. */ 909 case R_68K_8: 910 case R_68K_16: 911 case R_68K_32: 912 if (h != NULL) 913 { 914 /* Make sure a plt entry is created for this symbol if it 915 turns out to be a function defined by a dynamic object. */ 916 h->plt.refcount++; 917 } 918 919 /* If we are creating a shared library, we need to copy the 920 reloc into the shared library. */ 921 if (info->shared 922 && (sec->flags & SEC_ALLOC) != 0) 923 { 924 /* When creating a shared object, we must copy these 925 reloc types into the output file. We create a reloc 926 section in dynobj and make room for this reloc. */ 927 if (sreloc == NULL) 928 { 929 const char *name; 930 931 name = (bfd_elf_string_from_elf_section 932 (abfd, 933 elf_elfheader (abfd)->e_shstrndx, 934 elf_section_data (sec)->rel_hdr.sh_name)); 935 if (name == NULL) 936 return FALSE; 937 938 BFD_ASSERT (CONST_STRNEQ (name, ".rela") 939 && strcmp (bfd_get_section_name (abfd, sec), 940 name + 5) == 0); 941 942 sreloc = bfd_get_section_by_name (dynobj, name); 943 if (sreloc == NULL) 944 { 945 sreloc = bfd_make_section_with_flags (dynobj, 946 name, 947 (SEC_ALLOC 948 | SEC_LOAD 949 | SEC_HAS_CONTENTS 950 | SEC_IN_MEMORY 951 | SEC_LINKER_CREATED 952 | SEC_READONLY)); 953 if (sreloc == NULL 954 || !bfd_set_section_alignment (dynobj, sreloc, 2)) 955 return FALSE; 956 } 957 elf_section_data (sec)->sreloc = sreloc; 958 } 959 960 if (sec->flags & SEC_READONLY 961 /* Don't set DF_TEXTREL yet for PC relative 962 relocations, they might be discarded later. */ 963 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8 964 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16 965 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)) 966 info->flags |= DF_TEXTREL; 967 968 sreloc->size += sizeof (Elf32_External_Rela); 969 970 /* We count the number of PC relative relocations we have 971 entered for this symbol, so that we can discard them 972 again if, in the -Bsymbolic case, the symbol is later 973 defined by a regular object, or, in the normal shared 974 case, the symbol is forced to be local. Note that this 975 function is only called if we are using an m68kelf linker 976 hash table, which means that h is really a pointer to an 977 elf_m68k_link_hash_entry. */ 978 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8 979 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16 980 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32) 981 { 982 struct elf_m68k_pcrel_relocs_copied *p; 983 struct elf_m68k_pcrel_relocs_copied **head; 984 985 if (h != NULL) 986 { 987 struct elf_m68k_link_hash_entry *eh 988 = elf_m68k_hash_entry (h); 989 head = &eh->pcrel_relocs_copied; 990 } 991 else 992 { 993 asection *s; 994 void *vpp; 995 996 s = (bfd_section_from_r_symndx 997 (abfd, &elf_m68k_hash_table (info)->sym_sec, 998 sec, r_symndx)); 999 if (s == NULL) 1000 return FALSE; 1001 1002 vpp = &elf_section_data (s)->local_dynrel; 1003 head = (struct elf_m68k_pcrel_relocs_copied **) vpp; 1004 } 1005 1006 for (p = *head; p != NULL; p = p->next) 1007 if (p->section == sreloc) 1008 break; 1009 1010 if (p == NULL) 1011 { 1012 p = ((struct elf_m68k_pcrel_relocs_copied *) 1013 bfd_alloc (dynobj, (bfd_size_type) sizeof *p)); 1014 if (p == NULL) 1015 return FALSE; 1016 p->next = *head; 1017 *head = p; 1018 p->section = sreloc; 1019 p->count = 0; 1020 } 1021 1022 ++p->count; 1023 } 1024 } 1025 1026 break; 1027 1028 /* This relocation describes the C++ object vtable hierarchy. 1029 Reconstruct it for later use during GC. */ 1030 case R_68K_GNU_VTINHERIT: 1031 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1032 return FALSE; 1033 break; 1034 1035 /* This relocation describes which C++ vtable entries are actually 1036 used. Record for later use during GC. */ 1037 case R_68K_GNU_VTENTRY: 1038 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1039 return FALSE; 1040 break; 1041 1042 default: 1043 break; 1044 } 1045 } 1046 1047 return TRUE; 1048} 1049 1050/* Return the section that should be marked against GC for a given 1051 relocation. */ 1052 1053static asection * 1054elf_m68k_gc_mark_hook (asection *sec, 1055 struct bfd_link_info *info, 1056 Elf_Internal_Rela *rel, 1057 struct elf_link_hash_entry *h, 1058 Elf_Internal_Sym *sym) 1059{ 1060 if (h != NULL) 1061 switch (ELF32_R_TYPE (rel->r_info)) 1062 { 1063 case R_68K_GNU_VTINHERIT: 1064 case R_68K_GNU_VTENTRY: 1065 return NULL; 1066 } 1067 1068 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1069} 1070 1071/* Update the got entry reference counts for the section being removed. */ 1072 1073static bfd_boolean 1074elf_m68k_gc_sweep_hook (bfd *abfd, 1075 struct bfd_link_info *info, 1076 asection *sec, 1077 const Elf_Internal_Rela *relocs) 1078{ 1079 Elf_Internal_Shdr *symtab_hdr; 1080 struct elf_link_hash_entry **sym_hashes; 1081 bfd_signed_vma *local_got_refcounts; 1082 const Elf_Internal_Rela *rel, *relend; 1083 bfd *dynobj; 1084 asection *sgot; 1085 asection *srelgot; 1086 1087 dynobj = elf_hash_table (info)->dynobj; 1088 if (dynobj == NULL) 1089 return TRUE; 1090 1091 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1092 sym_hashes = elf_sym_hashes (abfd); 1093 local_got_refcounts = elf_local_got_refcounts (abfd); 1094 1095 sgot = bfd_get_section_by_name (dynobj, ".got"); 1096 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 1097 1098 relend = relocs + sec->reloc_count; 1099 for (rel = relocs; rel < relend; rel++) 1100 { 1101 unsigned long r_symndx; 1102 struct elf_link_hash_entry *h = NULL; 1103 1104 r_symndx = ELF32_R_SYM (rel->r_info); 1105 if (r_symndx >= symtab_hdr->sh_info) 1106 { 1107 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1108 while (h->root.type == bfd_link_hash_indirect 1109 || h->root.type == bfd_link_hash_warning) 1110 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1111 } 1112 1113 switch (ELF32_R_TYPE (rel->r_info)) 1114 { 1115 case R_68K_GOT8: 1116 case R_68K_GOT16: 1117 case R_68K_GOT32: 1118 case R_68K_GOT8O: 1119 case R_68K_GOT16O: 1120 case R_68K_GOT32O: 1121 if (h != NULL) 1122 { 1123 if (h->got.refcount > 0) 1124 { 1125 --h->got.refcount; 1126 if (h->got.refcount == 0) 1127 { 1128 /* We don't need the .got entry any more. */ 1129 sgot->size -= 4; 1130 srelgot->size -= sizeof (Elf32_External_Rela); 1131 } 1132 } 1133 } 1134 else if (local_got_refcounts != NULL) 1135 { 1136 if (local_got_refcounts[r_symndx] > 0) 1137 { 1138 --local_got_refcounts[r_symndx]; 1139 if (local_got_refcounts[r_symndx] == 0) 1140 { 1141 /* We don't need the .got entry any more. */ 1142 sgot->size -= 4; 1143 if (info->shared) 1144 srelgot->size -= sizeof (Elf32_External_Rela); 1145 } 1146 } 1147 } 1148 break; 1149 1150 case R_68K_PLT8: 1151 case R_68K_PLT16: 1152 case R_68K_PLT32: 1153 case R_68K_PLT8O: 1154 case R_68K_PLT16O: 1155 case R_68K_PLT32O: 1156 case R_68K_PC8: 1157 case R_68K_PC16: 1158 case R_68K_PC32: 1159 case R_68K_8: 1160 case R_68K_16: 1161 case R_68K_32: 1162 if (h != NULL) 1163 { 1164 if (h->plt.refcount > 0) 1165 --h->plt.refcount; 1166 } 1167 break; 1168 1169 default: 1170 break; 1171 } 1172 } 1173 1174 return TRUE; 1175} 1176 1177/* Return the type of PLT associated with OUTPUT_BFD. */ 1178 1179static const struct elf_m68k_plt_info * 1180elf_m68k_get_plt_info (bfd *output_bfd) 1181{ 1182 unsigned int features; 1183 1184 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd)); 1185 if (features & cpu32) 1186 return &elf_cpu32_plt_info; 1187 if (features & mcfisa_b) 1188 return &elf_isab_plt_info; 1189 if (features & mcfisa_c) 1190 return &elf_isac_plt_info; 1191 return &elf_m68k_plt_info; 1192} 1193 1194/* This function is called after all the input files have been read, 1195 and the input sections have been assigned to output sections. 1196 It's a convenient place to determine the PLT style. */ 1197 1198static bfd_boolean 1199elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) 1200{ 1201 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd); 1202 return TRUE; 1203} 1204 1205/* Adjust a symbol defined by a dynamic object and referenced by a 1206 regular object. The current definition is in some section of the 1207 dynamic object, but we're not including those sections. We have to 1208 change the definition to something the rest of the link can 1209 understand. */ 1210 1211static bfd_boolean 1212elf_m68k_adjust_dynamic_symbol (info, h) 1213 struct bfd_link_info *info; 1214 struct elf_link_hash_entry *h; 1215{ 1216 struct elf_m68k_link_hash_table *htab; 1217 bfd *dynobj; 1218 asection *s; 1219 1220 htab = elf_m68k_hash_table (info); 1221 dynobj = elf_hash_table (info)->dynobj; 1222 1223 /* Make sure we know what is going on here. */ 1224 BFD_ASSERT (dynobj != NULL 1225 && (h->needs_plt 1226 || h->u.weakdef != NULL 1227 || (h->def_dynamic 1228 && h->ref_regular 1229 && !h->def_regular))); 1230 1231 /* If this is a function, put it in the procedure linkage table. We 1232 will fill in the contents of the procedure linkage table later, 1233 when we know the address of the .got section. */ 1234 if (h->type == STT_FUNC 1235 || h->needs_plt) 1236 { 1237 if ((h->plt.refcount <= 0 1238 || SYMBOL_CALLS_LOCAL (info, h) 1239 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1240 && h->root.type == bfd_link_hash_undefweak)) 1241 /* We must always create the plt entry if it was referenced 1242 by a PLTxxO relocation. In this case we already recorded 1243 it as a dynamic symbol. */ 1244 && h->dynindx == -1) 1245 { 1246 /* This case can occur if we saw a PLTxx reloc in an input 1247 file, but the symbol was never referred to by a dynamic 1248 object, or if all references were garbage collected. In 1249 such a case, we don't actually need to build a procedure 1250 linkage table, and we can just do a PCxx reloc instead. */ 1251 h->plt.offset = (bfd_vma) -1; 1252 h->needs_plt = 0; 1253 return TRUE; 1254 } 1255 1256 /* Make sure this symbol is output as a dynamic symbol. */ 1257 if (h->dynindx == -1 1258 && !h->forced_local) 1259 { 1260 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1261 return FALSE; 1262 } 1263 1264 s = bfd_get_section_by_name (dynobj, ".plt"); 1265 BFD_ASSERT (s != NULL); 1266 1267 /* If this is the first .plt entry, make room for the special 1268 first entry. */ 1269 if (s->size == 0) 1270 s->size = htab->plt_info->size; 1271 1272 /* If this symbol is not defined in a regular file, and we are 1273 not generating a shared library, then set the symbol to this 1274 location in the .plt. This is required to make function 1275 pointers compare as equal between the normal executable and 1276 the shared library. */ 1277 if (!info->shared 1278 && !h->def_regular) 1279 { 1280 h->root.u.def.section = s; 1281 h->root.u.def.value = s->size; 1282 } 1283 1284 h->plt.offset = s->size; 1285 1286 /* Make room for this entry. */ 1287 s->size += htab->plt_info->size; 1288 1289 /* We also need to make an entry in the .got.plt section, which 1290 will be placed in the .got section by the linker script. */ 1291 s = bfd_get_section_by_name (dynobj, ".got.plt"); 1292 BFD_ASSERT (s != NULL); 1293 s->size += 4; 1294 1295 /* We also need to make an entry in the .rela.plt section. */ 1296 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 1297 BFD_ASSERT (s != NULL); 1298 s->size += sizeof (Elf32_External_Rela); 1299 1300 return TRUE; 1301 } 1302 1303 /* Reinitialize the plt offset now that it is not used as a reference 1304 count any more. */ 1305 h->plt.offset = (bfd_vma) -1; 1306 1307 /* If this is a weak symbol, and there is a real definition, the 1308 processor independent code will have arranged for us to see the 1309 real definition first, and we can just use the same value. */ 1310 if (h->u.weakdef != NULL) 1311 { 1312 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1313 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1314 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1315 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1316 return TRUE; 1317 } 1318 1319 /* This is a reference to a symbol defined by a dynamic object which 1320 is not a function. */ 1321 1322 /* If we are creating a shared library, we must presume that the 1323 only references to the symbol are via the global offset table. 1324 For such cases we need not do anything here; the relocations will 1325 be handled correctly by relocate_section. */ 1326 if (info->shared) 1327 return TRUE; 1328 1329 if (h->size == 0) 1330 { 1331 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 1332 h->root.root.string); 1333 return TRUE; 1334 } 1335 1336 /* We must allocate the symbol in our .dynbss section, which will 1337 become part of the .bss section of the executable. There will be 1338 an entry for this symbol in the .dynsym section. The dynamic 1339 object will contain position independent code, so all references 1340 from the dynamic object to this symbol will go through the global 1341 offset table. The dynamic linker will use the .dynsym entry to 1342 determine the address it must put in the global offset table, so 1343 both the dynamic object and the regular object will refer to the 1344 same memory location for the variable. */ 1345 1346 s = bfd_get_section_by_name (dynobj, ".dynbss"); 1347 BFD_ASSERT (s != NULL); 1348 1349 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to 1350 copy the initial value out of the dynamic object and into the 1351 runtime process image. We need to remember the offset into the 1352 .rela.bss section we are going to use. */ 1353 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1354 { 1355 asection *srel; 1356 1357 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 1358 BFD_ASSERT (srel != NULL); 1359 srel->size += sizeof (Elf32_External_Rela); 1360 h->needs_copy = 1; 1361 } 1362 1363 return _bfd_elf_adjust_dynamic_copy (h, s); 1364} 1365 1366/* Set the sizes of the dynamic sections. */ 1367 1368static bfd_boolean 1369elf_m68k_size_dynamic_sections (output_bfd, info) 1370 bfd *output_bfd ATTRIBUTE_UNUSED; 1371 struct bfd_link_info *info; 1372{ 1373 bfd *dynobj; 1374 asection *s; 1375 bfd_boolean plt; 1376 bfd_boolean relocs; 1377 1378 dynobj = elf_hash_table (info)->dynobj; 1379 BFD_ASSERT (dynobj != NULL); 1380 1381 if (elf_hash_table (info)->dynamic_sections_created) 1382 { 1383 /* Set the contents of the .interp section to the interpreter. */ 1384 if (info->executable) 1385 { 1386 s = bfd_get_section_by_name (dynobj, ".interp"); 1387 BFD_ASSERT (s != NULL); 1388 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 1389 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1390 } 1391 } 1392 else 1393 { 1394 /* We may have created entries in the .rela.got section. 1395 However, if we are not creating the dynamic sections, we will 1396 not actually use these entries. Reset the size of .rela.got, 1397 which will cause it to get stripped from the output file 1398 below. */ 1399 s = bfd_get_section_by_name (dynobj, ".rela.got"); 1400 if (s != NULL) 1401 s->size = 0; 1402 } 1403 1404 /* If this is a -Bsymbolic shared link, then we need to discard all 1405 PC relative relocs against symbols defined in a regular object. 1406 For the normal shared case we discard the PC relative relocs 1407 against symbols that have become local due to visibility changes. 1408 We allocated space for them in the check_relocs routine, but we 1409 will not fill them in in the relocate_section routine. */ 1410 if (info->shared) 1411 elf_link_hash_traverse (elf_hash_table (info), 1412 elf_m68k_discard_copies, 1413 (PTR) info); 1414 1415 /* The check_relocs and adjust_dynamic_symbol entry points have 1416 determined the sizes of the various dynamic sections. Allocate 1417 memory for them. */ 1418 plt = FALSE; 1419 relocs = FALSE; 1420 for (s = dynobj->sections; s != NULL; s = s->next) 1421 { 1422 const char *name; 1423 1424 if ((s->flags & SEC_LINKER_CREATED) == 0) 1425 continue; 1426 1427 /* It's OK to base decisions on the section name, because none 1428 of the dynobj section names depend upon the input files. */ 1429 name = bfd_get_section_name (dynobj, s); 1430 1431 if (strcmp (name, ".plt") == 0) 1432 { 1433 /* Remember whether there is a PLT. */ 1434 plt = s->size != 0; 1435 } 1436 else if (CONST_STRNEQ (name, ".rela")) 1437 { 1438 if (s->size != 0) 1439 { 1440 relocs = TRUE; 1441 1442 /* We use the reloc_count field as a counter if we need 1443 to copy relocs into the output file. */ 1444 s->reloc_count = 0; 1445 } 1446 } 1447 else if (! CONST_STRNEQ (name, ".got") 1448 && strcmp (name, ".dynbss") != 0) 1449 { 1450 /* It's not one of our sections, so don't allocate space. */ 1451 continue; 1452 } 1453 1454 if (s->size == 0) 1455 { 1456 /* If we don't need this section, strip it from the 1457 output file. This is mostly to handle .rela.bss and 1458 .rela.plt. We must create both sections in 1459 create_dynamic_sections, because they must be created 1460 before the linker maps input sections to output 1461 sections. The linker does that before 1462 adjust_dynamic_symbol is called, and it is that 1463 function which decides whether anything needs to go 1464 into these sections. */ 1465 s->flags |= SEC_EXCLUDE; 1466 continue; 1467 } 1468 1469 if ((s->flags & SEC_HAS_CONTENTS) == 0) 1470 continue; 1471 1472 /* Allocate memory for the section contents. */ 1473 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 1474 Unused entries should be reclaimed before the section's contents 1475 are written out, but at the moment this does not happen. Thus in 1476 order to prevent writing out garbage, we initialise the section's 1477 contents to zero. */ 1478 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 1479 if (s->contents == NULL) 1480 return FALSE; 1481 } 1482 1483 if (elf_hash_table (info)->dynamic_sections_created) 1484 { 1485 /* Add some entries to the .dynamic section. We fill in the 1486 values later, in elf_m68k_finish_dynamic_sections, but we 1487 must add the entries now so that we get the correct size for 1488 the .dynamic section. The DT_DEBUG entry is filled in by the 1489 dynamic linker and used by the debugger. */ 1490#define add_dynamic_entry(TAG, VAL) \ 1491 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1492 1493 if (!info->shared) 1494 { 1495 if (!add_dynamic_entry (DT_DEBUG, 0)) 1496 return FALSE; 1497 } 1498 1499 if (plt) 1500 { 1501 if (!add_dynamic_entry (DT_PLTGOT, 0) 1502 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1503 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1504 || !add_dynamic_entry (DT_JMPREL, 0)) 1505 return FALSE; 1506 } 1507 1508 if (relocs) 1509 { 1510 if (!add_dynamic_entry (DT_RELA, 0) 1511 || !add_dynamic_entry (DT_RELASZ, 0) 1512 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 1513 return FALSE; 1514 } 1515 1516 if ((info->flags & DF_TEXTREL) != 0) 1517 { 1518 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1519 return FALSE; 1520 } 1521 } 1522#undef add_dynamic_entry 1523 1524 return TRUE; 1525} 1526 1527/* This function is called via elf_link_hash_traverse if we are 1528 creating a shared object. In the -Bsymbolic case it discards the 1529 space allocated to copy PC relative relocs against symbols which 1530 are defined in regular objects. For the normal shared case, it 1531 discards space for pc-relative relocs that have become local due to 1532 symbol visibility changes. We allocated space for them in the 1533 check_relocs routine, but we won't fill them in in the 1534 relocate_section routine. 1535 1536 We also check whether any of the remaining relocations apply 1537 against a readonly section, and set the DF_TEXTREL flag in this 1538 case. */ 1539 1540static bfd_boolean 1541elf_m68k_discard_copies (h, inf) 1542 struct elf_link_hash_entry *h; 1543 PTR inf; 1544{ 1545 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1546 struct elf_m68k_pcrel_relocs_copied *s; 1547 1548 if (h->root.type == bfd_link_hash_warning) 1549 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1550 1551 if (!h->def_regular 1552 || (!info->symbolic 1553 && !h->forced_local)) 1554 { 1555 if ((info->flags & DF_TEXTREL) == 0) 1556 { 1557 /* Look for relocations against read-only sections. */ 1558 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied; 1559 s != NULL; 1560 s = s->next) 1561 if ((s->section->flags & SEC_READONLY) != 0) 1562 { 1563 info->flags |= DF_TEXTREL; 1564 break; 1565 } 1566 } 1567 1568 return TRUE; 1569 } 1570 1571 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied; 1572 s != NULL; 1573 s = s->next) 1574 s->section->size -= s->count * sizeof (Elf32_External_Rela); 1575 1576 return TRUE; 1577} 1578 1579/* Relocate an M68K ELF section. */ 1580 1581static bfd_boolean 1582elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section, 1583 contents, relocs, local_syms, local_sections) 1584 bfd *output_bfd; 1585 struct bfd_link_info *info; 1586 bfd *input_bfd; 1587 asection *input_section; 1588 bfd_byte *contents; 1589 Elf_Internal_Rela *relocs; 1590 Elf_Internal_Sym *local_syms; 1591 asection **local_sections; 1592{ 1593 bfd *dynobj; 1594 Elf_Internal_Shdr *symtab_hdr; 1595 struct elf_link_hash_entry **sym_hashes; 1596 bfd_vma *local_got_offsets; 1597 asection *sgot; 1598 asection *splt; 1599 asection *sreloc; 1600 Elf_Internal_Rela *rel; 1601 Elf_Internal_Rela *relend; 1602 1603 dynobj = elf_hash_table (info)->dynobj; 1604 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1605 sym_hashes = elf_sym_hashes (input_bfd); 1606 local_got_offsets = elf_local_got_offsets (input_bfd); 1607 1608 sgot = NULL; 1609 splt = NULL; 1610 sreloc = NULL; 1611 1612 rel = relocs; 1613 relend = relocs + input_section->reloc_count; 1614 for (; rel < relend; rel++) 1615 { 1616 int r_type; 1617 reloc_howto_type *howto; 1618 unsigned long r_symndx; 1619 struct elf_link_hash_entry *h; 1620 Elf_Internal_Sym *sym; 1621 asection *sec; 1622 bfd_vma relocation; 1623 bfd_boolean unresolved_reloc; 1624 bfd_reloc_status_type r; 1625 1626 r_type = ELF32_R_TYPE (rel->r_info); 1627 if (r_type < 0 || r_type >= (int) R_68K_max) 1628 { 1629 bfd_set_error (bfd_error_bad_value); 1630 return FALSE; 1631 } 1632 howto = howto_table + r_type; 1633 1634 r_symndx = ELF32_R_SYM (rel->r_info); 1635 1636 h = NULL; 1637 sym = NULL; 1638 sec = NULL; 1639 unresolved_reloc = FALSE; 1640 1641 if (r_symndx < symtab_hdr->sh_info) 1642 { 1643 sym = local_syms + r_symndx; 1644 sec = local_sections[r_symndx]; 1645 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1646 } 1647 else 1648 { 1649 bfd_boolean warned; 1650 1651 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1652 r_symndx, symtab_hdr, sym_hashes, 1653 h, sec, relocation, 1654 unresolved_reloc, warned); 1655 } 1656 1657 if (sec != NULL && elf_discarded_section (sec)) 1658 { 1659 /* For relocs against symbols from removed linkonce sections, 1660 or sections discarded by a linker script, we just want the 1661 section contents zeroed. Avoid any special processing. */ 1662 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 1663 rel->r_info = 0; 1664 rel->r_addend = 0; 1665 continue; 1666 } 1667 1668 if (info->relocatable) 1669 continue; 1670 1671 switch (r_type) 1672 { 1673 case R_68K_GOT8: 1674 case R_68K_GOT16: 1675 case R_68K_GOT32: 1676 /* Relocation is to the address of the entry for this symbol 1677 in the global offset table. */ 1678 if (h != NULL 1679 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1680 break; 1681 /* Fall through. */ 1682 case R_68K_GOT8O: 1683 case R_68K_GOT16O: 1684 case R_68K_GOT32O: 1685 /* Relocation is the offset of the entry for this symbol in 1686 the global offset table. */ 1687 1688 { 1689 bfd_vma off; 1690 1691 if (sgot == NULL) 1692 { 1693 sgot = bfd_get_section_by_name (dynobj, ".got"); 1694 BFD_ASSERT (sgot != NULL); 1695 } 1696 1697 if (h != NULL) 1698 { 1699 bfd_boolean dyn; 1700 1701 off = h->got.offset; 1702 BFD_ASSERT (off != (bfd_vma) -1); 1703 1704 dyn = elf_hash_table (info)->dynamic_sections_created; 1705 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 1706 || (info->shared 1707 && (info->symbolic 1708 || h->dynindx == -1 1709 || h->forced_local) 1710 && h->def_regular)) 1711 { 1712 /* This is actually a static link, or it is a 1713 -Bsymbolic link and the symbol is defined 1714 locally, or the symbol was forced to be local 1715 because of a version file.. We must initialize 1716 this entry in the global offset table. Since 1717 the offset must always be a multiple of 4, we 1718 use the least significant bit to record whether 1719 we have initialized it already. 1720 1721 When doing a dynamic link, we create a .rela.got 1722 relocation entry to initialize the value. This 1723 is done in the finish_dynamic_symbol routine. */ 1724 if ((off & 1) != 0) 1725 off &= ~1; 1726 else 1727 { 1728 bfd_put_32 (output_bfd, relocation, 1729 sgot->contents + off); 1730 h->got.offset |= 1; 1731 } 1732 } 1733 else 1734 unresolved_reloc = FALSE; 1735 } 1736 else 1737 { 1738 BFD_ASSERT (local_got_offsets != NULL 1739 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1740 1741 off = local_got_offsets[r_symndx]; 1742 1743 /* The offset must always be a multiple of 4. We use 1744 the least significant bit to record whether we have 1745 already generated the necessary reloc. */ 1746 if ((off & 1) != 0) 1747 off &= ~1; 1748 else 1749 { 1750 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1751 1752 if (info->shared) 1753 { 1754 asection *s; 1755 Elf_Internal_Rela outrel; 1756 bfd_byte *loc; 1757 1758 s = bfd_get_section_by_name (dynobj, ".rela.got"); 1759 BFD_ASSERT (s != NULL); 1760 1761 outrel.r_offset = (sgot->output_section->vma 1762 + sgot->output_offset 1763 + off); 1764 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE); 1765 outrel.r_addend = relocation; 1766 loc = s->contents; 1767 loc += s->reloc_count++ * sizeof (Elf32_External_Rela); 1768 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1769 } 1770 1771 local_got_offsets[r_symndx] |= 1; 1772 } 1773 } 1774 1775 relocation = sgot->output_offset + off; 1776 if (r_type == R_68K_GOT8O 1777 || r_type == R_68K_GOT16O 1778 || r_type == R_68K_GOT32O) 1779 { 1780 /* This relocation does not use the addend. */ 1781 rel->r_addend = 0; 1782 } 1783 else 1784 relocation += sgot->output_section->vma; 1785 } 1786 break; 1787 1788 case R_68K_PLT8: 1789 case R_68K_PLT16: 1790 case R_68K_PLT32: 1791 /* Relocation is to the entry for this symbol in the 1792 procedure linkage table. */ 1793 1794 /* Resolve a PLTxx reloc against a local symbol directly, 1795 without using the procedure linkage table. */ 1796 if (h == NULL) 1797 break; 1798 1799 if (h->plt.offset == (bfd_vma) -1 1800 || !elf_hash_table (info)->dynamic_sections_created) 1801 { 1802 /* We didn't make a PLT entry for this symbol. This 1803 happens when statically linking PIC code, or when 1804 using -Bsymbolic. */ 1805 break; 1806 } 1807 1808 if (splt == NULL) 1809 { 1810 splt = bfd_get_section_by_name (dynobj, ".plt"); 1811 BFD_ASSERT (splt != NULL); 1812 } 1813 1814 relocation = (splt->output_section->vma 1815 + splt->output_offset 1816 + h->plt.offset); 1817 unresolved_reloc = FALSE; 1818 break; 1819 1820 case R_68K_PLT8O: 1821 case R_68K_PLT16O: 1822 case R_68K_PLT32O: 1823 /* Relocation is the offset of the entry for this symbol in 1824 the procedure linkage table. */ 1825 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1); 1826 1827 if (splt == NULL) 1828 { 1829 splt = bfd_get_section_by_name (dynobj, ".plt"); 1830 BFD_ASSERT (splt != NULL); 1831 } 1832 1833 relocation = h->plt.offset; 1834 unresolved_reloc = FALSE; 1835 1836 /* This relocation does not use the addend. */ 1837 rel->r_addend = 0; 1838 1839 break; 1840 1841 case R_68K_PC8: 1842 case R_68K_PC16: 1843 case R_68K_PC32: 1844 if (h == NULL 1845 || (info->shared 1846 && h->forced_local)) 1847 break; 1848 /* Fall through. */ 1849 case R_68K_8: 1850 case R_68K_16: 1851 case R_68K_32: 1852 if (info->shared 1853 && r_symndx != 0 1854 && (input_section->flags & SEC_ALLOC) != 0 1855 && (h == NULL 1856 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1857 || h->root.type != bfd_link_hash_undefweak) 1858 && ((r_type != R_68K_PC8 1859 && r_type != R_68K_PC16 1860 && r_type != R_68K_PC32) 1861 || (h != NULL 1862 && h->dynindx != -1 1863 && (!info->symbolic 1864 || !h->def_regular)))) 1865 { 1866 Elf_Internal_Rela outrel; 1867 bfd_byte *loc; 1868 bfd_boolean skip, relocate; 1869 1870 /* When generating a shared object, these relocations 1871 are copied into the output file to be resolved at run 1872 time. */ 1873 1874 skip = FALSE; 1875 relocate = FALSE; 1876 1877 outrel.r_offset = 1878 _bfd_elf_section_offset (output_bfd, info, input_section, 1879 rel->r_offset); 1880 if (outrel.r_offset == (bfd_vma) -1) 1881 skip = TRUE; 1882 else if (outrel.r_offset == (bfd_vma) -2) 1883 skip = TRUE, relocate = TRUE; 1884 outrel.r_offset += (input_section->output_section->vma 1885 + input_section->output_offset); 1886 1887 if (skip) 1888 memset (&outrel, 0, sizeof outrel); 1889 else if (h != NULL 1890 && h->dynindx != -1 1891 && (r_type == R_68K_PC8 1892 || r_type == R_68K_PC16 1893 || r_type == R_68K_PC32 1894 || !info->shared 1895 || !info->symbolic 1896 || !h->def_regular)) 1897 { 1898 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1899 outrel.r_addend = rel->r_addend; 1900 } 1901 else 1902 { 1903 /* This symbol is local, or marked to become local. */ 1904 outrel.r_addend = relocation + rel->r_addend; 1905 1906 if (r_type == R_68K_32) 1907 { 1908 relocate = TRUE; 1909 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE); 1910 } 1911 else 1912 { 1913 long indx; 1914 1915 if (bfd_is_abs_section (sec)) 1916 indx = 0; 1917 else if (sec == NULL || sec->owner == NULL) 1918 { 1919 bfd_set_error (bfd_error_bad_value); 1920 return FALSE; 1921 } 1922 else 1923 { 1924 asection *osec; 1925 1926 /* We are turning this relocation into one 1927 against a section symbol. It would be 1928 proper to subtract the symbol's value, 1929 osec->vma, from the emitted reloc addend, 1930 but ld.so expects buggy relocs. */ 1931 osec = sec->output_section; 1932 indx = elf_section_data (osec)->dynindx; 1933 if (indx == 0) 1934 { 1935 struct elf_link_hash_table *htab; 1936 htab = elf_hash_table (info); 1937 osec = htab->text_index_section; 1938 indx = elf_section_data (osec)->dynindx; 1939 } 1940 BFD_ASSERT (indx != 0); 1941 } 1942 1943 outrel.r_info = ELF32_R_INFO (indx, r_type); 1944 } 1945 } 1946 1947 sreloc = elf_section_data (input_section)->sreloc; 1948 if (sreloc == NULL) 1949 abort (); 1950 1951 loc = sreloc->contents; 1952 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 1953 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1954 1955 /* This reloc will be computed at runtime, so there's no 1956 need to do anything now, except for R_68K_32 1957 relocations that have been turned into 1958 R_68K_RELATIVE. */ 1959 if (!relocate) 1960 continue; 1961 } 1962 1963 break; 1964 1965 case R_68K_GNU_VTINHERIT: 1966 case R_68K_GNU_VTENTRY: 1967 /* These are no-ops in the end. */ 1968 continue; 1969 1970 default: 1971 break; 1972 } 1973 1974 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 1975 because such sections are not SEC_ALLOC and thus ld.so will 1976 not process them. */ 1977 if (unresolved_reloc 1978 && !((input_section->flags & SEC_DEBUGGING) != 0 1979 && h->def_dynamic)) 1980 { 1981 (*_bfd_error_handler) 1982 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 1983 input_bfd, 1984 input_section, 1985 (long) rel->r_offset, 1986 howto->name, 1987 h->root.root.string); 1988 return FALSE; 1989 } 1990 1991 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1992 contents, rel->r_offset, 1993 relocation, rel->r_addend); 1994 1995 if (r != bfd_reloc_ok) 1996 { 1997 const char *name; 1998 1999 if (h != NULL) 2000 name = h->root.root.string; 2001 else 2002 { 2003 name = bfd_elf_string_from_elf_section (input_bfd, 2004 symtab_hdr->sh_link, 2005 sym->st_name); 2006 if (name == NULL) 2007 return FALSE; 2008 if (*name == '\0') 2009 name = bfd_section_name (input_bfd, sec); 2010 } 2011 2012 if (r == bfd_reloc_overflow) 2013 { 2014 if (!(info->callbacks->reloc_overflow 2015 (info, (h ? &h->root : NULL), name, howto->name, 2016 (bfd_vma) 0, input_bfd, input_section, 2017 rel->r_offset))) 2018 return FALSE; 2019 } 2020 else 2021 { 2022 (*_bfd_error_handler) 2023 (_("%B(%A+0x%lx): reloc against `%s': error %d"), 2024 input_bfd, input_section, 2025 (long) rel->r_offset, name, (int) r); 2026 return FALSE; 2027 } 2028 } 2029 } 2030 2031 return TRUE; 2032} 2033 2034/* Install an M_68K_PC32 relocation against VALUE at offset OFFSET 2035 into section SEC. */ 2036 2037static void 2038elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value) 2039{ 2040 /* Make VALUE PC-relative. */ 2041 value -= sec->output_section->vma + offset; 2042 2043 /* Apply any in-place addend. */ 2044 value += bfd_get_32 (sec->owner, sec->contents + offset); 2045 2046 bfd_put_32 (sec->owner, value, sec->contents + offset); 2047} 2048 2049/* Finish up dynamic symbol handling. We set the contents of various 2050 dynamic sections here. */ 2051 2052static bfd_boolean 2053elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym) 2054 bfd *output_bfd; 2055 struct bfd_link_info *info; 2056 struct elf_link_hash_entry *h; 2057 Elf_Internal_Sym *sym; 2058{ 2059 bfd *dynobj; 2060 2061 dynobj = elf_hash_table (info)->dynobj; 2062 2063 if (h->plt.offset != (bfd_vma) -1) 2064 { 2065 const struct elf_m68k_plt_info *plt_info; 2066 asection *splt; 2067 asection *sgot; 2068 asection *srela; 2069 bfd_vma plt_index; 2070 bfd_vma got_offset; 2071 Elf_Internal_Rela rela; 2072 bfd_byte *loc; 2073 2074 /* This symbol has an entry in the procedure linkage table. Set 2075 it up. */ 2076 2077 BFD_ASSERT (h->dynindx != -1); 2078 2079 plt_info = elf_m68k_hash_table (info)->plt_info; 2080 splt = bfd_get_section_by_name (dynobj, ".plt"); 2081 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 2082 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 2083 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL); 2084 2085 /* Get the index in the procedure linkage table which 2086 corresponds to this symbol. This is the index of this symbol 2087 in all the symbols for which we are making plt entries. The 2088 first entry in the procedure linkage table is reserved. */ 2089 plt_index = (h->plt.offset / plt_info->size) - 1; 2090 2091 /* Get the offset into the .got table of the entry that 2092 corresponds to this function. Each .got entry is 4 bytes. 2093 The first three are reserved. */ 2094 got_offset = (plt_index + 3) * 4; 2095 2096 memcpy (splt->contents + h->plt.offset, 2097 plt_info->symbol_entry, 2098 plt_info->size); 2099 2100 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got, 2101 (sgot->output_section->vma 2102 + sgot->output_offset 2103 + got_offset)); 2104 2105 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela), 2106 splt->contents 2107 + h->plt.offset 2108 + plt_info->symbol_resolve_entry + 2); 2109 2110 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt, 2111 splt->output_section->vma); 2112 2113 /* Fill in the entry in the global offset table. */ 2114 bfd_put_32 (output_bfd, 2115 (splt->output_section->vma 2116 + splt->output_offset 2117 + h->plt.offset 2118 + plt_info->symbol_resolve_entry), 2119 sgot->contents + got_offset); 2120 2121 /* Fill in the entry in the .rela.plt section. */ 2122 rela.r_offset = (sgot->output_section->vma 2123 + sgot->output_offset 2124 + got_offset); 2125 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT); 2126 rela.r_addend = 0; 2127 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela); 2128 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2129 2130 if (!h->def_regular) 2131 { 2132 /* Mark the symbol as undefined, rather than as defined in 2133 the .plt section. Leave the value alone. */ 2134 sym->st_shndx = SHN_UNDEF; 2135 } 2136 } 2137 2138 if (h->got.offset != (bfd_vma) -1) 2139 { 2140 asection *sgot; 2141 asection *srela; 2142 Elf_Internal_Rela rela; 2143 bfd_byte *loc; 2144 2145 /* This symbol has an entry in the global offset table. Set it 2146 up. */ 2147 2148 sgot = bfd_get_section_by_name (dynobj, ".got"); 2149 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 2150 BFD_ASSERT (sgot != NULL && srela != NULL); 2151 2152 rela.r_offset = (sgot->output_section->vma 2153 + sgot->output_offset 2154 + (h->got.offset &~ (bfd_vma) 1)); 2155 2156 /* If this is a -Bsymbolic link, and the symbol is defined 2157 locally, we just want to emit a RELATIVE reloc. Likewise if 2158 the symbol was forced to be local because of a version file. 2159 The entry in the global offset table will already have been 2160 initialized in the relocate_section function. */ 2161 if (info->shared 2162 && (info->symbolic 2163 || h->dynindx == -1 2164 || h->forced_local) 2165 && h->def_regular) 2166 { 2167 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE); 2168 rela.r_addend = bfd_get_signed_32 (output_bfd, 2169 (sgot->contents 2170 + (h->got.offset &~ (bfd_vma) 1))); 2171 } 2172 else 2173 { 2174 bfd_put_32 (output_bfd, (bfd_vma) 0, 2175 sgot->contents + (h->got.offset &~ (bfd_vma) 1)); 2176 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT); 2177 rela.r_addend = 0; 2178 } 2179 2180 loc = srela->contents; 2181 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela); 2182 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2183 } 2184 2185 if (h->needs_copy) 2186 { 2187 asection *s; 2188 Elf_Internal_Rela rela; 2189 bfd_byte *loc; 2190 2191 /* This symbol needs a copy reloc. Set it up. */ 2192 2193 BFD_ASSERT (h->dynindx != -1 2194 && (h->root.type == bfd_link_hash_defined 2195 || h->root.type == bfd_link_hash_defweak)); 2196 2197 s = bfd_get_section_by_name (h->root.u.def.section->owner, 2198 ".rela.bss"); 2199 BFD_ASSERT (s != NULL); 2200 2201 rela.r_offset = (h->root.u.def.value 2202 + h->root.u.def.section->output_section->vma 2203 + h->root.u.def.section->output_offset); 2204 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY); 2205 rela.r_addend = 0; 2206 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 2207 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2208 } 2209 2210 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2211 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2212 || h == elf_hash_table (info)->hgot) 2213 sym->st_shndx = SHN_ABS; 2214 2215 return TRUE; 2216} 2217 2218/* Finish up the dynamic sections. */ 2219 2220static bfd_boolean 2221elf_m68k_finish_dynamic_sections (output_bfd, info) 2222 bfd *output_bfd; 2223 struct bfd_link_info *info; 2224{ 2225 bfd *dynobj; 2226 asection *sgot; 2227 asection *sdyn; 2228 2229 dynobj = elf_hash_table (info)->dynobj; 2230 2231 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 2232 BFD_ASSERT (sgot != NULL); 2233 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2234 2235 if (elf_hash_table (info)->dynamic_sections_created) 2236 { 2237 asection *splt; 2238 Elf32_External_Dyn *dyncon, *dynconend; 2239 2240 splt = bfd_get_section_by_name (dynobj, ".plt"); 2241 BFD_ASSERT (splt != NULL && sdyn != NULL); 2242 2243 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2244 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 2245 for (; dyncon < dynconend; dyncon++) 2246 { 2247 Elf_Internal_Dyn dyn; 2248 const char *name; 2249 asection *s; 2250 2251 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2252 2253 switch (dyn.d_tag) 2254 { 2255 default: 2256 break; 2257 2258 case DT_PLTGOT: 2259 name = ".got"; 2260 goto get_vma; 2261 case DT_JMPREL: 2262 name = ".rela.plt"; 2263 get_vma: 2264 s = bfd_get_section_by_name (output_bfd, name); 2265 BFD_ASSERT (s != NULL); 2266 dyn.d_un.d_ptr = s->vma; 2267 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2268 break; 2269 2270 case DT_PLTRELSZ: 2271 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2272 BFD_ASSERT (s != NULL); 2273 dyn.d_un.d_val = s->size; 2274 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2275 break; 2276 2277 case DT_RELASZ: 2278 /* The procedure linkage table relocs (DT_JMPREL) should 2279 not be included in the overall relocs (DT_RELA). 2280 Therefore, we override the DT_RELASZ entry here to 2281 make it not include the JMPREL relocs. Since the 2282 linker script arranges for .rela.plt to follow all 2283 other relocation sections, we don't have to worry 2284 about changing the DT_RELA entry. */ 2285 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2286 if (s != NULL) 2287 dyn.d_un.d_val -= s->size; 2288 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2289 break; 2290 } 2291 } 2292 2293 /* Fill in the first entry in the procedure linkage table. */ 2294 if (splt->size > 0) 2295 { 2296 const struct elf_m68k_plt_info *plt_info; 2297 2298 plt_info = elf_m68k_hash_table (info)->plt_info; 2299 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size); 2300 2301 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4, 2302 (sgot->output_section->vma 2303 + sgot->output_offset 2304 + 4)); 2305 2306 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8, 2307 (sgot->output_section->vma 2308 + sgot->output_offset 2309 + 8)); 2310 2311 elf_section_data (splt->output_section)->this_hdr.sh_entsize 2312 = plt_info->size; 2313 } 2314 } 2315 2316 /* Fill in the first three entries in the global offset table. */ 2317 if (sgot->size > 0) 2318 { 2319 if (sdyn == NULL) 2320 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 2321 else 2322 bfd_put_32 (output_bfd, 2323 sdyn->output_section->vma + sdyn->output_offset, 2324 sgot->contents); 2325 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 2326 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 2327 } 2328 2329 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 2330 2331 return TRUE; 2332} 2333 2334/* Given a .data section and a .emreloc in-memory section, store 2335 relocation information into the .emreloc section which can be 2336 used at runtime to relocate the section. This is called by the 2337 linker when the --embedded-relocs switch is used. This is called 2338 after the add_symbols entry point has been called for all the 2339 objects, and before the final_link entry point is called. */ 2340 2341bfd_boolean 2342bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg) 2343 bfd *abfd; 2344 struct bfd_link_info *info; 2345 asection *datasec; 2346 asection *relsec; 2347 char **errmsg; 2348{ 2349 Elf_Internal_Shdr *symtab_hdr; 2350 Elf_Internal_Sym *isymbuf = NULL; 2351 Elf_Internal_Rela *internal_relocs = NULL; 2352 Elf_Internal_Rela *irel, *irelend; 2353 bfd_byte *p; 2354 bfd_size_type amt; 2355 2356 BFD_ASSERT (! info->relocatable); 2357 2358 *errmsg = NULL; 2359 2360 if (datasec->reloc_count == 0) 2361 return TRUE; 2362 2363 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2364 2365 /* Get a copy of the native relocations. */ 2366 internal_relocs = (_bfd_elf_link_read_relocs 2367 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 2368 info->keep_memory)); 2369 if (internal_relocs == NULL) 2370 goto error_return; 2371 2372 amt = (bfd_size_type) datasec->reloc_count * 12; 2373 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt); 2374 if (relsec->contents == NULL) 2375 goto error_return; 2376 2377 p = relsec->contents; 2378 2379 irelend = internal_relocs + datasec->reloc_count; 2380 for (irel = internal_relocs; irel < irelend; irel++, p += 12) 2381 { 2382 asection *targetsec; 2383 2384 /* We are going to write a four byte longword into the runtime 2385 reloc section. The longword will be the address in the data 2386 section which must be relocated. It is followed by the name 2387 of the target section NUL-padded or truncated to 8 2388 characters. */ 2389 2390 /* We can only relocate absolute longword relocs at run time. */ 2391 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32) 2392 { 2393 *errmsg = _("unsupported reloc type"); 2394 bfd_set_error (bfd_error_bad_value); 2395 goto error_return; 2396 } 2397 2398 /* Get the target section referred to by the reloc. */ 2399 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 2400 { 2401 /* A local symbol. */ 2402 Elf_Internal_Sym *isym; 2403 2404 /* Read this BFD's local symbols if we haven't done so already. */ 2405 if (isymbuf == NULL) 2406 { 2407 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2408 if (isymbuf == NULL) 2409 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 2410 symtab_hdr->sh_info, 0, 2411 NULL, NULL, NULL); 2412 if (isymbuf == NULL) 2413 goto error_return; 2414 } 2415 2416 isym = isymbuf + ELF32_R_SYM (irel->r_info); 2417 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2418 } 2419 else 2420 { 2421 unsigned long indx; 2422 struct elf_link_hash_entry *h; 2423 2424 /* An external symbol. */ 2425 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 2426 h = elf_sym_hashes (abfd)[indx]; 2427 BFD_ASSERT (h != NULL); 2428 if (h->root.type == bfd_link_hash_defined 2429 || h->root.type == bfd_link_hash_defweak) 2430 targetsec = h->root.u.def.section; 2431 else 2432 targetsec = NULL; 2433 } 2434 2435 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p); 2436 memset (p + 4, 0, 8); 2437 if (targetsec != NULL) 2438 strncpy ((char *) p + 4, targetsec->output_section->name, 8); 2439 } 2440 2441 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 2442 free (isymbuf); 2443 if (internal_relocs != NULL 2444 && elf_section_data (datasec)->relocs != internal_relocs) 2445 free (internal_relocs); 2446 return TRUE; 2447 2448error_return: 2449 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 2450 free (isymbuf); 2451 if (internal_relocs != NULL 2452 && elf_section_data (datasec)->relocs != internal_relocs) 2453 free (internal_relocs); 2454 return FALSE; 2455} 2456 2457static enum elf_reloc_type_class 2458elf32_m68k_reloc_type_class (rela) 2459 const Elf_Internal_Rela *rela; 2460{ 2461 switch ((int) ELF32_R_TYPE (rela->r_info)) 2462 { 2463 case R_68K_RELATIVE: 2464 return reloc_class_relative; 2465 case R_68K_JMP_SLOT: 2466 return reloc_class_plt; 2467 case R_68K_COPY: 2468 return reloc_class_copy; 2469 default: 2470 return reloc_class_normal; 2471 } 2472} 2473 2474/* Return address for Ith PLT stub in section PLT, for relocation REL 2475 or (bfd_vma) -1 if it should not be included. */ 2476 2477static bfd_vma 2478elf_m68k_plt_sym_val (bfd_vma i, const asection *plt, 2479 const arelent *rel ATTRIBUTE_UNUSED) 2480{ 2481 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size; 2482} 2483 2484#define TARGET_BIG_SYM bfd_elf32_m68k_vec 2485#define TARGET_BIG_NAME "elf32-m68k" 2486#define ELF_MACHINE_CODE EM_68K 2487#define ELF_MAXPAGESIZE 0x2000 2488#define elf_backend_create_dynamic_sections \ 2489 _bfd_elf_create_dynamic_sections 2490#define bfd_elf32_bfd_link_hash_table_create \ 2491 elf_m68k_link_hash_table_create 2492#define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link 2493 2494#define elf_backend_check_relocs elf_m68k_check_relocs 2495#define elf_backend_always_size_sections \ 2496 elf_m68k_always_size_sections 2497#define elf_backend_adjust_dynamic_symbol \ 2498 elf_m68k_adjust_dynamic_symbol 2499#define elf_backend_size_dynamic_sections \ 2500 elf_m68k_size_dynamic_sections 2501#define elf_backend_init_index_section _bfd_elf_init_1_index_section 2502#define elf_backend_relocate_section elf_m68k_relocate_section 2503#define elf_backend_finish_dynamic_symbol \ 2504 elf_m68k_finish_dynamic_symbol 2505#define elf_backend_finish_dynamic_sections \ 2506 elf_m68k_finish_dynamic_sections 2507#define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook 2508#define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook 2509#define bfd_elf32_bfd_merge_private_bfd_data \ 2510 elf32_m68k_merge_private_bfd_data 2511#define bfd_elf32_bfd_set_private_flags \ 2512 elf32_m68k_set_private_flags 2513#define bfd_elf32_bfd_print_private_bfd_data \ 2514 elf32_m68k_print_private_bfd_data 2515#define elf_backend_reloc_type_class elf32_m68k_reloc_type_class 2516#define elf_backend_plt_sym_val elf_m68k_plt_sym_val 2517#define elf_backend_object_p elf32_m68k_object_p 2518 2519#define elf_backend_can_gc_sections 1 2520#define elf_backend_can_refcount 1 2521#define elf_backend_want_got_plt 1 2522#define elf_backend_plt_readonly 1 2523#define elf_backend_want_plt_sym 0 2524#define elf_backend_got_header_size 12 2525#define elf_backend_rela_normal 1 2526 2527#include "elf32-target.h" 2528