1 /* Motorola 68k series support for 32-bit ELF 2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 30 static reloc_howto_type *reloc_type_lookup 31 PARAMS ((bfd *, bfd_reloc_code_real_type)); 32 static void rtype_to_howto 33 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 34 static struct bfd_hash_entry *elf_m68k_link_hash_newfunc 35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 36 static struct bfd_link_hash_table *elf_m68k_link_hash_table_create 37 PARAMS ((bfd *)); 38 static bfd_boolean elf_m68k_check_relocs 39 PARAMS ((bfd *, struct bfd_link_info *, asection *, 40 const Elf_Internal_Rela *)); 41 static bfd_boolean elf_m68k_adjust_dynamic_symbol 42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 43 static bfd_boolean elf_m68k_size_dynamic_sections 44 PARAMS ((bfd *, struct bfd_link_info *)); 45 static bfd_boolean elf_m68k_discard_copies 46 PARAMS ((struct elf_link_hash_entry *, PTR)); 47 static 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 **)); 50 static bfd_boolean elf_m68k_finish_dynamic_symbol 51 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 52 Elf_Internal_Sym *)); 53 static bfd_boolean elf_m68k_finish_dynamic_sections 54 PARAMS ((bfd *, struct bfd_link_info *)); 55 56 static bfd_boolean elf32_m68k_set_private_flags 57 PARAMS ((bfd *, flagword)); 58 static bfd_boolean elf32_m68k_merge_private_bfd_data 59 PARAMS ((bfd *, bfd *)); 60 static bfd_boolean elf32_m68k_print_private_bfd_data 61 PARAMS ((bfd *, PTR)); 62 static enum elf_reloc_type_class elf32_m68k_reloc_type_class 63 PARAMS ((const Elf_Internal_Rela *)); 64 65 static 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 /* TLS general dynamic variable reference. */ 119 HOWTO (R_68K_TLS_GD32, /* type */ 120 0, /* rightshift */ 121 2, /* size (0 = byte, 1 = short, 2 = long) */ 122 32, /* bitsize */ 123 FALSE, /* pc_relative */ 124 0, /* bitpos */ 125 complain_overflow_bitfield, /* complain_on_overflow */ 126 bfd_elf_generic_reloc, /* special_function */ 127 "R_68K_TLS_GD32", /* name */ 128 FALSE, /* partial_inplace */ 129 0, /* src_mask */ 130 0xffffffff, /* dst_mask */ 131 FALSE), /* pcrel_offset */ 132 133 HOWTO (R_68K_TLS_GD16, /* type */ 134 0, /* rightshift */ 135 1, /* size (0 = byte, 1 = short, 2 = long) */ 136 16, /* bitsize */ 137 FALSE, /* pc_relative */ 138 0, /* bitpos */ 139 complain_overflow_signed, /* complain_on_overflow */ 140 bfd_elf_generic_reloc, /* special_function */ 141 "R_68K_TLS_GD16", /* name */ 142 FALSE, /* partial_inplace */ 143 0, /* src_mask */ 144 0x0000ffff, /* dst_mask */ 145 FALSE), /* pcrel_offset */ 146 147 HOWTO (R_68K_TLS_GD8, /* type */ 148 0, /* rightshift */ 149 0, /* size (0 = byte, 1 = short, 2 = long) */ 150 8, /* bitsize */ 151 FALSE, /* pc_relative */ 152 0, /* bitpos */ 153 complain_overflow_signed, /* complain_on_overflow */ 154 bfd_elf_generic_reloc, /* special_function */ 155 "R_68K_TLS_GD8", /* name */ 156 FALSE, /* partial_inplace */ 157 0, /* src_mask */ 158 0x000000ff, /* dst_mask */ 159 FALSE), /* pcrel_offset */ 160 161 /* TLS local dynamic variable reference. */ 162 HOWTO (R_68K_TLS_LDM32, /* type */ 163 0, /* rightshift */ 164 2, /* size (0 = byte, 1 = short, 2 = long) */ 165 32, /* bitsize */ 166 FALSE, /* pc_relative */ 167 0, /* bitpos */ 168 complain_overflow_bitfield, /* complain_on_overflow */ 169 bfd_elf_generic_reloc, /* special_function */ 170 "R_68K_TLS_LDM32", /* name */ 171 FALSE, /* partial_inplace */ 172 0, /* src_mask */ 173 0xffffffff, /* dst_mask */ 174 FALSE), /* pcrel_offset */ 175 176 HOWTO (R_68K_TLS_LDM16, /* type */ 177 0, /* rightshift */ 178 1, /* size (0 = byte, 1 = short, 2 = long) */ 179 16, /* bitsize */ 180 FALSE, /* pc_relative */ 181 0, /* bitpos */ 182 complain_overflow_signed, /* complain_on_overflow */ 183 bfd_elf_generic_reloc, /* special_function */ 184 "R_68K_TLS_LDM16", /* name */ 185 FALSE, /* partial_inplace */ 186 0, /* src_mask */ 187 0x0000ffff, /* dst_mask */ 188 FALSE), /* pcrel_offset */ 189 190 HOWTO (R_68K_TLS_LDM8, /* type */ 191 0, /* rightshift */ 192 0, /* size (0 = byte, 1 = short, 2 = long) */ 193 8, /* bitsize */ 194 FALSE, /* pc_relative */ 195 0, /* bitpos */ 196 complain_overflow_signed, /* complain_on_overflow */ 197 bfd_elf_generic_reloc, /* special_function */ 198 "R_68K_TLS_LDM8", /* name */ 199 FALSE, /* partial_inplace */ 200 0, /* src_mask */ 201 0x000000ff, /* dst_mask */ 202 FALSE), /* pcrel_offset */ 203 204 HOWTO (R_68K_TLS_LDO32, /* type */ 205 0, /* rightshift */ 206 2, /* size (0 = byte, 1 = short, 2 = long) */ 207 32, /* bitsize */ 208 FALSE, /* pc_relative */ 209 0, /* bitpos */ 210 complain_overflow_bitfield, /* complain_on_overflow */ 211 bfd_elf_generic_reloc, /* special_function */ 212 "R_68K_TLS_LDO32", /* name */ 213 FALSE, /* partial_inplace */ 214 0, /* src_mask */ 215 0xffffffff, /* dst_mask */ 216 FALSE), /* pcrel_offset */ 217 218 HOWTO (R_68K_TLS_LDO16, /* type */ 219 0, /* rightshift */ 220 1, /* size (0 = byte, 1 = short, 2 = long) */ 221 16, /* bitsize */ 222 FALSE, /* pc_relative */ 223 0, /* bitpos */ 224 complain_overflow_signed, /* complain_on_overflow */ 225 bfd_elf_generic_reloc, /* special_function */ 226 "R_68K_TLS_LDO16", /* name */ 227 FALSE, /* partial_inplace */ 228 0, /* src_mask */ 229 0x0000ffff, /* dst_mask */ 230 FALSE), /* pcrel_offset */ 231 232 HOWTO (R_68K_TLS_LDO8, /* type */ 233 0, /* rightshift */ 234 0, /* size (0 = byte, 1 = short, 2 = long) */ 235 8, /* bitsize */ 236 FALSE, /* pc_relative */ 237 0, /* bitpos */ 238 complain_overflow_signed, /* complain_on_overflow */ 239 bfd_elf_generic_reloc, /* special_function */ 240 "R_68K_TLS_LDO8", /* name */ 241 FALSE, /* partial_inplace */ 242 0, /* src_mask */ 243 0x000000ff, /* dst_mask */ 244 FALSE), /* pcrel_offset */ 245 246 /* TLS initial execution variable reference. */ 247 HOWTO (R_68K_TLS_IE32, /* type */ 248 0, /* rightshift */ 249 2, /* size (0 = byte, 1 = short, 2 = long) */ 250 32, /* bitsize */ 251 FALSE, /* pc_relative */ 252 0, /* bitpos */ 253 complain_overflow_bitfield, /* complain_on_overflow */ 254 bfd_elf_generic_reloc, /* special_function */ 255 "R_68K_TLS_IE32", /* name */ 256 FALSE, /* partial_inplace */ 257 0, /* src_mask */ 258 0xffffffff, /* dst_mask */ 259 FALSE), /* pcrel_offset */ 260 261 HOWTO (R_68K_TLS_IE16, /* type */ 262 0, /* rightshift */ 263 1, /* size (0 = byte, 1 = short, 2 = long) */ 264 16, /* bitsize */ 265 FALSE, /* pc_relative */ 266 0, /* bitpos */ 267 complain_overflow_signed, /* complain_on_overflow */ 268 bfd_elf_generic_reloc, /* special_function */ 269 "R_68K_TLS_IE16", /* name */ 270 FALSE, /* partial_inplace */ 271 0, /* src_mask */ 272 0x0000ffff, /* dst_mask */ 273 FALSE), /* pcrel_offset */ 274 275 HOWTO (R_68K_TLS_IE8, /* type */ 276 0, /* rightshift */ 277 0, /* size (0 = byte, 1 = short, 2 = long) */ 278 8, /* bitsize */ 279 FALSE, /* pc_relative */ 280 0, /* bitpos */ 281 complain_overflow_signed, /* complain_on_overflow */ 282 bfd_elf_generic_reloc, /* special_function */ 283 "R_68K_TLS_IE8", /* name */ 284 FALSE, /* partial_inplace */ 285 0, /* src_mask */ 286 0x000000ff, /* dst_mask */ 287 FALSE), /* pcrel_offset */ 288 289 /* TLS local execution variable reference. */ 290 HOWTO (R_68K_TLS_LE32, /* type */ 291 0, /* rightshift */ 292 2, /* size (0 = byte, 1 = short, 2 = long) */ 293 32, /* bitsize */ 294 FALSE, /* pc_relative */ 295 0, /* bitpos */ 296 complain_overflow_bitfield, /* complain_on_overflow */ 297 bfd_elf_generic_reloc, /* special_function */ 298 "R_68K_TLS_LE32", /* name */ 299 FALSE, /* partial_inplace */ 300 0, /* src_mask */ 301 0xffffffff, /* dst_mask */ 302 FALSE), /* pcrel_offset */ 303 304 HOWTO (R_68K_TLS_LE16, /* type */ 305 0, /* rightshift */ 306 1, /* size (0 = byte, 1 = short, 2 = long) */ 307 16, /* bitsize */ 308 FALSE, /* pc_relative */ 309 0, /* bitpos */ 310 complain_overflow_signed, /* complain_on_overflow */ 311 bfd_elf_generic_reloc, /* special_function */ 312 "R_68K_TLS_LE16", /* name */ 313 FALSE, /* partial_inplace */ 314 0, /* src_mask */ 315 0x0000ffff, /* dst_mask */ 316 FALSE), /* pcrel_offset */ 317 318 HOWTO (R_68K_TLS_LE8, /* type */ 319 0, /* rightshift */ 320 0, /* size (0 = byte, 1 = short, 2 = long) */ 321 8, /* bitsize */ 322 FALSE, /* pc_relative */ 323 0, /* bitpos */ 324 complain_overflow_signed, /* complain_on_overflow */ 325 bfd_elf_generic_reloc, /* special_function */ 326 "R_68K_TLS_LE8", /* name */ 327 FALSE, /* partial_inplace */ 328 0, /* src_mask */ 329 0x000000ff, /* dst_mask */ 330 FALSE), /* pcrel_offset */ 331 332 /* TLS GD/LD dynamic relocations. */ 333 HOWTO (R_68K_TLS_DTPMOD32, /* type */ 334 0, /* rightshift */ 335 2, /* size (0 = byte, 1 = short, 2 = long) */ 336 32, /* bitsize */ 337 FALSE, /* pc_relative */ 338 0, /* bitpos */ 339 complain_overflow_dont, /* complain_on_overflow */ 340 bfd_elf_generic_reloc, /* special_function */ 341 "R_68K_TLS_DTPMOD32", /* name */ 342 FALSE, /* partial_inplace */ 343 0, /* src_mask */ 344 0xffffffff, /* dst_mask */ 345 FALSE), /* pcrel_offset */ 346 347 HOWTO (R_68K_TLS_DTPREL32, /* type */ 348 0, /* rightshift */ 349 2, /* size (0 = byte, 1 = short, 2 = long) */ 350 32, /* bitsize */ 351 FALSE, /* pc_relative */ 352 0, /* bitpos */ 353 complain_overflow_dont, /* complain_on_overflow */ 354 bfd_elf_generic_reloc, /* special_function */ 355 "R_68K_TLS_DTPREL32", /* name */ 356 FALSE, /* partial_inplace */ 357 0, /* src_mask */ 358 0xffffffff, /* dst_mask */ 359 FALSE), /* pcrel_offset */ 360 361 HOWTO (R_68K_TLS_TPREL32, /* type */ 362 0, /* rightshift */ 363 2, /* size (0 = byte, 1 = short, 2 = long) */ 364 32, /* bitsize */ 365 FALSE, /* pc_relative */ 366 0, /* bitpos */ 367 complain_overflow_dont, /* complain_on_overflow */ 368 bfd_elf_generic_reloc, /* special_function */ 369 "R_68K_TLS_TPREL32", /* name */ 370 FALSE, /* partial_inplace */ 371 0, /* src_mask */ 372 0xffffffff, /* dst_mask */ 373 FALSE), /* pcrel_offset */ 374 }; 375 376 static void 377 rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst) 378 { 379 unsigned int indx = ELF32_R_TYPE (dst->r_info); 380 381 if (indx >= (unsigned int) R_68K_max) 382 { 383 (*_bfd_error_handler) (_("%B: invalid relocation type %d"), 384 abfd, (int) indx); 385 indx = R_68K_NONE; 386 } 387 cache_ptr->howto = &howto_table[indx]; 388 } 389 390 #define elf_info_to_howto rtype_to_howto 391 392 static const struct 393 { 394 bfd_reloc_code_real_type bfd_val; 395 int elf_val; 396 } 397 reloc_map[] = 398 { 399 { BFD_RELOC_NONE, R_68K_NONE }, 400 { BFD_RELOC_32, R_68K_32 }, 401 { BFD_RELOC_16, R_68K_16 }, 402 { BFD_RELOC_8, R_68K_8 }, 403 { BFD_RELOC_32_PCREL, R_68K_PC32 }, 404 { BFD_RELOC_16_PCREL, R_68K_PC16 }, 405 { BFD_RELOC_8_PCREL, R_68K_PC8 }, 406 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 }, 407 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 }, 408 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 }, 409 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O }, 410 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O }, 411 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O }, 412 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 }, 413 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 }, 414 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 }, 415 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O }, 416 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O }, 417 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O }, 418 { BFD_RELOC_NONE, R_68K_COPY }, 419 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT }, 420 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT }, 421 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE }, 422 { BFD_RELOC_CTOR, R_68K_32 }, 423 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT }, 424 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY }, 425 { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 }, 426 { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 }, 427 { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 }, 428 { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 }, 429 { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 }, 430 { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 }, 431 { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 }, 432 { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 }, 433 { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 }, 434 { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 }, 435 { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 }, 436 { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 }, 437 { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 }, 438 { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 }, 439 { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 }, 440 }; 441 442 static reloc_howto_type * 443 reloc_type_lookup (abfd, code) 444 bfd *abfd ATTRIBUTE_UNUSED; 445 bfd_reloc_code_real_type code; 446 { 447 unsigned int i; 448 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++) 449 { 450 if (reloc_map[i].bfd_val == code) 451 return &howto_table[reloc_map[i].elf_val]; 452 } 453 return 0; 454 } 455 456 static reloc_howto_type * 457 reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 458 { 459 unsigned int i; 460 461 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++) 462 if (howto_table[i].name != NULL 463 && strcasecmp (howto_table[i].name, r_name) == 0) 464 return &howto_table[i]; 465 466 return NULL; 467 } 468 469 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup 470 #define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup 471 #define ELF_ARCH bfd_arch_m68k 472 #define ELF_TARGET_ID M68K_ELF_DATA 473 474 /* Functions for the m68k ELF linker. */ 475 476 /* The name of the dynamic interpreter. This is put in the .interp 477 section. */ 478 479 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 480 481 /* Describes one of the various PLT styles. */ 482 483 struct elf_m68k_plt_info 484 { 485 /* The size of each PLT entry. */ 486 bfd_vma size; 487 488 /* The template for the first PLT entry. */ 489 const bfd_byte *plt0_entry; 490 491 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations. 492 The comments by each member indicate the value that the relocation 493 is against. */ 494 struct { 495 unsigned int got4; /* .got + 4 */ 496 unsigned int got8; /* .got + 8 */ 497 } plt0_relocs; 498 499 /* The template for a symbol's PLT entry. */ 500 const bfd_byte *symbol_entry; 501 502 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations. 503 The comments by each member indicate the value that the relocation 504 is against. */ 505 struct { 506 unsigned int got; /* the symbol's .got.plt entry */ 507 unsigned int plt; /* .plt */ 508 } symbol_relocs; 509 510 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. 511 The stub starts with "move.l #relocoffset,%d0". */ 512 bfd_vma symbol_resolve_entry; 513 }; 514 515 /* The size in bytes of an entry in the procedure linkage table. */ 516 517 #define PLT_ENTRY_SIZE 20 518 519 /* The first entry in a procedure linkage table looks like this. See 520 the SVR4 ABI m68k supplement to see how this works. */ 521 522 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] = 523 { 524 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */ 525 0, 0, 0, 2, /* + (.got + 4) - . */ 526 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */ 527 0, 0, 0, 2, /* + (.got + 8) - . */ 528 0, 0, 0, 0 /* pad out to 20 bytes. */ 529 }; 530 531 /* Subsequent entries in a procedure linkage table look like this. */ 532 533 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] = 534 { 535 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */ 536 0, 0, 0, 2, /* + (.got.plt entry) - . */ 537 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 538 0, 0, 0, 0, /* + reloc index */ 539 0x60, 0xff, /* bra.l .plt */ 540 0, 0, 0, 0 /* + .plt - . */ 541 }; 542 543 static const struct elf_m68k_plt_info elf_m68k_plt_info = { 544 PLT_ENTRY_SIZE, 545 elf_m68k_plt0_entry, { 4, 12 }, 546 elf_m68k_plt_entry, { 4, 16 }, 8 547 }; 548 549 #define ISAB_PLT_ENTRY_SIZE 24 550 551 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] = 552 { 553 0x20, 0x3c, /* move.l #offset,%d0 */ 554 0, 0, 0, 0, /* + (.got + 4) - . */ 555 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */ 556 0x20, 0x3c, /* move.l #offset,%d0 */ 557 0, 0, 0, 0, /* + (.got + 8) - . */ 558 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 559 0x4e, 0xd0, /* jmp (%a0) */ 560 0x4e, 0x71 /* nop */ 561 }; 562 563 /* Subsequent entries in a procedure linkage table look like this. */ 564 565 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] = 566 { 567 0x20, 0x3c, /* move.l #offset,%d0 */ 568 0, 0, 0, 0, /* + (.got.plt entry) - . */ 569 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 570 0x4e, 0xd0, /* jmp (%a0) */ 571 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 572 0, 0, 0, 0, /* + reloc index */ 573 0x60, 0xff, /* bra.l .plt */ 574 0, 0, 0, 0 /* + .plt - . */ 575 }; 576 577 static const struct elf_m68k_plt_info elf_isab_plt_info = { 578 ISAB_PLT_ENTRY_SIZE, 579 elf_isab_plt0_entry, { 2, 12 }, 580 elf_isab_plt_entry, { 2, 20 }, 12 581 }; 582 583 #define ISAC_PLT_ENTRY_SIZE 24 584 585 static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] = 586 { 587 0x20, 0x3c, /* move.l #offset,%d0 */ 588 0, 0, 0, 0, /* replaced with .got + 4 - . */ 589 0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */ 590 0x20, 0x3c, /* move.l #offset,%d0 */ 591 0, 0, 0, 0, /* replaced with .got + 8 - . */ 592 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 593 0x4e, 0xd0, /* jmp (%a0) */ 594 0x4e, 0x71 /* nop */ 595 }; 596 597 /* Subsequent entries in a procedure linkage table look like this. */ 598 599 static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] = 600 { 601 0x20, 0x3c, /* move.l #offset,%d0 */ 602 0, 0, 0, 0, /* replaced with (.got entry) - . */ 603 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */ 604 0x4e, 0xd0, /* jmp (%a0) */ 605 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 606 0, 0, 0, 0, /* replaced with offset into relocation table */ 607 0x61, 0xff, /* bsr.l .plt */ 608 0, 0, 0, 0 /* replaced with .plt - . */ 609 }; 610 611 static const struct elf_m68k_plt_info elf_isac_plt_info = { 612 ISAC_PLT_ENTRY_SIZE, 613 elf_isac_plt0_entry, { 2, 12}, 614 elf_isac_plt_entry, { 2, 20 }, 12 615 }; 616 617 #define CPU32_PLT_ENTRY_SIZE 24 618 /* Procedure linkage table entries for the cpu32 */ 619 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] = 620 { 621 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */ 622 0, 0, 0, 2, /* + (.got + 4) - . */ 623 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */ 624 0, 0, 0, 2, /* + (.got + 8) - . */ 625 0x4e, 0xd1, /* jmp %a1@ */ 626 0, 0, 0, 0, /* pad out to 24 bytes. */ 627 0, 0 628 }; 629 630 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] = 631 { 632 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */ 633 0, 0, 0, 2, /* + (.got.plt entry) - . */ 634 0x4e, 0xd1, /* jmp %a1@ */ 635 0x2f, 0x3c, /* move.l #offset,-(%sp) */ 636 0, 0, 0, 0, /* + reloc index */ 637 0x60, 0xff, /* bra.l .plt */ 638 0, 0, 0, 0, /* + .plt - . */ 639 0, 0 640 }; 641 642 static const struct elf_m68k_plt_info elf_cpu32_plt_info = { 643 CPU32_PLT_ENTRY_SIZE, 644 elf_cpu32_plt0_entry, { 4, 12 }, 645 elf_cpu32_plt_entry, { 4, 18 }, 10 646 }; 647 648 /* The m68k linker needs to keep track of the number of relocs that it 649 decides to copy in check_relocs for each symbol. This is so that it 650 can discard PC relative relocs if it doesn't need them when linking 651 with -Bsymbolic. We store the information in a field extending the 652 regular ELF linker hash table. */ 653 654 /* This structure keeps track of the number of PC relative relocs we have 655 copied for a given symbol. */ 656 657 struct elf_m68k_pcrel_relocs_copied 658 { 659 /* Next section. */ 660 struct elf_m68k_pcrel_relocs_copied *next; 661 /* A section in dynobj. */ 662 asection *section; 663 /* Number of relocs copied in this section. */ 664 bfd_size_type count; 665 }; 666 667 /* Forward declaration. */ 668 struct elf_m68k_got_entry; 669 670 /* m68k ELF linker hash entry. */ 671 672 struct elf_m68k_link_hash_entry 673 { 674 struct elf_link_hash_entry root; 675 676 /* Number of PC relative relocs copied for this symbol. */ 677 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied; 678 679 /* Key to got_entries. */ 680 unsigned long got_entry_key; 681 682 /* List of GOT entries for this symbol. This list is build during 683 offset finalization and is used within elf_m68k_finish_dynamic_symbol 684 to traverse all GOT entries for a particular symbol. 685 686 ??? We could've used root.got.glist field instead, but having 687 a separate field is cleaner. */ 688 struct elf_m68k_got_entry *glist; 689 }; 690 691 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent)) 692 693 /* Key part of GOT entry in hashtable. */ 694 struct elf_m68k_got_entry_key 695 { 696 /* BFD in which this symbol was defined. NULL for global symbols. */ 697 const bfd *bfd; 698 699 /* Symbol index. Either local symbol index or h->got_entry_key. */ 700 unsigned long symndx; 701 702 /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32}, 703 R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}. 704 705 From perspective of hashtable key, only elf_m68k_got_reloc_type (type) 706 matters. That is, we distinguish between, say, R_68K_GOT16O 707 and R_68K_GOT32O when allocating offsets, but they are considered to be 708 the same when searching got->entries. */ 709 enum elf_m68k_reloc_type type; 710 }; 711 712 /* Size of the GOT offset suitable for relocation. */ 713 enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST }; 714 715 /* Entry of the GOT. */ 716 struct elf_m68k_got_entry 717 { 718 /* GOT entries are put into a got->entries hashtable. This is the key. */ 719 struct elf_m68k_got_entry_key key_; 720 721 /* GOT entry data. We need s1 before offset finalization and s2 after. */ 722 union 723 { 724 struct 725 { 726 /* Number of times this entry is referenced. It is used to 727 filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook. */ 728 bfd_vma refcount; 729 } s1; 730 731 struct 732 { 733 /* Offset from the start of .got section. To calculate offset relative 734 to GOT pointer one should substract got->offset from this value. */ 735 bfd_vma offset; 736 737 /* Pointer to the next GOT entry for this global symbol. 738 Symbols have at most one entry in one GOT, but might 739 have entries in more than one GOT. 740 Root of this list is h->glist. 741 NULL for local symbols. */ 742 struct elf_m68k_got_entry *next; 743 } s2; 744 } u; 745 }; 746 747 /* Return representative type for relocation R_TYPE. 748 This is used to avoid enumerating many relocations in comparisons, 749 switches etc. */ 750 751 static enum elf_m68k_reloc_type 752 elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type) 753 { 754 switch (r_type) 755 { 756 /* In most cases R_68K_GOTx relocations require the very same 757 handling as R_68K_GOT32O relocation. In cases when we need 758 to distinguish between the two, we use explicitly compare against 759 r_type. */ 760 case R_68K_GOT32: 761 case R_68K_GOT16: 762 case R_68K_GOT8: 763 case R_68K_GOT32O: 764 case R_68K_GOT16O: 765 case R_68K_GOT8O: 766 return R_68K_GOT32O; 767 768 case R_68K_TLS_GD32: 769 case R_68K_TLS_GD16: 770 case R_68K_TLS_GD8: 771 return R_68K_TLS_GD32; 772 773 case R_68K_TLS_LDM32: 774 case R_68K_TLS_LDM16: 775 case R_68K_TLS_LDM8: 776 return R_68K_TLS_LDM32; 777 778 case R_68K_TLS_IE32: 779 case R_68K_TLS_IE16: 780 case R_68K_TLS_IE8: 781 return R_68K_TLS_IE32; 782 783 default: 784 BFD_ASSERT (FALSE); 785 return 0; 786 } 787 } 788 789 /* Return size of the GOT entry offset for relocation R_TYPE. */ 790 791 static enum elf_m68k_got_offset_size 792 elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type) 793 { 794 switch (r_type) 795 { 796 case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8: 797 case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32: 798 case R_68K_TLS_IE32: 799 return R_32; 800 801 case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16: 802 case R_68K_TLS_IE16: 803 return R_16; 804 805 case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8: 806 case R_68K_TLS_IE8: 807 return R_8; 808 809 default: 810 BFD_ASSERT (FALSE); 811 return 0; 812 } 813 } 814 815 /* Return number of GOT entries we need to allocate in GOT for 816 relocation R_TYPE. */ 817 818 static bfd_vma 819 elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type) 820 { 821 switch (elf_m68k_reloc_got_type (r_type)) 822 { 823 case R_68K_GOT32O: 824 case R_68K_TLS_IE32: 825 return 1; 826 827 case R_68K_TLS_GD32: 828 case R_68K_TLS_LDM32: 829 return 2; 830 831 default: 832 BFD_ASSERT (FALSE); 833 return 0; 834 } 835 } 836 837 /* Return TRUE if relocation R_TYPE is a TLS one. */ 838 839 static bfd_boolean 840 elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type) 841 { 842 switch (r_type) 843 { 844 case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8: 845 case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8: 846 case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8: 847 case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8: 848 case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8: 849 case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32: 850 return TRUE; 851 852 default: 853 return FALSE; 854 } 855 } 856 857 /* Data structure representing a single GOT. */ 858 struct elf_m68k_got 859 { 860 /* Hashtable of 'struct elf_m68k_got_entry's. 861 Starting size of this table is the maximum number of 862 R_68K_GOT8O entries. */ 863 htab_t entries; 864 865 /* Number of R_x slots in this GOT. Some (e.g., TLS) entries require 866 several GOT slots. 867 868 n_slots[R_8] is the count of R_8 slots in this GOT. 869 n_slots[R_16] is the cumulative count of R_8 and R_16 slots 870 in this GOT. 871 n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots 872 in this GOT. This is the total number of slots. */ 873 bfd_vma n_slots[R_LAST]; 874 875 /* Number of local (entry->key_.h == NULL) slots in this GOT. 876 This is only used to properly calculate size of .rela.got section; 877 see elf_m68k_partition_multi_got. */ 878 bfd_vma local_n_slots; 879 880 /* Offset of this GOT relative to beginning of .got section. */ 881 bfd_vma offset; 882 }; 883 884 /* BFD and its GOT. This is an entry in multi_got->bfd2got hashtable. */ 885 struct elf_m68k_bfd2got_entry 886 { 887 /* BFD. */ 888 const bfd *bfd; 889 890 /* Assigned GOT. Before partitioning multi-GOT each BFD has its own 891 GOT structure. After partitioning several BFD's might [and often do] 892 share a single GOT. */ 893 struct elf_m68k_got *got; 894 }; 895 896 /* The main data structure holding all the pieces. */ 897 struct elf_m68k_multi_got 898 { 899 /* Hashtable mapping each BFD to its GOT. If a BFD doesn't have an entry 900 here, then it doesn't need a GOT (this includes the case of a BFD 901 having an empty GOT). 902 903 ??? This hashtable can be replaced by an array indexed by bfd->id. */ 904 htab_t bfd2got; 905 906 /* Next symndx to assign a global symbol. 907 h->got_entry_key is initialized from this counter. */ 908 unsigned long global_symndx; 909 }; 910 911 /* m68k ELF linker hash table. */ 912 913 struct elf_m68k_link_hash_table 914 { 915 struct elf_link_hash_table root; 916 917 /* Small local sym cache. */ 918 struct sym_cache sym_cache; 919 920 /* The PLT format used by this link, or NULL if the format has not 921 yet been chosen. */ 922 const struct elf_m68k_plt_info *plt_info; 923 924 /* True, if GP is loaded within each function which uses it. 925 Set to TRUE when GOT negative offsets or multi-GOT is enabled. */ 926 bfd_boolean local_gp_p; 927 928 /* Switch controlling use of negative offsets to double the size of GOTs. */ 929 bfd_boolean use_neg_got_offsets_p; 930 931 /* Switch controlling generation of multiple GOTs. */ 932 bfd_boolean allow_multigot_p; 933 934 /* Multi-GOT data structure. */ 935 struct elf_m68k_multi_got multi_got_; 936 }; 937 938 /* Get the m68k ELF linker hash table from a link_info structure. */ 939 940 #define elf_m68k_hash_table(p) \ 941 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 942 == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL) 943 944 /* Shortcut to multi-GOT data. */ 945 #define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_) 946 947 /* Create an entry in an m68k ELF linker hash table. */ 948 949 static struct bfd_hash_entry * 950 elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry, 951 struct bfd_hash_table *table, 952 const char *string) 953 { 954 struct bfd_hash_entry *ret = entry; 955 956 /* Allocate the structure if it has not already been allocated by a 957 subclass. */ 958 if (ret == NULL) 959 ret = bfd_hash_allocate (table, 960 sizeof (struct elf_m68k_link_hash_entry)); 961 if (ret == NULL) 962 return ret; 963 964 /* Call the allocation method of the superclass. */ 965 ret = _bfd_elf_link_hash_newfunc (ret, table, string); 966 if (ret != NULL) 967 { 968 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL; 969 elf_m68k_hash_entry (ret)->got_entry_key = 0; 970 elf_m68k_hash_entry (ret)->glist = NULL; 971 } 972 973 return ret; 974 } 975 976 /* Create an m68k ELF linker hash table. */ 977 978 static struct bfd_link_hash_table * 979 elf_m68k_link_hash_table_create (bfd *abfd) 980 { 981 struct elf_m68k_link_hash_table *ret; 982 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table); 983 984 ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt); 985 if (ret == (struct elf_m68k_link_hash_table *) NULL) 986 return NULL; 987 988 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 989 elf_m68k_link_hash_newfunc, 990 sizeof (struct elf_m68k_link_hash_entry), 991 M68K_ELF_DATA)) 992 { 993 free (ret); 994 return NULL; 995 } 996 997 ret->sym_cache.abfd = NULL; 998 ret->plt_info = NULL; 999 ret->local_gp_p = FALSE; 1000 ret->use_neg_got_offsets_p = FALSE; 1001 ret->allow_multigot_p = FALSE; 1002 ret->multi_got_.bfd2got = NULL; 1003 ret->multi_got_.global_symndx = 1; 1004 1005 return &ret->root.root; 1006 } 1007 1008 /* Destruct local data. */ 1009 1010 static void 1011 elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab) 1012 { 1013 struct elf_m68k_link_hash_table *htab; 1014 1015 htab = (struct elf_m68k_link_hash_table *) _htab; 1016 1017 if (htab->multi_got_.bfd2got != NULL) 1018 { 1019 htab_delete (htab->multi_got_.bfd2got); 1020 htab->multi_got_.bfd2got = NULL; 1021 } 1022 } 1023 1024 /* Set the right machine number. */ 1025 1026 static bfd_boolean 1027 elf32_m68k_object_p (bfd *abfd) 1028 { 1029 unsigned int mach = 0; 1030 unsigned features = 0; 1031 flagword eflags = elf_elfheader (abfd)->e_flags; 1032 1033 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 1034 features |= m68000; 1035 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 1036 features |= cpu32; 1037 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 1038 features |= fido_a; 1039 else 1040 { 1041 switch (eflags & EF_M68K_CF_ISA_MASK) 1042 { 1043 case EF_M68K_CF_ISA_A_NODIV: 1044 features |= mcfisa_a; 1045 break; 1046 case EF_M68K_CF_ISA_A: 1047 features |= mcfisa_a|mcfhwdiv; 1048 break; 1049 case EF_M68K_CF_ISA_A_PLUS: 1050 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp; 1051 break; 1052 case EF_M68K_CF_ISA_B_NOUSP: 1053 features |= mcfisa_a|mcfisa_b|mcfhwdiv; 1054 break; 1055 case EF_M68K_CF_ISA_B: 1056 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp; 1057 break; 1058 case EF_M68K_CF_ISA_C: 1059 features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp; 1060 break; 1061 case EF_M68K_CF_ISA_C_NODIV: 1062 features |= mcfisa_a|mcfisa_c|mcfusp; 1063 break; 1064 } 1065 switch (eflags & EF_M68K_CF_MAC_MASK) 1066 { 1067 case EF_M68K_CF_MAC: 1068 features |= mcfmac; 1069 break; 1070 case EF_M68K_CF_EMAC: 1071 features |= mcfemac; 1072 break; 1073 } 1074 if (eflags & EF_M68K_CF_FLOAT) 1075 features |= cfloat; 1076 } 1077 1078 mach = bfd_m68k_features_to_mach (features); 1079 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach); 1080 1081 return TRUE; 1082 } 1083 1084 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag 1085 field based on the machine number. */ 1086 1087 static void 1088 elf_m68k_final_write_processing (bfd *abfd, 1089 bfd_boolean linker ATTRIBUTE_UNUSED) 1090 { 1091 int mach = bfd_get_mach (abfd); 1092 unsigned long e_flags = elf_elfheader (abfd)->e_flags; 1093 1094 if (!e_flags) 1095 { 1096 unsigned int arch_mask; 1097 1098 arch_mask = bfd_m68k_mach_to_features (mach); 1099 1100 if (arch_mask & m68000) 1101 e_flags = EF_M68K_M68000; 1102 else if (arch_mask & cpu32) 1103 e_flags = EF_M68K_CPU32; 1104 else if (arch_mask & fido_a) 1105 e_flags = EF_M68K_FIDO; 1106 else 1107 { 1108 switch (arch_mask 1109 & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp)) 1110 { 1111 case mcfisa_a: 1112 e_flags |= EF_M68K_CF_ISA_A_NODIV; 1113 break; 1114 case mcfisa_a | mcfhwdiv: 1115 e_flags |= EF_M68K_CF_ISA_A; 1116 break; 1117 case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp: 1118 e_flags |= EF_M68K_CF_ISA_A_PLUS; 1119 break; 1120 case mcfisa_a | mcfisa_b | mcfhwdiv: 1121 e_flags |= EF_M68K_CF_ISA_B_NOUSP; 1122 break; 1123 case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp: 1124 e_flags |= EF_M68K_CF_ISA_B; 1125 break; 1126 case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp: 1127 e_flags |= EF_M68K_CF_ISA_C; 1128 break; 1129 case mcfisa_a | mcfisa_c | mcfusp: 1130 e_flags |= EF_M68K_CF_ISA_C_NODIV; 1131 break; 1132 } 1133 if (arch_mask & mcfmac) 1134 e_flags |= EF_M68K_CF_MAC; 1135 else if (arch_mask & mcfemac) 1136 e_flags |= EF_M68K_CF_EMAC; 1137 if (arch_mask & cfloat) 1138 e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E; 1139 } 1140 elf_elfheader (abfd)->e_flags = e_flags; 1141 } 1142 } 1143 1144 /* Keep m68k-specific flags in the ELF header. */ 1145 1146 static bfd_boolean 1147 elf32_m68k_set_private_flags (abfd, flags) 1148 bfd *abfd; 1149 flagword flags; 1150 { 1151 elf_elfheader (abfd)->e_flags = flags; 1152 elf_flags_init (abfd) = TRUE; 1153 return TRUE; 1154 } 1155 1156 /* Merge backend specific data from an object file to the output 1157 object file when linking. */ 1158 static bfd_boolean 1159 elf32_m68k_merge_private_bfd_data (ibfd, obfd) 1160 bfd *ibfd; 1161 bfd *obfd; 1162 { 1163 flagword out_flags; 1164 flagword in_flags; 1165 flagword out_isa; 1166 flagword in_isa; 1167 const bfd_arch_info_type *arch_info; 1168 1169 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1170 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1171 return FALSE; 1172 1173 /* Get the merged machine. This checks for incompatibility between 1174 Coldfire & non-Coldfire flags, incompability between different 1175 Coldfire ISAs, and incompability between different MAC types. */ 1176 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE); 1177 if (!arch_info) 1178 return FALSE; 1179 1180 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach); 1181 1182 in_flags = elf_elfheader (ibfd)->e_flags; 1183 if (!elf_flags_init (obfd)) 1184 { 1185 elf_flags_init (obfd) = TRUE; 1186 out_flags = in_flags; 1187 } 1188 else 1189 { 1190 out_flags = elf_elfheader (obfd)->e_flags; 1191 unsigned int variant_mask; 1192 1193 if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 1194 variant_mask = 0; 1195 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 1196 variant_mask = 0; 1197 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 1198 variant_mask = 0; 1199 else 1200 variant_mask = EF_M68K_CF_ISA_MASK; 1201 1202 in_isa = (in_flags & variant_mask); 1203 out_isa = (out_flags & variant_mask); 1204 if (in_isa > out_isa) 1205 out_flags ^= in_isa ^ out_isa; 1206 if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32 1207 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 1208 || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO 1209 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)) 1210 out_flags = EF_M68K_FIDO; 1211 else 1212 out_flags |= in_flags ^ in_isa; 1213 } 1214 elf_elfheader (obfd)->e_flags = out_flags; 1215 1216 return TRUE; 1217 } 1218 1219 /* Display the flags field. */ 1220 1221 static bfd_boolean 1222 elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr) 1223 { 1224 FILE *file = (FILE *) ptr; 1225 flagword eflags = elf_elfheader (abfd)->e_flags; 1226 1227 BFD_ASSERT (abfd != NULL && ptr != NULL); 1228 1229 /* Print normal ELF private data. */ 1230 _bfd_elf_print_private_bfd_data (abfd, ptr); 1231 1232 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */ 1233 1234 /* xgettext:c-format */ 1235 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 1236 1237 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000) 1238 fprintf (file, " [m68000]"); 1239 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32) 1240 fprintf (file, " [cpu32]"); 1241 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO) 1242 fprintf (file, " [fido]"); 1243 else 1244 { 1245 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E) 1246 fprintf (file, " [cfv4e]"); 1247 1248 if (eflags & EF_M68K_CF_ISA_MASK) 1249 { 1250 char const *isa = _("unknown"); 1251 char const *mac = _("unknown"); 1252 char const *additional = ""; 1253 1254 switch (eflags & EF_M68K_CF_ISA_MASK) 1255 { 1256 case EF_M68K_CF_ISA_A_NODIV: 1257 isa = "A"; 1258 additional = " [nodiv]"; 1259 break; 1260 case EF_M68K_CF_ISA_A: 1261 isa = "A"; 1262 break; 1263 case EF_M68K_CF_ISA_A_PLUS: 1264 isa = "A+"; 1265 break; 1266 case EF_M68K_CF_ISA_B_NOUSP: 1267 isa = "B"; 1268 additional = " [nousp]"; 1269 break; 1270 case EF_M68K_CF_ISA_B: 1271 isa = "B"; 1272 break; 1273 case EF_M68K_CF_ISA_C: 1274 isa = "C"; 1275 break; 1276 case EF_M68K_CF_ISA_C_NODIV: 1277 isa = "C"; 1278 additional = " [nodiv]"; 1279 break; 1280 } 1281 fprintf (file, " [isa %s]%s", isa, additional); 1282 1283 if (eflags & EF_M68K_CF_FLOAT) 1284 fprintf (file, " [float]"); 1285 1286 switch (eflags & EF_M68K_CF_MAC_MASK) 1287 { 1288 case 0: 1289 mac = NULL; 1290 break; 1291 case EF_M68K_CF_MAC: 1292 mac = "mac"; 1293 break; 1294 case EF_M68K_CF_EMAC: 1295 mac = "emac"; 1296 break; 1297 case EF_M68K_CF_EMAC_B: 1298 mac = "emac_b"; 1299 break; 1300 } 1301 if (mac) 1302 fprintf (file, " [%s]", mac); 1303 } 1304 } 1305 1306 fputc ('\n', file); 1307 1308 return TRUE; 1309 } 1310 1311 /* Multi-GOT support implementation design: 1312 1313 Multi-GOT starts in check_relocs hook. There we scan all 1314 relocations of a BFD and build a local GOT (struct elf_m68k_got) 1315 for it. If a single BFD appears to require too many GOT slots with 1316 R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification 1317 to user. 1318 After check_relocs has been invoked for each input BFD, we have 1319 constructed a GOT for each input BFD. 1320 1321 To minimize total number of GOTs required for a particular output BFD 1322 (as some environments support only 1 GOT per output object) we try 1323 to merge some of the GOTs to share an offset space. Ideally [and in most 1324 cases] we end up with a single GOT. In cases when there are too many 1325 restricted relocations (e.g., R_68K_GOT16O relocations) we end up with 1326 several GOTs, assuming the environment can handle them. 1327 1328 Partitioning is done in elf_m68k_partition_multi_got. We start with 1329 an empty GOT and traverse bfd2got hashtable putting got_entries from 1330 local GOTs to the new 'big' one. We do that by constructing an 1331 intermediate GOT holding all the entries the local GOT has and the big 1332 GOT lacks. Then we check if there is room in the big GOT to accomodate 1333 all the entries from diff. On success we add those entries to the big 1334 GOT; on failure we start the new 'big' GOT and retry the adding of 1335 entries from the local GOT. Note that this retry will always succeed as 1336 each local GOT doesn't overflow the limits. After partitioning we 1337 end up with each bfd assigned one of the big GOTs. GOT entries in the 1338 big GOTs are initialized with GOT offsets. Note that big GOTs are 1339 positioned consequently in program space and represent a single huge GOT 1340 to the outside world. 1341 1342 After that we get to elf_m68k_relocate_section. There we 1343 adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol 1344 relocations to refer to appropriate [assigned to current input_bfd] 1345 big GOT. 1346 1347 Notes: 1348 1349 GOT entry type: We have several types of GOT entries. 1350 * R_8 type is used in entries for symbols that have at least one 1351 R_68K_GOT8O or R_68K_TLS_*8 relocation. We can have at most 0x40 1352 such entries in one GOT. 1353 * R_16 type is used in entries for symbols that have at least one 1354 R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations. 1355 We can have at most 0x4000 such entries in one GOT. 1356 * R_32 type is used in all other cases. We can have as many 1357 such entries in one GOT as we'd like. 1358 When counting relocations we have to include the count of the smaller 1359 ranged relocations in the counts of the larger ranged ones in order 1360 to correctly detect overflow. 1361 1362 Sorting the GOT: In each GOT starting offsets are assigned to 1363 R_8 entries, which are followed by R_16 entries, and 1364 R_32 entries go at the end. See finalize_got_offsets for details. 1365 1366 Negative GOT offsets: To double usable offset range of GOTs we use 1367 negative offsets. As we assign entries with GOT offsets relative to 1368 start of .got section, the offset values are positive. They become 1369 negative only in relocate_section where got->offset value is 1370 subtracted from them. 1371 1372 3 special GOT entries: There are 3 special GOT entries used internally 1373 by loader. These entries happen to be placed to .got.plt section, 1374 so we don't do anything about them in multi-GOT support. 1375 1376 Memory management: All data except for hashtables 1377 multi_got->bfd2got and got->entries are allocated on 1378 elf_hash_table (info)->dynobj bfd (for this reason we pass 'info' 1379 to most functions), so we don't need to care to free them. At the 1380 moment of allocation hashtables are being linked into main data 1381 structure (multi_got), all pieces of which are reachable from 1382 elf_m68k_multi_got (info). We deallocate them in 1383 elf_m68k_link_hash_table_free. */ 1384 1385 /* Initialize GOT. */ 1386 1387 static void 1388 elf_m68k_init_got (struct elf_m68k_got *got) 1389 { 1390 got->entries = NULL; 1391 got->n_slots[R_8] = 0; 1392 got->n_slots[R_16] = 0; 1393 got->n_slots[R_32] = 0; 1394 got->local_n_slots = 0; 1395 got->offset = (bfd_vma) -1; 1396 } 1397 1398 /* Destruct GOT. */ 1399 1400 static void 1401 elf_m68k_clear_got (struct elf_m68k_got *got) 1402 { 1403 if (got->entries != NULL) 1404 { 1405 htab_delete (got->entries); 1406 got->entries = NULL; 1407 } 1408 } 1409 1410 /* Create and empty GOT structure. INFO is the context where memory 1411 should be allocated. */ 1412 1413 static struct elf_m68k_got * 1414 elf_m68k_create_empty_got (struct bfd_link_info *info) 1415 { 1416 struct elf_m68k_got *got; 1417 1418 got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got)); 1419 if (got == NULL) 1420 return NULL; 1421 1422 elf_m68k_init_got (got); 1423 1424 return got; 1425 } 1426 1427 /* Initialize KEY. */ 1428 1429 static void 1430 elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key, 1431 struct elf_link_hash_entry *h, 1432 const bfd *abfd, unsigned long symndx, 1433 enum elf_m68k_reloc_type reloc_type) 1434 { 1435 if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32) 1436 /* All TLS_LDM relocations share a single GOT entry. */ 1437 { 1438 key->bfd = NULL; 1439 key->symndx = 0; 1440 } 1441 else if (h != NULL) 1442 /* Global symbols are identified with their got_entry_key. */ 1443 { 1444 key->bfd = NULL; 1445 key->symndx = elf_m68k_hash_entry (h)->got_entry_key; 1446 BFD_ASSERT (key->symndx != 0); 1447 } 1448 else 1449 /* Local symbols are identified by BFD they appear in and symndx. */ 1450 { 1451 key->bfd = abfd; 1452 key->symndx = symndx; 1453 } 1454 1455 key->type = reloc_type; 1456 } 1457 1458 /* Calculate hash of got_entry. 1459 ??? Is it good? */ 1460 1461 static hashval_t 1462 elf_m68k_got_entry_hash (const void *_entry) 1463 { 1464 const struct elf_m68k_got_entry_key *key; 1465 1466 key = &((const struct elf_m68k_got_entry *) _entry)->key_; 1467 1468 return (key->symndx 1469 + (key->bfd != NULL ? (int) key->bfd->id : -1) 1470 + elf_m68k_reloc_got_type (key->type)); 1471 } 1472 1473 /* Check if two got entries are equal. */ 1474 1475 static int 1476 elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2) 1477 { 1478 const struct elf_m68k_got_entry_key *key1; 1479 const struct elf_m68k_got_entry_key *key2; 1480 1481 key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_; 1482 key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_; 1483 1484 return (key1->bfd == key2->bfd 1485 && key1->symndx == key2->symndx 1486 && (elf_m68k_reloc_got_type (key1->type) 1487 == elf_m68k_reloc_got_type (key2->type))); 1488 } 1489 1490 /* When using negative offsets, we allocate one extra R_8, one extra R_16 1491 and one extra R_32 slots to simplify handling of 2-slot entries during 1492 offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots. */ 1493 1494 /* Maximal number of R_8 slots in a single GOT. */ 1495 #define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO) \ 1496 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \ 1497 ? (0x40 - 1) \ 1498 : 0x20) 1499 1500 /* Maximal number of R_8 and R_16 slots in a single GOT. */ 1501 #define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO) \ 1502 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \ 1503 ? (0x4000 - 2) \ 1504 : 0x2000) 1505 1506 /* SEARCH - simply search the hashtable, don't insert new entries or fail when 1507 the entry cannot be found. 1508 FIND_OR_CREATE - search for an existing entry, but create new if there's 1509 no such. 1510 MUST_FIND - search for an existing entry and assert that it exist. 1511 MUST_CREATE - assert that there's no such entry and create new one. */ 1512 enum elf_m68k_get_entry_howto 1513 { 1514 SEARCH, 1515 FIND_OR_CREATE, 1516 MUST_FIND, 1517 MUST_CREATE 1518 }; 1519 1520 /* Get or create (depending on HOWTO) entry with KEY in GOT. 1521 INFO is context in which memory should be allocated (can be NULL if 1522 HOWTO is SEARCH or MUST_FIND). */ 1523 1524 static struct elf_m68k_got_entry * 1525 elf_m68k_get_got_entry (struct elf_m68k_got *got, 1526 const struct elf_m68k_got_entry_key *key, 1527 enum elf_m68k_get_entry_howto howto, 1528 struct bfd_link_info *info) 1529 { 1530 struct elf_m68k_got_entry entry_; 1531 struct elf_m68k_got_entry *entry; 1532 void **ptr; 1533 1534 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND)); 1535 1536 if (got->entries == NULL) 1537 /* This is the first entry in ABFD. Initialize hashtable. */ 1538 { 1539 if (howto == SEARCH) 1540 return NULL; 1541 1542 got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT 1543 (info), 1544 elf_m68k_got_entry_hash, 1545 elf_m68k_got_entry_eq, NULL); 1546 if (got->entries == NULL) 1547 { 1548 bfd_set_error (bfd_error_no_memory); 1549 return NULL; 1550 } 1551 } 1552 1553 entry_.key_ = *key; 1554 ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH 1555 ? INSERT : NO_INSERT)); 1556 if (ptr == NULL) 1557 { 1558 if (howto == SEARCH) 1559 /* Entry not found. */ 1560 return NULL; 1561 1562 /* We're out of memory. */ 1563 bfd_set_error (bfd_error_no_memory); 1564 return NULL; 1565 } 1566 1567 if (*ptr == NULL) 1568 /* We didn't find the entry and we're asked to create a new one. */ 1569 { 1570 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH); 1571 1572 entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)); 1573 if (entry == NULL) 1574 return NULL; 1575 1576 /* Initialize new entry. */ 1577 entry->key_ = *key; 1578 1579 entry->u.s1.refcount = 0; 1580 1581 /* Mark the entry as not initialized. */ 1582 entry->key_.type = R_68K_max; 1583 1584 *ptr = entry; 1585 } 1586 else 1587 /* We found the entry. */ 1588 { 1589 BFD_ASSERT (howto != MUST_CREATE); 1590 1591 entry = *ptr; 1592 } 1593 1594 return entry; 1595 } 1596 1597 /* Update GOT counters when merging entry of WAS type with entry of NEW type. 1598 Return the value to which ENTRY's type should be set. */ 1599 1600 static enum elf_m68k_reloc_type 1601 elf_m68k_update_got_entry_type (struct elf_m68k_got *got, 1602 enum elf_m68k_reloc_type was, 1603 enum elf_m68k_reloc_type new_reloc) 1604 { 1605 enum elf_m68k_got_offset_size was_size; 1606 enum elf_m68k_got_offset_size new_size; 1607 bfd_vma n_slots; 1608 1609 if (was == R_68K_max) 1610 /* The type of the entry is not initialized yet. */ 1611 { 1612 /* Update all got->n_slots counters, including n_slots[R_32]. */ 1613 was_size = R_LAST; 1614 1615 was = new_reloc; 1616 } 1617 else 1618 { 1619 /* !!! We, probably, should emit an error rather then fail on assert 1620 in such a case. */ 1621 BFD_ASSERT (elf_m68k_reloc_got_type (was) 1622 == elf_m68k_reloc_got_type (new_reloc)); 1623 1624 was_size = elf_m68k_reloc_got_offset_size (was); 1625 } 1626 1627 new_size = elf_m68k_reloc_got_offset_size (new_reloc); 1628 n_slots = elf_m68k_reloc_got_n_slots (new_reloc); 1629 1630 while (was_size > new_size) 1631 { 1632 --was_size; 1633 got->n_slots[was_size] += n_slots; 1634 } 1635 1636 if (new_reloc > was) 1637 /* Relocations are ordered from bigger got offset size to lesser, 1638 so choose the relocation type with lesser offset size. */ 1639 was = new_reloc; 1640 1641 return was; 1642 } 1643 1644 /* Update GOT counters when removing an entry of type TYPE. */ 1645 1646 static void 1647 elf_m68k_remove_got_entry_type (struct elf_m68k_got *got, 1648 enum elf_m68k_reloc_type type) 1649 { 1650 enum elf_m68k_got_offset_size os; 1651 bfd_vma n_slots; 1652 1653 n_slots = elf_m68k_reloc_got_n_slots (type); 1654 1655 /* Decrese counter of slots with offset size corresponding to TYPE 1656 and all greater offset sizes. */ 1657 for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os) 1658 { 1659 BFD_ASSERT (got->n_slots[os] >= n_slots); 1660 1661 got->n_slots[os] -= n_slots; 1662 } 1663 } 1664 1665 /* Add new or update existing entry to GOT. 1666 H, ABFD, TYPE and SYMNDX is data for the entry. 1667 INFO is a context where memory should be allocated. */ 1668 1669 static struct elf_m68k_got_entry * 1670 elf_m68k_add_entry_to_got (struct elf_m68k_got *got, 1671 struct elf_link_hash_entry *h, 1672 const bfd *abfd, 1673 enum elf_m68k_reloc_type reloc_type, 1674 unsigned long symndx, 1675 struct bfd_link_info *info) 1676 { 1677 struct elf_m68k_got_entry_key key_; 1678 struct elf_m68k_got_entry *entry; 1679 1680 if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0) 1681 elf_m68k_hash_entry (h)->got_entry_key 1682 = elf_m68k_multi_got (info)->global_symndx++; 1683 1684 elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type); 1685 1686 entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info); 1687 if (entry == NULL) 1688 return NULL; 1689 1690 /* Determine entry's type and update got->n_slots counters. */ 1691 entry->key_.type = elf_m68k_update_got_entry_type (got, 1692 entry->key_.type, 1693 reloc_type); 1694 1695 /* Update refcount. */ 1696 ++entry->u.s1.refcount; 1697 1698 if (entry->u.s1.refcount == 1) 1699 /* We see this entry for the first time. */ 1700 { 1701 if (entry->key_.bfd != NULL) 1702 got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type); 1703 } 1704 1705 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots); 1706 1707 if ((got->n_slots[R_8] 1708 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info)) 1709 || (got->n_slots[R_16] 1710 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))) 1711 /* This BFD has too many relocation. */ 1712 { 1713 if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info)) 1714 (*_bfd_error_handler) (_("%B: GOT overflow: " 1715 "Number of relocations with 8-bit " 1716 "offset > %d"), 1717 abfd, 1718 ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info)); 1719 else 1720 (*_bfd_error_handler) (_("%B: GOT overflow: " 1721 "Number of relocations with 8- or 16-bit " 1722 "offset > %d"), 1723 abfd, 1724 ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)); 1725 1726 return NULL; 1727 } 1728 1729 return entry; 1730 } 1731 1732 /* Compute the hash value of the bfd in a bfd2got hash entry. */ 1733 1734 static hashval_t 1735 elf_m68k_bfd2got_entry_hash (const void *entry) 1736 { 1737 const struct elf_m68k_bfd2got_entry *e; 1738 1739 e = (const struct elf_m68k_bfd2got_entry *) entry; 1740 1741 return e->bfd->id; 1742 } 1743 1744 /* Check whether two hash entries have the same bfd. */ 1745 1746 static int 1747 elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2) 1748 { 1749 const struct elf_m68k_bfd2got_entry *e1; 1750 const struct elf_m68k_bfd2got_entry *e2; 1751 1752 e1 = (const struct elf_m68k_bfd2got_entry *) entry1; 1753 e2 = (const struct elf_m68k_bfd2got_entry *) entry2; 1754 1755 return e1->bfd == e2->bfd; 1756 } 1757 1758 /* Destruct a bfd2got entry. */ 1759 1760 static void 1761 elf_m68k_bfd2got_entry_del (void *_entry) 1762 { 1763 struct elf_m68k_bfd2got_entry *entry; 1764 1765 entry = (struct elf_m68k_bfd2got_entry *) _entry; 1766 1767 BFD_ASSERT (entry->got != NULL); 1768 elf_m68k_clear_got (entry->got); 1769 } 1770 1771 /* Find existing or create new (depending on HOWTO) bfd2got entry in 1772 MULTI_GOT. ABFD is the bfd we need a GOT for. INFO is a context where 1773 memory should be allocated. */ 1774 1775 static struct elf_m68k_bfd2got_entry * 1776 elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got, 1777 const bfd *abfd, 1778 enum elf_m68k_get_entry_howto howto, 1779 struct bfd_link_info *info) 1780 { 1781 struct elf_m68k_bfd2got_entry entry_; 1782 void **ptr; 1783 struct elf_m68k_bfd2got_entry *entry; 1784 1785 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND)); 1786 1787 if (multi_got->bfd2got == NULL) 1788 /* This is the first GOT. Initialize bfd2got. */ 1789 { 1790 if (howto == SEARCH) 1791 return NULL; 1792 1793 multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash, 1794 elf_m68k_bfd2got_entry_eq, 1795 elf_m68k_bfd2got_entry_del); 1796 if (multi_got->bfd2got == NULL) 1797 { 1798 bfd_set_error (bfd_error_no_memory); 1799 return NULL; 1800 } 1801 } 1802 1803 entry_.bfd = abfd; 1804 ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH 1805 ? INSERT : NO_INSERT)); 1806 if (ptr == NULL) 1807 { 1808 if (howto == SEARCH) 1809 /* Entry not found. */ 1810 return NULL; 1811 1812 /* We're out of memory. */ 1813 bfd_set_error (bfd_error_no_memory); 1814 return NULL; 1815 } 1816 1817 if (*ptr == NULL) 1818 /* Entry was not found. Create new one. */ 1819 { 1820 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH); 1821 1822 entry = ((struct elf_m68k_bfd2got_entry *) 1823 bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry))); 1824 if (entry == NULL) 1825 return NULL; 1826 1827 entry->bfd = abfd; 1828 1829 entry->got = elf_m68k_create_empty_got (info); 1830 if (entry->got == NULL) 1831 return NULL; 1832 1833 *ptr = entry; 1834 } 1835 else 1836 { 1837 BFD_ASSERT (howto != MUST_CREATE); 1838 1839 /* Return existing entry. */ 1840 entry = *ptr; 1841 } 1842 1843 return entry; 1844 } 1845 1846 struct elf_m68k_can_merge_gots_arg 1847 { 1848 /* A current_got that we constructing a DIFF against. */ 1849 struct elf_m68k_got *big; 1850 1851 /* GOT holding entries not present or that should be changed in 1852 BIG. */ 1853 struct elf_m68k_got *diff; 1854 1855 /* Context where to allocate memory. */ 1856 struct bfd_link_info *info; 1857 1858 /* Error flag. */ 1859 bfd_boolean error_p; 1860 }; 1861 1862 /* Process a single entry from the small GOT to see if it should be added 1863 or updated in the big GOT. */ 1864 1865 static int 1866 elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg) 1867 { 1868 const struct elf_m68k_got_entry *entry1; 1869 struct elf_m68k_can_merge_gots_arg *arg; 1870 const struct elf_m68k_got_entry *entry2; 1871 enum elf_m68k_reloc_type type; 1872 1873 entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr; 1874 arg = (struct elf_m68k_can_merge_gots_arg *) _arg; 1875 1876 entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL); 1877 1878 if (entry2 != NULL) 1879 /* We found an existing entry. Check if we should update it. */ 1880 { 1881 type = elf_m68k_update_got_entry_type (arg->diff, 1882 entry2->key_.type, 1883 entry1->key_.type); 1884 1885 if (type == entry2->key_.type) 1886 /* ENTRY1 doesn't update data in ENTRY2. Skip it. 1887 To skip creation of difference entry we use the type, 1888 which we won't see in GOT entries for sure. */ 1889 type = R_68K_max; 1890 } 1891 else 1892 /* We didn't find the entry. Add entry1 to DIFF. */ 1893 { 1894 BFD_ASSERT (entry1->key_.type != R_68K_max); 1895 1896 type = elf_m68k_update_got_entry_type (arg->diff, 1897 R_68K_max, entry1->key_.type); 1898 1899 if (entry1->key_.bfd != NULL) 1900 arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type); 1901 } 1902 1903 if (type != R_68K_max) 1904 /* Create an entry in DIFF. */ 1905 { 1906 struct elf_m68k_got_entry *entry; 1907 1908 entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE, 1909 arg->info); 1910 if (entry == NULL) 1911 { 1912 arg->error_p = TRUE; 1913 return 0; 1914 } 1915 1916 entry->key_.type = type; 1917 } 1918 1919 return 1; 1920 } 1921 1922 /* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it. 1923 Construct DIFF GOT holding the entries which should be added or updated 1924 in BIG GOT to accumulate information from SMALL. 1925 INFO is the context where memory should be allocated. */ 1926 1927 static bfd_boolean 1928 elf_m68k_can_merge_gots (struct elf_m68k_got *big, 1929 const struct elf_m68k_got *small, 1930 struct bfd_link_info *info, 1931 struct elf_m68k_got *diff) 1932 { 1933 struct elf_m68k_can_merge_gots_arg arg_; 1934 1935 BFD_ASSERT (small->offset == (bfd_vma) -1); 1936 1937 arg_.big = big; 1938 arg_.diff = diff; 1939 arg_.info = info; 1940 arg_.error_p = FALSE; 1941 htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_); 1942 if (arg_.error_p) 1943 { 1944 diff->offset = 0; 1945 return FALSE; 1946 } 1947 1948 /* Check for overflow. */ 1949 if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8] 1950 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info)) 1951 || (big->n_slots[R_16] + arg_.diff->n_slots[R_16] 1952 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))) 1953 return FALSE; 1954 1955 return TRUE; 1956 } 1957 1958 struct elf_m68k_merge_gots_arg 1959 { 1960 /* The BIG got. */ 1961 struct elf_m68k_got *big; 1962 1963 /* Context where memory should be allocated. */ 1964 struct bfd_link_info *info; 1965 1966 /* Error flag. */ 1967 bfd_boolean error_p; 1968 }; 1969 1970 /* Process a single entry from DIFF got. Add or update corresponding 1971 entry in the BIG got. */ 1972 1973 static int 1974 elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg) 1975 { 1976 const struct elf_m68k_got_entry *from; 1977 struct elf_m68k_merge_gots_arg *arg; 1978 struct elf_m68k_got_entry *to; 1979 1980 from = (const struct elf_m68k_got_entry *) *entry_ptr; 1981 arg = (struct elf_m68k_merge_gots_arg *) _arg; 1982 1983 to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE, 1984 arg->info); 1985 if (to == NULL) 1986 { 1987 arg->error_p = TRUE; 1988 return 0; 1989 } 1990 1991 BFD_ASSERT (to->u.s1.refcount == 0); 1992 /* All we need to merge is TYPE. */ 1993 to->key_.type = from->key_.type; 1994 1995 return 1; 1996 } 1997 1998 /* Merge data from DIFF to BIG. INFO is context where memory should be 1999 allocated. */ 2000 2001 static bfd_boolean 2002 elf_m68k_merge_gots (struct elf_m68k_got *big, 2003 struct elf_m68k_got *diff, 2004 struct bfd_link_info *info) 2005 { 2006 if (diff->entries != NULL) 2007 /* DIFF is not empty. Merge it into BIG GOT. */ 2008 { 2009 struct elf_m68k_merge_gots_arg arg_; 2010 2011 /* Merge entries. */ 2012 arg_.big = big; 2013 arg_.info = info; 2014 arg_.error_p = FALSE; 2015 htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_); 2016 if (arg_.error_p) 2017 return FALSE; 2018 2019 /* Merge counters. */ 2020 big->n_slots[R_8] += diff->n_slots[R_8]; 2021 big->n_slots[R_16] += diff->n_slots[R_16]; 2022 big->n_slots[R_32] += diff->n_slots[R_32]; 2023 big->local_n_slots += diff->local_n_slots; 2024 } 2025 else 2026 /* DIFF is empty. */ 2027 { 2028 BFD_ASSERT (diff->n_slots[R_8] == 0); 2029 BFD_ASSERT (diff->n_slots[R_16] == 0); 2030 BFD_ASSERT (diff->n_slots[R_32] == 0); 2031 BFD_ASSERT (diff->local_n_slots == 0); 2032 } 2033 2034 BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p 2035 || ((big->n_slots[R_8] 2036 <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info)) 2037 && (big->n_slots[R_16] 2038 <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))); 2039 2040 return TRUE; 2041 } 2042 2043 struct elf_m68k_finalize_got_offsets_arg 2044 { 2045 /* Ranges of the offsets for GOT entries. 2046 R_x entries receive offsets between offset1[R_x] and offset2[R_x]. 2047 R_x is R_8, R_16 and R_32. */ 2048 bfd_vma *offset1; 2049 bfd_vma *offset2; 2050 2051 /* Mapping from global symndx to global symbols. 2052 This is used to build lists of got entries for global symbols. */ 2053 struct elf_m68k_link_hash_entry **symndx2h; 2054 2055 bfd_vma n_ldm_entries; 2056 }; 2057 2058 /* Assign ENTRY an offset. Build list of GOT entries for global symbols 2059 along the way. */ 2060 2061 static int 2062 elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg) 2063 { 2064 struct elf_m68k_got_entry *entry; 2065 struct elf_m68k_finalize_got_offsets_arg *arg; 2066 2067 enum elf_m68k_got_offset_size got_offset_size; 2068 bfd_vma entry_size; 2069 2070 entry = (struct elf_m68k_got_entry *) *entry_ptr; 2071 arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg; 2072 2073 /* This should be a fresh entry created in elf_m68k_can_merge_gots. */ 2074 BFD_ASSERT (entry->u.s1.refcount == 0); 2075 2076 /* Get GOT offset size for the entry . */ 2077 got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type); 2078 2079 /* Calculate entry size in bytes. */ 2080 entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type); 2081 2082 /* Check if we should switch to negative range of the offsets. */ 2083 if (arg->offset1[got_offset_size] + entry_size 2084 > arg->offset2[got_offset_size]) 2085 { 2086 /* Verify that this is the only switch to negative range for 2087 got_offset_size. If this assertion fails, then we've miscalculated 2088 range for got_offset_size entries in 2089 elf_m68k_finalize_got_offsets. */ 2090 BFD_ASSERT (arg->offset2[got_offset_size] 2091 != arg->offset2[-(int) got_offset_size - 1]); 2092 2093 /* Switch. */ 2094 arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1]; 2095 arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1]; 2096 2097 /* Verify that now we have enough room for the entry. */ 2098 BFD_ASSERT (arg->offset1[got_offset_size] + entry_size 2099 <= arg->offset2[got_offset_size]); 2100 } 2101 2102 /* Assign offset to entry. */ 2103 entry->u.s2.offset = arg->offset1[got_offset_size]; 2104 arg->offset1[got_offset_size] += entry_size; 2105 2106 if (entry->key_.bfd == NULL) 2107 /* Hook up this entry into the list of got_entries of H. */ 2108 { 2109 struct elf_m68k_link_hash_entry *h; 2110 2111 h = arg->symndx2h[entry->key_.symndx]; 2112 if (h != NULL) 2113 { 2114 entry->u.s2.next = h->glist; 2115 h->glist = entry; 2116 } 2117 else 2118 /* This should be the entry for TLS_LDM relocation then. */ 2119 { 2120 BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type) 2121 == R_68K_TLS_LDM32) 2122 && entry->key_.symndx == 0); 2123 2124 ++arg->n_ldm_entries; 2125 } 2126 } 2127 else 2128 /* This entry is for local symbol. */ 2129 entry->u.s2.next = NULL; 2130 2131 return 1; 2132 } 2133 2134 /* Assign offsets within GOT. USE_NEG_GOT_OFFSETS_P indicates if we 2135 should use negative offsets. 2136 Build list of GOT entries for global symbols along the way. 2137 SYMNDX2H is mapping from global symbol indices to actual 2138 global symbols. 2139 Return offset at which next GOT should start. */ 2140 2141 static void 2142 elf_m68k_finalize_got_offsets (struct elf_m68k_got *got, 2143 bfd_boolean use_neg_got_offsets_p, 2144 struct elf_m68k_link_hash_entry **symndx2h, 2145 bfd_vma *final_offset, bfd_vma *n_ldm_entries) 2146 { 2147 struct elf_m68k_finalize_got_offsets_arg arg_; 2148 bfd_vma offset1_[2 * R_LAST]; 2149 bfd_vma offset2_[2 * R_LAST]; 2150 int i; 2151 bfd_vma start_offset; 2152 2153 BFD_ASSERT (got->offset != (bfd_vma) -1); 2154 2155 /* We set entry offsets relative to the .got section (and not the 2156 start of a particular GOT), so that we can use them in 2157 finish_dynamic_symbol without needing to know the GOT which they come 2158 from. */ 2159 2160 /* Put offset1 in the middle of offset1_, same for offset2. */ 2161 arg_.offset1 = offset1_ + R_LAST; 2162 arg_.offset2 = offset2_ + R_LAST; 2163 2164 start_offset = got->offset; 2165 2166 if (use_neg_got_offsets_p) 2167 /* Setup both negative and positive ranges for R_8, R_16 and R_32. */ 2168 i = -(int) R_32 - 1; 2169 else 2170 /* Setup positives ranges for R_8, R_16 and R_32. */ 2171 i = (int) R_8; 2172 2173 for (; i <= (int) R_32; ++i) 2174 { 2175 int j; 2176 size_t n; 2177 2178 /* Set beginning of the range of offsets I. */ 2179 arg_.offset1[i] = start_offset; 2180 2181 /* Calculate number of slots that require I offsets. */ 2182 j = (i >= 0) ? i : -i - 1; 2183 n = (j >= 1) ? got->n_slots[j - 1] : 0; 2184 n = got->n_slots[j] - n; 2185 2186 if (use_neg_got_offsets_p && n != 0) 2187 { 2188 if (i < 0) 2189 /* We first fill the positive side of the range, so we might 2190 end up with one empty slot at that side when we can't fit 2191 whole 2-slot entry. Account for that at negative side of 2192 the interval with one additional entry. */ 2193 n = n / 2 + 1; 2194 else 2195 /* When the number of slots is odd, make positive side of the 2196 range one entry bigger. */ 2197 n = (n + 1) / 2; 2198 } 2199 2200 /* N is the number of slots that require I offsets. 2201 Calculate length of the range for I offsets. */ 2202 n = 4 * n; 2203 2204 /* Set end of the range. */ 2205 arg_.offset2[i] = start_offset + n; 2206 2207 start_offset = arg_.offset2[i]; 2208 } 2209 2210 if (!use_neg_got_offsets_p) 2211 /* Make sure that if we try to switch to negative offsets in 2212 elf_m68k_finalize_got_offsets_1, the assert therein will catch 2213 the bug. */ 2214 for (i = R_8; i <= R_32; ++i) 2215 arg_.offset2[-i - 1] = arg_.offset2[i]; 2216 2217 /* Setup got->offset. offset1[R_8] is either in the middle or at the 2218 beginning of GOT depending on use_neg_got_offsets_p. */ 2219 got->offset = arg_.offset1[R_8]; 2220 2221 arg_.symndx2h = symndx2h; 2222 arg_.n_ldm_entries = 0; 2223 2224 /* Assign offsets. */ 2225 htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_); 2226 2227 /* Check offset ranges we have actually assigned. */ 2228 for (i = (int) R_8; i <= (int) R_32; ++i) 2229 BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4); 2230 2231 *final_offset = start_offset; 2232 *n_ldm_entries = arg_.n_ldm_entries; 2233 } 2234 2235 struct elf_m68k_partition_multi_got_arg 2236 { 2237 /* The GOT we are adding entries to. Aka big got. */ 2238 struct elf_m68k_got *current_got; 2239 2240 /* Offset to assign the next CURRENT_GOT. */ 2241 bfd_vma offset; 2242 2243 /* Context where memory should be allocated. */ 2244 struct bfd_link_info *info; 2245 2246 /* Total number of slots in the .got section. 2247 This is used to calculate size of the .got and .rela.got sections. */ 2248 bfd_vma n_slots; 2249 2250 /* Difference in numbers of allocated slots in the .got section 2251 and necessary relocations in the .rela.got section. 2252 This is used to calculate size of the .rela.got section. */ 2253 bfd_vma slots_relas_diff; 2254 2255 /* Error flag. */ 2256 bfd_boolean error_p; 2257 2258 /* Mapping from global symndx to global symbols. 2259 This is used to build lists of got entries for global symbols. */ 2260 struct elf_m68k_link_hash_entry **symndx2h; 2261 }; 2262 2263 static void 2264 elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg) 2265 { 2266 bfd_vma n_ldm_entries; 2267 2268 elf_m68k_finalize_got_offsets (arg->current_got, 2269 (elf_m68k_hash_table (arg->info) 2270 ->use_neg_got_offsets_p), 2271 arg->symndx2h, 2272 &arg->offset, &n_ldm_entries); 2273 2274 arg->n_slots += arg->current_got->n_slots[R_32]; 2275 2276 if (!arg->info->shared) 2277 /* If we are generating a shared object, we need to 2278 output a R_68K_RELATIVE reloc so that the dynamic 2279 linker can adjust this GOT entry. Overwise we 2280 don't need space in .rela.got for local symbols. */ 2281 arg->slots_relas_diff += arg->current_got->local_n_slots; 2282 2283 /* @LDM relocations require a 2-slot GOT entry, but only 2284 one relocation. Account for that. */ 2285 arg->slots_relas_diff += n_ldm_entries; 2286 2287 BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots); 2288 } 2289 2290 2291 /* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT 2292 or start a new CURRENT_GOT. */ 2293 2294 static int 2295 elf_m68k_partition_multi_got_1 (void **_entry, void *_arg) 2296 { 2297 struct elf_m68k_bfd2got_entry *entry; 2298 struct elf_m68k_partition_multi_got_arg *arg; 2299 struct elf_m68k_got *got; 2300 struct elf_m68k_got diff_; 2301 struct elf_m68k_got *diff; 2302 2303 entry = (struct elf_m68k_bfd2got_entry *) *_entry; 2304 arg = (struct elf_m68k_partition_multi_got_arg *) _arg; 2305 2306 got = entry->got; 2307 BFD_ASSERT (got != NULL); 2308 BFD_ASSERT (got->offset == (bfd_vma) -1); 2309 2310 diff = NULL; 2311 2312 if (arg->current_got != NULL) 2313 /* Construct diff. */ 2314 { 2315 diff = &diff_; 2316 elf_m68k_init_got (diff); 2317 2318 if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff)) 2319 { 2320 if (diff->offset == 0) 2321 /* Offset set to 0 in the diff_ indicates an error. */ 2322 { 2323 arg->error_p = TRUE; 2324 goto final_return; 2325 } 2326 2327 if (elf_m68k_hash_table (arg->info)->allow_multigot_p) 2328 { 2329 elf_m68k_clear_got (diff); 2330 /* Schedule to finish up current_got and start new one. */ 2331 diff = NULL; 2332 } 2333 /* else 2334 Merge GOTs no matter what. If big GOT overflows, 2335 we'll fail in relocate_section due to truncated relocations. 2336 2337 ??? May be fail earlier? E.g., in can_merge_gots. */ 2338 } 2339 } 2340 else 2341 /* Diff of got against empty current_got is got itself. */ 2342 { 2343 /* Create empty current_got to put subsequent GOTs to. */ 2344 arg->current_got = elf_m68k_create_empty_got (arg->info); 2345 if (arg->current_got == NULL) 2346 { 2347 arg->error_p = TRUE; 2348 goto final_return; 2349 } 2350 2351 arg->current_got->offset = arg->offset; 2352 2353 diff = got; 2354 } 2355 2356 if (diff != NULL) 2357 { 2358 if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info)) 2359 { 2360 arg->error_p = TRUE; 2361 goto final_return; 2362 } 2363 2364 /* Now we can free GOT. */ 2365 elf_m68k_clear_got (got); 2366 2367 entry->got = arg->current_got; 2368 } 2369 else 2370 { 2371 /* Finish up current_got. */ 2372 elf_m68k_partition_multi_got_2 (arg); 2373 2374 /* Schedule to start a new current_got. */ 2375 arg->current_got = NULL; 2376 2377 /* Retry. */ 2378 if (!elf_m68k_partition_multi_got_1 (_entry, _arg)) 2379 { 2380 BFD_ASSERT (arg->error_p); 2381 goto final_return; 2382 } 2383 } 2384 2385 final_return: 2386 if (diff != NULL) 2387 elf_m68k_clear_got (diff); 2388 2389 return arg->error_p == FALSE ? 1 : 0; 2390 } 2391 2392 /* Helper function to build symndx2h mapping. */ 2393 2394 static bfd_boolean 2395 elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h, 2396 void *_arg) 2397 { 2398 struct elf_m68k_link_hash_entry *h; 2399 2400 h = elf_m68k_hash_entry (_h); 2401 2402 if (h->got_entry_key != 0) 2403 /* H has at least one entry in the GOT. */ 2404 { 2405 struct elf_m68k_partition_multi_got_arg *arg; 2406 2407 arg = (struct elf_m68k_partition_multi_got_arg *) _arg; 2408 2409 BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL); 2410 arg->symndx2h[h->got_entry_key] = h; 2411 } 2412 2413 return TRUE; 2414 } 2415 2416 /* Merge GOTs of some BFDs, assign offsets to GOT entries and build 2417 lists of GOT entries for global symbols. 2418 Calculate sizes of .got and .rela.got sections. */ 2419 2420 static bfd_boolean 2421 elf_m68k_partition_multi_got (struct bfd_link_info *info) 2422 { 2423 struct elf_m68k_multi_got *multi_got; 2424 struct elf_m68k_partition_multi_got_arg arg_; 2425 2426 multi_got = elf_m68k_multi_got (info); 2427 2428 arg_.current_got = NULL; 2429 arg_.offset = 0; 2430 arg_.info = info; 2431 arg_.n_slots = 0; 2432 arg_.slots_relas_diff = 0; 2433 arg_.error_p = FALSE; 2434 2435 if (multi_got->bfd2got != NULL) 2436 { 2437 /* Initialize symndx2h mapping. */ 2438 { 2439 arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx 2440 * sizeof (*arg_.symndx2h)); 2441 if (arg_.symndx2h == NULL) 2442 return FALSE; 2443 2444 elf_link_hash_traverse (elf_hash_table (info), 2445 elf_m68k_init_symndx2h_1, &arg_); 2446 } 2447 2448 /* Partition. */ 2449 htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1, 2450 &arg_); 2451 if (arg_.error_p) 2452 { 2453 free (arg_.symndx2h); 2454 arg_.symndx2h = NULL; 2455 2456 return FALSE; 2457 } 2458 2459 /* Finish up last current_got. */ 2460 elf_m68k_partition_multi_got_2 (&arg_); 2461 2462 free (arg_.symndx2h); 2463 } 2464 2465 if (elf_hash_table (info)->dynobj != NULL) 2466 /* Set sizes of .got and .rela.got sections. */ 2467 { 2468 asection *s; 2469 2470 s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".got"); 2471 if (s != NULL) 2472 s->size = arg_.offset; 2473 else 2474 BFD_ASSERT (arg_.offset == 0); 2475 2476 BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots); 2477 arg_.n_slots -= arg_.slots_relas_diff; 2478 2479 s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".rela.got"); 2480 if (s != NULL) 2481 s->size = arg_.n_slots * sizeof (Elf32_External_Rela); 2482 else 2483 BFD_ASSERT (arg_.n_slots == 0); 2484 } 2485 else 2486 BFD_ASSERT (multi_got->bfd2got == NULL); 2487 2488 return TRUE; 2489 } 2490 2491 /* Specialized version of elf_m68k_get_got_entry that returns pointer 2492 to hashtable slot, thus allowing removal of entry via 2493 elf_m68k_remove_got_entry. */ 2494 2495 static struct elf_m68k_got_entry ** 2496 elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got, 2497 struct elf_m68k_got_entry_key *key) 2498 { 2499 void **ptr; 2500 struct elf_m68k_got_entry entry_; 2501 struct elf_m68k_got_entry **entry_ptr; 2502 2503 entry_.key_ = *key; 2504 ptr = htab_find_slot (got->entries, &entry_, NO_INSERT); 2505 BFD_ASSERT (ptr != NULL); 2506 2507 entry_ptr = (struct elf_m68k_got_entry **) ptr; 2508 2509 return entry_ptr; 2510 } 2511 2512 /* Remove entry pointed to by ENTRY_PTR from GOT. */ 2513 2514 static void 2515 elf_m68k_remove_got_entry (struct elf_m68k_got *got, 2516 struct elf_m68k_got_entry **entry_ptr) 2517 { 2518 struct elf_m68k_got_entry *entry; 2519 2520 entry = *entry_ptr; 2521 2522 /* Check that offsets have not been finalized yet. */ 2523 BFD_ASSERT (got->offset == (bfd_vma) -1); 2524 /* Check that this entry is indeed unused. */ 2525 BFD_ASSERT (entry->u.s1.refcount == 0); 2526 2527 elf_m68k_remove_got_entry_type (got, entry->key_.type); 2528 2529 if (entry->key_.bfd != NULL) 2530 got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type); 2531 2532 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots); 2533 2534 htab_clear_slot (got->entries, (void **) entry_ptr); 2535 } 2536 2537 /* Copy any information related to dynamic linking from a pre-existing 2538 symbol to a newly created symbol. Also called to copy flags and 2539 other back-end info to a weakdef, in which case the symbol is not 2540 newly created and plt/got refcounts and dynamic indices should not 2541 be copied. */ 2542 2543 static void 2544 elf_m68k_copy_indirect_symbol (struct bfd_link_info *info, 2545 struct elf_link_hash_entry *_dir, 2546 struct elf_link_hash_entry *_ind) 2547 { 2548 struct elf_m68k_link_hash_entry *dir; 2549 struct elf_m68k_link_hash_entry *ind; 2550 2551 _bfd_elf_link_hash_copy_indirect (info, _dir, _ind); 2552 2553 if (_ind->root.type != bfd_link_hash_indirect) 2554 return; 2555 2556 dir = elf_m68k_hash_entry (_dir); 2557 ind = elf_m68k_hash_entry (_ind); 2558 2559 /* Any absolute non-dynamic relocations against an indirect or weak 2560 definition will be against the target symbol. */ 2561 _dir->non_got_ref |= _ind->non_got_ref; 2562 2563 /* We might have a direct symbol already having entries in the GOTs. 2564 Update its key only in case indirect symbol has GOT entries and 2565 assert that both indirect and direct symbols don't have GOT entries 2566 at the same time. */ 2567 if (ind->got_entry_key != 0) 2568 { 2569 BFD_ASSERT (dir->got_entry_key == 0); 2570 /* Assert that GOTs aren't partioned yet. */ 2571 BFD_ASSERT (ind->glist == NULL); 2572 2573 dir->got_entry_key = ind->got_entry_key; 2574 ind->got_entry_key = 0; 2575 } 2576 } 2577 2578 /* Look through the relocs for a section during the first phase, and 2579 allocate space in the global offset table or procedure linkage 2580 table. */ 2581 2582 static bfd_boolean 2583 elf_m68k_check_relocs (abfd, info, sec, relocs) 2584 bfd *abfd; 2585 struct bfd_link_info *info; 2586 asection *sec; 2587 const Elf_Internal_Rela *relocs; 2588 { 2589 bfd *dynobj; 2590 Elf_Internal_Shdr *symtab_hdr; 2591 struct elf_link_hash_entry **sym_hashes; 2592 const Elf_Internal_Rela *rel; 2593 const Elf_Internal_Rela *rel_end; 2594 asection *sgot; 2595 asection *srelgot; 2596 asection *sreloc; 2597 struct elf_m68k_got *got; 2598 2599 if (info->relocatable) 2600 return TRUE; 2601 2602 dynobj = elf_hash_table (info)->dynobj; 2603 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2604 sym_hashes = elf_sym_hashes (abfd); 2605 2606 sgot = NULL; 2607 srelgot = NULL; 2608 sreloc = NULL; 2609 2610 got = NULL; 2611 2612 rel_end = relocs + sec->reloc_count; 2613 for (rel = relocs; rel < rel_end; rel++) 2614 { 2615 unsigned long r_symndx; 2616 struct elf_link_hash_entry *h; 2617 2618 r_symndx = ELF32_R_SYM (rel->r_info); 2619 2620 if (r_symndx < symtab_hdr->sh_info) 2621 h = NULL; 2622 else 2623 { 2624 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2625 while (h->root.type == bfd_link_hash_indirect 2626 || h->root.type == bfd_link_hash_warning) 2627 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2628 } 2629 2630 switch (ELF32_R_TYPE (rel->r_info)) 2631 { 2632 case R_68K_GOT8: 2633 case R_68K_GOT16: 2634 case R_68K_GOT32: 2635 if (h != NULL 2636 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2637 break; 2638 /* Fall through. */ 2639 2640 /* Relative GOT relocations. */ 2641 case R_68K_GOT8O: 2642 case R_68K_GOT16O: 2643 case R_68K_GOT32O: 2644 /* Fall through. */ 2645 2646 /* TLS relocations. */ 2647 case R_68K_TLS_GD8: 2648 case R_68K_TLS_GD16: 2649 case R_68K_TLS_GD32: 2650 case R_68K_TLS_LDM8: 2651 case R_68K_TLS_LDM16: 2652 case R_68K_TLS_LDM32: 2653 case R_68K_TLS_IE8: 2654 case R_68K_TLS_IE16: 2655 case R_68K_TLS_IE32: 2656 2657 case R_68K_TLS_TPREL32: 2658 case R_68K_TLS_DTPREL32: 2659 2660 if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32 2661 && info->shared) 2662 /* Do the special chorus for libraries with static TLS. */ 2663 info->flags |= DF_STATIC_TLS; 2664 2665 /* This symbol requires a global offset table entry. */ 2666 2667 if (dynobj == NULL) 2668 { 2669 /* Create the .got section. */ 2670 elf_hash_table (info)->dynobj = dynobj = abfd; 2671 if (!_bfd_elf_create_got_section (dynobj, info)) 2672 return FALSE; 2673 } 2674 2675 if (sgot == NULL) 2676 { 2677 sgot = bfd_get_section_by_name (dynobj, ".got"); 2678 BFD_ASSERT (sgot != NULL); 2679 } 2680 2681 if (srelgot == NULL 2682 && (h != NULL || info->shared)) 2683 { 2684 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 2685 if (srelgot == NULL) 2686 { 2687 srelgot = bfd_make_section_with_flags (dynobj, 2688 ".rela.got", 2689 (SEC_ALLOC 2690 | SEC_LOAD 2691 | SEC_HAS_CONTENTS 2692 | SEC_IN_MEMORY 2693 | SEC_LINKER_CREATED 2694 | SEC_READONLY)); 2695 if (srelgot == NULL 2696 || !bfd_set_section_alignment (dynobj, srelgot, 2)) 2697 return FALSE; 2698 } 2699 } 2700 2701 if (got == NULL) 2702 { 2703 struct elf_m68k_bfd2got_entry *bfd2got_entry; 2704 2705 bfd2got_entry 2706 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info), 2707 abfd, FIND_OR_CREATE, info); 2708 if (bfd2got_entry == NULL) 2709 return FALSE; 2710 2711 got = bfd2got_entry->got; 2712 BFD_ASSERT (got != NULL); 2713 } 2714 2715 { 2716 struct elf_m68k_got_entry *got_entry; 2717 2718 /* Add entry to got. */ 2719 got_entry = elf_m68k_add_entry_to_got (got, h, abfd, 2720 ELF32_R_TYPE (rel->r_info), 2721 r_symndx, info); 2722 if (got_entry == NULL) 2723 return FALSE; 2724 2725 if (got_entry->u.s1.refcount == 1) 2726 { 2727 /* Make sure this symbol is output as a dynamic symbol. */ 2728 if (h != NULL 2729 && h->dynindx == -1 2730 && !h->forced_local) 2731 { 2732 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 2733 return FALSE; 2734 } 2735 } 2736 } 2737 2738 break; 2739 2740 case R_68K_PLT8: 2741 case R_68K_PLT16: 2742 case R_68K_PLT32: 2743 /* This symbol requires a procedure linkage table entry. We 2744 actually build the entry in adjust_dynamic_symbol, 2745 because this might be a case of linking PIC code which is 2746 never referenced by a dynamic object, in which case we 2747 don't need to generate a procedure linkage table entry 2748 after all. */ 2749 2750 /* If this is a local symbol, we resolve it directly without 2751 creating a procedure linkage table entry. */ 2752 if (h == NULL) 2753 continue; 2754 2755 h->needs_plt = 1; 2756 h->plt.refcount++; 2757 break; 2758 2759 case R_68K_PLT8O: 2760 case R_68K_PLT16O: 2761 case R_68K_PLT32O: 2762 /* This symbol requires a procedure linkage table entry. */ 2763 2764 if (h == NULL) 2765 { 2766 /* It does not make sense to have this relocation for a 2767 local symbol. FIXME: does it? How to handle it if 2768 it does make sense? */ 2769 bfd_set_error (bfd_error_bad_value); 2770 return FALSE; 2771 } 2772 2773 /* Make sure this symbol is output as a dynamic symbol. */ 2774 if (h->dynindx == -1 2775 && !h->forced_local) 2776 { 2777 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 2778 return FALSE; 2779 } 2780 2781 h->needs_plt = 1; 2782 h->plt.refcount++; 2783 break; 2784 2785 case R_68K_PC8: 2786 case R_68K_PC16: 2787 case R_68K_PC32: 2788 /* If we are creating a shared library and this is not a local 2789 symbol, we need to copy the reloc into the shared library. 2790 However when linking with -Bsymbolic and this is a global 2791 symbol which is defined in an object we are including in the 2792 link (i.e., DEF_REGULAR is set), then we can resolve the 2793 reloc directly. At this point we have not seen all the input 2794 files, so it is possible that DEF_REGULAR is not set now but 2795 will be set later (it is never cleared). We account for that 2796 possibility below by storing information in the 2797 pcrel_relocs_copied field of the hash table entry. */ 2798 if (!(info->shared 2799 && (sec->flags & SEC_ALLOC) != 0 2800 && h != NULL 2801 && (!info->symbolic 2802 || h->root.type == bfd_link_hash_defweak 2803 || !h->def_regular))) 2804 { 2805 if (h != NULL) 2806 { 2807 /* Make sure a plt entry is created for this symbol if 2808 it turns out to be a function defined by a dynamic 2809 object. */ 2810 h->plt.refcount++; 2811 } 2812 break; 2813 } 2814 /* Fall through. */ 2815 case R_68K_8: 2816 case R_68K_16: 2817 case R_68K_32: 2818 if (h != NULL) 2819 { 2820 /* Make sure a plt entry is created for this symbol if it 2821 turns out to be a function defined by a dynamic object. */ 2822 h->plt.refcount++; 2823 2824 if (!info->shared) 2825 /* This symbol needs a non-GOT reference. */ 2826 h->non_got_ref = 1; 2827 } 2828 2829 /* If we are creating a shared library, we need to copy the 2830 reloc into the shared library. */ 2831 if (info->shared 2832 && (sec->flags & SEC_ALLOC) != 0) 2833 { 2834 /* When creating a shared object, we must copy these 2835 reloc types into the output file. We create a reloc 2836 section in dynobj and make room for this reloc. */ 2837 if (sreloc == NULL) 2838 { 2839 sreloc = _bfd_elf_make_dynamic_reloc_section 2840 (sec, dynobj, 2, abfd, /*rela?*/ TRUE); 2841 2842 if (sreloc == NULL) 2843 return FALSE; 2844 } 2845 2846 if (sec->flags & SEC_READONLY 2847 /* Don't set DF_TEXTREL yet for PC relative 2848 relocations, they might be discarded later. */ 2849 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8 2850 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16 2851 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)) 2852 info->flags |= DF_TEXTREL; 2853 2854 sreloc->size += sizeof (Elf32_External_Rela); 2855 2856 /* We count the number of PC relative relocations we have 2857 entered for this symbol, so that we can discard them 2858 again if, in the -Bsymbolic case, the symbol is later 2859 defined by a regular object, or, in the normal shared 2860 case, the symbol is forced to be local. Note that this 2861 function is only called if we are using an m68kelf linker 2862 hash table, which means that h is really a pointer to an 2863 elf_m68k_link_hash_entry. */ 2864 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8 2865 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16 2866 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32) 2867 { 2868 struct elf_m68k_pcrel_relocs_copied *p; 2869 struct elf_m68k_pcrel_relocs_copied **head; 2870 2871 if (h != NULL) 2872 { 2873 struct elf_m68k_link_hash_entry *eh 2874 = elf_m68k_hash_entry (h); 2875 head = &eh->pcrel_relocs_copied; 2876 } 2877 else 2878 { 2879 asection *s; 2880 void *vpp; 2881 Elf_Internal_Sym *isym; 2882 2883 isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache, 2884 abfd, r_symndx); 2885 if (isym == NULL) 2886 return FALSE; 2887 2888 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 2889 if (s == NULL) 2890 s = sec; 2891 2892 vpp = &elf_section_data (s)->local_dynrel; 2893 head = (struct elf_m68k_pcrel_relocs_copied **) vpp; 2894 } 2895 2896 for (p = *head; p != NULL; p = p->next) 2897 if (p->section == sreloc) 2898 break; 2899 2900 if (p == NULL) 2901 { 2902 p = ((struct elf_m68k_pcrel_relocs_copied *) 2903 bfd_alloc (dynobj, (bfd_size_type) sizeof *p)); 2904 if (p == NULL) 2905 return FALSE; 2906 p->next = *head; 2907 *head = p; 2908 p->section = sreloc; 2909 p->count = 0; 2910 } 2911 2912 ++p->count; 2913 } 2914 } 2915 2916 break; 2917 2918 /* This relocation describes the C++ object vtable hierarchy. 2919 Reconstruct it for later use during GC. */ 2920 case R_68K_GNU_VTINHERIT: 2921 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2922 return FALSE; 2923 break; 2924 2925 /* This relocation describes which C++ vtable entries are actually 2926 used. Record for later use during GC. */ 2927 case R_68K_GNU_VTENTRY: 2928 BFD_ASSERT (h != NULL); 2929 if (h != NULL 2930 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 2931 return FALSE; 2932 break; 2933 2934 default: 2935 break; 2936 } 2937 } 2938 2939 return TRUE; 2940 } 2941 2942 /* Return the section that should be marked against GC for a given 2943 relocation. */ 2944 2945 static asection * 2946 elf_m68k_gc_mark_hook (asection *sec, 2947 struct bfd_link_info *info, 2948 Elf_Internal_Rela *rel, 2949 struct elf_link_hash_entry *h, 2950 Elf_Internal_Sym *sym) 2951 { 2952 if (h != NULL) 2953 switch (ELF32_R_TYPE (rel->r_info)) 2954 { 2955 case R_68K_GNU_VTINHERIT: 2956 case R_68K_GNU_VTENTRY: 2957 return NULL; 2958 } 2959 2960 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2961 } 2962 2963 /* Update the got entry reference counts for the section being removed. */ 2964 2965 static bfd_boolean 2966 elf_m68k_gc_sweep_hook (bfd *abfd, 2967 struct bfd_link_info *info, 2968 asection *sec, 2969 const Elf_Internal_Rela *relocs) 2970 { 2971 Elf_Internal_Shdr *symtab_hdr; 2972 struct elf_link_hash_entry **sym_hashes; 2973 const Elf_Internal_Rela *rel, *relend; 2974 bfd *dynobj; 2975 struct elf_m68k_got *got; 2976 2977 if (info->relocatable) 2978 return TRUE; 2979 2980 dynobj = elf_hash_table (info)->dynobj; 2981 if (dynobj == NULL) 2982 return TRUE; 2983 2984 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2985 sym_hashes = elf_sym_hashes (abfd); 2986 got = NULL; 2987 2988 relend = relocs + sec->reloc_count; 2989 for (rel = relocs; rel < relend; rel++) 2990 { 2991 unsigned long r_symndx; 2992 struct elf_link_hash_entry *h = NULL; 2993 2994 r_symndx = ELF32_R_SYM (rel->r_info); 2995 if (r_symndx >= symtab_hdr->sh_info) 2996 { 2997 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2998 while (h->root.type == bfd_link_hash_indirect 2999 || h->root.type == bfd_link_hash_warning) 3000 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3001 } 3002 3003 switch (ELF32_R_TYPE (rel->r_info)) 3004 { 3005 case R_68K_GOT8: 3006 case R_68K_GOT16: 3007 case R_68K_GOT32: 3008 if (h != NULL 3009 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3010 break; 3011 3012 /* FALLTHRU */ 3013 case R_68K_GOT8O: 3014 case R_68K_GOT16O: 3015 case R_68K_GOT32O: 3016 /* Fall through. */ 3017 3018 /* TLS relocations. */ 3019 case R_68K_TLS_GD8: 3020 case R_68K_TLS_GD16: 3021 case R_68K_TLS_GD32: 3022 case R_68K_TLS_LDM8: 3023 case R_68K_TLS_LDM16: 3024 case R_68K_TLS_LDM32: 3025 case R_68K_TLS_IE8: 3026 case R_68K_TLS_IE16: 3027 case R_68K_TLS_IE32: 3028 3029 case R_68K_TLS_TPREL32: 3030 case R_68K_TLS_DTPREL32: 3031 3032 if (got == NULL) 3033 { 3034 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info), 3035 abfd, MUST_FIND, NULL)->got; 3036 BFD_ASSERT (got != NULL); 3037 } 3038 3039 { 3040 struct elf_m68k_got_entry_key key_; 3041 struct elf_m68k_got_entry **got_entry_ptr; 3042 struct elf_m68k_got_entry *got_entry; 3043 3044 elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx, 3045 ELF32_R_TYPE (rel->r_info)); 3046 got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_); 3047 3048 got_entry = *got_entry_ptr; 3049 3050 if (got_entry->u.s1.refcount > 0) 3051 { 3052 --got_entry->u.s1.refcount; 3053 3054 if (got_entry->u.s1.refcount == 0) 3055 /* We don't need the .got entry any more. */ 3056 elf_m68k_remove_got_entry (got, got_entry_ptr); 3057 } 3058 } 3059 break; 3060 3061 case R_68K_PLT8: 3062 case R_68K_PLT16: 3063 case R_68K_PLT32: 3064 case R_68K_PLT8O: 3065 case R_68K_PLT16O: 3066 case R_68K_PLT32O: 3067 case R_68K_PC8: 3068 case R_68K_PC16: 3069 case R_68K_PC32: 3070 case R_68K_8: 3071 case R_68K_16: 3072 case R_68K_32: 3073 if (h != NULL) 3074 { 3075 if (h->plt.refcount > 0) 3076 --h->plt.refcount; 3077 } 3078 break; 3079 3080 default: 3081 break; 3082 } 3083 } 3084 3085 return TRUE; 3086 } 3087 3088 /* Return the type of PLT associated with OUTPUT_BFD. */ 3089 3090 static const struct elf_m68k_plt_info * 3091 elf_m68k_get_plt_info (bfd *output_bfd) 3092 { 3093 unsigned int features; 3094 3095 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd)); 3096 if (features & cpu32) 3097 return &elf_cpu32_plt_info; 3098 if (features & mcfisa_b) 3099 return &elf_isab_plt_info; 3100 if (features & mcfisa_c) 3101 return &elf_isac_plt_info; 3102 return &elf_m68k_plt_info; 3103 } 3104 3105 /* This function is called after all the input files have been read, 3106 and the input sections have been assigned to output sections. 3107 It's a convenient place to determine the PLT style. */ 3108 3109 static bfd_boolean 3110 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) 3111 { 3112 /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got 3113 sections. */ 3114 if (!elf_m68k_partition_multi_got (info)) 3115 return FALSE; 3116 3117 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd); 3118 return TRUE; 3119 } 3120 3121 /* Adjust a symbol defined by a dynamic object and referenced by a 3122 regular object. The current definition is in some section of the 3123 dynamic object, but we're not including those sections. We have to 3124 change the definition to something the rest of the link can 3125 understand. */ 3126 3127 static bfd_boolean 3128 elf_m68k_adjust_dynamic_symbol (info, h) 3129 struct bfd_link_info *info; 3130 struct elf_link_hash_entry *h; 3131 { 3132 struct elf_m68k_link_hash_table *htab; 3133 bfd *dynobj; 3134 asection *s; 3135 3136 htab = elf_m68k_hash_table (info); 3137 dynobj = elf_hash_table (info)->dynobj; 3138 3139 /* Make sure we know what is going on here. */ 3140 BFD_ASSERT (dynobj != NULL 3141 && (h->needs_plt 3142 || h->u.weakdef != NULL 3143 || (h->def_dynamic 3144 && h->ref_regular 3145 && !h->def_regular))); 3146 3147 /* If this is a function, put it in the procedure linkage table. We 3148 will fill in the contents of the procedure linkage table later, 3149 when we know the address of the .got section. */ 3150 if (h->type == STT_FUNC 3151 || h->needs_plt) 3152 { 3153 if ((h->plt.refcount <= 0 3154 || SYMBOL_CALLS_LOCAL (info, h) 3155 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 3156 && h->root.type == bfd_link_hash_undefweak)) 3157 /* We must always create the plt entry if it was referenced 3158 by a PLTxxO relocation. In this case we already recorded 3159 it as a dynamic symbol. */ 3160 && h->dynindx == -1) 3161 { 3162 /* This case can occur if we saw a PLTxx reloc in an input 3163 file, but the symbol was never referred to by a dynamic 3164 object, or if all references were garbage collected. In 3165 such a case, we don't actually need to build a procedure 3166 linkage table, and we can just do a PCxx reloc instead. */ 3167 h->plt.offset = (bfd_vma) -1; 3168 h->needs_plt = 0; 3169 return TRUE; 3170 } 3171 3172 /* Make sure this symbol is output as a dynamic symbol. */ 3173 if (h->dynindx == -1 3174 && !h->forced_local) 3175 { 3176 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3177 return FALSE; 3178 } 3179 3180 s = bfd_get_section_by_name (dynobj, ".plt"); 3181 BFD_ASSERT (s != NULL); 3182 3183 /* If this is the first .plt entry, make room for the special 3184 first entry. */ 3185 if (s->size == 0) 3186 s->size = htab->plt_info->size; 3187 3188 /* If this symbol is not defined in a regular file, and we are 3189 not generating a shared library, then set the symbol to this 3190 location in the .plt. This is required to make function 3191 pointers compare as equal between the normal executable and 3192 the shared library. */ 3193 if (!info->shared 3194 && !h->def_regular) 3195 { 3196 h->root.u.def.section = s; 3197 h->root.u.def.value = s->size; 3198 } 3199 3200 h->plt.offset = s->size; 3201 3202 /* Make room for this entry. */ 3203 s->size += htab->plt_info->size; 3204 3205 /* We also need to make an entry in the .got.plt section, which 3206 will be placed in the .got section by the linker script. */ 3207 s = bfd_get_section_by_name (dynobj, ".got.plt"); 3208 BFD_ASSERT (s != NULL); 3209 s->size += 4; 3210 3211 /* We also need to make an entry in the .rela.plt section. */ 3212 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 3213 BFD_ASSERT (s != NULL); 3214 s->size += sizeof (Elf32_External_Rela); 3215 3216 return TRUE; 3217 } 3218 3219 /* Reinitialize the plt offset now that it is not used as a reference 3220 count any more. */ 3221 h->plt.offset = (bfd_vma) -1; 3222 3223 /* If this is a weak symbol, and there is a real definition, the 3224 processor independent code will have arranged for us to see the 3225 real definition first, and we can just use the same value. */ 3226 if (h->u.weakdef != NULL) 3227 { 3228 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3229 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3230 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3231 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3232 return TRUE; 3233 } 3234 3235 /* This is a reference to a symbol defined by a dynamic object which 3236 is not a function. */ 3237 3238 /* If we are creating a shared library, we must presume that the 3239 only references to the symbol are via the global offset table. 3240 For such cases we need not do anything here; the relocations will 3241 be handled correctly by relocate_section. */ 3242 if (info->shared) 3243 return TRUE; 3244 3245 /* If there are no references to this symbol that do not use the 3246 GOT, we don't need to generate a copy reloc. */ 3247 if (!h->non_got_ref) 3248 return TRUE; 3249 3250 if (h->size == 0) 3251 { 3252 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 3253 h->root.root.string); 3254 return TRUE; 3255 } 3256 3257 /* We must allocate the symbol in our .dynbss section, which will 3258 become part of the .bss section of the executable. There will be 3259 an entry for this symbol in the .dynsym section. The dynamic 3260 object will contain position independent code, so all references 3261 from the dynamic object to this symbol will go through the global 3262 offset table. The dynamic linker will use the .dynsym entry to 3263 determine the address it must put in the global offset table, so 3264 both the dynamic object and the regular object will refer to the 3265 same memory location for the variable. */ 3266 3267 s = bfd_get_section_by_name (dynobj, ".dynbss"); 3268 BFD_ASSERT (s != NULL); 3269 3270 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to 3271 copy the initial value out of the dynamic object and into the 3272 runtime process image. We need to remember the offset into the 3273 .rela.bss section we are going to use. */ 3274 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 3275 { 3276 asection *srel; 3277 3278 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 3279 BFD_ASSERT (srel != NULL); 3280 srel->size += sizeof (Elf32_External_Rela); 3281 h->needs_copy = 1; 3282 } 3283 3284 return _bfd_elf_adjust_dynamic_copy (h, s); 3285 } 3286 3287 /* Set the sizes of the dynamic sections. */ 3288 3289 static bfd_boolean 3290 elf_m68k_size_dynamic_sections (output_bfd, info) 3291 bfd *output_bfd ATTRIBUTE_UNUSED; 3292 struct bfd_link_info *info; 3293 { 3294 bfd *dynobj; 3295 asection *s; 3296 bfd_boolean plt; 3297 bfd_boolean relocs; 3298 3299 dynobj = elf_hash_table (info)->dynobj; 3300 BFD_ASSERT (dynobj != NULL); 3301 3302 if (elf_hash_table (info)->dynamic_sections_created) 3303 { 3304 /* Set the contents of the .interp section to the interpreter. */ 3305 if (info->executable) 3306 { 3307 s = bfd_get_section_by_name (dynobj, ".interp"); 3308 BFD_ASSERT (s != NULL); 3309 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 3310 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3311 } 3312 } 3313 else 3314 { 3315 /* We may have created entries in the .rela.got section. 3316 However, if we are not creating the dynamic sections, we will 3317 not actually use these entries. Reset the size of .rela.got, 3318 which will cause it to get stripped from the output file 3319 below. */ 3320 s = bfd_get_section_by_name (dynobj, ".rela.got"); 3321 if (s != NULL) 3322 s->size = 0; 3323 } 3324 3325 /* If this is a -Bsymbolic shared link, then we need to discard all 3326 PC relative relocs against symbols defined in a regular object. 3327 For the normal shared case we discard the PC relative relocs 3328 against symbols that have become local due to visibility changes. 3329 We allocated space for them in the check_relocs routine, but we 3330 will not fill them in in the relocate_section routine. */ 3331 if (info->shared) 3332 elf_link_hash_traverse (elf_hash_table (info), 3333 elf_m68k_discard_copies, 3334 (PTR) info); 3335 3336 /* The check_relocs and adjust_dynamic_symbol entry points have 3337 determined the sizes of the various dynamic sections. Allocate 3338 memory for them. */ 3339 plt = FALSE; 3340 relocs = FALSE; 3341 for (s = dynobj->sections; s != NULL; s = s->next) 3342 { 3343 const char *name; 3344 3345 if ((s->flags & SEC_LINKER_CREATED) == 0) 3346 continue; 3347 3348 /* It's OK to base decisions on the section name, because none 3349 of the dynobj section names depend upon the input files. */ 3350 name = bfd_get_section_name (dynobj, s); 3351 3352 if (strcmp (name, ".plt") == 0) 3353 { 3354 /* Remember whether there is a PLT. */ 3355 plt = s->size != 0; 3356 } 3357 else if (CONST_STRNEQ (name, ".rela")) 3358 { 3359 if (s->size != 0) 3360 { 3361 relocs = TRUE; 3362 3363 /* We use the reloc_count field as a counter if we need 3364 to copy relocs into the output file. */ 3365 s->reloc_count = 0; 3366 } 3367 } 3368 else if (! CONST_STRNEQ (name, ".got") 3369 && strcmp (name, ".dynbss") != 0) 3370 { 3371 /* It's not one of our sections, so don't allocate space. */ 3372 continue; 3373 } 3374 3375 if (s->size == 0) 3376 { 3377 /* If we don't need this section, strip it from the 3378 output file. This is mostly to handle .rela.bss and 3379 .rela.plt. We must create both sections in 3380 create_dynamic_sections, because they must be created 3381 before the linker maps input sections to output 3382 sections. The linker does that before 3383 adjust_dynamic_symbol is called, and it is that 3384 function which decides whether anything needs to go 3385 into these sections. */ 3386 s->flags |= SEC_EXCLUDE; 3387 continue; 3388 } 3389 3390 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3391 continue; 3392 3393 /* Allocate memory for the section contents. */ 3394 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 3395 Unused entries should be reclaimed before the section's contents 3396 are written out, but at the moment this does not happen. Thus in 3397 order to prevent writing out garbage, we initialise the section's 3398 contents to zero. */ 3399 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3400 if (s->contents == NULL) 3401 return FALSE; 3402 } 3403 3404 if (elf_hash_table (info)->dynamic_sections_created) 3405 { 3406 /* Add some entries to the .dynamic section. We fill in the 3407 values later, in elf_m68k_finish_dynamic_sections, but we 3408 must add the entries now so that we get the correct size for 3409 the .dynamic section. The DT_DEBUG entry is filled in by the 3410 dynamic linker and used by the debugger. */ 3411 #define add_dynamic_entry(TAG, VAL) \ 3412 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 3413 3414 if (!info->shared) 3415 { 3416 if (!add_dynamic_entry (DT_DEBUG, 0)) 3417 return FALSE; 3418 } 3419 3420 if (plt) 3421 { 3422 if (!add_dynamic_entry (DT_PLTGOT, 0) 3423 || !add_dynamic_entry (DT_PLTRELSZ, 0) 3424 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 3425 || !add_dynamic_entry (DT_JMPREL, 0)) 3426 return FALSE; 3427 } 3428 3429 if (relocs) 3430 { 3431 if (!add_dynamic_entry (DT_RELA, 0) 3432 || !add_dynamic_entry (DT_RELASZ, 0) 3433 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 3434 return FALSE; 3435 } 3436 3437 if ((info->flags & DF_TEXTREL) != 0) 3438 { 3439 if (!add_dynamic_entry (DT_TEXTREL, 0)) 3440 return FALSE; 3441 } 3442 } 3443 #undef add_dynamic_entry 3444 3445 return TRUE; 3446 } 3447 3448 /* This function is called via elf_link_hash_traverse if we are 3449 creating a shared object. In the -Bsymbolic case it discards the 3450 space allocated to copy PC relative relocs against symbols which 3451 are defined in regular objects. For the normal shared case, it 3452 discards space for pc-relative relocs that have become local due to 3453 symbol visibility changes. We allocated space for them in the 3454 check_relocs routine, but we won't fill them in in the 3455 relocate_section routine. 3456 3457 We also check whether any of the remaining relocations apply 3458 against a readonly section, and set the DF_TEXTREL flag in this 3459 case. */ 3460 3461 static bfd_boolean 3462 elf_m68k_discard_copies (h, inf) 3463 struct elf_link_hash_entry *h; 3464 PTR inf; 3465 { 3466 struct bfd_link_info *info = (struct bfd_link_info *) inf; 3467 struct elf_m68k_pcrel_relocs_copied *s; 3468 3469 if (h->root.type == bfd_link_hash_warning) 3470 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3471 3472 if (!SYMBOL_CALLS_LOCAL (info, h)) 3473 { 3474 if ((info->flags & DF_TEXTREL) == 0) 3475 { 3476 /* Look for relocations against read-only sections. */ 3477 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied; 3478 s != NULL; 3479 s = s->next) 3480 if ((s->section->flags & SEC_READONLY) != 0) 3481 { 3482 info->flags |= DF_TEXTREL; 3483 break; 3484 } 3485 } 3486 3487 return TRUE; 3488 } 3489 3490 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied; 3491 s != NULL; 3492 s = s->next) 3493 s->section->size -= s->count * sizeof (Elf32_External_Rela); 3494 3495 return TRUE; 3496 } 3497 3498 3499 /* Install relocation RELA. */ 3500 3501 static void 3502 elf_m68k_install_rela (bfd *output_bfd, 3503 asection *srela, 3504 Elf_Internal_Rela *rela) 3505 { 3506 bfd_byte *loc; 3507 3508 loc = srela->contents; 3509 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela); 3510 bfd_elf32_swap_reloca_out (output_bfd, rela, loc); 3511 } 3512 3513 /* Find the base offsets for thread-local storage in this object, 3514 for GD/LD and IE/LE respectively. */ 3515 3516 #define DTP_OFFSET 0x8000 3517 #define TP_OFFSET 0x7000 3518 3519 static bfd_vma 3520 dtpoff_base (struct bfd_link_info *info) 3521 { 3522 /* If tls_sec is NULL, we should have signalled an error already. */ 3523 if (elf_hash_table (info)->tls_sec == NULL) 3524 return 0; 3525 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET; 3526 } 3527 3528 static bfd_vma 3529 tpoff_base (struct bfd_link_info *info) 3530 { 3531 /* If tls_sec is NULL, we should have signalled an error already. */ 3532 if (elf_hash_table (info)->tls_sec == NULL) 3533 return 0; 3534 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET; 3535 } 3536 3537 /* Output necessary relocation to handle a symbol during static link. 3538 This function is called from elf_m68k_relocate_section. */ 3539 3540 static void 3541 elf_m68k_init_got_entry_static (struct bfd_link_info *info, 3542 bfd *output_bfd, 3543 enum elf_m68k_reloc_type r_type, 3544 asection *sgot, 3545 bfd_vma got_entry_offset, 3546 bfd_vma relocation) 3547 { 3548 switch (elf_m68k_reloc_got_type (r_type)) 3549 { 3550 case R_68K_GOT32O: 3551 bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset); 3552 break; 3553 3554 case R_68K_TLS_GD32: 3555 /* We know the offset within the module, 3556 put it into the second GOT slot. */ 3557 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 3558 sgot->contents + got_entry_offset + 4); 3559 /* FALLTHRU */ 3560 3561 case R_68K_TLS_LDM32: 3562 /* Mark it as belonging to module 1, the executable. */ 3563 bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset); 3564 break; 3565 3566 case R_68K_TLS_IE32: 3567 bfd_put_32 (output_bfd, relocation - tpoff_base (info), 3568 sgot->contents + got_entry_offset); 3569 break; 3570 3571 default: 3572 BFD_ASSERT (FALSE); 3573 } 3574 } 3575 3576 /* Output necessary relocation to handle a local symbol 3577 during dynamic link. 3578 This function is called either from elf_m68k_relocate_section 3579 or from elf_m68k_finish_dynamic_symbol. */ 3580 3581 static void 3582 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info, 3583 bfd *output_bfd, 3584 enum elf_m68k_reloc_type r_type, 3585 asection *sgot, 3586 bfd_vma got_entry_offset, 3587 bfd_vma relocation, 3588 asection *srela) 3589 { 3590 Elf_Internal_Rela outrel; 3591 3592 switch (elf_m68k_reloc_got_type (r_type)) 3593 { 3594 case R_68K_GOT32O: 3595 /* Emit RELATIVE relocation to initialize GOT slot 3596 at run-time. */ 3597 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE); 3598 outrel.r_addend = relocation; 3599 break; 3600 3601 case R_68K_TLS_GD32: 3602 /* We know the offset within the module, 3603 put it into the second GOT slot. */ 3604 bfd_put_32 (output_bfd, relocation - dtpoff_base (info), 3605 sgot->contents + got_entry_offset + 4); 3606 /* FALLTHRU */ 3607 3608 case R_68K_TLS_LDM32: 3609 /* We don't know the module number, 3610 create a relocation for it. */ 3611 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32); 3612 outrel.r_addend = 0; 3613 break; 3614 3615 case R_68K_TLS_IE32: 3616 /* Emit TPREL relocation to initialize GOT slot 3617 at run-time. */ 3618 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32); 3619 outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma; 3620 break; 3621 3622 default: 3623 BFD_ASSERT (FALSE); 3624 } 3625 3626 /* Offset of the GOT entry. */ 3627 outrel.r_offset = (sgot->output_section->vma 3628 + sgot->output_offset 3629 + got_entry_offset); 3630 3631 /* Install one of the above relocations. */ 3632 elf_m68k_install_rela (output_bfd, srela, &outrel); 3633 3634 bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset); 3635 } 3636 3637 /* Relocate an M68K ELF section. */ 3638 3639 static bfd_boolean 3640 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section, 3641 contents, relocs, local_syms, local_sections) 3642 bfd *output_bfd; 3643 struct bfd_link_info *info; 3644 bfd *input_bfd; 3645 asection *input_section; 3646 bfd_byte *contents; 3647 Elf_Internal_Rela *relocs; 3648 Elf_Internal_Sym *local_syms; 3649 asection **local_sections; 3650 { 3651 bfd *dynobj; 3652 Elf_Internal_Shdr *symtab_hdr; 3653 struct elf_link_hash_entry **sym_hashes; 3654 asection *sgot; 3655 asection *splt; 3656 asection *sreloc; 3657 asection *srela; 3658 struct elf_m68k_got *got; 3659 Elf_Internal_Rela *rel; 3660 Elf_Internal_Rela *relend; 3661 3662 dynobj = elf_hash_table (info)->dynobj; 3663 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3664 sym_hashes = elf_sym_hashes (input_bfd); 3665 3666 sgot = NULL; 3667 splt = NULL; 3668 sreloc = NULL; 3669 srela = NULL; 3670 3671 got = NULL; 3672 3673 rel = relocs; 3674 relend = relocs + input_section->reloc_count; 3675 for (; rel < relend; rel++) 3676 { 3677 int r_type; 3678 reloc_howto_type *howto; 3679 unsigned long r_symndx; 3680 struct elf_link_hash_entry *h; 3681 Elf_Internal_Sym *sym; 3682 asection *sec; 3683 bfd_vma relocation; 3684 bfd_boolean unresolved_reloc; 3685 bfd_reloc_status_type r; 3686 3687 r_type = ELF32_R_TYPE (rel->r_info); 3688 if (r_type < 0 || r_type >= (int) R_68K_max) 3689 { 3690 bfd_set_error (bfd_error_bad_value); 3691 return FALSE; 3692 } 3693 howto = howto_table + r_type; 3694 3695 r_symndx = ELF32_R_SYM (rel->r_info); 3696 3697 h = NULL; 3698 sym = NULL; 3699 sec = NULL; 3700 unresolved_reloc = FALSE; 3701 3702 if (r_symndx < symtab_hdr->sh_info) 3703 { 3704 sym = local_syms + r_symndx; 3705 sec = local_sections[r_symndx]; 3706 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 3707 } 3708 else 3709 { 3710 bfd_boolean warned; 3711 3712 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 3713 r_symndx, symtab_hdr, sym_hashes, 3714 h, sec, relocation, 3715 unresolved_reloc, warned); 3716 } 3717 3718 if (sec != NULL && elf_discarded_section (sec)) 3719 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3720 rel, relend, howto, contents); 3721 3722 if (info->relocatable) 3723 continue; 3724 3725 switch (r_type) 3726 { 3727 case R_68K_GOT8: 3728 case R_68K_GOT16: 3729 case R_68K_GOT32: 3730 /* Relocation is to the address of the entry for this symbol 3731 in the global offset table. */ 3732 if (h != NULL 3733 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3734 { 3735 if (elf_m68k_hash_table (info)->local_gp_p) 3736 { 3737 bfd_vma sgot_output_offset; 3738 bfd_vma got_offset; 3739 3740 if (sgot == NULL) 3741 { 3742 sgot = bfd_get_section_by_name (dynobj, ".got"); 3743 3744 if (sgot != NULL) 3745 sgot_output_offset = sgot->output_offset; 3746 else 3747 /* In this case we have a reference to 3748 _GLOBAL_OFFSET_TABLE_, but the GOT itself is 3749 empty. 3750 ??? Issue a warning? */ 3751 sgot_output_offset = 0; 3752 } 3753 else 3754 sgot_output_offset = sgot->output_offset; 3755 3756 if (got == NULL) 3757 { 3758 struct elf_m68k_bfd2got_entry *bfd2got_entry; 3759 3760 bfd2got_entry 3761 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info), 3762 input_bfd, SEARCH, NULL); 3763 3764 if (bfd2got_entry != NULL) 3765 { 3766 got = bfd2got_entry->got; 3767 BFD_ASSERT (got != NULL); 3768 3769 got_offset = got->offset; 3770 } 3771 else 3772 /* In this case we have a reference to 3773 _GLOBAL_OFFSET_TABLE_, but no other references 3774 accessing any GOT entries. 3775 ??? Issue a warning? */ 3776 got_offset = 0; 3777 } 3778 else 3779 got_offset = got->offset; 3780 3781 /* Adjust GOT pointer to point to the GOT 3782 assigned to input_bfd. */ 3783 rel->r_addend += sgot_output_offset + got_offset; 3784 } 3785 else 3786 BFD_ASSERT (got == NULL || got->offset == 0); 3787 3788 break; 3789 } 3790 /* Fall through. */ 3791 case R_68K_GOT8O: 3792 case R_68K_GOT16O: 3793 case R_68K_GOT32O: 3794 3795 case R_68K_TLS_LDM32: 3796 case R_68K_TLS_LDM16: 3797 case R_68K_TLS_LDM8: 3798 3799 case R_68K_TLS_GD8: 3800 case R_68K_TLS_GD16: 3801 case R_68K_TLS_GD32: 3802 3803 case R_68K_TLS_IE8: 3804 case R_68K_TLS_IE16: 3805 case R_68K_TLS_IE32: 3806 3807 /* Relocation is the offset of the entry for this symbol in 3808 the global offset table. */ 3809 3810 { 3811 struct elf_m68k_got_entry_key key_; 3812 bfd_vma *off_ptr; 3813 bfd_vma off; 3814 3815 if (sgot == NULL) 3816 { 3817 sgot = bfd_get_section_by_name (dynobj, ".got"); 3818 BFD_ASSERT (sgot != NULL); 3819 } 3820 3821 if (got == NULL) 3822 { 3823 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info), 3824 input_bfd, MUST_FIND, 3825 NULL)->got; 3826 BFD_ASSERT (got != NULL); 3827 } 3828 3829 /* Get GOT offset for this symbol. */ 3830 elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx, 3831 r_type); 3832 off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND, 3833 NULL)->u.s2.offset; 3834 off = *off_ptr; 3835 3836 /* The offset must always be a multiple of 4. We use 3837 the least significant bit to record whether we have 3838 already generated the necessary reloc. */ 3839 if ((off & 1) != 0) 3840 off &= ~1; 3841 else 3842 { 3843 if (h != NULL 3844 /* @TLSLDM relocations are bounded to the module, in 3845 which the symbol is defined -- not to the symbol 3846 itself. */ 3847 && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32) 3848 { 3849 bfd_boolean dyn; 3850 3851 dyn = elf_hash_table (info)->dynamic_sections_created; 3852 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 3853 || (info->shared 3854 && SYMBOL_REFERENCES_LOCAL (info, h)) 3855 || (ELF_ST_VISIBILITY (h->other) 3856 && h->root.type == bfd_link_hash_undefweak)) 3857 { 3858 /* This is actually a static link, or it is a 3859 -Bsymbolic link and the symbol is defined 3860 locally, or the symbol was forced to be local 3861 because of a version file. We must initialize 3862 this entry in the global offset table. Since 3863 the offset must always be a multiple of 4, we 3864 use the least significant bit to record whether 3865 we have initialized it already. 3866 3867 When doing a dynamic link, we create a .rela.got 3868 relocation entry to initialize the value. This 3869 is done in the finish_dynamic_symbol routine. */ 3870 3871 elf_m68k_init_got_entry_static (info, 3872 output_bfd, 3873 r_type, 3874 sgot, 3875 off, 3876 relocation); 3877 3878 *off_ptr |= 1; 3879 } 3880 else 3881 unresolved_reloc = FALSE; 3882 } 3883 else if (info->shared) /* && h == NULL */ 3884 /* Process local symbol during dynamic link. */ 3885 { 3886 if (srela == NULL) 3887 { 3888 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 3889 BFD_ASSERT (srela != NULL); 3890 } 3891 3892 elf_m68k_init_got_entry_local_shared (info, 3893 output_bfd, 3894 r_type, 3895 sgot, 3896 off, 3897 relocation, 3898 srela); 3899 3900 *off_ptr |= 1; 3901 } 3902 else /* h == NULL && !info->shared */ 3903 { 3904 elf_m68k_init_got_entry_static (info, 3905 output_bfd, 3906 r_type, 3907 sgot, 3908 off, 3909 relocation); 3910 3911 *off_ptr |= 1; 3912 } 3913 } 3914 3915 /* We don't use elf_m68k_reloc_got_type in the condition below 3916 because this is the only place where difference between 3917 R_68K_GOTx and R_68K_GOTxO relocations matters. */ 3918 if (r_type == R_68K_GOT32O 3919 || r_type == R_68K_GOT16O 3920 || r_type == R_68K_GOT8O 3921 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32 3922 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32 3923 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32) 3924 { 3925 /* GOT pointer is adjusted to point to the start/middle 3926 of local GOT. Adjust the offset accordingly. */ 3927 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p 3928 || off >= got->offset); 3929 3930 if (elf_m68k_hash_table (info)->local_gp_p) 3931 relocation = off - got->offset; 3932 else 3933 { 3934 BFD_ASSERT (got->offset == 0); 3935 relocation = sgot->output_offset + off; 3936 } 3937 3938 /* This relocation does not use the addend. */ 3939 rel->r_addend = 0; 3940 } 3941 else 3942 relocation = (sgot->output_section->vma + sgot->output_offset 3943 + off); 3944 } 3945 break; 3946 3947 case R_68K_TLS_LDO32: 3948 case R_68K_TLS_LDO16: 3949 case R_68K_TLS_LDO8: 3950 relocation -= dtpoff_base (info); 3951 break; 3952 3953 case R_68K_TLS_LE32: 3954 case R_68K_TLS_LE16: 3955 case R_68K_TLS_LE8: 3956 if (info->shared) 3957 { 3958 (*_bfd_error_handler) 3959 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted " 3960 "in shared object"), 3961 input_bfd, input_section, (long) rel->r_offset, howto->name); 3962 3963 return FALSE; 3964 } 3965 else 3966 relocation -= tpoff_base (info); 3967 3968 break; 3969 3970 case R_68K_PLT8: 3971 case R_68K_PLT16: 3972 case R_68K_PLT32: 3973 /* Relocation is to the entry for this symbol in the 3974 procedure linkage table. */ 3975 3976 /* Resolve a PLTxx reloc against a local symbol directly, 3977 without using the procedure linkage table. */ 3978 if (h == NULL) 3979 break; 3980 3981 if (h->plt.offset == (bfd_vma) -1 3982 || !elf_hash_table (info)->dynamic_sections_created) 3983 { 3984 /* We didn't make a PLT entry for this symbol. This 3985 happens when statically linking PIC code, or when 3986 using -Bsymbolic. */ 3987 break; 3988 } 3989 3990 if (splt == NULL) 3991 { 3992 splt = bfd_get_section_by_name (dynobj, ".plt"); 3993 BFD_ASSERT (splt != NULL); 3994 } 3995 3996 relocation = (splt->output_section->vma 3997 + splt->output_offset 3998 + h->plt.offset); 3999 unresolved_reloc = FALSE; 4000 break; 4001 4002 case R_68K_PLT8O: 4003 case R_68K_PLT16O: 4004 case R_68K_PLT32O: 4005 /* Relocation is the offset of the entry for this symbol in 4006 the procedure linkage table. */ 4007 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1); 4008 4009 if (splt == NULL) 4010 { 4011 splt = bfd_get_section_by_name (dynobj, ".plt"); 4012 BFD_ASSERT (splt != NULL); 4013 } 4014 4015 relocation = h->plt.offset; 4016 unresolved_reloc = FALSE; 4017 4018 /* This relocation does not use the addend. */ 4019 rel->r_addend = 0; 4020 4021 break; 4022 4023 case R_68K_8: 4024 case R_68K_16: 4025 case R_68K_32: 4026 case R_68K_PC8: 4027 case R_68K_PC16: 4028 case R_68K_PC32: 4029 if (info->shared 4030 && r_symndx != STN_UNDEF 4031 && (input_section->flags & SEC_ALLOC) != 0 4032 && (h == NULL 4033 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4034 || h->root.type != bfd_link_hash_undefweak) 4035 && ((r_type != R_68K_PC8 4036 && r_type != R_68K_PC16 4037 && r_type != R_68K_PC32) 4038 || !SYMBOL_CALLS_LOCAL (info, h))) 4039 { 4040 Elf_Internal_Rela outrel; 4041 bfd_byte *loc; 4042 bfd_boolean skip, relocate; 4043 4044 /* When generating a shared object, these relocations 4045 are copied into the output file to be resolved at run 4046 time. */ 4047 4048 skip = FALSE; 4049 relocate = FALSE; 4050 4051 outrel.r_offset = 4052 _bfd_elf_section_offset (output_bfd, info, input_section, 4053 rel->r_offset); 4054 if (outrel.r_offset == (bfd_vma) -1) 4055 skip = TRUE; 4056 else if (outrel.r_offset == (bfd_vma) -2) 4057 skip = TRUE, relocate = TRUE; 4058 outrel.r_offset += (input_section->output_section->vma 4059 + input_section->output_offset); 4060 4061 if (skip) 4062 memset (&outrel, 0, sizeof outrel); 4063 else if (h != NULL 4064 && h->dynindx != -1 4065 && (r_type == R_68K_PC8 4066 || r_type == R_68K_PC16 4067 || r_type == R_68K_PC32 4068 || !info->shared 4069 || !info->symbolic 4070 || !h->def_regular)) 4071 { 4072 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 4073 outrel.r_addend = rel->r_addend; 4074 } 4075 else 4076 { 4077 /* This symbol is local, or marked to become local. */ 4078 outrel.r_addend = relocation + rel->r_addend; 4079 4080 if (r_type == R_68K_32) 4081 { 4082 relocate = TRUE; 4083 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE); 4084 } 4085 else 4086 { 4087 long indx; 4088 4089 if (bfd_is_abs_section (sec)) 4090 indx = 0; 4091 else if (sec == NULL || sec->owner == NULL) 4092 { 4093 bfd_set_error (bfd_error_bad_value); 4094 return FALSE; 4095 } 4096 else 4097 { 4098 asection *osec; 4099 4100 /* We are turning this relocation into one 4101 against a section symbol. It would be 4102 proper to subtract the symbol's value, 4103 osec->vma, from the emitted reloc addend, 4104 but ld.so expects buggy relocs. */ 4105 osec = sec->output_section; 4106 indx = elf_section_data (osec)->dynindx; 4107 if (indx == 0) 4108 { 4109 struct elf_link_hash_table *htab; 4110 htab = elf_hash_table (info); 4111 osec = htab->text_index_section; 4112 indx = elf_section_data (osec)->dynindx; 4113 } 4114 BFD_ASSERT (indx != 0); 4115 } 4116 4117 outrel.r_info = ELF32_R_INFO (indx, r_type); 4118 } 4119 } 4120 4121 sreloc = elf_section_data (input_section)->sreloc; 4122 if (sreloc == NULL) 4123 abort (); 4124 4125 loc = sreloc->contents; 4126 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 4127 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4128 4129 /* This reloc will be computed at runtime, so there's no 4130 need to do anything now, except for R_68K_32 4131 relocations that have been turned into 4132 R_68K_RELATIVE. */ 4133 if (!relocate) 4134 continue; 4135 } 4136 4137 break; 4138 4139 case R_68K_GNU_VTINHERIT: 4140 case R_68K_GNU_VTENTRY: 4141 /* These are no-ops in the end. */ 4142 continue; 4143 4144 default: 4145 break; 4146 } 4147 4148 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 4149 because such sections are not SEC_ALLOC and thus ld.so will 4150 not process them. */ 4151 if (unresolved_reloc 4152 && !((input_section->flags & SEC_DEBUGGING) != 0 4153 && h->def_dynamic)) 4154 { 4155 (*_bfd_error_handler) 4156 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 4157 input_bfd, 4158 input_section, 4159 (long) rel->r_offset, 4160 howto->name, 4161 h->root.root.string); 4162 return FALSE; 4163 } 4164 4165 if (r_symndx != STN_UNDEF 4166 && r_type != R_68K_NONE 4167 && (h == NULL 4168 || h->root.type == bfd_link_hash_defined 4169 || h->root.type == bfd_link_hash_defweak)) 4170 { 4171 char sym_type; 4172 4173 sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type; 4174 4175 if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS)) 4176 { 4177 const char *name; 4178 4179 if (h != NULL) 4180 name = h->root.root.string; 4181 else 4182 { 4183 name = (bfd_elf_string_from_elf_section 4184 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 4185 if (name == NULL || *name == '\0') 4186 name = bfd_section_name (input_bfd, sec); 4187 } 4188 4189 (*_bfd_error_handler) 4190 ((sym_type == STT_TLS 4191 ? _("%B(%A+0x%lx): %s used with TLS symbol %s") 4192 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")), 4193 input_bfd, 4194 input_section, 4195 (long) rel->r_offset, 4196 howto->name, 4197 name); 4198 } 4199 } 4200 4201 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 4202 contents, rel->r_offset, 4203 relocation, rel->r_addend); 4204 4205 if (r != bfd_reloc_ok) 4206 { 4207 const char *name; 4208 4209 if (h != NULL) 4210 name = h->root.root.string; 4211 else 4212 { 4213 name = bfd_elf_string_from_elf_section (input_bfd, 4214 symtab_hdr->sh_link, 4215 sym->st_name); 4216 if (name == NULL) 4217 return FALSE; 4218 if (*name == '\0') 4219 name = bfd_section_name (input_bfd, sec); 4220 } 4221 4222 if (r == bfd_reloc_overflow) 4223 { 4224 if (!(info->callbacks->reloc_overflow 4225 (info, (h ? &h->root : NULL), name, howto->name, 4226 (bfd_vma) 0, input_bfd, input_section, 4227 rel->r_offset))) 4228 return FALSE; 4229 } 4230 else 4231 { 4232 (*_bfd_error_handler) 4233 (_("%B(%A+0x%lx): reloc against `%s': error %d"), 4234 input_bfd, input_section, 4235 (long) rel->r_offset, name, (int) r); 4236 return FALSE; 4237 } 4238 } 4239 } 4240 4241 return TRUE; 4242 } 4243 4244 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET 4245 into section SEC. */ 4246 4247 static void 4248 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value) 4249 { 4250 /* Make VALUE PC-relative. */ 4251 value -= sec->output_section->vma + offset; 4252 4253 /* Apply any in-place addend. */ 4254 value += bfd_get_32 (sec->owner, sec->contents + offset); 4255 4256 bfd_put_32 (sec->owner, value, sec->contents + offset); 4257 } 4258 4259 /* Finish up dynamic symbol handling. We set the contents of various 4260 dynamic sections here. */ 4261 4262 static bfd_boolean 4263 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym) 4264 bfd *output_bfd; 4265 struct bfd_link_info *info; 4266 struct elf_link_hash_entry *h; 4267 Elf_Internal_Sym *sym; 4268 { 4269 bfd *dynobj; 4270 4271 dynobj = elf_hash_table (info)->dynobj; 4272 4273 if (h->plt.offset != (bfd_vma) -1) 4274 { 4275 const struct elf_m68k_plt_info *plt_info; 4276 asection *splt; 4277 asection *sgot; 4278 asection *srela; 4279 bfd_vma plt_index; 4280 bfd_vma got_offset; 4281 Elf_Internal_Rela rela; 4282 bfd_byte *loc; 4283 4284 /* This symbol has an entry in the procedure linkage table. Set 4285 it up. */ 4286 4287 BFD_ASSERT (h->dynindx != -1); 4288 4289 plt_info = elf_m68k_hash_table (info)->plt_info; 4290 splt = bfd_get_section_by_name (dynobj, ".plt"); 4291 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 4292 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 4293 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL); 4294 4295 /* Get the index in the procedure linkage table which 4296 corresponds to this symbol. This is the index of this symbol 4297 in all the symbols for which we are making plt entries. The 4298 first entry in the procedure linkage table is reserved. */ 4299 plt_index = (h->plt.offset / plt_info->size) - 1; 4300 4301 /* Get the offset into the .got table of the entry that 4302 corresponds to this function. Each .got entry is 4 bytes. 4303 The first three are reserved. */ 4304 got_offset = (plt_index + 3) * 4; 4305 4306 memcpy (splt->contents + h->plt.offset, 4307 plt_info->symbol_entry, 4308 plt_info->size); 4309 4310 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got, 4311 (sgot->output_section->vma 4312 + sgot->output_offset 4313 + got_offset)); 4314 4315 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela), 4316 splt->contents 4317 + h->plt.offset 4318 + plt_info->symbol_resolve_entry + 2); 4319 4320 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt, 4321 splt->output_section->vma); 4322 4323 /* Fill in the entry in the global offset table. */ 4324 bfd_put_32 (output_bfd, 4325 (splt->output_section->vma 4326 + splt->output_offset 4327 + h->plt.offset 4328 + plt_info->symbol_resolve_entry), 4329 sgot->contents + got_offset); 4330 4331 /* Fill in the entry in the .rela.plt section. */ 4332 rela.r_offset = (sgot->output_section->vma 4333 + sgot->output_offset 4334 + got_offset); 4335 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT); 4336 rela.r_addend = 0; 4337 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela); 4338 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4339 4340 if (!h->def_regular) 4341 { 4342 /* Mark the symbol as undefined, rather than as defined in 4343 the .plt section. Leave the value alone. */ 4344 sym->st_shndx = SHN_UNDEF; 4345 } 4346 } 4347 4348 if (elf_m68k_hash_entry (h)->glist != NULL) 4349 { 4350 asection *sgot; 4351 asection *srela; 4352 struct elf_m68k_got_entry *got_entry; 4353 4354 /* This symbol has an entry in the global offset table. Set it 4355 up. */ 4356 4357 sgot = bfd_get_section_by_name (dynobj, ".got"); 4358 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 4359 BFD_ASSERT (sgot != NULL && srela != NULL); 4360 4361 got_entry = elf_m68k_hash_entry (h)->glist; 4362 4363 while (got_entry != NULL) 4364 { 4365 enum elf_m68k_reloc_type r_type; 4366 bfd_vma got_entry_offset; 4367 4368 r_type = got_entry->key_.type; 4369 got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1; 4370 4371 /* If this is a -Bsymbolic link, and the symbol is defined 4372 locally, we just want to emit a RELATIVE reloc. Likewise if 4373 the symbol was forced to be local because of a version file. 4374 The entry in the global offset table already have been 4375 initialized in the relocate_section function. */ 4376 if (info->shared 4377 && SYMBOL_REFERENCES_LOCAL (info, h)) 4378 { 4379 bfd_vma relocation; 4380 4381 relocation = bfd_get_signed_32 (output_bfd, 4382 (sgot->contents 4383 + got_entry_offset)); 4384 4385 /* Undo TP bias. */ 4386 switch (elf_m68k_reloc_got_type (r_type)) 4387 { 4388 case R_68K_GOT32O: 4389 case R_68K_TLS_LDM32: 4390 break; 4391 4392 case R_68K_TLS_GD32: 4393 /* The value for this relocation is actually put in 4394 the second GOT slot. */ 4395 relocation = bfd_get_signed_32 (output_bfd, 4396 (sgot->contents 4397 + got_entry_offset + 4)); 4398 relocation += dtpoff_base (info); 4399 break; 4400 4401 case R_68K_TLS_IE32: 4402 relocation += tpoff_base (info); 4403 break; 4404 4405 default: 4406 BFD_ASSERT (FALSE); 4407 } 4408 4409 elf_m68k_init_got_entry_local_shared (info, 4410 output_bfd, 4411 r_type, 4412 sgot, 4413 got_entry_offset, 4414 relocation, 4415 srela); 4416 } 4417 else 4418 { 4419 Elf_Internal_Rela rela; 4420 4421 /* Put zeros to GOT slots that will be initialized 4422 at run-time. */ 4423 { 4424 bfd_vma n_slots; 4425 4426 n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type); 4427 while (n_slots--) 4428 bfd_put_32 (output_bfd, (bfd_vma) 0, 4429 (sgot->contents + got_entry_offset 4430 + 4 * n_slots)); 4431 } 4432 4433 rela.r_addend = 0; 4434 rela.r_offset = (sgot->output_section->vma 4435 + sgot->output_offset 4436 + got_entry_offset); 4437 4438 switch (elf_m68k_reloc_got_type (r_type)) 4439 { 4440 case R_68K_GOT32O: 4441 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT); 4442 elf_m68k_install_rela (output_bfd, srela, &rela); 4443 break; 4444 4445 case R_68K_TLS_GD32: 4446 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32); 4447 elf_m68k_install_rela (output_bfd, srela, &rela); 4448 4449 rela.r_offset += 4; 4450 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32); 4451 elf_m68k_install_rela (output_bfd, srela, &rela); 4452 break; 4453 4454 case R_68K_TLS_IE32: 4455 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32); 4456 elf_m68k_install_rela (output_bfd, srela, &rela); 4457 break; 4458 4459 default: 4460 BFD_ASSERT (FALSE); 4461 break; 4462 } 4463 } 4464 4465 got_entry = got_entry->u.s2.next; 4466 } 4467 } 4468 4469 if (h->needs_copy) 4470 { 4471 asection *s; 4472 Elf_Internal_Rela rela; 4473 bfd_byte *loc; 4474 4475 /* This symbol needs a copy reloc. Set it up. */ 4476 4477 BFD_ASSERT (h->dynindx != -1 4478 && (h->root.type == bfd_link_hash_defined 4479 || h->root.type == bfd_link_hash_defweak)); 4480 4481 s = bfd_get_section_by_name (h->root.u.def.section->owner, 4482 ".rela.bss"); 4483 BFD_ASSERT (s != NULL); 4484 4485 rela.r_offset = (h->root.u.def.value 4486 + h->root.u.def.section->output_section->vma 4487 + h->root.u.def.section->output_offset); 4488 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY); 4489 rela.r_addend = 0; 4490 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 4491 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4492 } 4493 4494 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 4495 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 4496 || h == elf_hash_table (info)->hgot) 4497 sym->st_shndx = SHN_ABS; 4498 4499 return TRUE; 4500 } 4501 4502 /* Finish up the dynamic sections. */ 4503 4504 static bfd_boolean 4505 elf_m68k_finish_dynamic_sections (output_bfd, info) 4506 bfd *output_bfd; 4507 struct bfd_link_info *info; 4508 { 4509 bfd *dynobj; 4510 asection *sgot; 4511 asection *sdyn; 4512 4513 dynobj = elf_hash_table (info)->dynobj; 4514 4515 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 4516 BFD_ASSERT (sgot != NULL); 4517 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 4518 4519 if (elf_hash_table (info)->dynamic_sections_created) 4520 { 4521 asection *splt; 4522 Elf32_External_Dyn *dyncon, *dynconend; 4523 4524 splt = bfd_get_section_by_name (dynobj, ".plt"); 4525 BFD_ASSERT (splt != NULL && sdyn != NULL); 4526 4527 dyncon = (Elf32_External_Dyn *) sdyn->contents; 4528 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 4529 for (; dyncon < dynconend; dyncon++) 4530 { 4531 Elf_Internal_Dyn dyn; 4532 const char *name; 4533 asection *s; 4534 4535 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 4536 4537 switch (dyn.d_tag) 4538 { 4539 default: 4540 break; 4541 4542 case DT_PLTGOT: 4543 name = ".got"; 4544 goto get_vma; 4545 case DT_JMPREL: 4546 name = ".rela.plt"; 4547 get_vma: 4548 s = bfd_get_section_by_name (output_bfd, name); 4549 BFD_ASSERT (s != NULL); 4550 dyn.d_un.d_ptr = s->vma; 4551 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4552 break; 4553 4554 case DT_PLTRELSZ: 4555 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 4556 BFD_ASSERT (s != NULL); 4557 dyn.d_un.d_val = s->size; 4558 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4559 break; 4560 4561 case DT_RELASZ: 4562 /* The procedure linkage table relocs (DT_JMPREL) should 4563 not be included in the overall relocs (DT_RELA). 4564 Therefore, we override the DT_RELASZ entry here to 4565 make it not include the JMPREL relocs. Since the 4566 linker script arranges for .rela.plt to follow all 4567 other relocation sections, we don't have to worry 4568 about changing the DT_RELA entry. */ 4569 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 4570 if (s != NULL) 4571 dyn.d_un.d_val -= s->size; 4572 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4573 break; 4574 } 4575 } 4576 4577 /* Fill in the first entry in the procedure linkage table. */ 4578 if (splt->size > 0) 4579 { 4580 const struct elf_m68k_plt_info *plt_info; 4581 4582 plt_info = elf_m68k_hash_table (info)->plt_info; 4583 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size); 4584 4585 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4, 4586 (sgot->output_section->vma 4587 + sgot->output_offset 4588 + 4)); 4589 4590 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8, 4591 (sgot->output_section->vma 4592 + sgot->output_offset 4593 + 8)); 4594 4595 elf_section_data (splt->output_section)->this_hdr.sh_entsize 4596 = plt_info->size; 4597 } 4598 } 4599 4600 /* Fill in the first three entries in the global offset table. */ 4601 if (sgot->size > 0) 4602 { 4603 if (sdyn == NULL) 4604 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 4605 else 4606 bfd_put_32 (output_bfd, 4607 sdyn->output_section->vma + sdyn->output_offset, 4608 sgot->contents); 4609 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 4610 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 4611 } 4612 4613 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 4614 4615 return TRUE; 4616 } 4617 4618 /* Given a .data section and a .emreloc in-memory section, store 4619 relocation information into the .emreloc section which can be 4620 used at runtime to relocate the section. This is called by the 4621 linker when the --embedded-relocs switch is used. This is called 4622 after the add_symbols entry point has been called for all the 4623 objects, and before the final_link entry point is called. */ 4624 4625 bfd_boolean 4626 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg) 4627 bfd *abfd; 4628 struct bfd_link_info *info; 4629 asection *datasec; 4630 asection *relsec; 4631 char **errmsg; 4632 { 4633 Elf_Internal_Shdr *symtab_hdr; 4634 Elf_Internal_Sym *isymbuf = NULL; 4635 Elf_Internal_Rela *internal_relocs = NULL; 4636 Elf_Internal_Rela *irel, *irelend; 4637 bfd_byte *p; 4638 bfd_size_type amt; 4639 4640 BFD_ASSERT (! info->relocatable); 4641 4642 *errmsg = NULL; 4643 4644 if (datasec->reloc_count == 0) 4645 return TRUE; 4646 4647 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 4648 4649 /* Get a copy of the native relocations. */ 4650 internal_relocs = (_bfd_elf_link_read_relocs 4651 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 4652 info->keep_memory)); 4653 if (internal_relocs == NULL) 4654 goto error_return; 4655 4656 amt = (bfd_size_type) datasec->reloc_count * 12; 4657 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt); 4658 if (relsec->contents == NULL) 4659 goto error_return; 4660 4661 p = relsec->contents; 4662 4663 irelend = internal_relocs + datasec->reloc_count; 4664 for (irel = internal_relocs; irel < irelend; irel++, p += 12) 4665 { 4666 asection *targetsec; 4667 4668 /* We are going to write a four byte longword into the runtime 4669 reloc section. The longword will be the address in the data 4670 section which must be relocated. It is followed by the name 4671 of the target section NUL-padded or truncated to 8 4672 characters. */ 4673 4674 /* We can only relocate absolute longword relocs at run time. */ 4675 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32) 4676 { 4677 *errmsg = _("unsupported reloc type"); 4678 bfd_set_error (bfd_error_bad_value); 4679 goto error_return; 4680 } 4681 4682 /* Get the target section referred to by the reloc. */ 4683 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 4684 { 4685 /* A local symbol. */ 4686 Elf_Internal_Sym *isym; 4687 4688 /* Read this BFD's local symbols if we haven't done so already. */ 4689 if (isymbuf == NULL) 4690 { 4691 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 4692 if (isymbuf == NULL) 4693 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 4694 symtab_hdr->sh_info, 0, 4695 NULL, NULL, NULL); 4696 if (isymbuf == NULL) 4697 goto error_return; 4698 } 4699 4700 isym = isymbuf + ELF32_R_SYM (irel->r_info); 4701 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 4702 } 4703 else 4704 { 4705 unsigned long indx; 4706 struct elf_link_hash_entry *h; 4707 4708 /* An external symbol. */ 4709 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 4710 h = elf_sym_hashes (abfd)[indx]; 4711 BFD_ASSERT (h != NULL); 4712 if (h->root.type == bfd_link_hash_defined 4713 || h->root.type == bfd_link_hash_defweak) 4714 targetsec = h->root.u.def.section; 4715 else 4716 targetsec = NULL; 4717 } 4718 4719 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p); 4720 memset (p + 4, 0, 8); 4721 if (targetsec != NULL) 4722 strncpy ((char *) p + 4, targetsec->output_section->name, 8); 4723 } 4724 4725 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 4726 free (isymbuf); 4727 if (internal_relocs != NULL 4728 && elf_section_data (datasec)->relocs != internal_relocs) 4729 free (internal_relocs); 4730 return TRUE; 4731 4732 error_return: 4733 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 4734 free (isymbuf); 4735 if (internal_relocs != NULL 4736 && elf_section_data (datasec)->relocs != internal_relocs) 4737 free (internal_relocs); 4738 return FALSE; 4739 } 4740 4741 /* Set target options. */ 4742 4743 void 4744 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling) 4745 { 4746 struct elf_m68k_link_hash_table *htab; 4747 bfd_boolean use_neg_got_offsets_p; 4748 bfd_boolean allow_multigot_p; 4749 bfd_boolean local_gp_p; 4750 4751 switch (got_handling) 4752 { 4753 case 0: 4754 /* --got=single. */ 4755 local_gp_p = FALSE; 4756 use_neg_got_offsets_p = FALSE; 4757 allow_multigot_p = FALSE; 4758 break; 4759 4760 case 1: 4761 /* --got=negative. */ 4762 local_gp_p = TRUE; 4763 use_neg_got_offsets_p = TRUE; 4764 allow_multigot_p = FALSE; 4765 break; 4766 4767 case 2: 4768 /* --got=multigot. */ 4769 local_gp_p = TRUE; 4770 use_neg_got_offsets_p = TRUE; 4771 allow_multigot_p = TRUE; 4772 break; 4773 4774 default: 4775 BFD_ASSERT (FALSE); 4776 return; 4777 } 4778 4779 htab = elf_m68k_hash_table (info); 4780 if (htab != NULL) 4781 { 4782 htab->local_gp_p = local_gp_p; 4783 htab->use_neg_got_offsets_p = use_neg_got_offsets_p; 4784 htab->allow_multigot_p = allow_multigot_p; 4785 } 4786 } 4787 4788 static enum elf_reloc_type_class 4789 elf32_m68k_reloc_type_class (rela) 4790 const Elf_Internal_Rela *rela; 4791 { 4792 switch ((int) ELF32_R_TYPE (rela->r_info)) 4793 { 4794 case R_68K_RELATIVE: 4795 return reloc_class_relative; 4796 case R_68K_JMP_SLOT: 4797 return reloc_class_plt; 4798 case R_68K_COPY: 4799 return reloc_class_copy; 4800 default: 4801 return reloc_class_normal; 4802 } 4803 } 4804 4805 /* Return address for Ith PLT stub in section PLT, for relocation REL 4806 or (bfd_vma) -1 if it should not be included. */ 4807 4808 static bfd_vma 4809 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt, 4810 const arelent *rel ATTRIBUTE_UNUSED) 4811 { 4812 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size; 4813 } 4814 4815 #define TARGET_BIG_SYM bfd_elf32_m68k_vec 4816 #define TARGET_BIG_NAME "elf32-m68k" 4817 #define ELF_MACHINE_CODE EM_68K 4818 #define ELF_MAXPAGESIZE 0x2000 4819 #define elf_backend_create_dynamic_sections \ 4820 _bfd_elf_create_dynamic_sections 4821 #define bfd_elf32_bfd_link_hash_table_create \ 4822 elf_m68k_link_hash_table_create 4823 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create? */ 4824 #define bfd_elf32_bfd_link_hash_table_free \ 4825 elf_m68k_link_hash_table_free 4826 #define bfd_elf32_bfd_final_link bfd_elf_final_link 4827 4828 #define elf_backend_check_relocs elf_m68k_check_relocs 4829 #define elf_backend_always_size_sections \ 4830 elf_m68k_always_size_sections 4831 #define elf_backend_adjust_dynamic_symbol \ 4832 elf_m68k_adjust_dynamic_symbol 4833 #define elf_backend_size_dynamic_sections \ 4834 elf_m68k_size_dynamic_sections 4835 #define elf_backend_final_write_processing elf_m68k_final_write_processing 4836 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 4837 #define elf_backend_relocate_section elf_m68k_relocate_section 4838 #define elf_backend_finish_dynamic_symbol \ 4839 elf_m68k_finish_dynamic_symbol 4840 #define elf_backend_finish_dynamic_sections \ 4841 elf_m68k_finish_dynamic_sections 4842 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook 4843 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook 4844 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol 4845 #define bfd_elf32_bfd_merge_private_bfd_data \ 4846 elf32_m68k_merge_private_bfd_data 4847 #define bfd_elf32_bfd_set_private_flags \ 4848 elf32_m68k_set_private_flags 4849 #define bfd_elf32_bfd_print_private_bfd_data \ 4850 elf32_m68k_print_private_bfd_data 4851 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class 4852 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val 4853 #define elf_backend_object_p elf32_m68k_object_p 4854 4855 #define elf_backend_can_gc_sections 1 4856 #define elf_backend_can_refcount 1 4857 #define elf_backend_want_got_plt 1 4858 #define elf_backend_plt_readonly 1 4859 #define elf_backend_want_plt_sym 0 4860 #define elf_backend_got_header_size 12 4861 #define elf_backend_rela_normal 1 4862 4863 #include "elf32-target.h" 4864