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