1 /* PowerPC64-specific support for 64-bit ELF. 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 3 2009 Free Software Foundation, Inc. 4 Written by Linus Nordberg, Swox AB <info@swox.com>, 5 based on elf32-ppc.c by Ian Lance Taylor. 6 Largely rewritten by Alan Modra <amodra@bigpond.net.au> 7 8 This file is part of BFD, the Binary File Descriptor library. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License along 21 with this program; if not, write to the Free Software Foundation, Inc., 22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 23 24 25 /* The 64-bit PowerPC ELF ABI may be found at 26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and 27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */ 28 29 #include "sysdep.h" 30 #include <stdarg.h> 31 #include "bfd.h" 32 #include "bfdlink.h" 33 #include "libbfd.h" 34 #include "elf-bfd.h" 35 #include "elf/ppc64.h" 36 #include "elf64-ppc.h" 37 38 static bfd_reloc_status_type ppc64_elf_ha_reloc 39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 40 static bfd_reloc_status_type ppc64_elf_branch_reloc 41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc 45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc 47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 48 static bfd_reloc_status_type ppc64_elf_toc_reloc 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 52 static bfd_reloc_status_type ppc64_elf_toc64_reloc 53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc 55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 56 static bfd_vma opd_entry_value 57 (asection *, bfd_vma, asection **, bfd_vma *); 58 59 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec 60 #define TARGET_LITTLE_NAME "elf64-powerpcle" 61 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec 62 #define TARGET_BIG_NAME "elf64-powerpc" 63 #define ELF_ARCH bfd_arch_powerpc 64 #define ELF_MACHINE_CODE EM_PPC64 65 #define ELF_MAXPAGESIZE 0x10000 66 #define ELF_COMMONPAGESIZE 0x1000 67 #define elf_info_to_howto ppc64_elf_info_to_howto 68 69 #define elf_backend_want_got_sym 0 70 #define elf_backend_want_plt_sym 0 71 #define elf_backend_plt_alignment 3 72 #define elf_backend_plt_not_loaded 1 73 #define elf_backend_got_header_size 8 74 #define elf_backend_can_gc_sections 1 75 #define elf_backend_can_refcount 1 76 #define elf_backend_rela_normal 1 77 #define elf_backend_default_execstack 0 78 79 #define bfd_elf64_mkobject ppc64_elf_mkobject 80 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup 81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup 82 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data 83 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook 84 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create 85 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free 86 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab 87 88 #define elf_backend_object_p ppc64_elf_object_p 89 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus 90 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo 91 #define elf_backend_write_core_note ppc64_elf_write_core_note 92 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections 93 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol 94 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook 95 #define elf_backend_check_directives ppc64_elf_check_directives 96 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup 97 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup 98 #define elf_backend_check_relocs ppc64_elf_check_relocs 99 #define elf_backend_gc_keep ppc64_elf_gc_keep 100 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref 101 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook 102 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook 103 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol 104 #define elf_backend_hide_symbol ppc64_elf_hide_symbol 105 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust 106 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections 107 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections 108 #define elf_backend_action_discarded ppc64_elf_action_discarded 109 #define elf_backend_relocate_section ppc64_elf_relocate_section 110 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol 111 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class 112 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections 113 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook 114 #define elf_backend_special_sections ppc64_elf_special_sections 115 116 /* The name of the dynamic interpreter. This is put in the .interp 117 section. */ 118 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 119 120 /* The size in bytes of an entry in the procedure linkage table. */ 121 #define PLT_ENTRY_SIZE 24 122 123 /* The initial size of the plt reserved for the dynamic linker. */ 124 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE 125 126 /* TOC base pointers offset from start of TOC. */ 127 #define TOC_BASE_OFF 0x8000 128 129 /* Offset of tp and dtp pointers from start of TLS block. */ 130 #define TP_OFFSET 0x7000 131 #define DTP_OFFSET 0x8000 132 133 /* .plt call stub instructions. The normal stub is like this, but 134 sometimes the .plt entry crosses a 64k boundary and we need to 135 insert an addi to adjust r12. */ 136 #define PLT_CALL_STUB_SIZE (7*4) 137 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */ 138 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */ 139 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */ 140 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */ 141 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */ 142 /* ld %r11,xxx+16@l(%r12) */ 143 #define BCTR 0x4e800420 /* bctr */ 144 145 146 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */ 147 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */ 148 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */ 149 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */ 150 151 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */ 152 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */ 153 154 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */ 155 156 /* glink call stub instructions. We enter with the index in R0. */ 157 #define GLINK_CALL_STUB_SIZE (16*4) 158 /* 0: */ 159 /* .quad plt0-1f */ 160 /* __glink: */ 161 #define MFLR_R12 0x7d8802a6 /* mflr %12 */ 162 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */ 163 /* 1: */ 164 #define MFLR_R11 0x7d6802a6 /* mflr %11 */ 165 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */ 166 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */ 167 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */ 168 /* ld %11,0(%12) */ 169 /* ld %2,8(%12) */ 170 /* mtctr %11 */ 171 /* ld %11,16(%12) */ 172 /* bctr */ 173 174 /* Pad with this. */ 175 #define NOP 0x60000000 176 177 /* Some other nops. */ 178 #define CROR_151515 0x4def7b82 179 #define CROR_313131 0x4ffffb82 180 181 /* .glink entries for the first 32k functions are two instructions. */ 182 #define LI_R0_0 0x38000000 /* li %r0,0 */ 183 #define B_DOT 0x48000000 /* b . */ 184 185 /* After that, we need two instructions to load the index, followed by 186 a branch. */ 187 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */ 188 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */ 189 190 /* Instructions used by the save and restore reg functions. */ 191 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */ 192 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */ 193 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */ 194 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */ 195 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */ 196 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */ 197 #define LI_R12_0 0x39800000 /* li %r12,0 */ 198 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */ 199 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */ 200 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */ 201 #define BLR 0x4e800020 /* blr */ 202 203 /* Since .opd is an array of descriptors and each entry will end up 204 with identical R_PPC64_RELATIVE relocs, there is really no need to 205 propagate .opd relocs; The dynamic linker should be taught to 206 relocate .opd without reloc entries. */ 207 #ifndef NO_OPD_RELOCS 208 #define NO_OPD_RELOCS 0 209 #endif 210 211 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1) 212 213 /* Relocation HOWTO's. */ 214 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max]; 215 216 static reloc_howto_type ppc64_elf_howto_raw[] = { 217 /* This reloc does nothing. */ 218 HOWTO (R_PPC64_NONE, /* type */ 219 0, /* rightshift */ 220 2, /* size (0 = byte, 1 = short, 2 = long) */ 221 32, /* bitsize */ 222 FALSE, /* pc_relative */ 223 0, /* bitpos */ 224 complain_overflow_dont, /* complain_on_overflow */ 225 bfd_elf_generic_reloc, /* special_function */ 226 "R_PPC64_NONE", /* name */ 227 FALSE, /* partial_inplace */ 228 0, /* src_mask */ 229 0, /* dst_mask */ 230 FALSE), /* pcrel_offset */ 231 232 /* A standard 32 bit relocation. */ 233 HOWTO (R_PPC64_ADDR32, /* type */ 234 0, /* rightshift */ 235 2, /* size (0 = byte, 1 = short, 2 = long) */ 236 32, /* bitsize */ 237 FALSE, /* pc_relative */ 238 0, /* bitpos */ 239 complain_overflow_bitfield, /* complain_on_overflow */ 240 bfd_elf_generic_reloc, /* special_function */ 241 "R_PPC64_ADDR32", /* name */ 242 FALSE, /* partial_inplace */ 243 0, /* src_mask */ 244 0xffffffff, /* dst_mask */ 245 FALSE), /* pcrel_offset */ 246 247 /* An absolute 26 bit branch; the lower two bits must be zero. 248 FIXME: we don't check that, we just clear them. */ 249 HOWTO (R_PPC64_ADDR24, /* type */ 250 0, /* rightshift */ 251 2, /* size (0 = byte, 1 = short, 2 = long) */ 252 26, /* bitsize */ 253 FALSE, /* pc_relative */ 254 0, /* bitpos */ 255 complain_overflow_bitfield, /* complain_on_overflow */ 256 bfd_elf_generic_reloc, /* special_function */ 257 "R_PPC64_ADDR24", /* name */ 258 FALSE, /* partial_inplace */ 259 0, /* src_mask */ 260 0x03fffffc, /* dst_mask */ 261 FALSE), /* pcrel_offset */ 262 263 /* A standard 16 bit relocation. */ 264 HOWTO (R_PPC64_ADDR16, /* type */ 265 0, /* rightshift */ 266 1, /* size (0 = byte, 1 = short, 2 = long) */ 267 16, /* bitsize */ 268 FALSE, /* pc_relative */ 269 0, /* bitpos */ 270 complain_overflow_bitfield, /* complain_on_overflow */ 271 bfd_elf_generic_reloc, /* special_function */ 272 "R_PPC64_ADDR16", /* name */ 273 FALSE, /* partial_inplace */ 274 0, /* src_mask */ 275 0xffff, /* dst_mask */ 276 FALSE), /* pcrel_offset */ 277 278 /* A 16 bit relocation without overflow. */ 279 HOWTO (R_PPC64_ADDR16_LO, /* type */ 280 0, /* rightshift */ 281 1, /* size (0 = byte, 1 = short, 2 = long) */ 282 16, /* bitsize */ 283 FALSE, /* pc_relative */ 284 0, /* bitpos */ 285 complain_overflow_dont,/* complain_on_overflow */ 286 bfd_elf_generic_reloc, /* special_function */ 287 "R_PPC64_ADDR16_LO", /* name */ 288 FALSE, /* partial_inplace */ 289 0, /* src_mask */ 290 0xffff, /* dst_mask */ 291 FALSE), /* pcrel_offset */ 292 293 /* Bits 16-31 of an address. */ 294 HOWTO (R_PPC64_ADDR16_HI, /* type */ 295 16, /* rightshift */ 296 1, /* size (0 = byte, 1 = short, 2 = long) */ 297 16, /* bitsize */ 298 FALSE, /* pc_relative */ 299 0, /* bitpos */ 300 complain_overflow_dont, /* complain_on_overflow */ 301 bfd_elf_generic_reloc, /* special_function */ 302 "R_PPC64_ADDR16_HI", /* name */ 303 FALSE, /* partial_inplace */ 304 0, /* src_mask */ 305 0xffff, /* dst_mask */ 306 FALSE), /* pcrel_offset */ 307 308 /* Bits 16-31 of an address, plus 1 if the contents of the low 16 309 bits, treated as a signed number, is negative. */ 310 HOWTO (R_PPC64_ADDR16_HA, /* type */ 311 16, /* rightshift */ 312 1, /* size (0 = byte, 1 = short, 2 = long) */ 313 16, /* bitsize */ 314 FALSE, /* pc_relative */ 315 0, /* bitpos */ 316 complain_overflow_dont, /* complain_on_overflow */ 317 ppc64_elf_ha_reloc, /* special_function */ 318 "R_PPC64_ADDR16_HA", /* name */ 319 FALSE, /* partial_inplace */ 320 0, /* src_mask */ 321 0xffff, /* dst_mask */ 322 FALSE), /* pcrel_offset */ 323 324 /* An absolute 16 bit branch; the lower two bits must be zero. 325 FIXME: we don't check that, we just clear them. */ 326 HOWTO (R_PPC64_ADDR14, /* type */ 327 0, /* rightshift */ 328 2, /* size (0 = byte, 1 = short, 2 = long) */ 329 16, /* bitsize */ 330 FALSE, /* pc_relative */ 331 0, /* bitpos */ 332 complain_overflow_bitfield, /* complain_on_overflow */ 333 ppc64_elf_branch_reloc, /* special_function */ 334 "R_PPC64_ADDR14", /* name */ 335 FALSE, /* partial_inplace */ 336 0, /* src_mask */ 337 0x0000fffc, /* dst_mask */ 338 FALSE), /* pcrel_offset */ 339 340 /* An absolute 16 bit branch, for which bit 10 should be set to 341 indicate that the branch is expected to be taken. The lower two 342 bits must be zero. */ 343 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */ 344 0, /* rightshift */ 345 2, /* size (0 = byte, 1 = short, 2 = long) */ 346 16, /* bitsize */ 347 FALSE, /* pc_relative */ 348 0, /* bitpos */ 349 complain_overflow_bitfield, /* complain_on_overflow */ 350 ppc64_elf_brtaken_reloc, /* special_function */ 351 "R_PPC64_ADDR14_BRTAKEN",/* name */ 352 FALSE, /* partial_inplace */ 353 0, /* src_mask */ 354 0x0000fffc, /* dst_mask */ 355 FALSE), /* pcrel_offset */ 356 357 /* An absolute 16 bit branch, for which bit 10 should be set to 358 indicate that the branch is not expected to be taken. The lower 359 two bits must be zero. */ 360 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */ 361 0, /* rightshift */ 362 2, /* size (0 = byte, 1 = short, 2 = long) */ 363 16, /* bitsize */ 364 FALSE, /* pc_relative */ 365 0, /* bitpos */ 366 complain_overflow_bitfield, /* complain_on_overflow */ 367 ppc64_elf_brtaken_reloc, /* special_function */ 368 "R_PPC64_ADDR14_BRNTAKEN",/* name */ 369 FALSE, /* partial_inplace */ 370 0, /* src_mask */ 371 0x0000fffc, /* dst_mask */ 372 FALSE), /* pcrel_offset */ 373 374 /* A relative 26 bit branch; the lower two bits must be zero. */ 375 HOWTO (R_PPC64_REL24, /* type */ 376 0, /* rightshift */ 377 2, /* size (0 = byte, 1 = short, 2 = long) */ 378 26, /* bitsize */ 379 TRUE, /* pc_relative */ 380 0, /* bitpos */ 381 complain_overflow_signed, /* complain_on_overflow */ 382 ppc64_elf_branch_reloc, /* special_function */ 383 "R_PPC64_REL24", /* name */ 384 FALSE, /* partial_inplace */ 385 0, /* src_mask */ 386 0x03fffffc, /* dst_mask */ 387 TRUE), /* pcrel_offset */ 388 389 /* A relative 16 bit branch; the lower two bits must be zero. */ 390 HOWTO (R_PPC64_REL14, /* type */ 391 0, /* rightshift */ 392 2, /* size (0 = byte, 1 = short, 2 = long) */ 393 16, /* bitsize */ 394 TRUE, /* pc_relative */ 395 0, /* bitpos */ 396 complain_overflow_signed, /* complain_on_overflow */ 397 ppc64_elf_branch_reloc, /* special_function */ 398 "R_PPC64_REL14", /* name */ 399 FALSE, /* partial_inplace */ 400 0, /* src_mask */ 401 0x0000fffc, /* dst_mask */ 402 TRUE), /* pcrel_offset */ 403 404 /* A relative 16 bit branch. Bit 10 should be set to indicate that 405 the branch is expected to be taken. The lower two bits must be 406 zero. */ 407 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */ 408 0, /* rightshift */ 409 2, /* size (0 = byte, 1 = short, 2 = long) */ 410 16, /* bitsize */ 411 TRUE, /* pc_relative */ 412 0, /* bitpos */ 413 complain_overflow_signed, /* complain_on_overflow */ 414 ppc64_elf_brtaken_reloc, /* special_function */ 415 "R_PPC64_REL14_BRTAKEN", /* name */ 416 FALSE, /* partial_inplace */ 417 0, /* src_mask */ 418 0x0000fffc, /* dst_mask */ 419 TRUE), /* pcrel_offset */ 420 421 /* A relative 16 bit branch. Bit 10 should be set to indicate that 422 the branch is not expected to be taken. The lower two bits must 423 be zero. */ 424 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */ 425 0, /* rightshift */ 426 2, /* size (0 = byte, 1 = short, 2 = long) */ 427 16, /* bitsize */ 428 TRUE, /* pc_relative */ 429 0, /* bitpos */ 430 complain_overflow_signed, /* complain_on_overflow */ 431 ppc64_elf_brtaken_reloc, /* special_function */ 432 "R_PPC64_REL14_BRNTAKEN",/* name */ 433 FALSE, /* partial_inplace */ 434 0, /* src_mask */ 435 0x0000fffc, /* dst_mask */ 436 TRUE), /* pcrel_offset */ 437 438 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the 439 symbol. */ 440 HOWTO (R_PPC64_GOT16, /* type */ 441 0, /* rightshift */ 442 1, /* size (0 = byte, 1 = short, 2 = long) */ 443 16, /* bitsize */ 444 FALSE, /* pc_relative */ 445 0, /* bitpos */ 446 complain_overflow_signed, /* complain_on_overflow */ 447 ppc64_elf_unhandled_reloc, /* special_function */ 448 "R_PPC64_GOT16", /* name */ 449 FALSE, /* partial_inplace */ 450 0, /* src_mask */ 451 0xffff, /* dst_mask */ 452 FALSE), /* pcrel_offset */ 453 454 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for 455 the symbol. */ 456 HOWTO (R_PPC64_GOT16_LO, /* type */ 457 0, /* rightshift */ 458 1, /* size (0 = byte, 1 = short, 2 = long) */ 459 16, /* bitsize */ 460 FALSE, /* pc_relative */ 461 0, /* bitpos */ 462 complain_overflow_dont, /* complain_on_overflow */ 463 ppc64_elf_unhandled_reloc, /* special_function */ 464 "R_PPC64_GOT16_LO", /* name */ 465 FALSE, /* partial_inplace */ 466 0, /* src_mask */ 467 0xffff, /* dst_mask */ 468 FALSE), /* pcrel_offset */ 469 470 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for 471 the symbol. */ 472 HOWTO (R_PPC64_GOT16_HI, /* type */ 473 16, /* rightshift */ 474 1, /* size (0 = byte, 1 = short, 2 = long) */ 475 16, /* bitsize */ 476 FALSE, /* pc_relative */ 477 0, /* bitpos */ 478 complain_overflow_dont,/* complain_on_overflow */ 479 ppc64_elf_unhandled_reloc, /* special_function */ 480 "R_PPC64_GOT16_HI", /* name */ 481 FALSE, /* partial_inplace */ 482 0, /* src_mask */ 483 0xffff, /* dst_mask */ 484 FALSE), /* pcrel_offset */ 485 486 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for 487 the symbol. */ 488 HOWTO (R_PPC64_GOT16_HA, /* type */ 489 16, /* rightshift */ 490 1, /* size (0 = byte, 1 = short, 2 = long) */ 491 16, /* bitsize */ 492 FALSE, /* pc_relative */ 493 0, /* bitpos */ 494 complain_overflow_dont,/* complain_on_overflow */ 495 ppc64_elf_unhandled_reloc, /* special_function */ 496 "R_PPC64_GOT16_HA", /* name */ 497 FALSE, /* partial_inplace */ 498 0, /* src_mask */ 499 0xffff, /* dst_mask */ 500 FALSE), /* pcrel_offset */ 501 502 /* This is used only by the dynamic linker. The symbol should exist 503 both in the object being run and in some shared library. The 504 dynamic linker copies the data addressed by the symbol from the 505 shared library into the object, because the object being 506 run has to have the data at some particular address. */ 507 HOWTO (R_PPC64_COPY, /* type */ 508 0, /* rightshift */ 509 0, /* this one is variable size */ 510 0, /* bitsize */ 511 FALSE, /* pc_relative */ 512 0, /* bitpos */ 513 complain_overflow_dont, /* complain_on_overflow */ 514 ppc64_elf_unhandled_reloc, /* special_function */ 515 "R_PPC64_COPY", /* name */ 516 FALSE, /* partial_inplace */ 517 0, /* src_mask */ 518 0, /* dst_mask */ 519 FALSE), /* pcrel_offset */ 520 521 /* Like R_PPC64_ADDR64, but used when setting global offset table 522 entries. */ 523 HOWTO (R_PPC64_GLOB_DAT, /* type */ 524 0, /* rightshift */ 525 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 526 64, /* bitsize */ 527 FALSE, /* pc_relative */ 528 0, /* bitpos */ 529 complain_overflow_dont, /* complain_on_overflow */ 530 ppc64_elf_unhandled_reloc, /* special_function */ 531 "R_PPC64_GLOB_DAT", /* name */ 532 FALSE, /* partial_inplace */ 533 0, /* src_mask */ 534 ONES (64), /* dst_mask */ 535 FALSE), /* pcrel_offset */ 536 537 /* Created by the link editor. Marks a procedure linkage table 538 entry for a symbol. */ 539 HOWTO (R_PPC64_JMP_SLOT, /* type */ 540 0, /* rightshift */ 541 0, /* size (0 = byte, 1 = short, 2 = long) */ 542 0, /* bitsize */ 543 FALSE, /* pc_relative */ 544 0, /* bitpos */ 545 complain_overflow_dont, /* complain_on_overflow */ 546 ppc64_elf_unhandled_reloc, /* special_function */ 547 "R_PPC64_JMP_SLOT", /* name */ 548 FALSE, /* partial_inplace */ 549 0, /* src_mask */ 550 0, /* dst_mask */ 551 FALSE), /* pcrel_offset */ 552 553 /* Used only by the dynamic linker. When the object is run, this 554 doubleword64 is set to the load address of the object, plus the 555 addend. */ 556 HOWTO (R_PPC64_RELATIVE, /* type */ 557 0, /* rightshift */ 558 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 559 64, /* bitsize */ 560 FALSE, /* pc_relative */ 561 0, /* bitpos */ 562 complain_overflow_dont, /* complain_on_overflow */ 563 bfd_elf_generic_reloc, /* special_function */ 564 "R_PPC64_RELATIVE", /* name */ 565 FALSE, /* partial_inplace */ 566 0, /* src_mask */ 567 ONES (64), /* dst_mask */ 568 FALSE), /* pcrel_offset */ 569 570 /* Like R_PPC64_ADDR32, but may be unaligned. */ 571 HOWTO (R_PPC64_UADDR32, /* type */ 572 0, /* rightshift */ 573 2, /* size (0 = byte, 1 = short, 2 = long) */ 574 32, /* bitsize */ 575 FALSE, /* pc_relative */ 576 0, /* bitpos */ 577 complain_overflow_bitfield, /* complain_on_overflow */ 578 bfd_elf_generic_reloc, /* special_function */ 579 "R_PPC64_UADDR32", /* name */ 580 FALSE, /* partial_inplace */ 581 0, /* src_mask */ 582 0xffffffff, /* dst_mask */ 583 FALSE), /* pcrel_offset */ 584 585 /* Like R_PPC64_ADDR16, but may be unaligned. */ 586 HOWTO (R_PPC64_UADDR16, /* type */ 587 0, /* rightshift */ 588 1, /* size (0 = byte, 1 = short, 2 = long) */ 589 16, /* bitsize */ 590 FALSE, /* pc_relative */ 591 0, /* bitpos */ 592 complain_overflow_bitfield, /* complain_on_overflow */ 593 bfd_elf_generic_reloc, /* special_function */ 594 "R_PPC64_UADDR16", /* name */ 595 FALSE, /* partial_inplace */ 596 0, /* src_mask */ 597 0xffff, /* dst_mask */ 598 FALSE), /* pcrel_offset */ 599 600 /* 32-bit PC relative. */ 601 HOWTO (R_PPC64_REL32, /* type */ 602 0, /* rightshift */ 603 2, /* size (0 = byte, 1 = short, 2 = long) */ 604 32, /* bitsize */ 605 TRUE, /* pc_relative */ 606 0, /* bitpos */ 607 /* FIXME: Verify. Was complain_overflow_bitfield. */ 608 complain_overflow_signed, /* complain_on_overflow */ 609 bfd_elf_generic_reloc, /* special_function */ 610 "R_PPC64_REL32", /* name */ 611 FALSE, /* partial_inplace */ 612 0, /* src_mask */ 613 0xffffffff, /* dst_mask */ 614 TRUE), /* pcrel_offset */ 615 616 /* 32-bit relocation to the symbol's procedure linkage table. */ 617 HOWTO (R_PPC64_PLT32, /* type */ 618 0, /* rightshift */ 619 2, /* size (0 = byte, 1 = short, 2 = long) */ 620 32, /* bitsize */ 621 FALSE, /* pc_relative */ 622 0, /* bitpos */ 623 complain_overflow_bitfield, /* complain_on_overflow */ 624 ppc64_elf_unhandled_reloc, /* special_function */ 625 "R_PPC64_PLT32", /* name */ 626 FALSE, /* partial_inplace */ 627 0, /* src_mask */ 628 0xffffffff, /* dst_mask */ 629 FALSE), /* pcrel_offset */ 630 631 /* 32-bit PC relative relocation to the symbol's procedure linkage table. 632 FIXME: R_PPC64_PLTREL32 not supported. */ 633 HOWTO (R_PPC64_PLTREL32, /* type */ 634 0, /* rightshift */ 635 2, /* size (0 = byte, 1 = short, 2 = long) */ 636 32, /* bitsize */ 637 TRUE, /* pc_relative */ 638 0, /* bitpos */ 639 complain_overflow_signed, /* complain_on_overflow */ 640 bfd_elf_generic_reloc, /* special_function */ 641 "R_PPC64_PLTREL32", /* name */ 642 FALSE, /* partial_inplace */ 643 0, /* src_mask */ 644 0xffffffff, /* dst_mask */ 645 TRUE), /* pcrel_offset */ 646 647 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for 648 the symbol. */ 649 HOWTO (R_PPC64_PLT16_LO, /* type */ 650 0, /* rightshift */ 651 1, /* size (0 = byte, 1 = short, 2 = long) */ 652 16, /* bitsize */ 653 FALSE, /* pc_relative */ 654 0, /* bitpos */ 655 complain_overflow_dont, /* complain_on_overflow */ 656 ppc64_elf_unhandled_reloc, /* special_function */ 657 "R_PPC64_PLT16_LO", /* name */ 658 FALSE, /* partial_inplace */ 659 0, /* src_mask */ 660 0xffff, /* dst_mask */ 661 FALSE), /* pcrel_offset */ 662 663 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for 664 the symbol. */ 665 HOWTO (R_PPC64_PLT16_HI, /* type */ 666 16, /* rightshift */ 667 1, /* size (0 = byte, 1 = short, 2 = long) */ 668 16, /* bitsize */ 669 FALSE, /* pc_relative */ 670 0, /* bitpos */ 671 complain_overflow_dont, /* complain_on_overflow */ 672 ppc64_elf_unhandled_reloc, /* special_function */ 673 "R_PPC64_PLT16_HI", /* name */ 674 FALSE, /* partial_inplace */ 675 0, /* src_mask */ 676 0xffff, /* dst_mask */ 677 FALSE), /* pcrel_offset */ 678 679 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for 680 the symbol. */ 681 HOWTO (R_PPC64_PLT16_HA, /* type */ 682 16, /* rightshift */ 683 1, /* size (0 = byte, 1 = short, 2 = long) */ 684 16, /* bitsize */ 685 FALSE, /* pc_relative */ 686 0, /* bitpos */ 687 complain_overflow_dont, /* complain_on_overflow */ 688 ppc64_elf_unhandled_reloc, /* special_function */ 689 "R_PPC64_PLT16_HA", /* name */ 690 FALSE, /* partial_inplace */ 691 0, /* src_mask */ 692 0xffff, /* dst_mask */ 693 FALSE), /* pcrel_offset */ 694 695 /* 16-bit section relative relocation. */ 696 HOWTO (R_PPC64_SECTOFF, /* type */ 697 0, /* rightshift */ 698 1, /* size (0 = byte, 1 = short, 2 = long) */ 699 16, /* bitsize */ 700 FALSE, /* pc_relative */ 701 0, /* bitpos */ 702 complain_overflow_bitfield, /* complain_on_overflow */ 703 ppc64_elf_sectoff_reloc, /* special_function */ 704 "R_PPC64_SECTOFF", /* name */ 705 FALSE, /* partial_inplace */ 706 0, /* src_mask */ 707 0xffff, /* dst_mask */ 708 FALSE), /* pcrel_offset */ 709 710 /* Like R_PPC64_SECTOFF, but no overflow warning. */ 711 HOWTO (R_PPC64_SECTOFF_LO, /* type */ 712 0, /* rightshift */ 713 1, /* size (0 = byte, 1 = short, 2 = long) */ 714 16, /* bitsize */ 715 FALSE, /* pc_relative */ 716 0, /* bitpos */ 717 complain_overflow_dont, /* complain_on_overflow */ 718 ppc64_elf_sectoff_reloc, /* special_function */ 719 "R_PPC64_SECTOFF_LO", /* name */ 720 FALSE, /* partial_inplace */ 721 0, /* src_mask */ 722 0xffff, /* dst_mask */ 723 FALSE), /* pcrel_offset */ 724 725 /* 16-bit upper half section relative relocation. */ 726 HOWTO (R_PPC64_SECTOFF_HI, /* type */ 727 16, /* rightshift */ 728 1, /* size (0 = byte, 1 = short, 2 = long) */ 729 16, /* bitsize */ 730 FALSE, /* pc_relative */ 731 0, /* bitpos */ 732 complain_overflow_dont, /* complain_on_overflow */ 733 ppc64_elf_sectoff_reloc, /* special_function */ 734 "R_PPC64_SECTOFF_HI", /* name */ 735 FALSE, /* partial_inplace */ 736 0, /* src_mask */ 737 0xffff, /* dst_mask */ 738 FALSE), /* pcrel_offset */ 739 740 /* 16-bit upper half adjusted section relative relocation. */ 741 HOWTO (R_PPC64_SECTOFF_HA, /* type */ 742 16, /* rightshift */ 743 1, /* size (0 = byte, 1 = short, 2 = long) */ 744 16, /* bitsize */ 745 FALSE, /* pc_relative */ 746 0, /* bitpos */ 747 complain_overflow_dont, /* complain_on_overflow */ 748 ppc64_elf_sectoff_ha_reloc, /* special_function */ 749 "R_PPC64_SECTOFF_HA", /* name */ 750 FALSE, /* partial_inplace */ 751 0, /* src_mask */ 752 0xffff, /* dst_mask */ 753 FALSE), /* pcrel_offset */ 754 755 /* Like R_PPC64_REL24 without touching the two least significant bits. */ 756 HOWTO (R_PPC64_REL30, /* type */ 757 2, /* rightshift */ 758 2, /* size (0 = byte, 1 = short, 2 = long) */ 759 30, /* bitsize */ 760 TRUE, /* pc_relative */ 761 0, /* bitpos */ 762 complain_overflow_dont, /* complain_on_overflow */ 763 bfd_elf_generic_reloc, /* special_function */ 764 "R_PPC64_REL30", /* name */ 765 FALSE, /* partial_inplace */ 766 0, /* src_mask */ 767 0xfffffffc, /* dst_mask */ 768 TRUE), /* pcrel_offset */ 769 770 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */ 771 772 /* A standard 64-bit relocation. */ 773 HOWTO (R_PPC64_ADDR64, /* type */ 774 0, /* rightshift */ 775 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 776 64, /* bitsize */ 777 FALSE, /* pc_relative */ 778 0, /* bitpos */ 779 complain_overflow_dont, /* complain_on_overflow */ 780 bfd_elf_generic_reloc, /* special_function */ 781 "R_PPC64_ADDR64", /* name */ 782 FALSE, /* partial_inplace */ 783 0, /* src_mask */ 784 ONES (64), /* dst_mask */ 785 FALSE), /* pcrel_offset */ 786 787 /* The bits 32-47 of an address. */ 788 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */ 789 32, /* rightshift */ 790 1, /* size (0 = byte, 1 = short, 2 = long) */ 791 16, /* bitsize */ 792 FALSE, /* pc_relative */ 793 0, /* bitpos */ 794 complain_overflow_dont, /* complain_on_overflow */ 795 bfd_elf_generic_reloc, /* special_function */ 796 "R_PPC64_ADDR16_HIGHER", /* name */ 797 FALSE, /* partial_inplace */ 798 0, /* src_mask */ 799 0xffff, /* dst_mask */ 800 FALSE), /* pcrel_offset */ 801 802 /* The bits 32-47 of an address, plus 1 if the contents of the low 803 16 bits, treated as a signed number, is negative. */ 804 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */ 805 32, /* rightshift */ 806 1, /* size (0 = byte, 1 = short, 2 = long) */ 807 16, /* bitsize */ 808 FALSE, /* pc_relative */ 809 0, /* bitpos */ 810 complain_overflow_dont, /* complain_on_overflow */ 811 ppc64_elf_ha_reloc, /* special_function */ 812 "R_PPC64_ADDR16_HIGHERA", /* name */ 813 FALSE, /* partial_inplace */ 814 0, /* src_mask */ 815 0xffff, /* dst_mask */ 816 FALSE), /* pcrel_offset */ 817 818 /* The bits 48-63 of an address. */ 819 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */ 820 48, /* rightshift */ 821 1, /* size (0 = byte, 1 = short, 2 = long) */ 822 16, /* bitsize */ 823 FALSE, /* pc_relative */ 824 0, /* bitpos */ 825 complain_overflow_dont, /* complain_on_overflow */ 826 bfd_elf_generic_reloc, /* special_function */ 827 "R_PPC64_ADDR16_HIGHEST", /* name */ 828 FALSE, /* partial_inplace */ 829 0, /* src_mask */ 830 0xffff, /* dst_mask */ 831 FALSE), /* pcrel_offset */ 832 833 /* The bits 48-63 of an address, plus 1 if the contents of the low 834 16 bits, treated as a signed number, is negative. */ 835 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */ 836 48, /* rightshift */ 837 1, /* size (0 = byte, 1 = short, 2 = long) */ 838 16, /* bitsize */ 839 FALSE, /* pc_relative */ 840 0, /* bitpos */ 841 complain_overflow_dont, /* complain_on_overflow */ 842 ppc64_elf_ha_reloc, /* special_function */ 843 "R_PPC64_ADDR16_HIGHESTA", /* name */ 844 FALSE, /* partial_inplace */ 845 0, /* src_mask */ 846 0xffff, /* dst_mask */ 847 FALSE), /* pcrel_offset */ 848 849 /* Like ADDR64, but may be unaligned. */ 850 HOWTO (R_PPC64_UADDR64, /* type */ 851 0, /* rightshift */ 852 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 853 64, /* bitsize */ 854 FALSE, /* pc_relative */ 855 0, /* bitpos */ 856 complain_overflow_dont, /* complain_on_overflow */ 857 bfd_elf_generic_reloc, /* special_function */ 858 "R_PPC64_UADDR64", /* name */ 859 FALSE, /* partial_inplace */ 860 0, /* src_mask */ 861 ONES (64), /* dst_mask */ 862 FALSE), /* pcrel_offset */ 863 864 /* 64-bit relative relocation. */ 865 HOWTO (R_PPC64_REL64, /* type */ 866 0, /* rightshift */ 867 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 868 64, /* bitsize */ 869 TRUE, /* pc_relative */ 870 0, /* bitpos */ 871 complain_overflow_dont, /* complain_on_overflow */ 872 bfd_elf_generic_reloc, /* special_function */ 873 "R_PPC64_REL64", /* name */ 874 FALSE, /* partial_inplace */ 875 0, /* src_mask */ 876 ONES (64), /* dst_mask */ 877 TRUE), /* pcrel_offset */ 878 879 /* 64-bit relocation to the symbol's procedure linkage table. */ 880 HOWTO (R_PPC64_PLT64, /* type */ 881 0, /* rightshift */ 882 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 883 64, /* bitsize */ 884 FALSE, /* pc_relative */ 885 0, /* bitpos */ 886 complain_overflow_dont, /* complain_on_overflow */ 887 ppc64_elf_unhandled_reloc, /* special_function */ 888 "R_PPC64_PLT64", /* name */ 889 FALSE, /* partial_inplace */ 890 0, /* src_mask */ 891 ONES (64), /* dst_mask */ 892 FALSE), /* pcrel_offset */ 893 894 /* 64-bit PC relative relocation to the symbol's procedure linkage 895 table. */ 896 /* FIXME: R_PPC64_PLTREL64 not supported. */ 897 HOWTO (R_PPC64_PLTREL64, /* type */ 898 0, /* rightshift */ 899 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 900 64, /* bitsize */ 901 TRUE, /* pc_relative */ 902 0, /* bitpos */ 903 complain_overflow_dont, /* complain_on_overflow */ 904 ppc64_elf_unhandled_reloc, /* special_function */ 905 "R_PPC64_PLTREL64", /* name */ 906 FALSE, /* partial_inplace */ 907 0, /* src_mask */ 908 ONES (64), /* dst_mask */ 909 TRUE), /* pcrel_offset */ 910 911 /* 16 bit TOC-relative relocation. */ 912 913 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */ 914 HOWTO (R_PPC64_TOC16, /* type */ 915 0, /* rightshift */ 916 1, /* size (0 = byte, 1 = short, 2 = long) */ 917 16, /* bitsize */ 918 FALSE, /* pc_relative */ 919 0, /* bitpos */ 920 complain_overflow_signed, /* complain_on_overflow */ 921 ppc64_elf_toc_reloc, /* special_function */ 922 "R_PPC64_TOC16", /* name */ 923 FALSE, /* partial_inplace */ 924 0, /* src_mask */ 925 0xffff, /* dst_mask */ 926 FALSE), /* pcrel_offset */ 927 928 /* 16 bit TOC-relative relocation without overflow. */ 929 930 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */ 931 HOWTO (R_PPC64_TOC16_LO, /* type */ 932 0, /* rightshift */ 933 1, /* size (0 = byte, 1 = short, 2 = long) */ 934 16, /* bitsize */ 935 FALSE, /* pc_relative */ 936 0, /* bitpos */ 937 complain_overflow_dont, /* complain_on_overflow */ 938 ppc64_elf_toc_reloc, /* special_function */ 939 "R_PPC64_TOC16_LO", /* name */ 940 FALSE, /* partial_inplace */ 941 0, /* src_mask */ 942 0xffff, /* dst_mask */ 943 FALSE), /* pcrel_offset */ 944 945 /* 16 bit TOC-relative relocation, high 16 bits. */ 946 947 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */ 948 HOWTO (R_PPC64_TOC16_HI, /* type */ 949 16, /* rightshift */ 950 1, /* size (0 = byte, 1 = short, 2 = long) */ 951 16, /* bitsize */ 952 FALSE, /* pc_relative */ 953 0, /* bitpos */ 954 complain_overflow_dont, /* complain_on_overflow */ 955 ppc64_elf_toc_reloc, /* special_function */ 956 "R_PPC64_TOC16_HI", /* name */ 957 FALSE, /* partial_inplace */ 958 0, /* src_mask */ 959 0xffff, /* dst_mask */ 960 FALSE), /* pcrel_offset */ 961 962 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the 963 contents of the low 16 bits, treated as a signed number, is 964 negative. */ 965 966 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */ 967 HOWTO (R_PPC64_TOC16_HA, /* type */ 968 16, /* rightshift */ 969 1, /* size (0 = byte, 1 = short, 2 = long) */ 970 16, /* bitsize */ 971 FALSE, /* pc_relative */ 972 0, /* bitpos */ 973 complain_overflow_dont, /* complain_on_overflow */ 974 ppc64_elf_toc_ha_reloc, /* special_function */ 975 "R_PPC64_TOC16_HA", /* name */ 976 FALSE, /* partial_inplace */ 977 0, /* src_mask */ 978 0xffff, /* dst_mask */ 979 FALSE), /* pcrel_offset */ 980 981 /* 64-bit relocation; insert value of TOC base (.TOC.). */ 982 983 /* R_PPC64_TOC 51 doubleword64 .TOC. */ 984 HOWTO (R_PPC64_TOC, /* type */ 985 0, /* rightshift */ 986 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 987 64, /* bitsize */ 988 FALSE, /* pc_relative */ 989 0, /* bitpos */ 990 complain_overflow_bitfield, /* complain_on_overflow */ 991 ppc64_elf_toc64_reloc, /* special_function */ 992 "R_PPC64_TOC", /* name */ 993 FALSE, /* partial_inplace */ 994 0, /* src_mask */ 995 ONES (64), /* dst_mask */ 996 FALSE), /* pcrel_offset */ 997 998 /* Like R_PPC64_GOT16, but also informs the link editor that the 999 value to relocate may (!) refer to a PLT entry which the link 1000 editor (a) may replace with the symbol value. If the link editor 1001 is unable to fully resolve the symbol, it may (b) create a PLT 1002 entry and store the address to the new PLT entry in the GOT. 1003 This permits lazy resolution of function symbols at run time. 1004 The link editor may also skip all of this and just (c) emit a 1005 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */ 1006 /* FIXME: R_PPC64_PLTGOT16 not implemented. */ 1007 HOWTO (R_PPC64_PLTGOT16, /* type */ 1008 0, /* rightshift */ 1009 1, /* size (0 = byte, 1 = short, 2 = long) */ 1010 16, /* bitsize */ 1011 FALSE, /* pc_relative */ 1012 0, /* bitpos */ 1013 complain_overflow_signed, /* complain_on_overflow */ 1014 ppc64_elf_unhandled_reloc, /* special_function */ 1015 "R_PPC64_PLTGOT16", /* name */ 1016 FALSE, /* partial_inplace */ 1017 0, /* src_mask */ 1018 0xffff, /* dst_mask */ 1019 FALSE), /* pcrel_offset */ 1020 1021 /* Like R_PPC64_PLTGOT16, but without overflow. */ 1022 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */ 1023 HOWTO (R_PPC64_PLTGOT16_LO, /* type */ 1024 0, /* rightshift */ 1025 1, /* size (0 = byte, 1 = short, 2 = long) */ 1026 16, /* bitsize */ 1027 FALSE, /* pc_relative */ 1028 0, /* bitpos */ 1029 complain_overflow_dont, /* complain_on_overflow */ 1030 ppc64_elf_unhandled_reloc, /* special_function */ 1031 "R_PPC64_PLTGOT16_LO", /* name */ 1032 FALSE, /* partial_inplace */ 1033 0, /* src_mask */ 1034 0xffff, /* dst_mask */ 1035 FALSE), /* pcrel_offset */ 1036 1037 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */ 1038 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */ 1039 HOWTO (R_PPC64_PLTGOT16_HI, /* type */ 1040 16, /* rightshift */ 1041 1, /* size (0 = byte, 1 = short, 2 = long) */ 1042 16, /* bitsize */ 1043 FALSE, /* pc_relative */ 1044 0, /* bitpos */ 1045 complain_overflow_dont, /* complain_on_overflow */ 1046 ppc64_elf_unhandled_reloc, /* special_function */ 1047 "R_PPC64_PLTGOT16_HI", /* name */ 1048 FALSE, /* partial_inplace */ 1049 0, /* src_mask */ 1050 0xffff, /* dst_mask */ 1051 FALSE), /* pcrel_offset */ 1052 1053 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus 1054 1 if the contents of the low 16 bits, treated as a signed number, 1055 is negative. */ 1056 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */ 1057 HOWTO (R_PPC64_PLTGOT16_HA, /* type */ 1058 16, /* rightshift */ 1059 1, /* size (0 = byte, 1 = short, 2 = long) */ 1060 16, /* bitsize */ 1061 FALSE, /* pc_relative */ 1062 0, /* bitpos */ 1063 complain_overflow_dont,/* complain_on_overflow */ 1064 ppc64_elf_unhandled_reloc, /* special_function */ 1065 "R_PPC64_PLTGOT16_HA", /* name */ 1066 FALSE, /* partial_inplace */ 1067 0, /* src_mask */ 1068 0xffff, /* dst_mask */ 1069 FALSE), /* pcrel_offset */ 1070 1071 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */ 1072 HOWTO (R_PPC64_ADDR16_DS, /* type */ 1073 0, /* rightshift */ 1074 1, /* size (0 = byte, 1 = short, 2 = long) */ 1075 16, /* bitsize */ 1076 FALSE, /* pc_relative */ 1077 0, /* bitpos */ 1078 complain_overflow_bitfield, /* complain_on_overflow */ 1079 bfd_elf_generic_reloc, /* special_function */ 1080 "R_PPC64_ADDR16_DS", /* name */ 1081 FALSE, /* partial_inplace */ 1082 0, /* src_mask */ 1083 0xfffc, /* dst_mask */ 1084 FALSE), /* pcrel_offset */ 1085 1086 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */ 1087 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */ 1088 0, /* rightshift */ 1089 1, /* size (0 = byte, 1 = short, 2 = long) */ 1090 16, /* bitsize */ 1091 FALSE, /* pc_relative */ 1092 0, /* bitpos */ 1093 complain_overflow_dont,/* complain_on_overflow */ 1094 bfd_elf_generic_reloc, /* special_function */ 1095 "R_PPC64_ADDR16_LO_DS",/* name */ 1096 FALSE, /* partial_inplace */ 1097 0, /* src_mask */ 1098 0xfffc, /* dst_mask */ 1099 FALSE), /* pcrel_offset */ 1100 1101 /* Like R_PPC64_GOT16, but for instructions with a DS field. */ 1102 HOWTO (R_PPC64_GOT16_DS, /* type */ 1103 0, /* rightshift */ 1104 1, /* size (0 = byte, 1 = short, 2 = long) */ 1105 16, /* bitsize */ 1106 FALSE, /* pc_relative */ 1107 0, /* bitpos */ 1108 complain_overflow_signed, /* complain_on_overflow */ 1109 ppc64_elf_unhandled_reloc, /* special_function */ 1110 "R_PPC64_GOT16_DS", /* name */ 1111 FALSE, /* partial_inplace */ 1112 0, /* src_mask */ 1113 0xfffc, /* dst_mask */ 1114 FALSE), /* pcrel_offset */ 1115 1116 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */ 1117 HOWTO (R_PPC64_GOT16_LO_DS, /* type */ 1118 0, /* rightshift */ 1119 1, /* size (0 = byte, 1 = short, 2 = long) */ 1120 16, /* bitsize */ 1121 FALSE, /* pc_relative */ 1122 0, /* bitpos */ 1123 complain_overflow_dont, /* complain_on_overflow */ 1124 ppc64_elf_unhandled_reloc, /* special_function */ 1125 "R_PPC64_GOT16_LO_DS", /* name */ 1126 FALSE, /* partial_inplace */ 1127 0, /* src_mask */ 1128 0xfffc, /* dst_mask */ 1129 FALSE), /* pcrel_offset */ 1130 1131 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */ 1132 HOWTO (R_PPC64_PLT16_LO_DS, /* type */ 1133 0, /* rightshift */ 1134 1, /* size (0 = byte, 1 = short, 2 = long) */ 1135 16, /* bitsize */ 1136 FALSE, /* pc_relative */ 1137 0, /* bitpos */ 1138 complain_overflow_dont, /* complain_on_overflow */ 1139 ppc64_elf_unhandled_reloc, /* special_function */ 1140 "R_PPC64_PLT16_LO_DS", /* name */ 1141 FALSE, /* partial_inplace */ 1142 0, /* src_mask */ 1143 0xfffc, /* dst_mask */ 1144 FALSE), /* pcrel_offset */ 1145 1146 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */ 1147 HOWTO (R_PPC64_SECTOFF_DS, /* type */ 1148 0, /* rightshift */ 1149 1, /* size (0 = byte, 1 = short, 2 = long) */ 1150 16, /* bitsize */ 1151 FALSE, /* pc_relative */ 1152 0, /* bitpos */ 1153 complain_overflow_bitfield, /* complain_on_overflow */ 1154 ppc64_elf_sectoff_reloc, /* special_function */ 1155 "R_PPC64_SECTOFF_DS", /* name */ 1156 FALSE, /* partial_inplace */ 1157 0, /* src_mask */ 1158 0xfffc, /* dst_mask */ 1159 FALSE), /* pcrel_offset */ 1160 1161 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */ 1162 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */ 1163 0, /* rightshift */ 1164 1, /* size (0 = byte, 1 = short, 2 = long) */ 1165 16, /* bitsize */ 1166 FALSE, /* pc_relative */ 1167 0, /* bitpos */ 1168 complain_overflow_dont, /* complain_on_overflow */ 1169 ppc64_elf_sectoff_reloc, /* special_function */ 1170 "R_PPC64_SECTOFF_LO_DS",/* name */ 1171 FALSE, /* partial_inplace */ 1172 0, /* src_mask */ 1173 0xfffc, /* dst_mask */ 1174 FALSE), /* pcrel_offset */ 1175 1176 /* Like R_PPC64_TOC16, but for instructions with a DS field. */ 1177 HOWTO (R_PPC64_TOC16_DS, /* type */ 1178 0, /* rightshift */ 1179 1, /* size (0 = byte, 1 = short, 2 = long) */ 1180 16, /* bitsize */ 1181 FALSE, /* pc_relative */ 1182 0, /* bitpos */ 1183 complain_overflow_signed, /* complain_on_overflow */ 1184 ppc64_elf_toc_reloc, /* special_function */ 1185 "R_PPC64_TOC16_DS", /* name */ 1186 FALSE, /* partial_inplace */ 1187 0, /* src_mask */ 1188 0xfffc, /* dst_mask */ 1189 FALSE), /* pcrel_offset */ 1190 1191 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */ 1192 HOWTO (R_PPC64_TOC16_LO_DS, /* type */ 1193 0, /* rightshift */ 1194 1, /* size (0 = byte, 1 = short, 2 = long) */ 1195 16, /* bitsize */ 1196 FALSE, /* pc_relative */ 1197 0, /* bitpos */ 1198 complain_overflow_dont, /* complain_on_overflow */ 1199 ppc64_elf_toc_reloc, /* special_function */ 1200 "R_PPC64_TOC16_LO_DS", /* name */ 1201 FALSE, /* partial_inplace */ 1202 0, /* src_mask */ 1203 0xfffc, /* dst_mask */ 1204 FALSE), /* pcrel_offset */ 1205 1206 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */ 1207 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */ 1208 HOWTO (R_PPC64_PLTGOT16_DS, /* type */ 1209 0, /* rightshift */ 1210 1, /* size (0 = byte, 1 = short, 2 = long) */ 1211 16, /* bitsize */ 1212 FALSE, /* pc_relative */ 1213 0, /* bitpos */ 1214 complain_overflow_signed, /* complain_on_overflow */ 1215 ppc64_elf_unhandled_reloc, /* special_function */ 1216 "R_PPC64_PLTGOT16_DS", /* name */ 1217 FALSE, /* partial_inplace */ 1218 0, /* src_mask */ 1219 0xfffc, /* dst_mask */ 1220 FALSE), /* pcrel_offset */ 1221 1222 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */ 1223 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */ 1224 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */ 1225 0, /* rightshift */ 1226 1, /* size (0 = byte, 1 = short, 2 = long) */ 1227 16, /* bitsize */ 1228 FALSE, /* pc_relative */ 1229 0, /* bitpos */ 1230 complain_overflow_dont, /* complain_on_overflow */ 1231 ppc64_elf_unhandled_reloc, /* special_function */ 1232 "R_PPC64_PLTGOT16_LO_DS",/* name */ 1233 FALSE, /* partial_inplace */ 1234 0, /* src_mask */ 1235 0xfffc, /* dst_mask */ 1236 FALSE), /* pcrel_offset */ 1237 1238 /* Marker reloc for TLS. */ 1239 HOWTO (R_PPC64_TLS, 1240 0, /* rightshift */ 1241 2, /* size (0 = byte, 1 = short, 2 = long) */ 1242 32, /* bitsize */ 1243 FALSE, /* pc_relative */ 1244 0, /* bitpos */ 1245 complain_overflow_dont, /* complain_on_overflow */ 1246 bfd_elf_generic_reloc, /* special_function */ 1247 "R_PPC64_TLS", /* name */ 1248 FALSE, /* partial_inplace */ 1249 0, /* src_mask */ 1250 0, /* dst_mask */ 1251 FALSE), /* pcrel_offset */ 1252 1253 /* Computes the load module index of the load module that contains the 1254 definition of its TLS sym. */ 1255 HOWTO (R_PPC64_DTPMOD64, 1256 0, /* rightshift */ 1257 4, /* size (0 = byte, 1 = short, 2 = long) */ 1258 64, /* bitsize */ 1259 FALSE, /* pc_relative */ 1260 0, /* bitpos */ 1261 complain_overflow_dont, /* complain_on_overflow */ 1262 ppc64_elf_unhandled_reloc, /* special_function */ 1263 "R_PPC64_DTPMOD64", /* name */ 1264 FALSE, /* partial_inplace */ 1265 0, /* src_mask */ 1266 ONES (64), /* dst_mask */ 1267 FALSE), /* pcrel_offset */ 1268 1269 /* Computes a dtv-relative displacement, the difference between the value 1270 of sym+add and the base address of the thread-local storage block that 1271 contains the definition of sym, minus 0x8000. */ 1272 HOWTO (R_PPC64_DTPREL64, 1273 0, /* rightshift */ 1274 4, /* size (0 = byte, 1 = short, 2 = long) */ 1275 64, /* bitsize */ 1276 FALSE, /* pc_relative */ 1277 0, /* bitpos */ 1278 complain_overflow_dont, /* complain_on_overflow */ 1279 ppc64_elf_unhandled_reloc, /* special_function */ 1280 "R_PPC64_DTPREL64", /* name */ 1281 FALSE, /* partial_inplace */ 1282 0, /* src_mask */ 1283 ONES (64), /* dst_mask */ 1284 FALSE), /* pcrel_offset */ 1285 1286 /* A 16 bit dtprel reloc. */ 1287 HOWTO (R_PPC64_DTPREL16, 1288 0, /* rightshift */ 1289 1, /* size (0 = byte, 1 = short, 2 = long) */ 1290 16, /* bitsize */ 1291 FALSE, /* pc_relative */ 1292 0, /* bitpos */ 1293 complain_overflow_signed, /* complain_on_overflow */ 1294 ppc64_elf_unhandled_reloc, /* special_function */ 1295 "R_PPC64_DTPREL16", /* name */ 1296 FALSE, /* partial_inplace */ 1297 0, /* src_mask */ 1298 0xffff, /* dst_mask */ 1299 FALSE), /* pcrel_offset */ 1300 1301 /* Like DTPREL16, but no overflow. */ 1302 HOWTO (R_PPC64_DTPREL16_LO, 1303 0, /* rightshift */ 1304 1, /* size (0 = byte, 1 = short, 2 = long) */ 1305 16, /* bitsize */ 1306 FALSE, /* pc_relative */ 1307 0, /* bitpos */ 1308 complain_overflow_dont, /* complain_on_overflow */ 1309 ppc64_elf_unhandled_reloc, /* special_function */ 1310 "R_PPC64_DTPREL16_LO", /* name */ 1311 FALSE, /* partial_inplace */ 1312 0, /* src_mask */ 1313 0xffff, /* dst_mask */ 1314 FALSE), /* pcrel_offset */ 1315 1316 /* Like DTPREL16_LO, but next higher group of 16 bits. */ 1317 HOWTO (R_PPC64_DTPREL16_HI, 1318 16, /* rightshift */ 1319 1, /* size (0 = byte, 1 = short, 2 = long) */ 1320 16, /* bitsize */ 1321 FALSE, /* pc_relative */ 1322 0, /* bitpos */ 1323 complain_overflow_dont, /* complain_on_overflow */ 1324 ppc64_elf_unhandled_reloc, /* special_function */ 1325 "R_PPC64_DTPREL16_HI", /* name */ 1326 FALSE, /* partial_inplace */ 1327 0, /* src_mask */ 1328 0xffff, /* dst_mask */ 1329 FALSE), /* pcrel_offset */ 1330 1331 /* Like DTPREL16_HI, but adjust for low 16 bits. */ 1332 HOWTO (R_PPC64_DTPREL16_HA, 1333 16, /* rightshift */ 1334 1, /* size (0 = byte, 1 = short, 2 = long) */ 1335 16, /* bitsize */ 1336 FALSE, /* pc_relative */ 1337 0, /* bitpos */ 1338 complain_overflow_dont, /* complain_on_overflow */ 1339 ppc64_elf_unhandled_reloc, /* special_function */ 1340 "R_PPC64_DTPREL16_HA", /* name */ 1341 FALSE, /* partial_inplace */ 1342 0, /* src_mask */ 1343 0xffff, /* dst_mask */ 1344 FALSE), /* pcrel_offset */ 1345 1346 /* Like DTPREL16_HI, but next higher group of 16 bits. */ 1347 HOWTO (R_PPC64_DTPREL16_HIGHER, 1348 32, /* rightshift */ 1349 1, /* size (0 = byte, 1 = short, 2 = long) */ 1350 16, /* bitsize */ 1351 FALSE, /* pc_relative */ 1352 0, /* bitpos */ 1353 complain_overflow_dont, /* complain_on_overflow */ 1354 ppc64_elf_unhandled_reloc, /* special_function */ 1355 "R_PPC64_DTPREL16_HIGHER", /* name */ 1356 FALSE, /* partial_inplace */ 1357 0, /* src_mask */ 1358 0xffff, /* dst_mask */ 1359 FALSE), /* pcrel_offset */ 1360 1361 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */ 1362 HOWTO (R_PPC64_DTPREL16_HIGHERA, 1363 32, /* rightshift */ 1364 1, /* size (0 = byte, 1 = short, 2 = long) */ 1365 16, /* bitsize */ 1366 FALSE, /* pc_relative */ 1367 0, /* bitpos */ 1368 complain_overflow_dont, /* complain_on_overflow */ 1369 ppc64_elf_unhandled_reloc, /* special_function */ 1370 "R_PPC64_DTPREL16_HIGHERA", /* name */ 1371 FALSE, /* partial_inplace */ 1372 0, /* src_mask */ 1373 0xffff, /* dst_mask */ 1374 FALSE), /* pcrel_offset */ 1375 1376 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */ 1377 HOWTO (R_PPC64_DTPREL16_HIGHEST, 1378 48, /* rightshift */ 1379 1, /* size (0 = byte, 1 = short, 2 = long) */ 1380 16, /* bitsize */ 1381 FALSE, /* pc_relative */ 1382 0, /* bitpos */ 1383 complain_overflow_dont, /* complain_on_overflow */ 1384 ppc64_elf_unhandled_reloc, /* special_function */ 1385 "R_PPC64_DTPREL16_HIGHEST", /* name */ 1386 FALSE, /* partial_inplace */ 1387 0, /* src_mask */ 1388 0xffff, /* dst_mask */ 1389 FALSE), /* pcrel_offset */ 1390 1391 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */ 1392 HOWTO (R_PPC64_DTPREL16_HIGHESTA, 1393 48, /* rightshift */ 1394 1, /* size (0 = byte, 1 = short, 2 = long) */ 1395 16, /* bitsize */ 1396 FALSE, /* pc_relative */ 1397 0, /* bitpos */ 1398 complain_overflow_dont, /* complain_on_overflow */ 1399 ppc64_elf_unhandled_reloc, /* special_function */ 1400 "R_PPC64_DTPREL16_HIGHESTA", /* name */ 1401 FALSE, /* partial_inplace */ 1402 0, /* src_mask */ 1403 0xffff, /* dst_mask */ 1404 FALSE), /* pcrel_offset */ 1405 1406 /* Like DTPREL16, but for insns with a DS field. */ 1407 HOWTO (R_PPC64_DTPREL16_DS, 1408 0, /* rightshift */ 1409 1, /* size (0 = byte, 1 = short, 2 = long) */ 1410 16, /* bitsize */ 1411 FALSE, /* pc_relative */ 1412 0, /* bitpos */ 1413 complain_overflow_signed, /* complain_on_overflow */ 1414 ppc64_elf_unhandled_reloc, /* special_function */ 1415 "R_PPC64_DTPREL16_DS", /* name */ 1416 FALSE, /* partial_inplace */ 1417 0, /* src_mask */ 1418 0xfffc, /* dst_mask */ 1419 FALSE), /* pcrel_offset */ 1420 1421 /* Like DTPREL16_DS, but no overflow. */ 1422 HOWTO (R_PPC64_DTPREL16_LO_DS, 1423 0, /* rightshift */ 1424 1, /* size (0 = byte, 1 = short, 2 = long) */ 1425 16, /* bitsize */ 1426 FALSE, /* pc_relative */ 1427 0, /* bitpos */ 1428 complain_overflow_dont, /* complain_on_overflow */ 1429 ppc64_elf_unhandled_reloc, /* special_function */ 1430 "R_PPC64_DTPREL16_LO_DS", /* name */ 1431 FALSE, /* partial_inplace */ 1432 0, /* src_mask */ 1433 0xfffc, /* dst_mask */ 1434 FALSE), /* pcrel_offset */ 1435 1436 /* Computes a tp-relative displacement, the difference between the value of 1437 sym+add and the value of the thread pointer (r13). */ 1438 HOWTO (R_PPC64_TPREL64, 1439 0, /* rightshift */ 1440 4, /* size (0 = byte, 1 = short, 2 = long) */ 1441 64, /* bitsize */ 1442 FALSE, /* pc_relative */ 1443 0, /* bitpos */ 1444 complain_overflow_dont, /* complain_on_overflow */ 1445 ppc64_elf_unhandled_reloc, /* special_function */ 1446 "R_PPC64_TPREL64", /* name */ 1447 FALSE, /* partial_inplace */ 1448 0, /* src_mask */ 1449 ONES (64), /* dst_mask */ 1450 FALSE), /* pcrel_offset */ 1451 1452 /* A 16 bit tprel reloc. */ 1453 HOWTO (R_PPC64_TPREL16, 1454 0, /* rightshift */ 1455 1, /* size (0 = byte, 1 = short, 2 = long) */ 1456 16, /* bitsize */ 1457 FALSE, /* pc_relative */ 1458 0, /* bitpos */ 1459 complain_overflow_signed, /* complain_on_overflow */ 1460 ppc64_elf_unhandled_reloc, /* special_function */ 1461 "R_PPC64_TPREL16", /* name */ 1462 FALSE, /* partial_inplace */ 1463 0, /* src_mask */ 1464 0xffff, /* dst_mask */ 1465 FALSE), /* pcrel_offset */ 1466 1467 /* Like TPREL16, but no overflow. */ 1468 HOWTO (R_PPC64_TPREL16_LO, 1469 0, /* rightshift */ 1470 1, /* size (0 = byte, 1 = short, 2 = long) */ 1471 16, /* bitsize */ 1472 FALSE, /* pc_relative */ 1473 0, /* bitpos */ 1474 complain_overflow_dont, /* complain_on_overflow */ 1475 ppc64_elf_unhandled_reloc, /* special_function */ 1476 "R_PPC64_TPREL16_LO", /* name */ 1477 FALSE, /* partial_inplace */ 1478 0, /* src_mask */ 1479 0xffff, /* dst_mask */ 1480 FALSE), /* pcrel_offset */ 1481 1482 /* Like TPREL16_LO, but next higher group of 16 bits. */ 1483 HOWTO (R_PPC64_TPREL16_HI, 1484 16, /* rightshift */ 1485 1, /* size (0 = byte, 1 = short, 2 = long) */ 1486 16, /* bitsize */ 1487 FALSE, /* pc_relative */ 1488 0, /* bitpos */ 1489 complain_overflow_dont, /* complain_on_overflow */ 1490 ppc64_elf_unhandled_reloc, /* special_function */ 1491 "R_PPC64_TPREL16_HI", /* name */ 1492 FALSE, /* partial_inplace */ 1493 0, /* src_mask */ 1494 0xffff, /* dst_mask */ 1495 FALSE), /* pcrel_offset */ 1496 1497 /* Like TPREL16_HI, but adjust for low 16 bits. */ 1498 HOWTO (R_PPC64_TPREL16_HA, 1499 16, /* rightshift */ 1500 1, /* size (0 = byte, 1 = short, 2 = long) */ 1501 16, /* bitsize */ 1502 FALSE, /* pc_relative */ 1503 0, /* bitpos */ 1504 complain_overflow_dont, /* complain_on_overflow */ 1505 ppc64_elf_unhandled_reloc, /* special_function */ 1506 "R_PPC64_TPREL16_HA", /* name */ 1507 FALSE, /* partial_inplace */ 1508 0, /* src_mask */ 1509 0xffff, /* dst_mask */ 1510 FALSE), /* pcrel_offset */ 1511 1512 /* Like TPREL16_HI, but next higher group of 16 bits. */ 1513 HOWTO (R_PPC64_TPREL16_HIGHER, 1514 32, /* rightshift */ 1515 1, /* size (0 = byte, 1 = short, 2 = long) */ 1516 16, /* bitsize */ 1517 FALSE, /* pc_relative */ 1518 0, /* bitpos */ 1519 complain_overflow_dont, /* complain_on_overflow */ 1520 ppc64_elf_unhandled_reloc, /* special_function */ 1521 "R_PPC64_TPREL16_HIGHER", /* name */ 1522 FALSE, /* partial_inplace */ 1523 0, /* src_mask */ 1524 0xffff, /* dst_mask */ 1525 FALSE), /* pcrel_offset */ 1526 1527 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */ 1528 HOWTO (R_PPC64_TPREL16_HIGHERA, 1529 32, /* rightshift */ 1530 1, /* size (0 = byte, 1 = short, 2 = long) */ 1531 16, /* bitsize */ 1532 FALSE, /* pc_relative */ 1533 0, /* bitpos */ 1534 complain_overflow_dont, /* complain_on_overflow */ 1535 ppc64_elf_unhandled_reloc, /* special_function */ 1536 "R_PPC64_TPREL16_HIGHERA", /* name */ 1537 FALSE, /* partial_inplace */ 1538 0, /* src_mask */ 1539 0xffff, /* dst_mask */ 1540 FALSE), /* pcrel_offset */ 1541 1542 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */ 1543 HOWTO (R_PPC64_TPREL16_HIGHEST, 1544 48, /* rightshift */ 1545 1, /* size (0 = byte, 1 = short, 2 = long) */ 1546 16, /* bitsize */ 1547 FALSE, /* pc_relative */ 1548 0, /* bitpos */ 1549 complain_overflow_dont, /* complain_on_overflow */ 1550 ppc64_elf_unhandled_reloc, /* special_function */ 1551 "R_PPC64_TPREL16_HIGHEST", /* name */ 1552 FALSE, /* partial_inplace */ 1553 0, /* src_mask */ 1554 0xffff, /* dst_mask */ 1555 FALSE), /* pcrel_offset */ 1556 1557 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */ 1558 HOWTO (R_PPC64_TPREL16_HIGHESTA, 1559 48, /* rightshift */ 1560 1, /* size (0 = byte, 1 = short, 2 = long) */ 1561 16, /* bitsize */ 1562 FALSE, /* pc_relative */ 1563 0, /* bitpos */ 1564 complain_overflow_dont, /* complain_on_overflow */ 1565 ppc64_elf_unhandled_reloc, /* special_function */ 1566 "R_PPC64_TPREL16_HIGHESTA", /* name */ 1567 FALSE, /* partial_inplace */ 1568 0, /* src_mask */ 1569 0xffff, /* dst_mask */ 1570 FALSE), /* pcrel_offset */ 1571 1572 /* Like TPREL16, but for insns with a DS field. */ 1573 HOWTO (R_PPC64_TPREL16_DS, 1574 0, /* rightshift */ 1575 1, /* size (0 = byte, 1 = short, 2 = long) */ 1576 16, /* bitsize */ 1577 FALSE, /* pc_relative */ 1578 0, /* bitpos */ 1579 complain_overflow_signed, /* complain_on_overflow */ 1580 ppc64_elf_unhandled_reloc, /* special_function */ 1581 "R_PPC64_TPREL16_DS", /* name */ 1582 FALSE, /* partial_inplace */ 1583 0, /* src_mask */ 1584 0xfffc, /* dst_mask */ 1585 FALSE), /* pcrel_offset */ 1586 1587 /* Like TPREL16_DS, but no overflow. */ 1588 HOWTO (R_PPC64_TPREL16_LO_DS, 1589 0, /* rightshift */ 1590 1, /* size (0 = byte, 1 = short, 2 = long) */ 1591 16, /* bitsize */ 1592 FALSE, /* pc_relative */ 1593 0, /* bitpos */ 1594 complain_overflow_dont, /* complain_on_overflow */ 1595 ppc64_elf_unhandled_reloc, /* special_function */ 1596 "R_PPC64_TPREL16_LO_DS", /* name */ 1597 FALSE, /* partial_inplace */ 1598 0, /* src_mask */ 1599 0xfffc, /* dst_mask */ 1600 FALSE), /* pcrel_offset */ 1601 1602 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 1603 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset 1604 to the first entry relative to the TOC base (r2). */ 1605 HOWTO (R_PPC64_GOT_TLSGD16, 1606 0, /* rightshift */ 1607 1, /* size (0 = byte, 1 = short, 2 = long) */ 1608 16, /* bitsize */ 1609 FALSE, /* pc_relative */ 1610 0, /* bitpos */ 1611 complain_overflow_signed, /* complain_on_overflow */ 1612 ppc64_elf_unhandled_reloc, /* special_function */ 1613 "R_PPC64_GOT_TLSGD16", /* name */ 1614 FALSE, /* partial_inplace */ 1615 0, /* src_mask */ 1616 0xffff, /* dst_mask */ 1617 FALSE), /* pcrel_offset */ 1618 1619 /* Like GOT_TLSGD16, but no overflow. */ 1620 HOWTO (R_PPC64_GOT_TLSGD16_LO, 1621 0, /* rightshift */ 1622 1, /* size (0 = byte, 1 = short, 2 = long) */ 1623 16, /* bitsize */ 1624 FALSE, /* pc_relative */ 1625 0, /* bitpos */ 1626 complain_overflow_dont, /* complain_on_overflow */ 1627 ppc64_elf_unhandled_reloc, /* special_function */ 1628 "R_PPC64_GOT_TLSGD16_LO", /* name */ 1629 FALSE, /* partial_inplace */ 1630 0, /* src_mask */ 1631 0xffff, /* dst_mask */ 1632 FALSE), /* pcrel_offset */ 1633 1634 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */ 1635 HOWTO (R_PPC64_GOT_TLSGD16_HI, 1636 16, /* rightshift */ 1637 1, /* size (0 = byte, 1 = short, 2 = long) */ 1638 16, /* bitsize */ 1639 FALSE, /* pc_relative */ 1640 0, /* bitpos */ 1641 complain_overflow_dont, /* complain_on_overflow */ 1642 ppc64_elf_unhandled_reloc, /* special_function */ 1643 "R_PPC64_GOT_TLSGD16_HI", /* name */ 1644 FALSE, /* partial_inplace */ 1645 0, /* src_mask */ 1646 0xffff, /* dst_mask */ 1647 FALSE), /* pcrel_offset */ 1648 1649 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */ 1650 HOWTO (R_PPC64_GOT_TLSGD16_HA, 1651 16, /* rightshift */ 1652 1, /* size (0 = byte, 1 = short, 2 = long) */ 1653 16, /* bitsize */ 1654 FALSE, /* pc_relative */ 1655 0, /* bitpos */ 1656 complain_overflow_dont, /* complain_on_overflow */ 1657 ppc64_elf_unhandled_reloc, /* special_function */ 1658 "R_PPC64_GOT_TLSGD16_HA", /* name */ 1659 FALSE, /* partial_inplace */ 1660 0, /* src_mask */ 1661 0xffff, /* dst_mask */ 1662 FALSE), /* pcrel_offset */ 1663 1664 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 1665 with values (sym+add)@dtpmod and zero, and computes the offset to the 1666 first entry relative to the TOC base (r2). */ 1667 HOWTO (R_PPC64_GOT_TLSLD16, 1668 0, /* rightshift */ 1669 1, /* size (0 = byte, 1 = short, 2 = long) */ 1670 16, /* bitsize */ 1671 FALSE, /* pc_relative */ 1672 0, /* bitpos */ 1673 complain_overflow_signed, /* complain_on_overflow */ 1674 ppc64_elf_unhandled_reloc, /* special_function */ 1675 "R_PPC64_GOT_TLSLD16", /* name */ 1676 FALSE, /* partial_inplace */ 1677 0, /* src_mask */ 1678 0xffff, /* dst_mask */ 1679 FALSE), /* pcrel_offset */ 1680 1681 /* Like GOT_TLSLD16, but no overflow. */ 1682 HOWTO (R_PPC64_GOT_TLSLD16_LO, 1683 0, /* rightshift */ 1684 1, /* size (0 = byte, 1 = short, 2 = long) */ 1685 16, /* bitsize */ 1686 FALSE, /* pc_relative */ 1687 0, /* bitpos */ 1688 complain_overflow_dont, /* complain_on_overflow */ 1689 ppc64_elf_unhandled_reloc, /* special_function */ 1690 "R_PPC64_GOT_TLSLD16_LO", /* name */ 1691 FALSE, /* partial_inplace */ 1692 0, /* src_mask */ 1693 0xffff, /* dst_mask */ 1694 FALSE), /* pcrel_offset */ 1695 1696 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */ 1697 HOWTO (R_PPC64_GOT_TLSLD16_HI, 1698 16, /* rightshift */ 1699 1, /* size (0 = byte, 1 = short, 2 = long) */ 1700 16, /* bitsize */ 1701 FALSE, /* pc_relative */ 1702 0, /* bitpos */ 1703 complain_overflow_dont, /* complain_on_overflow */ 1704 ppc64_elf_unhandled_reloc, /* special_function */ 1705 "R_PPC64_GOT_TLSLD16_HI", /* name */ 1706 FALSE, /* partial_inplace */ 1707 0, /* src_mask */ 1708 0xffff, /* dst_mask */ 1709 FALSE), /* pcrel_offset */ 1710 1711 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */ 1712 HOWTO (R_PPC64_GOT_TLSLD16_HA, 1713 16, /* rightshift */ 1714 1, /* size (0 = byte, 1 = short, 2 = long) */ 1715 16, /* bitsize */ 1716 FALSE, /* pc_relative */ 1717 0, /* bitpos */ 1718 complain_overflow_dont, /* complain_on_overflow */ 1719 ppc64_elf_unhandled_reloc, /* special_function */ 1720 "R_PPC64_GOT_TLSLD16_HA", /* name */ 1721 FALSE, /* partial_inplace */ 1722 0, /* src_mask */ 1723 0xffff, /* dst_mask */ 1724 FALSE), /* pcrel_offset */ 1725 1726 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes 1727 the offset to the entry relative to the TOC base (r2). */ 1728 HOWTO (R_PPC64_GOT_DTPREL16_DS, 1729 0, /* rightshift */ 1730 1, /* size (0 = byte, 1 = short, 2 = long) */ 1731 16, /* bitsize */ 1732 FALSE, /* pc_relative */ 1733 0, /* bitpos */ 1734 complain_overflow_signed, /* complain_on_overflow */ 1735 ppc64_elf_unhandled_reloc, /* special_function */ 1736 "R_PPC64_GOT_DTPREL16_DS", /* name */ 1737 FALSE, /* partial_inplace */ 1738 0, /* src_mask */ 1739 0xfffc, /* dst_mask */ 1740 FALSE), /* pcrel_offset */ 1741 1742 /* Like GOT_DTPREL16_DS, but no overflow. */ 1743 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS, 1744 0, /* rightshift */ 1745 1, /* size (0 = byte, 1 = short, 2 = long) */ 1746 16, /* bitsize */ 1747 FALSE, /* pc_relative */ 1748 0, /* bitpos */ 1749 complain_overflow_dont, /* complain_on_overflow */ 1750 ppc64_elf_unhandled_reloc, /* special_function */ 1751 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */ 1752 FALSE, /* partial_inplace */ 1753 0, /* src_mask */ 1754 0xfffc, /* dst_mask */ 1755 FALSE), /* pcrel_offset */ 1756 1757 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */ 1758 HOWTO (R_PPC64_GOT_DTPREL16_HI, 1759 16, /* rightshift */ 1760 1, /* size (0 = byte, 1 = short, 2 = long) */ 1761 16, /* bitsize */ 1762 FALSE, /* pc_relative */ 1763 0, /* bitpos */ 1764 complain_overflow_dont, /* complain_on_overflow */ 1765 ppc64_elf_unhandled_reloc, /* special_function */ 1766 "R_PPC64_GOT_DTPREL16_HI", /* name */ 1767 FALSE, /* partial_inplace */ 1768 0, /* src_mask */ 1769 0xffff, /* dst_mask */ 1770 FALSE), /* pcrel_offset */ 1771 1772 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */ 1773 HOWTO (R_PPC64_GOT_DTPREL16_HA, 1774 16, /* rightshift */ 1775 1, /* size (0 = byte, 1 = short, 2 = long) */ 1776 16, /* bitsize */ 1777 FALSE, /* pc_relative */ 1778 0, /* bitpos */ 1779 complain_overflow_dont, /* complain_on_overflow */ 1780 ppc64_elf_unhandled_reloc, /* special_function */ 1781 "R_PPC64_GOT_DTPREL16_HA", /* name */ 1782 FALSE, /* partial_inplace */ 1783 0, /* src_mask */ 1784 0xffff, /* dst_mask */ 1785 FALSE), /* pcrel_offset */ 1786 1787 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the 1788 offset to the entry relative to the TOC base (r2). */ 1789 HOWTO (R_PPC64_GOT_TPREL16_DS, 1790 0, /* rightshift */ 1791 1, /* size (0 = byte, 1 = short, 2 = long) */ 1792 16, /* bitsize */ 1793 FALSE, /* pc_relative */ 1794 0, /* bitpos */ 1795 complain_overflow_signed, /* complain_on_overflow */ 1796 ppc64_elf_unhandled_reloc, /* special_function */ 1797 "R_PPC64_GOT_TPREL16_DS", /* name */ 1798 FALSE, /* partial_inplace */ 1799 0, /* src_mask */ 1800 0xfffc, /* dst_mask */ 1801 FALSE), /* pcrel_offset */ 1802 1803 /* Like GOT_TPREL16_DS, but no overflow. */ 1804 HOWTO (R_PPC64_GOT_TPREL16_LO_DS, 1805 0, /* rightshift */ 1806 1, /* size (0 = byte, 1 = short, 2 = long) */ 1807 16, /* bitsize */ 1808 FALSE, /* pc_relative */ 1809 0, /* bitpos */ 1810 complain_overflow_dont, /* complain_on_overflow */ 1811 ppc64_elf_unhandled_reloc, /* special_function */ 1812 "R_PPC64_GOT_TPREL16_LO_DS", /* name */ 1813 FALSE, /* partial_inplace */ 1814 0, /* src_mask */ 1815 0xfffc, /* dst_mask */ 1816 FALSE), /* pcrel_offset */ 1817 1818 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */ 1819 HOWTO (R_PPC64_GOT_TPREL16_HI, 1820 16, /* rightshift */ 1821 1, /* size (0 = byte, 1 = short, 2 = long) */ 1822 16, /* bitsize */ 1823 FALSE, /* pc_relative */ 1824 0, /* bitpos */ 1825 complain_overflow_dont, /* complain_on_overflow */ 1826 ppc64_elf_unhandled_reloc, /* special_function */ 1827 "R_PPC64_GOT_TPREL16_HI", /* name */ 1828 FALSE, /* partial_inplace */ 1829 0, /* src_mask */ 1830 0xffff, /* dst_mask */ 1831 FALSE), /* pcrel_offset */ 1832 1833 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */ 1834 HOWTO (R_PPC64_GOT_TPREL16_HA, 1835 16, /* rightshift */ 1836 1, /* size (0 = byte, 1 = short, 2 = long) */ 1837 16, /* bitsize */ 1838 FALSE, /* pc_relative */ 1839 0, /* bitpos */ 1840 complain_overflow_dont, /* complain_on_overflow */ 1841 ppc64_elf_unhandled_reloc, /* special_function */ 1842 "R_PPC64_GOT_TPREL16_HA", /* name */ 1843 FALSE, /* partial_inplace */ 1844 0, /* src_mask */ 1845 0xffff, /* dst_mask */ 1846 FALSE), /* pcrel_offset */ 1847 1848 /* GNU extension to record C++ vtable hierarchy. */ 1849 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */ 1850 0, /* rightshift */ 1851 0, /* size (0 = byte, 1 = short, 2 = long) */ 1852 0, /* bitsize */ 1853 FALSE, /* pc_relative */ 1854 0, /* bitpos */ 1855 complain_overflow_dont, /* complain_on_overflow */ 1856 NULL, /* special_function */ 1857 "R_PPC64_GNU_VTINHERIT", /* name */ 1858 FALSE, /* partial_inplace */ 1859 0, /* src_mask */ 1860 0, /* dst_mask */ 1861 FALSE), /* pcrel_offset */ 1862 1863 /* GNU extension to record C++ vtable member usage. */ 1864 HOWTO (R_PPC64_GNU_VTENTRY, /* type */ 1865 0, /* rightshift */ 1866 0, /* size (0 = byte, 1 = short, 2 = long) */ 1867 0, /* bitsize */ 1868 FALSE, /* pc_relative */ 1869 0, /* bitpos */ 1870 complain_overflow_dont, /* complain_on_overflow */ 1871 NULL, /* special_function */ 1872 "R_PPC64_GNU_VTENTRY", /* name */ 1873 FALSE, /* partial_inplace */ 1874 0, /* src_mask */ 1875 0, /* dst_mask */ 1876 FALSE), /* pcrel_offset */ 1877 }; 1878 1879 1880 /* Initialize the ppc64_elf_howto_table, so that linear accesses can 1881 be done. */ 1882 1883 static void 1884 ppc_howto_init (void) 1885 { 1886 unsigned int i, type; 1887 1888 for (i = 0; 1889 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]); 1890 i++) 1891 { 1892 type = ppc64_elf_howto_raw[i].type; 1893 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table) 1894 / sizeof (ppc64_elf_howto_table[0]))); 1895 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i]; 1896 } 1897 } 1898 1899 static reloc_howto_type * 1900 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1901 bfd_reloc_code_real_type code) 1902 { 1903 enum elf_ppc64_reloc_type r = R_PPC64_NONE; 1904 1905 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 1906 /* Initialize howto table if needed. */ 1907 ppc_howto_init (); 1908 1909 switch (code) 1910 { 1911 default: 1912 return NULL; 1913 1914 case BFD_RELOC_NONE: r = R_PPC64_NONE; 1915 break; 1916 case BFD_RELOC_32: r = R_PPC64_ADDR32; 1917 break; 1918 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24; 1919 break; 1920 case BFD_RELOC_16: r = R_PPC64_ADDR16; 1921 break; 1922 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO; 1923 break; 1924 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI; 1925 break; 1926 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA; 1927 break; 1928 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14; 1929 break; 1930 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN; 1931 break; 1932 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN; 1933 break; 1934 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24; 1935 break; 1936 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14; 1937 break; 1938 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN; 1939 break; 1940 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN; 1941 break; 1942 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16; 1943 break; 1944 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO; 1945 break; 1946 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI; 1947 break; 1948 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA; 1949 break; 1950 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY; 1951 break; 1952 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT; 1953 break; 1954 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32; 1955 break; 1956 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32; 1957 break; 1958 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32; 1959 break; 1960 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO; 1961 break; 1962 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI; 1963 break; 1964 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA; 1965 break; 1966 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF; 1967 break; 1968 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO; 1969 break; 1970 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI; 1971 break; 1972 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA; 1973 break; 1974 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64; 1975 break; 1976 case BFD_RELOC_64: r = R_PPC64_ADDR64; 1977 break; 1978 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER; 1979 break; 1980 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA; 1981 break; 1982 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST; 1983 break; 1984 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA; 1985 break; 1986 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64; 1987 break; 1988 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64; 1989 break; 1990 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64; 1991 break; 1992 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16; 1993 break; 1994 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO; 1995 break; 1996 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI; 1997 break; 1998 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA; 1999 break; 2000 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC; 2001 break; 2002 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16; 2003 break; 2004 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO; 2005 break; 2006 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI; 2007 break; 2008 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA; 2009 break; 2010 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS; 2011 break; 2012 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS; 2013 break; 2014 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS; 2015 break; 2016 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS; 2017 break; 2018 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS; 2019 break; 2020 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS; 2021 break; 2022 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS; 2023 break; 2024 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS; 2025 break; 2026 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS; 2027 break; 2028 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS; 2029 break; 2030 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS; 2031 break; 2032 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS; 2033 break; 2034 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64; 2035 break; 2036 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16; 2037 break; 2038 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO; 2039 break; 2040 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI; 2041 break; 2042 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA; 2043 break; 2044 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64; 2045 break; 2046 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16; 2047 break; 2048 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO; 2049 break; 2050 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI; 2051 break; 2052 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA; 2053 break; 2054 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64; 2055 break; 2056 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16; 2057 break; 2058 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO; 2059 break; 2060 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI; 2061 break; 2062 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA; 2063 break; 2064 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16; 2065 break; 2066 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO; 2067 break; 2068 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI; 2069 break; 2070 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA; 2071 break; 2072 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS; 2073 break; 2074 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS; 2075 break; 2076 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI; 2077 break; 2078 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA; 2079 break; 2080 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS; 2081 break; 2082 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS; 2083 break; 2084 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI; 2085 break; 2086 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA; 2087 break; 2088 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS; 2089 break; 2090 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS; 2091 break; 2092 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER; 2093 break; 2094 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA; 2095 break; 2096 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST; 2097 break; 2098 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA; 2099 break; 2100 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS; 2101 break; 2102 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS; 2103 break; 2104 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER; 2105 break; 2106 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA; 2107 break; 2108 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST; 2109 break; 2110 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA; 2111 break; 2112 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT; 2113 break; 2114 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY; 2115 break; 2116 } 2117 2118 return ppc64_elf_howto_table[r]; 2119 }; 2120 2121 static reloc_howto_type * 2122 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 2123 const char *r_name) 2124 { 2125 unsigned int i; 2126 2127 for (i = 0; 2128 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]); 2129 i++) 2130 if (ppc64_elf_howto_raw[i].name != NULL 2131 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0) 2132 return &ppc64_elf_howto_raw[i]; 2133 2134 return NULL; 2135 } 2136 2137 /* Set the howto pointer for a PowerPC ELF reloc. */ 2138 2139 static void 2140 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, 2141 Elf_Internal_Rela *dst) 2142 { 2143 unsigned int type; 2144 2145 /* Initialize howto table if needed. */ 2146 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 2147 ppc_howto_init (); 2148 2149 type = ELF64_R_TYPE (dst->r_info); 2150 if (type >= (sizeof (ppc64_elf_howto_table) 2151 / sizeof (ppc64_elf_howto_table[0]))) 2152 { 2153 (*_bfd_error_handler) (_("%B: invalid relocation type %d"), 2154 abfd, (int) type); 2155 type = R_PPC64_NONE; 2156 } 2157 cache_ptr->howto = ppc64_elf_howto_table[type]; 2158 } 2159 2160 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */ 2161 2162 static bfd_reloc_status_type 2163 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2164 void *data, asection *input_section, 2165 bfd *output_bfd, char **error_message) 2166 { 2167 /* If this is a relocatable link (output_bfd test tells us), just 2168 call the generic function. Any adjustment will be done at final 2169 link time. */ 2170 if (output_bfd != NULL) 2171 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2172 input_section, output_bfd, error_message); 2173 2174 /* Adjust the addend for sign extension of the low 16 bits. 2175 We won't actually be using the low 16 bits, so trashing them 2176 doesn't matter. */ 2177 reloc_entry->addend += 0x8000; 2178 return bfd_reloc_continue; 2179 } 2180 2181 static bfd_reloc_status_type 2182 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2183 void *data, asection *input_section, 2184 bfd *output_bfd, char **error_message) 2185 { 2186 if (output_bfd != NULL) 2187 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2188 input_section, output_bfd, error_message); 2189 2190 if (strcmp (symbol->section->name, ".opd") == 0 2191 && (symbol->section->owner->flags & DYNAMIC) == 0) 2192 { 2193 bfd_vma dest = opd_entry_value (symbol->section, 2194 symbol->value + reloc_entry->addend, 2195 NULL, NULL); 2196 if (dest != (bfd_vma) -1) 2197 reloc_entry->addend = dest - (symbol->value 2198 + symbol->section->output_section->vma 2199 + symbol->section->output_offset); 2200 } 2201 return bfd_reloc_continue; 2202 } 2203 2204 static bfd_reloc_status_type 2205 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2206 void *data, asection *input_section, 2207 bfd *output_bfd, char **error_message) 2208 { 2209 long insn; 2210 enum elf_ppc64_reloc_type r_type; 2211 bfd_size_type octets; 2212 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */ 2213 bfd_boolean is_power4 = FALSE; 2214 2215 /* If this is a relocatable link (output_bfd test tells us), just 2216 call the generic function. Any adjustment will be done at final 2217 link time. */ 2218 if (output_bfd != NULL) 2219 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2220 input_section, output_bfd, error_message); 2221 2222 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2223 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets); 2224 insn &= ~(0x01 << 21); 2225 r_type = reloc_entry->howto->type; 2226 if (r_type == R_PPC64_ADDR14_BRTAKEN 2227 || r_type == R_PPC64_REL14_BRTAKEN) 2228 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */ 2229 2230 if (is_power4) 2231 { 2232 /* Set 'a' bit. This is 0b00010 in BO field for branch 2233 on CR(BI) insns (BO == 001at or 011at), and 0b01000 2234 for branch on CTR insns (BO == 1a00t or 1a01t). */ 2235 if ((insn & (0x14 << 21)) == (0x04 << 21)) 2236 insn |= 0x02 << 21; 2237 else if ((insn & (0x14 << 21)) == (0x10 << 21)) 2238 insn |= 0x08 << 21; 2239 else 2240 goto out; 2241 } 2242 else 2243 { 2244 bfd_vma target = 0; 2245 bfd_vma from; 2246 2247 if (!bfd_is_com_section (symbol->section)) 2248 target = symbol->value; 2249 target += symbol->section->output_section->vma; 2250 target += symbol->section->output_offset; 2251 target += reloc_entry->addend; 2252 2253 from = (reloc_entry->address 2254 + input_section->output_offset 2255 + input_section->output_section->vma); 2256 2257 /* Invert 'y' bit if not the default. */ 2258 if ((bfd_signed_vma) (target - from) < 0) 2259 insn ^= 0x01 << 21; 2260 } 2261 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets); 2262 out: 2263 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data, 2264 input_section, output_bfd, error_message); 2265 } 2266 2267 static bfd_reloc_status_type 2268 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2269 void *data, asection *input_section, 2270 bfd *output_bfd, char **error_message) 2271 { 2272 /* If this is a relocatable link (output_bfd test tells us), just 2273 call the generic function. Any adjustment will be done at final 2274 link time. */ 2275 if (output_bfd != NULL) 2276 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2277 input_section, output_bfd, error_message); 2278 2279 /* Subtract the symbol section base address. */ 2280 reloc_entry->addend -= symbol->section->output_section->vma; 2281 return bfd_reloc_continue; 2282 } 2283 2284 static bfd_reloc_status_type 2285 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2286 void *data, asection *input_section, 2287 bfd *output_bfd, char **error_message) 2288 { 2289 /* If this is a relocatable link (output_bfd test tells us), just 2290 call the generic function. Any adjustment will be done at final 2291 link time. */ 2292 if (output_bfd != NULL) 2293 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2294 input_section, output_bfd, error_message); 2295 2296 /* Subtract the symbol section base address. */ 2297 reloc_entry->addend -= symbol->section->output_section->vma; 2298 2299 /* Adjust the addend for sign extension of the low 16 bits. */ 2300 reloc_entry->addend += 0x8000; 2301 return bfd_reloc_continue; 2302 } 2303 2304 static bfd_reloc_status_type 2305 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2306 void *data, asection *input_section, 2307 bfd *output_bfd, char **error_message) 2308 { 2309 bfd_vma TOCstart; 2310 2311 /* If this is a relocatable link (output_bfd test tells us), just 2312 call the generic function. Any adjustment will be done at final 2313 link time. */ 2314 if (output_bfd != NULL) 2315 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2316 input_section, output_bfd, error_message); 2317 2318 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2319 if (TOCstart == 0) 2320 TOCstart = ppc64_elf_toc (input_section->output_section->owner); 2321 2322 /* Subtract the TOC base address. */ 2323 reloc_entry->addend -= TOCstart + TOC_BASE_OFF; 2324 return bfd_reloc_continue; 2325 } 2326 2327 static bfd_reloc_status_type 2328 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2329 void *data, asection *input_section, 2330 bfd *output_bfd, char **error_message) 2331 { 2332 bfd_vma TOCstart; 2333 2334 /* If this is a relocatable link (output_bfd test tells us), just 2335 call the generic function. Any adjustment will be done at final 2336 link time. */ 2337 if (output_bfd != NULL) 2338 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2339 input_section, output_bfd, error_message); 2340 2341 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2342 if (TOCstart == 0) 2343 TOCstart = ppc64_elf_toc (input_section->output_section->owner); 2344 2345 /* Subtract the TOC base address. */ 2346 reloc_entry->addend -= TOCstart + TOC_BASE_OFF; 2347 2348 /* Adjust the addend for sign extension of the low 16 bits. */ 2349 reloc_entry->addend += 0x8000; 2350 return bfd_reloc_continue; 2351 } 2352 2353 static bfd_reloc_status_type 2354 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2355 void *data, asection *input_section, 2356 bfd *output_bfd, char **error_message) 2357 { 2358 bfd_vma TOCstart; 2359 bfd_size_type octets; 2360 2361 /* If this is a relocatable link (output_bfd test tells us), just 2362 call the generic function. Any adjustment will be done at final 2363 link time. */ 2364 if (output_bfd != NULL) 2365 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2366 input_section, output_bfd, error_message); 2367 2368 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2369 if (TOCstart == 0) 2370 TOCstart = ppc64_elf_toc (input_section->output_section->owner); 2371 2372 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2373 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets); 2374 return bfd_reloc_ok; 2375 } 2376 2377 static bfd_reloc_status_type 2378 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2379 void *data, asection *input_section, 2380 bfd *output_bfd, char **error_message) 2381 { 2382 /* If this is a relocatable link (output_bfd test tells us), just 2383 call the generic function. Any adjustment will be done at final 2384 link time. */ 2385 if (output_bfd != NULL) 2386 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2387 input_section, output_bfd, error_message); 2388 2389 if (error_message != NULL) 2390 { 2391 static char buf[60]; 2392 sprintf (buf, "generic linker can't handle %s", 2393 reloc_entry->howto->name); 2394 *error_message = buf; 2395 } 2396 return bfd_reloc_dangerous; 2397 } 2398 2399 struct ppc64_elf_obj_tdata 2400 { 2401 struct elf_obj_tdata elf; 2402 2403 /* Shortcuts to dynamic linker sections. */ 2404 asection *got; 2405 asection *relgot; 2406 2407 /* Used during garbage collection. We attach global symbols defined 2408 on removed .opd entries to this section so that the sym is removed. */ 2409 asection *deleted_section; 2410 2411 /* TLS local dynamic got entry handling. Suppose for multiple GOT 2412 sections means we potentially need one of these for each input bfd. */ 2413 union { 2414 bfd_signed_vma refcount; 2415 bfd_vma offset; 2416 } tlsld_got; 2417 2418 /* A copy of relocs before they are modified for --emit-relocs. */ 2419 Elf_Internal_Rela *opd_relocs; 2420 }; 2421 2422 #define ppc64_elf_tdata(bfd) \ 2423 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any) 2424 2425 #define ppc64_tlsld_got(bfd) \ 2426 (&ppc64_elf_tdata (bfd)->tlsld_got) 2427 2428 #define is_ppc64_elf(bfd) \ 2429 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 2430 && elf_object_id (bfd) == PPC64_ELF_TDATA) 2431 2432 /* Override the generic function because we store some extras. */ 2433 2434 static bfd_boolean 2435 ppc64_elf_mkobject (bfd *abfd) 2436 { 2437 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata), 2438 PPC64_ELF_TDATA); 2439 } 2440 2441 /* Fix bad default arch selected for a 64 bit input bfd when the 2442 default is 32 bit. */ 2443 2444 static bfd_boolean 2445 ppc64_elf_object_p (bfd *abfd) 2446 { 2447 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32) 2448 { 2449 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd); 2450 2451 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64) 2452 { 2453 /* Relies on arch after 32 bit default being 64 bit default. */ 2454 abfd->arch_info = abfd->arch_info->next; 2455 BFD_ASSERT (abfd->arch_info->bits_per_word == 64); 2456 } 2457 } 2458 return TRUE; 2459 } 2460 2461 /* Support for core dump NOTE sections. */ 2462 2463 static bfd_boolean 2464 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2465 { 2466 size_t offset, size; 2467 2468 if (note->descsz != 504) 2469 return FALSE; 2470 2471 /* pr_cursig */ 2472 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 2473 2474 /* pr_pid */ 2475 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32); 2476 2477 /* pr_reg */ 2478 offset = 112; 2479 size = 384; 2480 2481 /* Make a ".reg/999" section. */ 2482 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2483 size, note->descpos + offset); 2484 } 2485 2486 static bfd_boolean 2487 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 2488 { 2489 if (note->descsz != 136) 2490 return FALSE; 2491 2492 elf_tdata (abfd)->core_program 2493 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 2494 elf_tdata (abfd)->core_command 2495 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 2496 2497 return TRUE; 2498 } 2499 2500 static char * 2501 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, 2502 ...) 2503 { 2504 switch (note_type) 2505 { 2506 default: 2507 return NULL; 2508 2509 case NT_PRPSINFO: 2510 { 2511 char data[136]; 2512 va_list ap; 2513 2514 va_start (ap, note_type); 2515 memset (data, 0, 40); 2516 strncpy (data + 40, va_arg (ap, const char *), 16); 2517 strncpy (data + 56, va_arg (ap, const char *), 80); 2518 va_end (ap); 2519 return elfcore_write_note (abfd, buf, bufsiz, 2520 "CORE", note_type, data, sizeof (data)); 2521 } 2522 2523 case NT_PRSTATUS: 2524 { 2525 char data[504]; 2526 va_list ap; 2527 long pid; 2528 int cursig; 2529 const void *greg; 2530 2531 va_start (ap, note_type); 2532 memset (data, 0, 112); 2533 pid = va_arg (ap, long); 2534 bfd_put_32 (abfd, pid, data + 32); 2535 cursig = va_arg (ap, int); 2536 bfd_put_16 (abfd, cursig, data + 12); 2537 greg = va_arg (ap, const void *); 2538 memcpy (data + 112, greg, 384); 2539 memset (data + 496, 0, 8); 2540 va_end (ap); 2541 return elfcore_write_note (abfd, buf, bufsiz, 2542 "CORE", note_type, data, sizeof (data)); 2543 } 2544 } 2545 } 2546 2547 /* Merge backend specific data from an object file to the output 2548 object file when linking. */ 2549 2550 static bfd_boolean 2551 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 2552 { 2553 /* Check if we have the same endianess. */ 2554 if (ibfd->xvec->byteorder != obfd->xvec->byteorder 2555 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN 2556 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) 2557 { 2558 const char *msg; 2559 2560 if (bfd_big_endian (ibfd)) 2561 msg = _("%B: compiled for a big endian system " 2562 "and target is little endian"); 2563 else 2564 msg = _("%B: compiled for a little endian system " 2565 "and target is big endian"); 2566 2567 (*_bfd_error_handler) (msg, ibfd); 2568 2569 bfd_set_error (bfd_error_wrong_format); 2570 return FALSE; 2571 } 2572 2573 return TRUE; 2574 } 2575 2576 /* Add extra PPC sections. */ 2577 2578 static const struct bfd_elf_special_section ppc64_elf_special_sections[]= 2579 { 2580 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 }, 2581 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 2582 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2583 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2584 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2585 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 2586 { NULL, 0, 0, 0, 0 } 2587 }; 2588 2589 enum _ppc64_sec_type { 2590 sec_normal = 0, 2591 sec_opd = 1, 2592 sec_toc = 2 2593 }; 2594 2595 struct _ppc64_elf_section_data 2596 { 2597 struct bfd_elf_section_data elf; 2598 2599 union 2600 { 2601 /* An array with one entry for each opd function descriptor. */ 2602 struct _opd_sec_data 2603 { 2604 /* Points to the function code section for local opd entries. */ 2605 asection **func_sec; 2606 2607 /* After editing .opd, adjust references to opd local syms. */ 2608 long *adjust; 2609 } opd; 2610 2611 /* An array for toc sections, indexed by offset/8. */ 2612 struct _toc_sec_data 2613 { 2614 /* Specifies the relocation symbol index used at a given toc offset. */ 2615 unsigned *symndx; 2616 2617 /* And the relocation addend. */ 2618 bfd_vma *add; 2619 } toc; 2620 } u; 2621 2622 enum _ppc64_sec_type sec_type:2; 2623 2624 /* Flag set when small branches are detected. Used to 2625 select suitable defaults for the stub group size. */ 2626 unsigned int has_14bit_branch:1; 2627 }; 2628 2629 #define ppc64_elf_section_data(sec) \ 2630 ((struct _ppc64_elf_section_data *) elf_section_data (sec)) 2631 2632 static bfd_boolean 2633 ppc64_elf_new_section_hook (bfd *abfd, asection *sec) 2634 { 2635 if (!sec->used_by_bfd) 2636 { 2637 struct _ppc64_elf_section_data *sdata; 2638 bfd_size_type amt = sizeof (*sdata); 2639 2640 sdata = bfd_zalloc (abfd, amt); 2641 if (sdata == NULL) 2642 return FALSE; 2643 sec->used_by_bfd = sdata; 2644 } 2645 2646 return _bfd_elf_new_section_hook (abfd, sec); 2647 } 2648 2649 static struct _opd_sec_data * 2650 get_opd_info (asection * sec) 2651 { 2652 if (sec != NULL 2653 && ppc64_elf_section_data (sec) != NULL 2654 && ppc64_elf_section_data (sec)->sec_type == sec_opd) 2655 return &ppc64_elf_section_data (sec)->u.opd; 2656 return NULL; 2657 } 2658 2659 /* Parameters for the qsort hook. */ 2660 static asection *synthetic_opd; 2661 static bfd_boolean synthetic_relocatable; 2662 2663 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */ 2664 2665 static int 2666 compare_symbols (const void *ap, const void *bp) 2667 { 2668 const asymbol *a = * (const asymbol **) ap; 2669 const asymbol *b = * (const asymbol **) bp; 2670 2671 /* Section symbols first. */ 2672 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM)) 2673 return -1; 2674 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM)) 2675 return 1; 2676 2677 /* then .opd symbols. */ 2678 if (a->section == synthetic_opd && b->section != synthetic_opd) 2679 return -1; 2680 if (a->section != synthetic_opd && b->section == synthetic_opd) 2681 return 1; 2682 2683 /* then other code symbols. */ 2684 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2685 == (SEC_CODE | SEC_ALLOC) 2686 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2687 != (SEC_CODE | SEC_ALLOC)) 2688 return -1; 2689 2690 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2691 != (SEC_CODE | SEC_ALLOC) 2692 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2693 == (SEC_CODE | SEC_ALLOC)) 2694 return 1; 2695 2696 if (synthetic_relocatable) 2697 { 2698 if (a->section->id < b->section->id) 2699 return -1; 2700 2701 if (a->section->id > b->section->id) 2702 return 1; 2703 } 2704 2705 if (a->value + a->section->vma < b->value + b->section->vma) 2706 return -1; 2707 2708 if (a->value + a->section->vma > b->value + b->section->vma) 2709 return 1; 2710 2711 /* For syms with the same value, prefer strong dynamic global function 2712 syms over other syms. */ 2713 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0) 2714 return -1; 2715 2716 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0) 2717 return 1; 2718 2719 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0) 2720 return -1; 2721 2722 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0) 2723 return 1; 2724 2725 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0) 2726 return -1; 2727 2728 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0) 2729 return 1; 2730 2731 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0) 2732 return -1; 2733 2734 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0) 2735 return 1; 2736 2737 return 0; 2738 } 2739 2740 /* Search SYMS for a symbol of the given VALUE. */ 2741 2742 static asymbol * 2743 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value) 2744 { 2745 long mid; 2746 2747 if (id == -1) 2748 { 2749 while (lo < hi) 2750 { 2751 mid = (lo + hi) >> 1; 2752 if (syms[mid]->value + syms[mid]->section->vma < value) 2753 lo = mid + 1; 2754 else if (syms[mid]->value + syms[mid]->section->vma > value) 2755 hi = mid; 2756 else 2757 return syms[mid]; 2758 } 2759 } 2760 else 2761 { 2762 while (lo < hi) 2763 { 2764 mid = (lo + hi) >> 1; 2765 if (syms[mid]->section->id < id) 2766 lo = mid + 1; 2767 else if (syms[mid]->section->id > id) 2768 hi = mid; 2769 else if (syms[mid]->value < value) 2770 lo = mid + 1; 2771 else if (syms[mid]->value > value) 2772 hi = mid; 2773 else 2774 return syms[mid]; 2775 } 2776 } 2777 return NULL; 2778 } 2779 2780 static bfd_boolean 2781 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr) 2782 { 2783 bfd_vma vma = *(bfd_vma *) ptr; 2784 return ((section->flags & SEC_ALLOC) != 0 2785 && section->vma <= vma 2786 && vma < section->vma + section->size); 2787 } 2788 2789 /* Create synthetic symbols, effectively restoring "dot-symbol" function 2790 entry syms. Also generate @plt symbols for the glink branch table. */ 2791 2792 static long 2793 ppc64_elf_get_synthetic_symtab (bfd *abfd, 2794 long static_count, asymbol **static_syms, 2795 long dyn_count, asymbol **dyn_syms, 2796 asymbol **ret) 2797 { 2798 asymbol *s; 2799 long i; 2800 long count; 2801 char *names; 2802 long symcount, codesecsym, codesecsymend, secsymend, opdsymend; 2803 asection *opd; 2804 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0; 2805 asymbol **syms; 2806 2807 *ret = NULL; 2808 2809 opd = bfd_get_section_by_name (abfd, ".opd"); 2810 if (opd == NULL) 2811 return 0; 2812 2813 symcount = static_count; 2814 if (!relocatable) 2815 symcount += dyn_count; 2816 if (symcount == 0) 2817 return 0; 2818 2819 syms = bfd_malloc ((symcount + 1) * sizeof (*syms)); 2820 if (syms == NULL) 2821 return -1; 2822 2823 if (!relocatable && static_count != 0 && dyn_count != 0) 2824 { 2825 /* Use both symbol tables. */ 2826 memcpy (syms, static_syms, static_count * sizeof (*syms)); 2827 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms)); 2828 } 2829 else if (!relocatable && static_count == 0) 2830 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms)); 2831 else 2832 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms)); 2833 2834 synthetic_opd = opd; 2835 synthetic_relocatable = relocatable; 2836 qsort (syms, symcount, sizeof (*syms), compare_symbols); 2837 2838 if (!relocatable && symcount > 1) 2839 { 2840 long j; 2841 /* Trim duplicate syms, since we may have merged the normal and 2842 dynamic symbols. Actually, we only care about syms that have 2843 different values, so trim any with the same value. */ 2844 for (i = 1, j = 1; i < symcount; ++i) 2845 if (syms[i - 1]->value + syms[i - 1]->section->vma 2846 != syms[i]->value + syms[i]->section->vma) 2847 syms[j++] = syms[i]; 2848 symcount = j; 2849 } 2850 2851 i = 0; 2852 if (syms[i]->section == opd) 2853 ++i; 2854 codesecsym = i; 2855 2856 for (; i < symcount; ++i) 2857 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2858 != (SEC_CODE | SEC_ALLOC)) 2859 || (syms[i]->flags & BSF_SECTION_SYM) == 0) 2860 break; 2861 codesecsymend = i; 2862 2863 for (; i < symcount; ++i) 2864 if ((syms[i]->flags & BSF_SECTION_SYM) == 0) 2865 break; 2866 secsymend = i; 2867 2868 for (; i < symcount; ++i) 2869 if (syms[i]->section != opd) 2870 break; 2871 opdsymend = i; 2872 2873 for (; i < symcount; ++i) 2874 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 2875 != (SEC_CODE | SEC_ALLOC)) 2876 break; 2877 symcount = i; 2878 2879 count = 0; 2880 2881 if (relocatable) 2882 { 2883 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 2884 arelent *r; 2885 size_t size; 2886 long relcount; 2887 2888 if (opdsymend == secsymend) 2889 goto done; 2890 2891 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 2892 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0; 2893 if (relcount == 0) 2894 goto done; 2895 2896 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE)) 2897 { 2898 count = -1; 2899 goto done; 2900 } 2901 2902 size = 0; 2903 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i) 2904 { 2905 asymbol *sym; 2906 2907 while (r < opd->relocation + relcount 2908 && r->address < syms[i]->value + opd->vma) 2909 ++r; 2910 2911 if (r == opd->relocation + relcount) 2912 break; 2913 2914 if (r->address != syms[i]->value + opd->vma) 2915 continue; 2916 2917 if (r->howto->type != R_PPC64_ADDR64) 2918 continue; 2919 2920 sym = *r->sym_ptr_ptr; 2921 if (!sym_exists_at (syms, opdsymend, symcount, 2922 sym->section->id, sym->value + r->addend)) 2923 { 2924 ++count; 2925 size += sizeof (asymbol); 2926 size += strlen (syms[i]->name) + 2; 2927 } 2928 } 2929 2930 s = *ret = bfd_malloc (size); 2931 if (s == NULL) 2932 { 2933 count = -1; 2934 goto done; 2935 } 2936 2937 names = (char *) (s + count); 2938 2939 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i) 2940 { 2941 asymbol *sym; 2942 2943 while (r < opd->relocation + relcount 2944 && r->address < syms[i]->value + opd->vma) 2945 ++r; 2946 2947 if (r == opd->relocation + relcount) 2948 break; 2949 2950 if (r->address != syms[i]->value + opd->vma) 2951 continue; 2952 2953 if (r->howto->type != R_PPC64_ADDR64) 2954 continue; 2955 2956 sym = *r->sym_ptr_ptr; 2957 if (!sym_exists_at (syms, opdsymend, symcount, 2958 sym->section->id, sym->value + r->addend)) 2959 { 2960 size_t len; 2961 2962 *s = *syms[i]; 2963 s->flags |= BSF_SYNTHETIC; 2964 s->section = sym->section; 2965 s->value = sym->value + r->addend; 2966 s->name = names; 2967 *names++ = '.'; 2968 len = strlen (syms[i]->name); 2969 memcpy (names, syms[i]->name, len + 1); 2970 names += len + 1; 2971 /* Have udata.p point back to the original symbol this 2972 synthetic symbol was derived from. */ 2973 s->udata.p = syms[i]; 2974 s++; 2975 } 2976 } 2977 } 2978 else 2979 { 2980 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 2981 bfd_byte *contents; 2982 size_t size; 2983 long plt_count = 0; 2984 bfd_vma glink_vma = 0, resolv_vma = 0; 2985 asection *dynamic, *glink = NULL, *relplt = NULL; 2986 arelent *p; 2987 2988 if (!bfd_malloc_and_get_section (abfd, opd, &contents)) 2989 { 2990 if (contents) 2991 { 2992 free_contents_and_exit: 2993 free (contents); 2994 } 2995 count = -1; 2996 goto done; 2997 } 2998 2999 size = 0; 3000 for (i = secsymend; i < opdsymend; ++i) 3001 { 3002 bfd_vma ent; 3003 3004 ent = bfd_get_64 (abfd, contents + syms[i]->value); 3005 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent)) 3006 { 3007 ++count; 3008 size += sizeof (asymbol); 3009 size += strlen (syms[i]->name) + 2; 3010 } 3011 } 3012 3013 /* Get start of .glink stubs from DT_PPC64_GLINK. */ 3014 if (dyn_count != 0 3015 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL) 3016 { 3017 bfd_byte *dynbuf, *extdyn, *extdynend; 3018 size_t extdynsize; 3019 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 3020 3021 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf)) 3022 goto free_contents_and_exit; 3023 3024 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 3025 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 3026 3027 extdyn = dynbuf; 3028 extdynend = extdyn + dynamic->size; 3029 for (; extdyn < extdynend; extdyn += extdynsize) 3030 { 3031 Elf_Internal_Dyn dyn; 3032 (*swap_dyn_in) (abfd, extdyn, &dyn); 3033 3034 if (dyn.d_tag == DT_NULL) 3035 break; 3036 3037 if (dyn.d_tag == DT_PPC64_GLINK) 3038 { 3039 /* The first glink stub starts at offset 32; see comment in 3040 ppc64_elf_finish_dynamic_sections. */ 3041 glink_vma = dyn.d_un.d_val + 32; 3042 /* The .glink section usually does not survive the final 3043 link; search for the section (usually .text) where the 3044 glink stubs now reside. */ 3045 glink = bfd_sections_find_if (abfd, section_covers_vma, 3046 &glink_vma); 3047 break; 3048 } 3049 } 3050 3051 free (dynbuf); 3052 } 3053 3054 if (glink != NULL) 3055 { 3056 /* Determine __glink trampoline by reading the relative branch 3057 from the first glink stub. */ 3058 bfd_byte buf[4]; 3059 if (bfd_get_section_contents (abfd, glink, buf, 3060 glink_vma + 4 - glink->vma, 4)) 3061 { 3062 unsigned int insn = bfd_get_32 (abfd, buf); 3063 insn ^= B_DOT; 3064 if ((insn & ~0x3fffffc) == 0) 3065 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000; 3066 } 3067 3068 if (resolv_vma) 3069 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve"); 3070 3071 relplt = bfd_get_section_by_name (abfd, ".rela.plt"); 3072 if (relplt != NULL) 3073 { 3074 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3075 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE)) 3076 goto free_contents_and_exit; 3077 3078 plt_count = relplt->size / sizeof (Elf64_External_Rela); 3079 size += plt_count * sizeof (asymbol); 3080 3081 p = relplt->relocation; 3082 for (i = 0; i < plt_count; i++, p++) 3083 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 3084 } 3085 } 3086 3087 s = *ret = bfd_malloc (size); 3088 if (s == NULL) 3089 goto free_contents_and_exit; 3090 3091 names = (char *) (s + count + plt_count + (resolv_vma != 0)); 3092 3093 for (i = secsymend; i < opdsymend; ++i) 3094 { 3095 bfd_vma ent; 3096 3097 ent = bfd_get_64 (abfd, contents + syms[i]->value); 3098 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent)) 3099 { 3100 long lo, hi; 3101 size_t len; 3102 asection *sec = abfd->sections; 3103 3104 *s = *syms[i]; 3105 lo = codesecsym; 3106 hi = codesecsymend; 3107 while (lo < hi) 3108 { 3109 long mid = (lo + hi) >> 1; 3110 if (syms[mid]->section->vma < ent) 3111 lo = mid + 1; 3112 else if (syms[mid]->section->vma > ent) 3113 hi = mid; 3114 else 3115 { 3116 sec = syms[mid]->section; 3117 break; 3118 } 3119 } 3120 3121 if (lo >= hi && lo > codesecsym) 3122 sec = syms[lo - 1]->section; 3123 3124 for (; sec != NULL; sec = sec->next) 3125 { 3126 if (sec->vma > ent) 3127 break; 3128 if ((sec->flags & SEC_ALLOC) == 0 3129 || (sec->flags & SEC_LOAD) == 0) 3130 break; 3131 if ((sec->flags & SEC_CODE) != 0) 3132 s->section = sec; 3133 } 3134 s->flags |= BSF_SYNTHETIC; 3135 s->value = ent - s->section->vma; 3136 s->name = names; 3137 *names++ = '.'; 3138 len = strlen (syms[i]->name); 3139 memcpy (names, syms[i]->name, len + 1); 3140 names += len + 1; 3141 /* Have udata.p point back to the original symbol this 3142 synthetic symbol was derived from. */ 3143 s->udata.p = syms[i]; 3144 s++; 3145 } 3146 } 3147 free (contents); 3148 3149 if (glink != NULL && relplt != NULL) 3150 { 3151 if (resolv_vma) 3152 { 3153 /* Add a symbol for the main glink trampoline. */ 3154 memset (s, 0, sizeof *s); 3155 s->the_bfd = abfd; 3156 s->flags = BSF_GLOBAL | BSF_SYNTHETIC; 3157 s->section = glink; 3158 s->value = resolv_vma - glink->vma; 3159 s->name = names; 3160 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve")); 3161 names += sizeof ("__glink_PLTresolve"); 3162 s++; 3163 count++; 3164 } 3165 3166 /* FIXME: It would be very much nicer to put sym@plt on the 3167 stub rather than on the glink branch table entry. The 3168 objdump disassembler would then use a sensible symbol 3169 name on plt calls. The difficulty in doing so is 3170 a) finding the stubs, and, 3171 b) matching stubs against plt entries, and, 3172 c) there can be multiple stubs for a given plt entry. 3173 3174 Solving (a) could be done by code scanning, but older 3175 ppc64 binaries used different stubs to current code. 3176 (b) is the tricky one since you need to known the toc 3177 pointer for at least one function that uses a pic stub to 3178 be able to calculate the plt address referenced. 3179 (c) means gdb would need to set multiple breakpoints (or 3180 find the glink branch itself) when setting breakpoints 3181 for pending shared library loads. */ 3182 p = relplt->relocation; 3183 for (i = 0; i < plt_count; i++, p++) 3184 { 3185 size_t len; 3186 3187 *s = **p->sym_ptr_ptr; 3188 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 3189 we are defining a symbol, ensure one of them is set. */ 3190 if ((s->flags & BSF_LOCAL) == 0) 3191 s->flags |= BSF_GLOBAL; 3192 s->flags |= BSF_SYNTHETIC; 3193 s->section = glink; 3194 s->value = glink_vma - glink->vma; 3195 s->name = names; 3196 s->udata.p = NULL; 3197 len = strlen ((*p->sym_ptr_ptr)->name); 3198 memcpy (names, (*p->sym_ptr_ptr)->name, len); 3199 names += len; 3200 memcpy (names, "@plt", sizeof ("@plt")); 3201 names += sizeof ("@plt"); 3202 s++; 3203 glink_vma += 8; 3204 if (i >= 0x8000) 3205 glink_vma += 4; 3206 } 3207 count += plt_count; 3208 } 3209 } 3210 3211 done: 3212 free (syms); 3213 return count; 3214 } 3215 3216 /* The following functions are specific to the ELF linker, while 3217 functions above are used generally. Those named ppc64_elf_* are 3218 called by the main ELF linker code. They appear in this file more 3219 or less in the order in which they are called. eg. 3220 ppc64_elf_check_relocs is called early in the link process, 3221 ppc64_elf_finish_dynamic_sections is one of the last functions 3222 called. 3223 3224 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that 3225 functions have both a function code symbol and a function descriptor 3226 symbol. A call to foo in a relocatable object file looks like: 3227 3228 . .text 3229 . x: 3230 . bl .foo 3231 . nop 3232 3233 The function definition in another object file might be: 3234 3235 . .section .opd 3236 . foo: .quad .foo 3237 . .quad .TOC.@tocbase 3238 . .quad 0 3239 . 3240 . .text 3241 . .foo: blr 3242 3243 When the linker resolves the call during a static link, the branch 3244 unsurprisingly just goes to .foo and the .opd information is unused. 3245 If the function definition is in a shared library, things are a little 3246 different: The call goes via a plt call stub, the opd information gets 3247 copied to the plt, and the linker patches the nop. 3248 3249 . x: 3250 . bl .foo_stub 3251 . ld 2,40(1) 3252 . 3253 . 3254 . .foo_stub: 3255 . addis 12,2,Lfoo@toc@ha # in practice, the call stub 3256 . addi 12,12,Lfoo@toc@l # is slightly optimized, but 3257 . std 2,40(1) # this is the general idea 3258 . ld 11,0(12) 3259 . ld 2,8(12) 3260 . mtctr 11 3261 . ld 11,16(12) 3262 . bctr 3263 . 3264 . .section .plt 3265 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo) 3266 3267 The "reloc ()" notation is supposed to indicate that the linker emits 3268 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd 3269 copying. 3270 3271 What are the difficulties here? Well, firstly, the relocations 3272 examined by the linker in check_relocs are against the function code 3273 sym .foo, while the dynamic relocation in the plt is emitted against 3274 the function descriptor symbol, foo. Somewhere along the line, we need 3275 to carefully copy dynamic link information from one symbol to the other. 3276 Secondly, the generic part of the elf linker will make .foo a dynamic 3277 symbol as is normal for most other backends. We need foo dynamic 3278 instead, at least for an application final link. However, when 3279 creating a shared library containing foo, we need to have both symbols 3280 dynamic so that references to .foo are satisfied during the early 3281 stages of linking. Otherwise the linker might decide to pull in a 3282 definition from some other object, eg. a static library. 3283 3284 Update: As of August 2004, we support a new convention. Function 3285 calls may use the function descriptor symbol, ie. "bl foo". This 3286 behaves exactly as "bl .foo". */ 3287 3288 /* The linker needs to keep track of the number of relocs that it 3289 decides to copy as dynamic relocs in check_relocs for each symbol. 3290 This is so that it can later discard them if they are found to be 3291 unnecessary. We store the information in a field extending the 3292 regular ELF linker hash table. */ 3293 3294 struct ppc_dyn_relocs 3295 { 3296 struct ppc_dyn_relocs *next; 3297 3298 /* The input section of the reloc. */ 3299 asection *sec; 3300 3301 /* Total number of relocs copied for the input section. */ 3302 bfd_size_type count; 3303 3304 /* Number of pc-relative relocs copied for the input section. */ 3305 bfd_size_type pc_count; 3306 }; 3307 3308 /* Track GOT entries needed for a given symbol. We might need more 3309 than one got entry per symbol. */ 3310 struct got_entry 3311 { 3312 struct got_entry *next; 3313 3314 /* The symbol addend that we'll be placing in the GOT. */ 3315 bfd_vma addend; 3316 3317 /* Unlike other ELF targets, we use separate GOT entries for the same 3318 symbol referenced from different input files. This is to support 3319 automatic multiple TOC/GOT sections, where the TOC base can vary 3320 from one input file to another. FIXME: After group_sections we 3321 ought to merge entries within the group. 3322 3323 Point to the BFD owning this GOT entry. */ 3324 bfd *owner; 3325 3326 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD, 3327 TLS_TPREL or TLS_DTPREL for tls entries. */ 3328 char tls_type; 3329 3330 /* Reference count until size_dynamic_sections, GOT offset thereafter. */ 3331 union 3332 { 3333 bfd_signed_vma refcount; 3334 bfd_vma offset; 3335 } got; 3336 }; 3337 3338 /* The same for PLT. */ 3339 struct plt_entry 3340 { 3341 struct plt_entry *next; 3342 3343 bfd_vma addend; 3344 3345 union 3346 { 3347 bfd_signed_vma refcount; 3348 bfd_vma offset; 3349 } plt; 3350 }; 3351 3352 /* Of those relocs that might be copied as dynamic relocs, this function 3353 selects those that must be copied when linking a shared library, 3354 even when the symbol is local. */ 3355 3356 static int 3357 must_be_dyn_reloc (struct bfd_link_info *info, 3358 enum elf_ppc64_reloc_type r_type) 3359 { 3360 switch (r_type) 3361 { 3362 default: 3363 return 1; 3364 3365 case R_PPC64_REL32: 3366 case R_PPC64_REL64: 3367 case R_PPC64_REL30: 3368 return 0; 3369 3370 case R_PPC64_TPREL16: 3371 case R_PPC64_TPREL16_LO: 3372 case R_PPC64_TPREL16_HI: 3373 case R_PPC64_TPREL16_HA: 3374 case R_PPC64_TPREL16_DS: 3375 case R_PPC64_TPREL16_LO_DS: 3376 case R_PPC64_TPREL16_HIGHER: 3377 case R_PPC64_TPREL16_HIGHERA: 3378 case R_PPC64_TPREL16_HIGHEST: 3379 case R_PPC64_TPREL16_HIGHESTA: 3380 case R_PPC64_TPREL64: 3381 return !info->executable; 3382 } 3383 } 3384 3385 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 3386 copying dynamic variables from a shared lib into an app's dynbss 3387 section, and instead use a dynamic relocation to point into the 3388 shared lib. With code that gcc generates, it's vital that this be 3389 enabled; In the PowerPC64 ABI, the address of a function is actually 3390 the address of a function descriptor, which resides in the .opd 3391 section. gcc uses the descriptor directly rather than going via the 3392 GOT as some other ABI's do, which means that initialized function 3393 pointers must reference the descriptor. Thus, a function pointer 3394 initialized to the address of a function in a shared library will 3395 either require a copy reloc, or a dynamic reloc. Using a copy reloc 3396 redefines the function descriptor symbol to point to the copy. This 3397 presents a problem as a plt entry for that function is also 3398 initialized from the function descriptor symbol and the copy reloc 3399 may not be initialized first. */ 3400 #define ELIMINATE_COPY_RELOCS 1 3401 3402 /* Section name for stubs is the associated section name plus this 3403 string. */ 3404 #define STUB_SUFFIX ".stub" 3405 3406 /* Linker stubs. 3407 ppc_stub_long_branch: 3408 Used when a 14 bit branch (or even a 24 bit branch) can't reach its 3409 destination, but a 24 bit branch in a stub section will reach. 3410 . b dest 3411 3412 ppc_stub_plt_branch: 3413 Similar to the above, but a 24 bit branch in the stub section won't 3414 reach its destination. 3415 . addis %r12,%r2,xxx@toc@ha 3416 . ld %r11,xxx@toc@l(%r12) 3417 . mtctr %r11 3418 . bctr 3419 3420 ppc_stub_plt_call: 3421 Used to call a function in a shared library. If it so happens that 3422 the plt entry referenced crosses a 64k boundary, then an extra 3423 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr". 3424 . addis %r12,%r2,xxx@toc@ha 3425 . std %r2,40(%r1) 3426 . ld %r11,xxx+0@toc@l(%r12) 3427 . mtctr %r11 3428 . ld %r2,xxx+8@toc@l(%r12) 3429 . ld %r11,xxx+16@toc@l(%r12) 3430 . bctr 3431 3432 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional 3433 code to adjust the value and save r2 to support multiple toc sections. 3434 A ppc_stub_long_branch with an r2 offset looks like: 3435 . std %r2,40(%r1) 3436 . addis %r2,%r2,off@ha 3437 . addi %r2,%r2,off@l 3438 . b dest 3439 3440 A ppc_stub_plt_branch with an r2 offset looks like: 3441 . std %r2,40(%r1) 3442 . addis %r12,%r2,xxx@toc@ha 3443 . ld %r11,xxx@toc@l(%r12) 3444 . addis %r2,%r2,off@ha 3445 . addi %r2,%r2,off@l 3446 . mtctr %r11 3447 . bctr 3448 3449 In cases where the "addis" instruction would add zero, the "addis" is 3450 omitted and following instructions modified slightly in some cases. 3451 */ 3452 3453 enum ppc_stub_type { 3454 ppc_stub_none, 3455 ppc_stub_long_branch, 3456 ppc_stub_long_branch_r2off, 3457 ppc_stub_plt_branch, 3458 ppc_stub_plt_branch_r2off, 3459 ppc_stub_plt_call 3460 }; 3461 3462 struct ppc_stub_hash_entry { 3463 3464 /* Base hash table entry structure. */ 3465 struct bfd_hash_entry root; 3466 3467 enum ppc_stub_type stub_type; 3468 3469 /* The stub section. */ 3470 asection *stub_sec; 3471 3472 /* Offset within stub_sec of the beginning of this stub. */ 3473 bfd_vma stub_offset; 3474 3475 /* Given the symbol's value and its section we can determine its final 3476 value when building the stubs (so the stub knows where to jump. */ 3477 bfd_vma target_value; 3478 asection *target_section; 3479 3480 /* The symbol table entry, if any, that this was derived from. */ 3481 struct ppc_link_hash_entry *h; 3482 3483 /* And the reloc addend that this was derived from. */ 3484 bfd_vma addend; 3485 3486 /* Where this stub is being called from, or, in the case of combined 3487 stub sections, the first input section in the group. */ 3488 asection *id_sec; 3489 }; 3490 3491 struct ppc_branch_hash_entry { 3492 3493 /* Base hash table entry structure. */ 3494 struct bfd_hash_entry root; 3495 3496 /* Offset within branch lookup table. */ 3497 unsigned int offset; 3498 3499 /* Generation marker. */ 3500 unsigned int iter; 3501 }; 3502 3503 struct ppc_link_hash_entry 3504 { 3505 struct elf_link_hash_entry elf; 3506 3507 union { 3508 /* A pointer to the most recently used stub hash entry against this 3509 symbol. */ 3510 struct ppc_stub_hash_entry *stub_cache; 3511 3512 /* A pointer to the next symbol starting with a '.' */ 3513 struct ppc_link_hash_entry *next_dot_sym; 3514 } u; 3515 3516 /* Track dynamic relocs copied for this symbol. */ 3517 struct ppc_dyn_relocs *dyn_relocs; 3518 3519 /* Link between function code and descriptor symbols. */ 3520 struct ppc_link_hash_entry *oh; 3521 3522 /* Flag function code and descriptor symbols. */ 3523 unsigned int is_func:1; 3524 unsigned int is_func_descriptor:1; 3525 unsigned int fake:1; 3526 3527 /* Whether global opd/toc sym has been adjusted or not. 3528 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag 3529 should be set for all globals defined in any opd/toc section. */ 3530 unsigned int adjust_done:1; 3531 3532 /* Set if we twiddled this symbol to weak at some stage. */ 3533 unsigned int was_undefined:1; 3534 3535 /* Contexts in which symbol is used in the GOT (or TOC). 3536 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the 3537 corresponding relocs are encountered during check_relocs. 3538 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to 3539 indicate the corresponding GOT entry type is not needed. 3540 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into 3541 a TPREL one. We use a separate flag rather than setting TPREL 3542 just for convenience in distinguishing the two cases. */ 3543 #define TLS_GD 1 /* GD reloc. */ 3544 #define TLS_LD 2 /* LD reloc. */ 3545 #define TLS_TPREL 4 /* TPREL reloc, => IE. */ 3546 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ 3547 #define TLS_TLS 16 /* Any TLS reloc. */ 3548 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */ 3549 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */ 3550 char tls_mask; 3551 }; 3552 3553 /* ppc64 ELF linker hash table. */ 3554 3555 struct ppc_link_hash_table 3556 { 3557 struct elf_link_hash_table elf; 3558 3559 /* The stub hash table. */ 3560 struct bfd_hash_table stub_hash_table; 3561 3562 /* Another hash table for plt_branch stubs. */ 3563 struct bfd_hash_table branch_hash_table; 3564 3565 /* Linker stub bfd. */ 3566 bfd *stub_bfd; 3567 3568 /* Linker call-backs. */ 3569 asection * (*add_stub_section) (const char *, asection *); 3570 void (*layout_sections_again) (void); 3571 3572 /* Array to keep track of which stub sections have been created, and 3573 information on stub grouping. */ 3574 struct map_stub { 3575 /* This is the section to which stubs in the group will be attached. */ 3576 asection *link_sec; 3577 /* The stub section. */ 3578 asection *stub_sec; 3579 /* Along with elf_gp, specifies the TOC pointer used in this group. */ 3580 bfd_vma toc_off; 3581 } *stub_group; 3582 3583 /* Temp used when calculating TOC pointers. */ 3584 bfd_vma toc_curr; 3585 3586 /* Highest input section id. */ 3587 int top_id; 3588 3589 /* Highest output section index. */ 3590 int top_index; 3591 3592 /* Used when adding symbols. */ 3593 struct ppc_link_hash_entry *dot_syms; 3594 3595 /* List of input sections for each output section. */ 3596 asection **input_list; 3597 3598 /* Short-cuts to get to dynamic linker sections. */ 3599 asection *got; 3600 asection *plt; 3601 asection *relplt; 3602 asection *dynbss; 3603 asection *relbss; 3604 asection *glink; 3605 asection *sfpr; 3606 asection *brlt; 3607 asection *relbrlt; 3608 3609 /* Shortcut to .__tls_get_addr and __tls_get_addr. */ 3610 struct ppc_link_hash_entry *tls_get_addr; 3611 struct ppc_link_hash_entry *tls_get_addr_fd; 3612 3613 /* Statistics. */ 3614 unsigned long stub_count[ppc_stub_plt_call]; 3615 3616 /* Number of stubs against global syms. */ 3617 unsigned long stub_globals; 3618 3619 /* Set if we should emit symbols for stubs. */ 3620 unsigned int emit_stub_syms:1; 3621 3622 /* Support for multiple toc sections. */ 3623 unsigned int no_multi_toc:1; 3624 unsigned int multi_toc_needed:1; 3625 3626 /* Set on error. */ 3627 unsigned int stub_error:1; 3628 3629 /* Temp used by ppc64_elf_check_directives. */ 3630 unsigned int twiddled_syms:1; 3631 3632 /* Incremented every time we size stubs. */ 3633 unsigned int stub_iteration; 3634 3635 /* Small local sym to section mapping cache. */ 3636 struct sym_sec_cache sym_sec; 3637 }; 3638 3639 /* Rename some of the generic section flags to better document how they 3640 are used here. */ 3641 #define has_toc_reloc has_gp_reloc 3642 #define makes_toc_func_call need_finalize_relax 3643 #define call_check_in_progress reloc_done 3644 3645 /* Get the ppc64 ELF linker hash table from a link_info structure. */ 3646 3647 #define ppc_hash_table(p) \ 3648 ((struct ppc_link_hash_table *) ((p)->hash)) 3649 3650 #define ppc_stub_hash_lookup(table, string, create, copy) \ 3651 ((struct ppc_stub_hash_entry *) \ 3652 bfd_hash_lookup ((table), (string), (create), (copy))) 3653 3654 #define ppc_branch_hash_lookup(table, string, create, copy) \ 3655 ((struct ppc_branch_hash_entry *) \ 3656 bfd_hash_lookup ((table), (string), (create), (copy))) 3657 3658 /* Create an entry in the stub hash table. */ 3659 3660 static struct bfd_hash_entry * 3661 stub_hash_newfunc (struct bfd_hash_entry *entry, 3662 struct bfd_hash_table *table, 3663 const char *string) 3664 { 3665 /* Allocate the structure if it has not already been allocated by a 3666 subclass. */ 3667 if (entry == NULL) 3668 { 3669 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry)); 3670 if (entry == NULL) 3671 return entry; 3672 } 3673 3674 /* Call the allocation method of the superclass. */ 3675 entry = bfd_hash_newfunc (entry, table, string); 3676 if (entry != NULL) 3677 { 3678 struct ppc_stub_hash_entry *eh; 3679 3680 /* Initialize the local fields. */ 3681 eh = (struct ppc_stub_hash_entry *) entry; 3682 eh->stub_type = ppc_stub_none; 3683 eh->stub_sec = NULL; 3684 eh->stub_offset = 0; 3685 eh->target_value = 0; 3686 eh->target_section = NULL; 3687 eh->h = NULL; 3688 eh->id_sec = NULL; 3689 } 3690 3691 return entry; 3692 } 3693 3694 /* Create an entry in the branch hash table. */ 3695 3696 static struct bfd_hash_entry * 3697 branch_hash_newfunc (struct bfd_hash_entry *entry, 3698 struct bfd_hash_table *table, 3699 const char *string) 3700 { 3701 /* Allocate the structure if it has not already been allocated by a 3702 subclass. */ 3703 if (entry == NULL) 3704 { 3705 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry)); 3706 if (entry == NULL) 3707 return entry; 3708 } 3709 3710 /* Call the allocation method of the superclass. */ 3711 entry = bfd_hash_newfunc (entry, table, string); 3712 if (entry != NULL) 3713 { 3714 struct ppc_branch_hash_entry *eh; 3715 3716 /* Initialize the local fields. */ 3717 eh = (struct ppc_branch_hash_entry *) entry; 3718 eh->offset = 0; 3719 eh->iter = 0; 3720 } 3721 3722 return entry; 3723 } 3724 3725 /* Create an entry in a ppc64 ELF linker hash table. */ 3726 3727 static struct bfd_hash_entry * 3728 link_hash_newfunc (struct bfd_hash_entry *entry, 3729 struct bfd_hash_table *table, 3730 const char *string) 3731 { 3732 /* Allocate the structure if it has not already been allocated by a 3733 subclass. */ 3734 if (entry == NULL) 3735 { 3736 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry)); 3737 if (entry == NULL) 3738 return entry; 3739 } 3740 3741 /* Call the allocation method of the superclass. */ 3742 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 3743 if (entry != NULL) 3744 { 3745 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry; 3746 3747 memset (&eh->u.stub_cache, 0, 3748 (sizeof (struct ppc_link_hash_entry) 3749 - offsetof (struct ppc_link_hash_entry, u.stub_cache))); 3750 3751 /* When making function calls, old ABI code references function entry 3752 points (dot symbols), while new ABI code references the function 3753 descriptor symbol. We need to make any combination of reference and 3754 definition work together, without breaking archive linking. 3755 3756 For a defined function "foo" and an undefined call to "bar": 3757 An old object defines "foo" and ".foo", references ".bar" (possibly 3758 "bar" too). 3759 A new object defines "foo" and references "bar". 3760 3761 A new object thus has no problem with its undefined symbols being 3762 satisfied by definitions in an old object. On the other hand, the 3763 old object won't have ".bar" satisfied by a new object. 3764 3765 Keep a list of newly added dot-symbols. */ 3766 3767 if (string[0] == '.') 3768 { 3769 struct ppc_link_hash_table *htab; 3770 3771 htab = (struct ppc_link_hash_table *) table; 3772 eh->u.next_dot_sym = htab->dot_syms; 3773 htab->dot_syms = eh; 3774 } 3775 } 3776 3777 return entry; 3778 } 3779 3780 /* Create a ppc64 ELF linker hash table. */ 3781 3782 static struct bfd_link_hash_table * 3783 ppc64_elf_link_hash_table_create (bfd *abfd) 3784 { 3785 struct ppc_link_hash_table *htab; 3786 bfd_size_type amt = sizeof (struct ppc_link_hash_table); 3787 3788 htab = bfd_zmalloc (amt); 3789 if (htab == NULL) 3790 return NULL; 3791 3792 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc, 3793 sizeof (struct ppc_link_hash_entry))) 3794 { 3795 free (htab); 3796 return NULL; 3797 } 3798 3799 /* Init the stub hash table too. */ 3800 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc, 3801 sizeof (struct ppc_stub_hash_entry))) 3802 return NULL; 3803 3804 /* And the branch hash table. */ 3805 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc, 3806 sizeof (struct ppc_branch_hash_entry))) 3807 return NULL; 3808 3809 /* Initializing two fields of the union is just cosmetic. We really 3810 only care about glist, but when compiled on a 32-bit host the 3811 bfd_vma fields are larger. Setting the bfd_vma to zero makes 3812 debugger inspection of these fields look nicer. */ 3813 htab->elf.init_got_refcount.refcount = 0; 3814 htab->elf.init_got_refcount.glist = NULL; 3815 htab->elf.init_plt_refcount.refcount = 0; 3816 htab->elf.init_plt_refcount.glist = NULL; 3817 htab->elf.init_got_offset.offset = 0; 3818 htab->elf.init_got_offset.glist = NULL; 3819 htab->elf.init_plt_offset.offset = 0; 3820 htab->elf.init_plt_offset.glist = NULL; 3821 3822 return &htab->elf.root; 3823 } 3824 3825 /* Free the derived linker hash table. */ 3826 3827 static void 3828 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash) 3829 { 3830 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash; 3831 3832 bfd_hash_table_free (&ret->stub_hash_table); 3833 bfd_hash_table_free (&ret->branch_hash_table); 3834 _bfd_generic_link_hash_table_free (hash); 3835 } 3836 3837 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */ 3838 3839 void 3840 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info) 3841 { 3842 struct ppc_link_hash_table *htab; 3843 3844 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64; 3845 3846 /* Always hook our dynamic sections into the first bfd, which is the 3847 linker created stub bfd. This ensures that the GOT header is at 3848 the start of the output TOC section. */ 3849 htab = ppc_hash_table (info); 3850 htab->stub_bfd = abfd; 3851 htab->elf.dynobj = abfd; 3852 } 3853 3854 /* Build a name for an entry in the stub hash table. */ 3855 3856 static char * 3857 ppc_stub_name (const asection *input_section, 3858 const asection *sym_sec, 3859 const struct ppc_link_hash_entry *h, 3860 const Elf_Internal_Rela *rel) 3861 { 3862 char *stub_name; 3863 bfd_size_type len; 3864 3865 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31 3866 offsets from a sym as a branch target? In fact, we could 3867 probably assume the addend is always zero. */ 3868 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend); 3869 3870 if (h) 3871 { 3872 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1; 3873 stub_name = bfd_malloc (len); 3874 if (stub_name == NULL) 3875 return stub_name; 3876 3877 sprintf (stub_name, "%08x.%s+%x", 3878 input_section->id & 0xffffffff, 3879 h->elf.root.root.string, 3880 (int) rel->r_addend & 0xffffffff); 3881 } 3882 else 3883 { 3884 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1; 3885 stub_name = bfd_malloc (len); 3886 if (stub_name == NULL) 3887 return stub_name; 3888 3889 sprintf (stub_name, "%08x.%x:%x+%x", 3890 input_section->id & 0xffffffff, 3891 sym_sec->id & 0xffffffff, 3892 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff, 3893 (int) rel->r_addend & 0xffffffff); 3894 } 3895 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0') 3896 stub_name[len - 2] = 0; 3897 return stub_name; 3898 } 3899 3900 /* Look up an entry in the stub hash. Stub entries are cached because 3901 creating the stub name takes a bit of time. */ 3902 3903 static struct ppc_stub_hash_entry * 3904 ppc_get_stub_entry (const asection *input_section, 3905 const asection *sym_sec, 3906 struct ppc_link_hash_entry *h, 3907 const Elf_Internal_Rela *rel, 3908 struct ppc_link_hash_table *htab) 3909 { 3910 struct ppc_stub_hash_entry *stub_entry; 3911 const asection *id_sec; 3912 3913 /* If this input section is part of a group of sections sharing one 3914 stub section, then use the id of the first section in the group. 3915 Stub names need to include a section id, as there may well be 3916 more than one stub used to reach say, printf, and we need to 3917 distinguish between them. */ 3918 id_sec = htab->stub_group[input_section->id].link_sec; 3919 3920 if (h != NULL && h->u.stub_cache != NULL 3921 && h->u.stub_cache->h == h 3922 && h->u.stub_cache->id_sec == id_sec) 3923 { 3924 stub_entry = h->u.stub_cache; 3925 } 3926 else 3927 { 3928 char *stub_name; 3929 3930 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel); 3931 if (stub_name == NULL) 3932 return NULL; 3933 3934 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, 3935 stub_name, FALSE, FALSE); 3936 if (h != NULL) 3937 h->u.stub_cache = stub_entry; 3938 3939 free (stub_name); 3940 } 3941 3942 return stub_entry; 3943 } 3944 3945 /* Add a new stub entry to the stub hash. Not all fields of the new 3946 stub entry are initialised. */ 3947 3948 static struct ppc_stub_hash_entry * 3949 ppc_add_stub (const char *stub_name, 3950 asection *section, 3951 struct ppc_link_hash_table *htab) 3952 { 3953 asection *link_sec; 3954 asection *stub_sec; 3955 struct ppc_stub_hash_entry *stub_entry; 3956 3957 link_sec = htab->stub_group[section->id].link_sec; 3958 stub_sec = htab->stub_group[section->id].stub_sec; 3959 if (stub_sec == NULL) 3960 { 3961 stub_sec = htab->stub_group[link_sec->id].stub_sec; 3962 if (stub_sec == NULL) 3963 { 3964 size_t namelen; 3965 bfd_size_type len; 3966 char *s_name; 3967 3968 namelen = strlen (link_sec->name); 3969 len = namelen + sizeof (STUB_SUFFIX); 3970 s_name = bfd_alloc (htab->stub_bfd, len); 3971 if (s_name == NULL) 3972 return NULL; 3973 3974 memcpy (s_name, link_sec->name, namelen); 3975 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX)); 3976 stub_sec = (*htab->add_stub_section) (s_name, link_sec); 3977 if (stub_sec == NULL) 3978 return NULL; 3979 htab->stub_group[link_sec->id].stub_sec = stub_sec; 3980 } 3981 htab->stub_group[section->id].stub_sec = stub_sec; 3982 } 3983 3984 /* Enter this entry into the linker stub hash table. */ 3985 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name, 3986 TRUE, FALSE); 3987 if (stub_entry == NULL) 3988 { 3989 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"), 3990 section->owner, stub_name); 3991 return NULL; 3992 } 3993 3994 stub_entry->stub_sec = stub_sec; 3995 stub_entry->stub_offset = 0; 3996 stub_entry->id_sec = link_sec; 3997 return stub_entry; 3998 } 3999 4000 /* Create sections for linker generated code. */ 4001 4002 static bfd_boolean 4003 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info) 4004 { 4005 struct ppc_link_hash_table *htab; 4006 flagword flags; 4007 4008 htab = ppc_hash_table (info); 4009 4010 /* Create .sfpr for code to save and restore fp regs. */ 4011 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 4012 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4013 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr", 4014 flags); 4015 if (htab->sfpr == NULL 4016 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2)) 4017 return FALSE; 4018 4019 /* Create .glink for lazy dynamic linking support. */ 4020 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink", 4021 flags); 4022 if (htab->glink == NULL 4023 || ! bfd_set_section_alignment (dynobj, htab->glink, 3)) 4024 return FALSE; 4025 4026 /* Create branch lookup table for plt_branch stubs. */ 4027 flags = (SEC_ALLOC | SEC_LOAD 4028 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4029 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt", 4030 flags); 4031 if (htab->brlt == NULL 4032 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3)) 4033 return FALSE; 4034 4035 if (!info->shared) 4036 return TRUE; 4037 4038 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 4039 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4040 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj, 4041 ".rela.branch_lt", 4042 flags); 4043 if (!htab->relbrlt 4044 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3)) 4045 return FALSE; 4046 4047 return TRUE; 4048 } 4049 4050 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if 4051 not already done. */ 4052 4053 static bfd_boolean 4054 create_got_section (bfd *abfd, struct bfd_link_info *info) 4055 { 4056 asection *got, *relgot; 4057 flagword flags; 4058 struct ppc_link_hash_table *htab = ppc_hash_table (info); 4059 4060 if (!is_ppc64_elf (abfd)) 4061 return FALSE; 4062 4063 if (!htab->got) 4064 { 4065 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info)) 4066 return FALSE; 4067 4068 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got"); 4069 if (!htab->got) 4070 abort (); 4071 } 4072 4073 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 4074 | SEC_LINKER_CREATED); 4075 4076 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 4077 if (!got 4078 || !bfd_set_section_alignment (abfd, got, 3)) 4079 return FALSE; 4080 4081 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got", 4082 flags | SEC_READONLY); 4083 if (!relgot 4084 || ! bfd_set_section_alignment (abfd, relgot, 3)) 4085 return FALSE; 4086 4087 ppc64_elf_tdata (abfd)->got = got; 4088 ppc64_elf_tdata (abfd)->relgot = relgot; 4089 return TRUE; 4090 } 4091 4092 /* Create the dynamic sections, and set up shortcuts. */ 4093 4094 static bfd_boolean 4095 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) 4096 { 4097 struct ppc_link_hash_table *htab; 4098 4099 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 4100 return FALSE; 4101 4102 htab = ppc_hash_table (info); 4103 if (!htab->got) 4104 htab->got = bfd_get_section_by_name (dynobj, ".got"); 4105 htab->plt = bfd_get_section_by_name (dynobj, ".plt"); 4106 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 4107 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 4108 if (!info->shared) 4109 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss"); 4110 4111 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss 4112 || (!info->shared && !htab->relbss)) 4113 abort (); 4114 4115 return TRUE; 4116 } 4117 4118 /* Merge PLT info on FROM with that on TO. */ 4119 4120 static void 4121 move_plt_plist (struct ppc_link_hash_entry *from, 4122 struct ppc_link_hash_entry *to) 4123 { 4124 if (from->elf.plt.plist != NULL) 4125 { 4126 if (to->elf.plt.plist != NULL) 4127 { 4128 struct plt_entry **entp; 4129 struct plt_entry *ent; 4130 4131 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; ) 4132 { 4133 struct plt_entry *dent; 4134 4135 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next) 4136 if (dent->addend == ent->addend) 4137 { 4138 dent->plt.refcount += ent->plt.refcount; 4139 *entp = ent->next; 4140 break; 4141 } 4142 if (dent == NULL) 4143 entp = &ent->next; 4144 } 4145 *entp = to->elf.plt.plist; 4146 } 4147 4148 to->elf.plt.plist = from->elf.plt.plist; 4149 from->elf.plt.plist = NULL; 4150 } 4151 } 4152 4153 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 4154 4155 static void 4156 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info, 4157 struct elf_link_hash_entry *dir, 4158 struct elf_link_hash_entry *ind) 4159 { 4160 struct ppc_link_hash_entry *edir, *eind; 4161 4162 edir = (struct ppc_link_hash_entry *) dir; 4163 eind = (struct ppc_link_hash_entry *) ind; 4164 4165 /* Copy over any dynamic relocs we may have on the indirect sym. */ 4166 if (eind->dyn_relocs != NULL) 4167 { 4168 if (edir->dyn_relocs != NULL) 4169 { 4170 struct ppc_dyn_relocs **pp; 4171 struct ppc_dyn_relocs *p; 4172 4173 /* Add reloc counts against the indirect sym to the direct sym 4174 list. Merge any entries against the same section. */ 4175 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 4176 { 4177 struct ppc_dyn_relocs *q; 4178 4179 for (q = edir->dyn_relocs; q != NULL; q = q->next) 4180 if (q->sec == p->sec) 4181 { 4182 q->pc_count += p->pc_count; 4183 q->count += p->count; 4184 *pp = p->next; 4185 break; 4186 } 4187 if (q == NULL) 4188 pp = &p->next; 4189 } 4190 *pp = edir->dyn_relocs; 4191 } 4192 4193 edir->dyn_relocs = eind->dyn_relocs; 4194 eind->dyn_relocs = NULL; 4195 } 4196 4197 edir->is_func |= eind->is_func; 4198 edir->is_func_descriptor |= eind->is_func_descriptor; 4199 edir->tls_mask |= eind->tls_mask; 4200 4201 /* If called to transfer flags for a weakdef during processing 4202 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF. 4203 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 4204 if (!(ELIMINATE_COPY_RELOCS 4205 && eind->elf.root.type != bfd_link_hash_indirect 4206 && edir->elf.dynamic_adjusted)) 4207 edir->elf.non_got_ref |= eind->elf.non_got_ref; 4208 4209 edir->elf.ref_dynamic |= eind->elf.ref_dynamic; 4210 edir->elf.ref_regular |= eind->elf.ref_regular; 4211 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak; 4212 edir->elf.needs_plt |= eind->elf.needs_plt; 4213 4214 /* If we were called to copy over info for a weak sym, that's all. */ 4215 if (eind->elf.root.type != bfd_link_hash_indirect) 4216 return; 4217 4218 /* Copy over got entries that we may have already seen to the 4219 symbol which just became indirect. */ 4220 if (eind->elf.got.glist != NULL) 4221 { 4222 if (edir->elf.got.glist != NULL) 4223 { 4224 struct got_entry **entp; 4225 struct got_entry *ent; 4226 4227 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; ) 4228 { 4229 struct got_entry *dent; 4230 4231 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next) 4232 if (dent->addend == ent->addend 4233 && dent->owner == ent->owner 4234 && dent->tls_type == ent->tls_type) 4235 { 4236 dent->got.refcount += ent->got.refcount; 4237 *entp = ent->next; 4238 break; 4239 } 4240 if (dent == NULL) 4241 entp = &ent->next; 4242 } 4243 *entp = edir->elf.got.glist; 4244 } 4245 4246 edir->elf.got.glist = eind->elf.got.glist; 4247 eind->elf.got.glist = NULL; 4248 } 4249 4250 /* And plt entries. */ 4251 move_plt_plist (eind, edir); 4252 4253 if (eind->elf.dynindx != -1) 4254 { 4255 if (edir->elf.dynindx != -1) 4256 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 4257 edir->elf.dynstr_index); 4258 edir->elf.dynindx = eind->elf.dynindx; 4259 edir->elf.dynstr_index = eind->elf.dynstr_index; 4260 eind->elf.dynindx = -1; 4261 eind->elf.dynstr_index = 0; 4262 } 4263 } 4264 4265 /* Find the function descriptor hash entry from the given function code 4266 hash entry FH. Link the entries via their OH fields. */ 4267 4268 static struct ppc_link_hash_entry * 4269 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab) 4270 { 4271 struct ppc_link_hash_entry *fdh = fh->oh; 4272 4273 if (fdh == NULL) 4274 { 4275 const char *fd_name = fh->elf.root.root.string + 1; 4276 4277 fdh = (struct ppc_link_hash_entry *) 4278 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE); 4279 if (fdh != NULL) 4280 { 4281 fdh->is_func_descriptor = 1; 4282 fdh->oh = fh; 4283 fh->is_func = 1; 4284 fh->oh = fdh; 4285 } 4286 } 4287 4288 return fdh; 4289 } 4290 4291 /* Make a fake function descriptor sym for the code sym FH. */ 4292 4293 static struct ppc_link_hash_entry * 4294 make_fdh (struct bfd_link_info *info, 4295 struct ppc_link_hash_entry *fh) 4296 { 4297 bfd *abfd; 4298 asymbol *newsym; 4299 struct bfd_link_hash_entry *bh; 4300 struct ppc_link_hash_entry *fdh; 4301 4302 abfd = fh->elf.root.u.undef.abfd; 4303 newsym = bfd_make_empty_symbol (abfd); 4304 newsym->name = fh->elf.root.root.string + 1; 4305 newsym->section = bfd_und_section_ptr; 4306 newsym->value = 0; 4307 newsym->flags = BSF_WEAK; 4308 4309 bh = NULL; 4310 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name, 4311 newsym->flags, newsym->section, 4312 newsym->value, NULL, FALSE, FALSE, 4313 &bh)) 4314 return NULL; 4315 4316 fdh = (struct ppc_link_hash_entry *) bh; 4317 fdh->elf.non_elf = 0; 4318 fdh->fake = 1; 4319 fdh->is_func_descriptor = 1; 4320 fdh->oh = fh; 4321 fh->is_func = 1; 4322 fh->oh = fdh; 4323 return fdh; 4324 } 4325 4326 /* Fix function descriptor symbols defined in .opd sections to be 4327 function type. */ 4328 4329 static bfd_boolean 4330 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED, 4331 struct bfd_link_info *info ATTRIBUTE_UNUSED, 4332 Elf_Internal_Sym *isym, 4333 const char **name ATTRIBUTE_UNUSED, 4334 flagword *flags ATTRIBUTE_UNUSED, 4335 asection **sec, 4336 bfd_vma *value ATTRIBUTE_UNUSED) 4337 { 4338 if (*sec != NULL 4339 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0) 4340 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC); 4341 4342 return TRUE; 4343 } 4344 4345 /* This function makes an old ABI object reference to ".bar" cause the 4346 inclusion of a new ABI object archive that defines "bar". 4347 NAME is a symbol defined in an archive. Return a symbol in the hash 4348 table that might be satisfied by the archive symbols. */ 4349 4350 static struct elf_link_hash_entry * 4351 ppc64_elf_archive_symbol_lookup (bfd *abfd, 4352 struct bfd_link_info *info, 4353 const char *name) 4354 { 4355 struct elf_link_hash_entry *h; 4356 char *dot_name; 4357 size_t len; 4358 4359 h = _bfd_elf_archive_symbol_lookup (abfd, info, name); 4360 if (h != NULL 4361 /* Don't return this sym if it is a fake function descriptor 4362 created by add_symbol_adjust. */ 4363 && !(h->root.type == bfd_link_hash_undefweak 4364 && ((struct ppc_link_hash_entry *) h)->fake)) 4365 return h; 4366 4367 if (name[0] == '.') 4368 return h; 4369 4370 len = strlen (name); 4371 dot_name = bfd_alloc (abfd, len + 2); 4372 if (dot_name == NULL) 4373 return (struct elf_link_hash_entry *) 0 - 1; 4374 dot_name[0] = '.'; 4375 memcpy (dot_name + 1, name, len + 1); 4376 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name); 4377 bfd_release (abfd, dot_name); 4378 return h; 4379 } 4380 4381 /* This function satisfies all old ABI object references to ".bar" if a 4382 new ABI object defines "bar". Well, at least, undefined dot symbols 4383 are made weak. This stops later archive searches from including an 4384 object if we already have a function descriptor definition. It also 4385 prevents the linker complaining about undefined symbols. 4386 We also check and correct mismatched symbol visibility here. The 4387 most restrictive visibility of the function descriptor and the 4388 function entry symbol is used. */ 4389 4390 static bfd_boolean 4391 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info) 4392 { 4393 struct ppc_link_hash_table *htab; 4394 struct ppc_link_hash_entry *fdh; 4395 4396 if (eh->elf.root.type == bfd_link_hash_indirect) 4397 return TRUE; 4398 4399 if (eh->elf.root.type == bfd_link_hash_warning) 4400 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link; 4401 4402 if (eh->elf.root.root.string[0] != '.') 4403 abort (); 4404 4405 htab = ppc_hash_table (info); 4406 fdh = get_fdh (eh, htab); 4407 if (fdh == NULL 4408 && !info->relocatable 4409 && (eh->elf.root.type == bfd_link_hash_undefined 4410 || eh->elf.root.type == bfd_link_hash_undefweak) 4411 && eh->elf.ref_regular) 4412 { 4413 /* Make an undefweak function descriptor sym, which is enough to 4414 pull in an --as-needed shared lib, but won't cause link 4415 errors. Archives are handled elsewhere. */ 4416 fdh = make_fdh (info, eh); 4417 if (fdh == NULL) 4418 return FALSE; 4419 else 4420 fdh->elf.ref_regular = 1; 4421 } 4422 else if (fdh != NULL) 4423 { 4424 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1; 4425 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1; 4426 if (entry_vis < descr_vis) 4427 fdh->elf.other += entry_vis - descr_vis; 4428 else if (entry_vis > descr_vis) 4429 eh->elf.other += descr_vis - entry_vis; 4430 4431 if ((fdh->elf.root.type == bfd_link_hash_defined 4432 || fdh->elf.root.type == bfd_link_hash_defweak) 4433 && eh->elf.root.type == bfd_link_hash_undefined) 4434 { 4435 eh->elf.root.type = bfd_link_hash_undefweak; 4436 eh->was_undefined = 1; 4437 htab->twiddled_syms = 1; 4438 } 4439 } 4440 4441 return TRUE; 4442 } 4443 4444 /* Process list of dot-symbols we made in link_hash_newfunc. */ 4445 4446 static bfd_boolean 4447 ppc64_elf_check_directives (bfd *ibfd, struct bfd_link_info *info) 4448 { 4449 struct ppc_link_hash_table *htab; 4450 struct ppc_link_hash_entry **p, *eh; 4451 4452 htab = ppc_hash_table (info); 4453 if (!is_ppc64_elf (info->output_bfd)) 4454 return TRUE; 4455 4456 if (is_ppc64_elf (ibfd)) 4457 { 4458 p = &htab->dot_syms; 4459 while ((eh = *p) != NULL) 4460 { 4461 *p = NULL; 4462 if (!add_symbol_adjust (eh, info)) 4463 return FALSE; 4464 p = &eh->u.next_dot_sym; 4465 } 4466 } 4467 4468 /* Clear the list for non-ppc64 input files. */ 4469 p = &htab->dot_syms; 4470 while ((eh = *p) != NULL) 4471 { 4472 *p = NULL; 4473 p = &eh->u.next_dot_sym; 4474 } 4475 4476 /* We need to fix the undefs list for any syms we have twiddled to 4477 undef_weak. */ 4478 if (htab->twiddled_syms) 4479 { 4480 bfd_link_repair_undef_list (&htab->elf.root); 4481 htab->twiddled_syms = 0; 4482 } 4483 return TRUE; 4484 } 4485 4486 /* Undo hash table changes when an --as-needed input file is determined 4487 not to be needed. */ 4488 4489 static bfd_boolean 4490 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED, 4491 struct bfd_link_info *info) 4492 { 4493 ppc_hash_table (info)->dot_syms = NULL; 4494 return TRUE; 4495 } 4496 4497 static bfd_boolean 4498 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr, 4499 unsigned long r_symndx, bfd_vma r_addend, int tls_type) 4500 { 4501 struct got_entry **local_got_ents = elf_local_got_ents (abfd); 4502 char *local_got_tls_masks; 4503 4504 if (local_got_ents == NULL) 4505 { 4506 bfd_size_type size = symtab_hdr->sh_info; 4507 4508 size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks); 4509 local_got_ents = bfd_zalloc (abfd, size); 4510 if (local_got_ents == NULL) 4511 return FALSE; 4512 elf_local_got_ents (abfd) = local_got_ents; 4513 } 4514 4515 if ((tls_type & TLS_EXPLICIT) == 0) 4516 { 4517 struct got_entry *ent; 4518 4519 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next) 4520 if (ent->addend == r_addend 4521 && ent->owner == abfd 4522 && ent->tls_type == tls_type) 4523 break; 4524 if (ent == NULL) 4525 { 4526 bfd_size_type amt = sizeof (*ent); 4527 ent = bfd_alloc (abfd, amt); 4528 if (ent == NULL) 4529 return FALSE; 4530 ent->next = local_got_ents[r_symndx]; 4531 ent->addend = r_addend; 4532 ent->owner = abfd; 4533 ent->tls_type = tls_type; 4534 ent->got.refcount = 0; 4535 local_got_ents[r_symndx] = ent; 4536 } 4537 ent->got.refcount += 1; 4538 } 4539 4540 local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info); 4541 local_got_tls_masks[r_symndx] |= tls_type; 4542 return TRUE; 4543 } 4544 4545 static bfd_boolean 4546 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend) 4547 { 4548 struct plt_entry *ent; 4549 4550 for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next) 4551 if (ent->addend == addend) 4552 break; 4553 if (ent == NULL) 4554 { 4555 bfd_size_type amt = sizeof (*ent); 4556 ent = bfd_alloc (abfd, amt); 4557 if (ent == NULL) 4558 return FALSE; 4559 ent->next = eh->elf.plt.plist; 4560 ent->addend = addend; 4561 ent->plt.refcount = 0; 4562 eh->elf.plt.plist = ent; 4563 } 4564 ent->plt.refcount += 1; 4565 eh->elf.needs_plt = 1; 4566 if (eh->elf.root.root.string[0] == '.' 4567 && eh->elf.root.root.string[1] != '\0') 4568 eh->is_func = 1; 4569 return TRUE; 4570 } 4571 4572 /* Look through the relocs for a section during the first phase, and 4573 calculate needed space in the global offset table, procedure 4574 linkage table, and dynamic reloc sections. */ 4575 4576 static bfd_boolean 4577 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 4578 asection *sec, const Elf_Internal_Rela *relocs) 4579 { 4580 struct ppc_link_hash_table *htab; 4581 Elf_Internal_Shdr *symtab_hdr; 4582 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 4583 const Elf_Internal_Rela *rel; 4584 const Elf_Internal_Rela *rel_end; 4585 asection *sreloc; 4586 asection **opd_sym_map; 4587 struct elf_link_hash_entry *tga, *dottga; 4588 4589 if (info->relocatable) 4590 return TRUE; 4591 4592 /* Don't do anything special with non-loaded, non-alloced sections. 4593 In particular, any relocs in such sections should not affect GOT 4594 and PLT reference counting (ie. we don't allow them to create GOT 4595 or PLT entries), there's no possibility or desire to optimize TLS 4596 relocs, and there's not much point in propagating relocs to shared 4597 libs that the dynamic linker won't relocate. */ 4598 if ((sec->flags & SEC_ALLOC) == 0) 4599 return TRUE; 4600 4601 BFD_ASSERT (is_ppc64_elf (abfd)); 4602 4603 htab = ppc_hash_table (info); 4604 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 4605 FALSE, FALSE, TRUE); 4606 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr", 4607 FALSE, FALSE, TRUE); 4608 symtab_hdr = &elf_symtab_hdr (abfd); 4609 4610 sym_hashes = elf_sym_hashes (abfd); 4611 sym_hashes_end = (sym_hashes 4612 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym) 4613 - symtab_hdr->sh_info); 4614 4615 sreloc = NULL; 4616 opd_sym_map = NULL; 4617 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0) 4618 { 4619 /* Garbage collection needs some extra help with .opd sections. 4620 We don't want to necessarily keep everything referenced by 4621 relocs in .opd, as that would keep all functions. Instead, 4622 if we reference an .opd symbol (a function descriptor), we 4623 want to keep the function code symbol's section. This is 4624 easy for global symbols, but for local syms we need to keep 4625 information about the associated function section. */ 4626 bfd_size_type amt; 4627 4628 amt = sec->size * sizeof (*opd_sym_map) / 8; 4629 opd_sym_map = bfd_zalloc (abfd, amt); 4630 if (opd_sym_map == NULL) 4631 return FALSE; 4632 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map; 4633 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal); 4634 ppc64_elf_section_data (sec)->sec_type = sec_opd; 4635 } 4636 4637 if (htab->sfpr == NULL 4638 && !create_linkage_sections (htab->elf.dynobj, info)) 4639 return FALSE; 4640 4641 rel_end = relocs + sec->reloc_count; 4642 for (rel = relocs; rel < rel_end; rel++) 4643 { 4644 unsigned long r_symndx; 4645 struct elf_link_hash_entry *h; 4646 enum elf_ppc64_reloc_type r_type; 4647 int tls_type = 0; 4648 struct _ppc64_elf_section_data *ppc64_sec; 4649 4650 r_symndx = ELF64_R_SYM (rel->r_info); 4651 if (r_symndx < symtab_hdr->sh_info) 4652 h = NULL; 4653 else 4654 { 4655 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 4656 while (h->root.type == bfd_link_hash_indirect 4657 || h->root.type == bfd_link_hash_warning) 4658 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4659 } 4660 4661 r_type = ELF64_R_TYPE (rel->r_info); 4662 switch (r_type) 4663 { 4664 case R_PPC64_GOT_TLSLD16: 4665 case R_PPC64_GOT_TLSLD16_LO: 4666 case R_PPC64_GOT_TLSLD16_HI: 4667 case R_PPC64_GOT_TLSLD16_HA: 4668 tls_type = TLS_TLS | TLS_LD; 4669 goto dogottls; 4670 4671 case R_PPC64_GOT_TLSGD16: 4672 case R_PPC64_GOT_TLSGD16_LO: 4673 case R_PPC64_GOT_TLSGD16_HI: 4674 case R_PPC64_GOT_TLSGD16_HA: 4675 tls_type = TLS_TLS | TLS_GD; 4676 goto dogottls; 4677 4678 case R_PPC64_GOT_TPREL16_DS: 4679 case R_PPC64_GOT_TPREL16_LO_DS: 4680 case R_PPC64_GOT_TPREL16_HI: 4681 case R_PPC64_GOT_TPREL16_HA: 4682 if (!info->executable) 4683 info->flags |= DF_STATIC_TLS; 4684 tls_type = TLS_TLS | TLS_TPREL; 4685 goto dogottls; 4686 4687 case R_PPC64_GOT_DTPREL16_DS: 4688 case R_PPC64_GOT_DTPREL16_LO_DS: 4689 case R_PPC64_GOT_DTPREL16_HI: 4690 case R_PPC64_GOT_DTPREL16_HA: 4691 tls_type = TLS_TLS | TLS_DTPREL; 4692 dogottls: 4693 sec->has_tls_reloc = 1; 4694 /* Fall thru */ 4695 4696 case R_PPC64_GOT16: 4697 case R_PPC64_GOT16_DS: 4698 case R_PPC64_GOT16_HA: 4699 case R_PPC64_GOT16_HI: 4700 case R_PPC64_GOT16_LO: 4701 case R_PPC64_GOT16_LO_DS: 4702 /* This symbol requires a global offset table entry. */ 4703 sec->has_toc_reloc = 1; 4704 if (ppc64_elf_tdata (abfd)->got == NULL 4705 && !create_got_section (abfd, info)) 4706 return FALSE; 4707 4708 if (h != NULL) 4709 { 4710 struct ppc_link_hash_entry *eh; 4711 struct got_entry *ent; 4712 4713 eh = (struct ppc_link_hash_entry *) h; 4714 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next) 4715 if (ent->addend == rel->r_addend 4716 && ent->owner == abfd 4717 && ent->tls_type == tls_type) 4718 break; 4719 if (ent == NULL) 4720 { 4721 bfd_size_type amt = sizeof (*ent); 4722 ent = bfd_alloc (abfd, amt); 4723 if (ent == NULL) 4724 return FALSE; 4725 ent->next = eh->elf.got.glist; 4726 ent->addend = rel->r_addend; 4727 ent->owner = abfd; 4728 ent->tls_type = tls_type; 4729 ent->got.refcount = 0; 4730 eh->elf.got.glist = ent; 4731 } 4732 ent->got.refcount += 1; 4733 eh->tls_mask |= tls_type; 4734 } 4735 else 4736 /* This is a global offset table entry for a local symbol. */ 4737 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, 4738 rel->r_addend, tls_type)) 4739 return FALSE; 4740 break; 4741 4742 case R_PPC64_PLT16_HA: 4743 case R_PPC64_PLT16_HI: 4744 case R_PPC64_PLT16_LO: 4745 case R_PPC64_PLT32: 4746 case R_PPC64_PLT64: 4747 /* This symbol requires a procedure linkage table entry. We 4748 actually build the entry in adjust_dynamic_symbol, 4749 because this might be a case of linking PIC code without 4750 linking in any dynamic objects, in which case we don't 4751 need to generate a procedure linkage table after all. */ 4752 if (h == NULL) 4753 { 4754 /* It does not make sense to have a procedure linkage 4755 table entry for a local symbol. */ 4756 bfd_set_error (bfd_error_bad_value); 4757 return FALSE; 4758 } 4759 else 4760 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h, 4761 rel->r_addend)) 4762 return FALSE; 4763 break; 4764 4765 /* The following relocations don't need to propagate the 4766 relocation if linking a shared object since they are 4767 section relative. */ 4768 case R_PPC64_SECTOFF: 4769 case R_PPC64_SECTOFF_LO: 4770 case R_PPC64_SECTOFF_HI: 4771 case R_PPC64_SECTOFF_HA: 4772 case R_PPC64_SECTOFF_DS: 4773 case R_PPC64_SECTOFF_LO_DS: 4774 case R_PPC64_DTPREL16: 4775 case R_PPC64_DTPREL16_LO: 4776 case R_PPC64_DTPREL16_HI: 4777 case R_PPC64_DTPREL16_HA: 4778 case R_PPC64_DTPREL16_DS: 4779 case R_PPC64_DTPREL16_LO_DS: 4780 case R_PPC64_DTPREL16_HIGHER: 4781 case R_PPC64_DTPREL16_HIGHERA: 4782 case R_PPC64_DTPREL16_HIGHEST: 4783 case R_PPC64_DTPREL16_HIGHESTA: 4784 break; 4785 4786 /* Nor do these. */ 4787 case R_PPC64_TOC16: 4788 case R_PPC64_TOC16_LO: 4789 case R_PPC64_TOC16_HI: 4790 case R_PPC64_TOC16_HA: 4791 case R_PPC64_TOC16_DS: 4792 case R_PPC64_TOC16_LO_DS: 4793 sec->has_toc_reloc = 1; 4794 break; 4795 4796 /* This relocation describes the C++ object vtable hierarchy. 4797 Reconstruct it for later use during GC. */ 4798 case R_PPC64_GNU_VTINHERIT: 4799 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 4800 return FALSE; 4801 break; 4802 4803 /* This relocation describes which C++ vtable entries are actually 4804 used. Record for later use during GC. */ 4805 case R_PPC64_GNU_VTENTRY: 4806 BFD_ASSERT (h != NULL); 4807 if (h != NULL 4808 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 4809 return FALSE; 4810 break; 4811 4812 case R_PPC64_REL14: 4813 case R_PPC64_REL14_BRTAKEN: 4814 case R_PPC64_REL14_BRNTAKEN: 4815 { 4816 asection *dest = NULL; 4817 4818 /* Heuristic: If jumping outside our section, chances are 4819 we are going to need a stub. */ 4820 if (h != NULL) 4821 { 4822 /* If the sym is weak it may be overridden later, so 4823 don't assume we know where a weak sym lives. */ 4824 if (h->root.type == bfd_link_hash_defined) 4825 dest = h->root.u.def.section; 4826 } 4827 else 4828 dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 4829 sec, r_symndx); 4830 if (dest != sec) 4831 ppc64_elf_section_data (sec)->has_14bit_branch = 1; 4832 } 4833 /* Fall through. */ 4834 4835 case R_PPC64_REL24: 4836 if (h != NULL) 4837 { 4838 /* We may need a .plt entry if the function this reloc 4839 refers to is in a shared lib. */ 4840 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h, 4841 rel->r_addend)) 4842 return FALSE; 4843 if (h == tga || h == dottga) 4844 sec->has_tls_reloc = 1; 4845 } 4846 break; 4847 4848 case R_PPC64_TPREL64: 4849 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL; 4850 if (!info->executable) 4851 info->flags |= DF_STATIC_TLS; 4852 goto dotlstoc; 4853 4854 case R_PPC64_DTPMOD64: 4855 if (rel + 1 < rel_end 4856 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64) 4857 && rel[1].r_offset == rel->r_offset + 8) 4858 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD; 4859 else 4860 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD; 4861 goto dotlstoc; 4862 4863 case R_PPC64_DTPREL64: 4864 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL; 4865 if (rel != relocs 4866 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64) 4867 && rel[-1].r_offset == rel->r_offset - 8) 4868 /* This is the second reloc of a dtpmod, dtprel pair. 4869 Don't mark with TLS_DTPREL. */ 4870 goto dodyn; 4871 4872 dotlstoc: 4873 sec->has_tls_reloc = 1; 4874 if (h != NULL) 4875 { 4876 struct ppc_link_hash_entry *eh; 4877 eh = (struct ppc_link_hash_entry *) h; 4878 eh->tls_mask |= tls_type; 4879 } 4880 else 4881 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, 4882 rel->r_addend, tls_type)) 4883 return FALSE; 4884 4885 ppc64_sec = ppc64_elf_section_data (sec); 4886 if (ppc64_sec->sec_type != sec_toc) 4887 { 4888 bfd_size_type amt; 4889 4890 /* One extra to simplify get_tls_mask. */ 4891 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned); 4892 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt); 4893 if (ppc64_sec->u.toc.symndx == NULL) 4894 return FALSE; 4895 amt = sec->size * sizeof (bfd_vma) / 8; 4896 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt); 4897 if (ppc64_sec->u.toc.add == NULL) 4898 return FALSE; 4899 BFD_ASSERT (ppc64_sec->sec_type == sec_normal); 4900 ppc64_sec->sec_type = sec_toc; 4901 } 4902 BFD_ASSERT (rel->r_offset % 8 == 0); 4903 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx; 4904 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend; 4905 4906 /* Mark the second slot of a GD or LD entry. 4907 -1 to indicate GD and -2 to indicate LD. */ 4908 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD)) 4909 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1; 4910 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD)) 4911 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2; 4912 goto dodyn; 4913 4914 case R_PPC64_TPREL16: 4915 case R_PPC64_TPREL16_LO: 4916 case R_PPC64_TPREL16_HI: 4917 case R_PPC64_TPREL16_HA: 4918 case R_PPC64_TPREL16_DS: 4919 case R_PPC64_TPREL16_LO_DS: 4920 case R_PPC64_TPREL16_HIGHER: 4921 case R_PPC64_TPREL16_HIGHERA: 4922 case R_PPC64_TPREL16_HIGHEST: 4923 case R_PPC64_TPREL16_HIGHESTA: 4924 if (info->shared) 4925 { 4926 if (!info->executable) 4927 info->flags |= DF_STATIC_TLS; 4928 goto dodyn; 4929 } 4930 break; 4931 4932 case R_PPC64_ADDR64: 4933 if (opd_sym_map != NULL 4934 && rel + 1 < rel_end 4935 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC) 4936 { 4937 if (h != NULL) 4938 { 4939 if (h->root.root.string[0] == '.' 4940 && h->root.root.string[1] != 0 4941 && get_fdh ((struct ppc_link_hash_entry *) h, htab)) 4942 ; 4943 else 4944 ((struct ppc_link_hash_entry *) h)->is_func = 1; 4945 } 4946 else 4947 { 4948 asection *s; 4949 4950 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec, 4951 r_symndx); 4952 if (s == NULL) 4953 return FALSE; 4954 else if (s != sec) 4955 opd_sym_map[rel->r_offset / 8] = s; 4956 } 4957 } 4958 /* Fall through. */ 4959 4960 case R_PPC64_REL30: 4961 case R_PPC64_REL32: 4962 case R_PPC64_REL64: 4963 case R_PPC64_ADDR14: 4964 case R_PPC64_ADDR14_BRNTAKEN: 4965 case R_PPC64_ADDR14_BRTAKEN: 4966 case R_PPC64_ADDR16: 4967 case R_PPC64_ADDR16_DS: 4968 case R_PPC64_ADDR16_HA: 4969 case R_PPC64_ADDR16_HI: 4970 case R_PPC64_ADDR16_HIGHER: 4971 case R_PPC64_ADDR16_HIGHERA: 4972 case R_PPC64_ADDR16_HIGHEST: 4973 case R_PPC64_ADDR16_HIGHESTA: 4974 case R_PPC64_ADDR16_LO: 4975 case R_PPC64_ADDR16_LO_DS: 4976 case R_PPC64_ADDR24: 4977 case R_PPC64_ADDR32: 4978 case R_PPC64_UADDR16: 4979 case R_PPC64_UADDR32: 4980 case R_PPC64_UADDR64: 4981 case R_PPC64_TOC: 4982 if (h != NULL && !info->shared) 4983 /* We may need a copy reloc. */ 4984 h->non_got_ref = 1; 4985 4986 /* Don't propagate .opd relocs. */ 4987 if (NO_OPD_RELOCS && opd_sym_map != NULL) 4988 break; 4989 4990 /* If we are creating a shared library, and this is a reloc 4991 against a global symbol, or a non PC relative reloc 4992 against a local symbol, then we need to copy the reloc 4993 into the shared library. However, if we are linking with 4994 -Bsymbolic, we do not need to copy a reloc against a 4995 global symbol which is defined in an object we are 4996 including in the link (i.e., DEF_REGULAR is set). At 4997 this point we have not seen all the input files, so it is 4998 possible that DEF_REGULAR is not set now but will be set 4999 later (it is never cleared). In case of a weak definition, 5000 DEF_REGULAR may be cleared later by a strong definition in 5001 a shared library. We account for that possibility below by 5002 storing information in the dyn_relocs field of the hash 5003 table entry. A similar situation occurs when creating 5004 shared libraries and symbol visibility changes render the 5005 symbol local. 5006 5007 If on the other hand, we are creating an executable, we 5008 may need to keep relocations for symbols satisfied by a 5009 dynamic library if we manage to avoid copy relocs for the 5010 symbol. */ 5011 dodyn: 5012 if ((info->shared 5013 && (must_be_dyn_reloc (info, r_type) 5014 || (h != NULL 5015 && (! info->symbolic 5016 || h->root.type == bfd_link_hash_defweak 5017 || !h->def_regular)))) 5018 || (ELIMINATE_COPY_RELOCS 5019 && !info->shared 5020 && h != NULL 5021 && (h->root.type == bfd_link_hash_defweak 5022 || !h->def_regular))) 5023 { 5024 struct ppc_dyn_relocs *p; 5025 struct ppc_dyn_relocs **head; 5026 5027 /* We must copy these reloc types into the output file. 5028 Create a reloc section in dynobj and make room for 5029 this reloc. */ 5030 if (sreloc == NULL) 5031 { 5032 const char *name; 5033 bfd *dynobj; 5034 5035 name = (bfd_elf_string_from_elf_section 5036 (abfd, 5037 elf_elfheader (abfd)->e_shstrndx, 5038 elf_section_data (sec)->rel_hdr.sh_name)); 5039 if (name == NULL) 5040 return FALSE; 5041 5042 if (! CONST_STRNEQ (name, ".rela") 5043 || strcmp (bfd_get_section_name (abfd, sec), 5044 name + 5) != 0) 5045 { 5046 (*_bfd_error_handler) 5047 (_("%B: bad relocation section name `%s\'"), 5048 abfd, name); 5049 bfd_set_error (bfd_error_bad_value); 5050 } 5051 5052 dynobj = htab->elf.dynobj; 5053 sreloc = bfd_get_section_by_name (dynobj, name); 5054 if (sreloc == NULL) 5055 { 5056 flagword flags; 5057 5058 flags = (SEC_HAS_CONTENTS | SEC_READONLY 5059 | SEC_IN_MEMORY | SEC_LINKER_CREATED 5060 | SEC_ALLOC | SEC_LOAD); 5061 sreloc = bfd_make_section_with_flags (dynobj, 5062 name, 5063 flags); 5064 if (sreloc == NULL 5065 || ! bfd_set_section_alignment (dynobj, sreloc, 3)) 5066 return FALSE; 5067 } 5068 elf_section_data (sec)->sreloc = sreloc; 5069 } 5070 5071 /* If this is a global symbol, we count the number of 5072 relocations we need for this symbol. */ 5073 if (h != NULL) 5074 { 5075 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs; 5076 } 5077 else 5078 { 5079 /* Track dynamic relocs needed for local syms too. 5080 We really need local syms available to do this 5081 easily. Oh well. */ 5082 5083 asection *s; 5084 void *vpp; 5085 5086 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 5087 sec, r_symndx); 5088 if (s == NULL) 5089 return FALSE; 5090 5091 vpp = &elf_section_data (s)->local_dynrel; 5092 head = (struct ppc_dyn_relocs **) vpp; 5093 } 5094 5095 p = *head; 5096 if (p == NULL || p->sec != sec) 5097 { 5098 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 5099 if (p == NULL) 5100 return FALSE; 5101 p->next = *head; 5102 *head = p; 5103 p->sec = sec; 5104 p->count = 0; 5105 p->pc_count = 0; 5106 } 5107 5108 p->count += 1; 5109 if (!must_be_dyn_reloc (info, r_type)) 5110 p->pc_count += 1; 5111 } 5112 break; 5113 5114 default: 5115 break; 5116 } 5117 } 5118 5119 return TRUE; 5120 } 5121 5122 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address 5123 of the code entry point, and its section. */ 5124 5125 static bfd_vma 5126 opd_entry_value (asection *opd_sec, 5127 bfd_vma offset, 5128 asection **code_sec, 5129 bfd_vma *code_off) 5130 { 5131 bfd *opd_bfd = opd_sec->owner; 5132 Elf_Internal_Rela *relocs; 5133 Elf_Internal_Rela *lo, *hi, *look; 5134 bfd_vma val; 5135 5136 /* No relocs implies we are linking a --just-symbols object. */ 5137 if (opd_sec->reloc_count == 0) 5138 { 5139 bfd_vma val; 5140 5141 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8)) 5142 return (bfd_vma) -1; 5143 5144 if (code_sec != NULL) 5145 { 5146 asection *sec, *likely = NULL; 5147 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next) 5148 if (sec->vma <= val 5149 && (sec->flags & SEC_LOAD) != 0 5150 && (sec->flags & SEC_ALLOC) != 0) 5151 likely = sec; 5152 if (likely != NULL) 5153 { 5154 *code_sec = likely; 5155 if (code_off != NULL) 5156 *code_off = val - likely->vma; 5157 } 5158 } 5159 return val; 5160 } 5161 5162 BFD_ASSERT (is_ppc64_elf (opd_bfd)); 5163 5164 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs; 5165 if (relocs == NULL) 5166 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE); 5167 5168 /* Go find the opd reloc at the sym address. */ 5169 lo = relocs; 5170 BFD_ASSERT (lo != NULL); 5171 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */ 5172 val = (bfd_vma) -1; 5173 while (lo < hi) 5174 { 5175 look = lo + (hi - lo) / 2; 5176 if (look->r_offset < offset) 5177 lo = look + 1; 5178 else if (look->r_offset > offset) 5179 hi = look; 5180 else 5181 { 5182 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd); 5183 5184 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64 5185 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC) 5186 { 5187 unsigned long symndx = ELF64_R_SYM (look->r_info); 5188 asection *sec; 5189 5190 if (symndx < symtab_hdr->sh_info) 5191 { 5192 Elf_Internal_Sym *sym; 5193 5194 sym = (Elf_Internal_Sym *) symtab_hdr->contents; 5195 if (sym == NULL) 5196 { 5197 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 5198 symtab_hdr->sh_info, 5199 0, NULL, NULL, NULL); 5200 if (sym == NULL) 5201 break; 5202 symtab_hdr->contents = (bfd_byte *) sym; 5203 } 5204 5205 sym += symndx; 5206 val = sym->st_value; 5207 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx); 5208 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0); 5209 } 5210 else 5211 { 5212 struct elf_link_hash_entry **sym_hashes; 5213 struct elf_link_hash_entry *rh; 5214 5215 sym_hashes = elf_sym_hashes (opd_bfd); 5216 rh = sym_hashes[symndx - symtab_hdr->sh_info]; 5217 while (rh->root.type == bfd_link_hash_indirect 5218 || rh->root.type == bfd_link_hash_warning) 5219 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link); 5220 BFD_ASSERT (rh->root.type == bfd_link_hash_defined 5221 || rh->root.type == bfd_link_hash_defweak); 5222 val = rh->root.u.def.value; 5223 sec = rh->root.u.def.section; 5224 } 5225 val += look->r_addend; 5226 if (code_off != NULL) 5227 *code_off = val; 5228 if (code_sec != NULL) 5229 *code_sec = sec; 5230 if (sec != NULL && sec->output_section != NULL) 5231 val += sec->output_section->vma + sec->output_offset; 5232 } 5233 break; 5234 } 5235 } 5236 5237 return val; 5238 } 5239 5240 /* Mark all our entry sym sections, both opd and code section. */ 5241 5242 static void 5243 ppc64_elf_gc_keep (struct bfd_link_info *info) 5244 { 5245 struct ppc_link_hash_table *htab = ppc_hash_table (info); 5246 struct bfd_sym_chain *sym; 5247 5248 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next) 5249 { 5250 struct ppc_link_hash_entry *eh; 5251 asection *sec; 5252 5253 eh = (struct ppc_link_hash_entry *) 5254 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE); 5255 if (eh == NULL) 5256 continue; 5257 if (eh->elf.root.type != bfd_link_hash_defined 5258 && eh->elf.root.type != bfd_link_hash_defweak) 5259 continue; 5260 5261 if (eh->is_func_descriptor 5262 && (eh->oh->elf.root.type == bfd_link_hash_defined 5263 || eh->oh->elf.root.type == bfd_link_hash_defweak)) 5264 { 5265 sec = eh->oh->elf.root.u.def.section; 5266 sec->flags |= SEC_KEEP; 5267 } 5268 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 5269 && opd_entry_value (eh->elf.root.u.def.section, 5270 eh->elf.root.u.def.value, 5271 &sec, NULL) != (bfd_vma) -1) 5272 sec->flags |= SEC_KEEP; 5273 5274 sec = eh->elf.root.u.def.section; 5275 sec->flags |= SEC_KEEP; 5276 } 5277 } 5278 5279 /* Mark sections containing dynamically referenced symbols. When 5280 building shared libraries, we must assume that any visible symbol is 5281 referenced. */ 5282 5283 static bfd_boolean 5284 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf) 5285 { 5286 struct bfd_link_info *info = (struct bfd_link_info *) inf; 5287 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h; 5288 5289 if (eh->elf.root.type == bfd_link_hash_warning) 5290 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link; 5291 5292 /* Dynamic linking info is on the func descriptor sym. */ 5293 if (eh->oh != NULL 5294 && eh->oh->is_func_descriptor 5295 && (eh->oh->elf.root.type == bfd_link_hash_defined 5296 || eh->oh->elf.root.type == bfd_link_hash_defweak)) 5297 eh = eh->oh; 5298 5299 if ((eh->elf.root.type == bfd_link_hash_defined 5300 || eh->elf.root.type == bfd_link_hash_defweak) 5301 && (eh->elf.ref_dynamic 5302 || (!info->executable 5303 && eh->elf.def_regular 5304 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL 5305 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN))) 5306 { 5307 asection *code_sec; 5308 5309 eh->elf.root.u.def.section->flags |= SEC_KEEP; 5310 5311 /* Function descriptor syms cause the associated 5312 function code sym section to be marked. */ 5313 if (eh->is_func_descriptor 5314 && (eh->oh->elf.root.type == bfd_link_hash_defined 5315 || eh->oh->elf.root.type == bfd_link_hash_defweak)) 5316 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP; 5317 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 5318 && opd_entry_value (eh->elf.root.u.def.section, 5319 eh->elf.root.u.def.value, 5320 &code_sec, NULL) != (bfd_vma) -1) 5321 code_sec->flags |= SEC_KEEP; 5322 } 5323 5324 return TRUE; 5325 } 5326 5327 /* Return the section that should be marked against GC for a given 5328 relocation. */ 5329 5330 static asection * 5331 ppc64_elf_gc_mark_hook (asection *sec, 5332 struct bfd_link_info *info ATTRIBUTE_UNUSED, 5333 Elf_Internal_Rela *rel, 5334 struct elf_link_hash_entry *h, 5335 Elf_Internal_Sym *sym) 5336 { 5337 asection *rsec; 5338 5339 /* Syms return NULL if we're marking .opd, so we avoid marking all 5340 function sections, as all functions are referenced in .opd. */ 5341 rsec = NULL; 5342 if (get_opd_info (sec) != NULL) 5343 return rsec; 5344 5345 if (h != NULL) 5346 { 5347 enum elf_ppc64_reloc_type r_type; 5348 struct ppc_link_hash_entry *eh; 5349 5350 r_type = ELF64_R_TYPE (rel->r_info); 5351 switch (r_type) 5352 { 5353 case R_PPC64_GNU_VTINHERIT: 5354 case R_PPC64_GNU_VTENTRY: 5355 break; 5356 5357 default: 5358 switch (h->root.type) 5359 { 5360 case bfd_link_hash_defined: 5361 case bfd_link_hash_defweak: 5362 eh = (struct ppc_link_hash_entry *) h; 5363 if (eh->oh != NULL 5364 && eh->oh->is_func_descriptor 5365 && (eh->oh->elf.root.type == bfd_link_hash_defined 5366 || eh->oh->elf.root.type == bfd_link_hash_defweak)) 5367 eh = eh->oh; 5368 5369 /* Function descriptor syms cause the associated 5370 function code sym section to be marked. */ 5371 if (eh->is_func_descriptor 5372 && (eh->oh->elf.root.type == bfd_link_hash_defined 5373 || eh->oh->elf.root.type == bfd_link_hash_defweak)) 5374 { 5375 /* They also mark their opd section. */ 5376 eh->elf.root.u.def.section->gc_mark = 1; 5377 5378 rsec = eh->oh->elf.root.u.def.section; 5379 } 5380 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 5381 && opd_entry_value (eh->elf.root.u.def.section, 5382 eh->elf.root.u.def.value, 5383 &rsec, NULL) != (bfd_vma) -1) 5384 eh->elf.root.u.def.section->gc_mark = 1; 5385 else 5386 rsec = h->root.u.def.section; 5387 break; 5388 5389 case bfd_link_hash_common: 5390 rsec = h->root.u.c.p->section; 5391 break; 5392 5393 default: 5394 break; 5395 } 5396 } 5397 } 5398 else 5399 { 5400 struct _opd_sec_data *opd; 5401 5402 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx); 5403 opd = get_opd_info (rsec); 5404 if (opd != NULL && opd->func_sec != NULL) 5405 { 5406 rsec->gc_mark = 1; 5407 5408 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8]; 5409 } 5410 } 5411 5412 return rsec; 5413 } 5414 5415 /* Update the .got, .plt. and dynamic reloc reference counts for the 5416 section being removed. */ 5417 5418 static bfd_boolean 5419 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, 5420 asection *sec, const Elf_Internal_Rela *relocs) 5421 { 5422 struct ppc_link_hash_table *htab; 5423 Elf_Internal_Shdr *symtab_hdr; 5424 struct elf_link_hash_entry **sym_hashes; 5425 struct got_entry **local_got_ents; 5426 const Elf_Internal_Rela *rel, *relend; 5427 5428 if (info->relocatable) 5429 return TRUE; 5430 5431 if ((sec->flags & SEC_ALLOC) == 0) 5432 return TRUE; 5433 5434 elf_section_data (sec)->local_dynrel = NULL; 5435 5436 htab = ppc_hash_table (info); 5437 symtab_hdr = &elf_symtab_hdr (abfd); 5438 sym_hashes = elf_sym_hashes (abfd); 5439 local_got_ents = elf_local_got_ents (abfd); 5440 5441 relend = relocs + sec->reloc_count; 5442 for (rel = relocs; rel < relend; rel++) 5443 { 5444 unsigned long r_symndx; 5445 enum elf_ppc64_reloc_type r_type; 5446 struct elf_link_hash_entry *h = NULL; 5447 char tls_type = 0; 5448 5449 r_symndx = ELF64_R_SYM (rel->r_info); 5450 r_type = ELF64_R_TYPE (rel->r_info); 5451 if (r_symndx >= symtab_hdr->sh_info) 5452 { 5453 struct ppc_link_hash_entry *eh; 5454 struct ppc_dyn_relocs **pp; 5455 struct ppc_dyn_relocs *p; 5456 5457 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5458 while (h->root.type == bfd_link_hash_indirect 5459 || h->root.type == bfd_link_hash_warning) 5460 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5461 eh = (struct ppc_link_hash_entry *) h; 5462 5463 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 5464 if (p->sec == sec) 5465 { 5466 /* Everything must go for SEC. */ 5467 *pp = p->next; 5468 break; 5469 } 5470 } 5471 5472 switch (r_type) 5473 { 5474 case R_PPC64_GOT_TLSLD16: 5475 case R_PPC64_GOT_TLSLD16_LO: 5476 case R_PPC64_GOT_TLSLD16_HI: 5477 case R_PPC64_GOT_TLSLD16_HA: 5478 tls_type = TLS_TLS | TLS_LD; 5479 goto dogot; 5480 5481 case R_PPC64_GOT_TLSGD16: 5482 case R_PPC64_GOT_TLSGD16_LO: 5483 case R_PPC64_GOT_TLSGD16_HI: 5484 case R_PPC64_GOT_TLSGD16_HA: 5485 tls_type = TLS_TLS | TLS_GD; 5486 goto dogot; 5487 5488 case R_PPC64_GOT_TPREL16_DS: 5489 case R_PPC64_GOT_TPREL16_LO_DS: 5490 case R_PPC64_GOT_TPREL16_HI: 5491 case R_PPC64_GOT_TPREL16_HA: 5492 tls_type = TLS_TLS | TLS_TPREL; 5493 goto dogot; 5494 5495 case R_PPC64_GOT_DTPREL16_DS: 5496 case R_PPC64_GOT_DTPREL16_LO_DS: 5497 case R_PPC64_GOT_DTPREL16_HI: 5498 case R_PPC64_GOT_DTPREL16_HA: 5499 tls_type = TLS_TLS | TLS_DTPREL; 5500 goto dogot; 5501 5502 case R_PPC64_GOT16: 5503 case R_PPC64_GOT16_DS: 5504 case R_PPC64_GOT16_HA: 5505 case R_PPC64_GOT16_HI: 5506 case R_PPC64_GOT16_LO: 5507 case R_PPC64_GOT16_LO_DS: 5508 dogot: 5509 { 5510 struct got_entry *ent; 5511 5512 if (h != NULL) 5513 ent = h->got.glist; 5514 else 5515 ent = local_got_ents[r_symndx]; 5516 5517 for (; ent != NULL; ent = ent->next) 5518 if (ent->addend == rel->r_addend 5519 && ent->owner == abfd 5520 && ent->tls_type == tls_type) 5521 break; 5522 if (ent == NULL) 5523 abort (); 5524 if (ent->got.refcount > 0) 5525 ent->got.refcount -= 1; 5526 } 5527 break; 5528 5529 case R_PPC64_PLT16_HA: 5530 case R_PPC64_PLT16_HI: 5531 case R_PPC64_PLT16_LO: 5532 case R_PPC64_PLT32: 5533 case R_PPC64_PLT64: 5534 case R_PPC64_REL14: 5535 case R_PPC64_REL14_BRNTAKEN: 5536 case R_PPC64_REL14_BRTAKEN: 5537 case R_PPC64_REL24: 5538 if (h != NULL) 5539 { 5540 struct plt_entry *ent; 5541 5542 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 5543 if (ent->addend == rel->r_addend) 5544 break; 5545 if (ent == NULL) 5546 abort (); 5547 if (ent->plt.refcount > 0) 5548 ent->plt.refcount -= 1; 5549 } 5550 break; 5551 5552 default: 5553 break; 5554 } 5555 } 5556 return TRUE; 5557 } 5558 5559 /* The maximum size of .sfpr. */ 5560 #define SFPR_MAX (218*4) 5561 5562 struct sfpr_def_parms 5563 { 5564 const char name[12]; 5565 unsigned char lo, hi; 5566 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int); 5567 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int); 5568 }; 5569 5570 /* Auto-generate _save*, _rest* functions in .sfpr. */ 5571 5572 static unsigned int 5573 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm) 5574 { 5575 struct ppc_link_hash_table *htab = ppc_hash_table (info); 5576 unsigned int i; 5577 size_t len = strlen (parm->name); 5578 bfd_boolean writing = FALSE; 5579 char sym[16]; 5580 5581 memcpy (sym, parm->name, len); 5582 sym[len + 2] = 0; 5583 5584 for (i = parm->lo; i <= parm->hi; i++) 5585 { 5586 struct elf_link_hash_entry *h; 5587 5588 sym[len + 0] = i / 10 + '0'; 5589 sym[len + 1] = i % 10 + '0'; 5590 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE); 5591 if (h != NULL 5592 && !h->def_regular) 5593 { 5594 h->root.type = bfd_link_hash_defined; 5595 h->root.u.def.section = htab->sfpr; 5596 h->root.u.def.value = htab->sfpr->size; 5597 h->type = STT_FUNC; 5598 h->def_regular = 1; 5599 _bfd_elf_link_hash_hide_symbol (info, h, TRUE); 5600 writing = TRUE; 5601 if (htab->sfpr->contents == NULL) 5602 { 5603 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX); 5604 if (htab->sfpr->contents == NULL) 5605 return FALSE; 5606 } 5607 } 5608 if (writing) 5609 { 5610 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size; 5611 if (i != parm->hi) 5612 p = (*parm->write_ent) (htab->elf.dynobj, p, i); 5613 else 5614 p = (*parm->write_tail) (htab->elf.dynobj, p, i); 5615 htab->sfpr->size = p - htab->sfpr->contents; 5616 } 5617 } 5618 5619 return TRUE; 5620 } 5621 5622 static bfd_byte * 5623 savegpr0 (bfd *abfd, bfd_byte *p, int r) 5624 { 5625 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5626 return p + 4; 5627 } 5628 5629 static bfd_byte * 5630 savegpr0_tail (bfd *abfd, bfd_byte *p, int r) 5631 { 5632 p = savegpr0 (abfd, p, r); 5633 bfd_put_32 (abfd, STD_R0_0R1 + 16, p); 5634 p = p + 4; 5635 bfd_put_32 (abfd, BLR, p); 5636 return p + 4; 5637 } 5638 5639 static bfd_byte * 5640 restgpr0 (bfd *abfd, bfd_byte *p, int r) 5641 { 5642 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5643 return p + 4; 5644 } 5645 5646 static bfd_byte * 5647 restgpr0_tail (bfd *abfd, bfd_byte *p, int r) 5648 { 5649 bfd_put_32 (abfd, LD_R0_0R1 + 16, p); 5650 p = p + 4; 5651 p = restgpr0 (abfd, p, r); 5652 bfd_put_32 (abfd, MTLR_R0, p); 5653 p = p + 4; 5654 if (r == 29) 5655 { 5656 p = restgpr0 (abfd, p, 30); 5657 p = restgpr0 (abfd, p, 31); 5658 } 5659 bfd_put_32 (abfd, BLR, p); 5660 return p + 4; 5661 } 5662 5663 static bfd_byte * 5664 savegpr1 (bfd *abfd, bfd_byte *p, int r) 5665 { 5666 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5667 return p + 4; 5668 } 5669 5670 static bfd_byte * 5671 savegpr1_tail (bfd *abfd, bfd_byte *p, int r) 5672 { 5673 p = savegpr1 (abfd, p, r); 5674 bfd_put_32 (abfd, BLR, p); 5675 return p + 4; 5676 } 5677 5678 static bfd_byte * 5679 restgpr1 (bfd *abfd, bfd_byte *p, int r) 5680 { 5681 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5682 return p + 4; 5683 } 5684 5685 static bfd_byte * 5686 restgpr1_tail (bfd *abfd, bfd_byte *p, int r) 5687 { 5688 p = restgpr1 (abfd, p, r); 5689 bfd_put_32 (abfd, BLR, p); 5690 return p + 4; 5691 } 5692 5693 static bfd_byte * 5694 savefpr (bfd *abfd, bfd_byte *p, int r) 5695 { 5696 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5697 return p + 4; 5698 } 5699 5700 static bfd_byte * 5701 savefpr0_tail (bfd *abfd, bfd_byte *p, int r) 5702 { 5703 p = savefpr (abfd, p, r); 5704 bfd_put_32 (abfd, STD_R0_0R1 + 16, p); 5705 p = p + 4; 5706 bfd_put_32 (abfd, BLR, p); 5707 return p + 4; 5708 } 5709 5710 static bfd_byte * 5711 restfpr (bfd *abfd, bfd_byte *p, int r) 5712 { 5713 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 5714 return p + 4; 5715 } 5716 5717 static bfd_byte * 5718 restfpr0_tail (bfd *abfd, bfd_byte *p, int r) 5719 { 5720 bfd_put_32 (abfd, LD_R0_0R1 + 16, p); 5721 p = p + 4; 5722 p = restfpr (abfd, p, r); 5723 bfd_put_32 (abfd, MTLR_R0, p); 5724 p = p + 4; 5725 if (r == 29) 5726 { 5727 p = restfpr (abfd, p, 30); 5728 p = restfpr (abfd, p, 31); 5729 } 5730 bfd_put_32 (abfd, BLR, p); 5731 return p + 4; 5732 } 5733 5734 static bfd_byte * 5735 savefpr1_tail (bfd *abfd, bfd_byte *p, int r) 5736 { 5737 p = savefpr (abfd, p, r); 5738 bfd_put_32 (abfd, BLR, p); 5739 return p + 4; 5740 } 5741 5742 static bfd_byte * 5743 restfpr1_tail (bfd *abfd, bfd_byte *p, int r) 5744 { 5745 p = restfpr (abfd, p, r); 5746 bfd_put_32 (abfd, BLR, p); 5747 return p + 4; 5748 } 5749 5750 static bfd_byte * 5751 savevr (bfd *abfd, bfd_byte *p, int r) 5752 { 5753 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p); 5754 p = p + 4; 5755 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p); 5756 return p + 4; 5757 } 5758 5759 static bfd_byte * 5760 savevr_tail (bfd *abfd, bfd_byte *p, int r) 5761 { 5762 p = savevr (abfd, p, r); 5763 bfd_put_32 (abfd, BLR, p); 5764 return p + 4; 5765 } 5766 5767 static bfd_byte * 5768 restvr (bfd *abfd, bfd_byte *p, int r) 5769 { 5770 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p); 5771 p = p + 4; 5772 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p); 5773 return p + 4; 5774 } 5775 5776 static bfd_byte * 5777 restvr_tail (bfd *abfd, bfd_byte *p, int r) 5778 { 5779 p = restvr (abfd, p, r); 5780 bfd_put_32 (abfd, BLR, p); 5781 return p + 4; 5782 } 5783 5784 /* Called via elf_link_hash_traverse to transfer dynamic linking 5785 information on function code symbol entries to their corresponding 5786 function descriptor symbol entries. */ 5787 5788 static bfd_boolean 5789 func_desc_adjust (struct elf_link_hash_entry *h, void *inf) 5790 { 5791 struct bfd_link_info *info; 5792 struct ppc_link_hash_table *htab; 5793 struct plt_entry *ent; 5794 struct ppc_link_hash_entry *fh; 5795 struct ppc_link_hash_entry *fdh; 5796 bfd_boolean force_local; 5797 5798 fh = (struct ppc_link_hash_entry *) h; 5799 if (fh->elf.root.type == bfd_link_hash_indirect) 5800 return TRUE; 5801 5802 if (fh->elf.root.type == bfd_link_hash_warning) 5803 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link; 5804 5805 info = inf; 5806 htab = ppc_hash_table (info); 5807 5808 /* Resolve undefined references to dot-symbols as the value 5809 in the function descriptor, if we have one in a regular object. 5810 This is to satisfy cases like ".quad .foo". Calls to functions 5811 in dynamic objects are handled elsewhere. */ 5812 if (fh->elf.root.type == bfd_link_hash_undefweak 5813 && fh->was_undefined 5814 && (fh->oh->elf.root.type == bfd_link_hash_defined 5815 || fh->oh->elf.root.type == bfd_link_hash_defweak) 5816 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL 5817 && opd_entry_value (fh->oh->elf.root.u.def.section, 5818 fh->oh->elf.root.u.def.value, 5819 &fh->elf.root.u.def.section, 5820 &fh->elf.root.u.def.value) != (bfd_vma) -1) 5821 { 5822 fh->elf.root.type = fh->oh->elf.root.type; 5823 fh->elf.forced_local = 1; 5824 fh->elf.def_regular = fh->oh->elf.def_regular; 5825 fh->elf.def_dynamic = fh->oh->elf.def_dynamic; 5826 } 5827 5828 /* If this is a function code symbol, transfer dynamic linking 5829 information to the function descriptor symbol. */ 5830 if (!fh->is_func) 5831 return TRUE; 5832 5833 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next) 5834 if (ent->plt.refcount > 0) 5835 break; 5836 if (ent == NULL 5837 || fh->elf.root.root.string[0] != '.' 5838 || fh->elf.root.root.string[1] == '\0') 5839 return TRUE; 5840 5841 /* Find the corresponding function descriptor symbol. Create it 5842 as undefined if necessary. */ 5843 5844 fdh = get_fdh (fh, htab); 5845 if (fdh != NULL) 5846 while (fdh->elf.root.type == bfd_link_hash_indirect 5847 || fdh->elf.root.type == bfd_link_hash_warning) 5848 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link; 5849 5850 if (fdh == NULL 5851 && !info->executable 5852 && (fh->elf.root.type == bfd_link_hash_undefined 5853 || fh->elf.root.type == bfd_link_hash_undefweak)) 5854 { 5855 fdh = make_fdh (info, fh); 5856 if (fdh == NULL) 5857 return FALSE; 5858 } 5859 5860 /* Fake function descriptors are made undefweak. If the function 5861 code symbol is strong undefined, make the fake sym the same. 5862 If the function code symbol is defined, then force the fake 5863 descriptor local; We can't support overriding of symbols in a 5864 shared library on a fake descriptor. */ 5865 5866 if (fdh != NULL 5867 && fdh->fake 5868 && fdh->elf.root.type == bfd_link_hash_undefweak) 5869 { 5870 if (fh->elf.root.type == bfd_link_hash_undefined) 5871 { 5872 fdh->elf.root.type = bfd_link_hash_undefined; 5873 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root); 5874 } 5875 else if (fh->elf.root.type == bfd_link_hash_defined 5876 || fh->elf.root.type == bfd_link_hash_defweak) 5877 { 5878 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE); 5879 } 5880 } 5881 5882 if (fdh != NULL 5883 && !fdh->elf.forced_local 5884 && (!info->executable 5885 || fdh->elf.def_dynamic 5886 || fdh->elf.ref_dynamic 5887 || (fdh->elf.root.type == bfd_link_hash_undefweak 5888 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT))) 5889 { 5890 if (fdh->elf.dynindx == -1) 5891 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf)) 5892 return FALSE; 5893 fdh->elf.ref_regular |= fh->elf.ref_regular; 5894 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic; 5895 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak; 5896 fdh->elf.non_got_ref |= fh->elf.non_got_ref; 5897 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT) 5898 { 5899 move_plt_plist (fh, fdh); 5900 fdh->elf.needs_plt = 1; 5901 } 5902 fdh->is_func_descriptor = 1; 5903 fdh->oh = fh; 5904 fh->oh = fdh; 5905 } 5906 5907 /* Now that the info is on the function descriptor, clear the 5908 function code sym info. Any function code syms for which we 5909 don't have a definition in a regular file, we force local. 5910 This prevents a shared library from exporting syms that have 5911 been imported from another library. Function code syms that 5912 are really in the library we must leave global to prevent the 5913 linker dragging in a definition from a static library. */ 5914 force_local = (!fh->elf.def_regular 5915 || fdh == NULL 5916 || !fdh->elf.def_regular 5917 || fdh->elf.forced_local); 5918 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local); 5919 5920 return TRUE; 5921 } 5922 5923 /* Called near the start of bfd_elf_size_dynamic_sections. We use 5924 this hook to a) provide some gcc support functions, and b) transfer 5925 dynamic linking information gathered so far on function code symbol 5926 entries, to their corresponding function descriptor symbol entries. */ 5927 5928 static bfd_boolean 5929 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED, 5930 struct bfd_link_info *info) 5931 { 5932 struct ppc_link_hash_table *htab; 5933 unsigned int i; 5934 const struct sfpr_def_parms funcs[] = 5935 { 5936 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail }, 5937 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail }, 5938 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail }, 5939 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail }, 5940 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail }, 5941 { "_savefpr_", 14, 31, savefpr, savefpr0_tail }, 5942 { "_restfpr_", 14, 29, restfpr, restfpr0_tail }, 5943 { "_restfpr_", 30, 31, restfpr, restfpr0_tail }, 5944 { "._savef", 14, 31, savefpr, savefpr1_tail }, 5945 { "._restf", 14, 31, restfpr, restfpr1_tail }, 5946 { "_savevr_", 20, 31, savevr, savevr_tail }, 5947 { "_restvr_", 20, 31, restvr, restvr_tail } 5948 }; 5949 5950 htab = ppc_hash_table (info); 5951 if (htab->sfpr == NULL) 5952 /* We don't have any relocs. */ 5953 return TRUE; 5954 5955 /* Provide any missing _save* and _rest* functions. */ 5956 htab->sfpr->size = 0; 5957 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++) 5958 if (!sfpr_define (info, &funcs[i])) 5959 return FALSE; 5960 5961 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info); 5962 5963 if (htab->sfpr->size == 0) 5964 htab->sfpr->flags |= SEC_EXCLUDE; 5965 5966 return TRUE; 5967 } 5968 5969 /* Adjust a symbol defined by a dynamic object and referenced by a 5970 regular object. The current definition is in some section of the 5971 dynamic object, but we're not including those sections. We have to 5972 change the definition to something the rest of the link can 5973 understand. */ 5974 5975 static bfd_boolean 5976 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 5977 struct elf_link_hash_entry *h) 5978 { 5979 struct ppc_link_hash_table *htab; 5980 asection *s; 5981 5982 htab = ppc_hash_table (info); 5983 5984 /* Deal with function syms. */ 5985 if (h->type == STT_FUNC 5986 || h->needs_plt) 5987 { 5988 /* Clear procedure linkage table information for any symbol that 5989 won't need a .plt entry. */ 5990 struct plt_entry *ent; 5991 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 5992 if (ent->plt.refcount > 0) 5993 break; 5994 if (ent == NULL 5995 || SYMBOL_CALLS_LOCAL (info, h) 5996 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 5997 && h->root.type == bfd_link_hash_undefweak)) 5998 { 5999 h->plt.plist = NULL; 6000 h->needs_plt = 0; 6001 } 6002 } 6003 else 6004 h->plt.plist = NULL; 6005 6006 /* If this is a weak symbol, and there is a real definition, the 6007 processor independent code will have arranged for us to see the 6008 real definition first, and we can just use the same value. */ 6009 if (h->u.weakdef != NULL) 6010 { 6011 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 6012 || h->u.weakdef->root.type == bfd_link_hash_defweak); 6013 h->root.u.def.section = h->u.weakdef->root.u.def.section; 6014 h->root.u.def.value = h->u.weakdef->root.u.def.value; 6015 if (ELIMINATE_COPY_RELOCS) 6016 h->non_got_ref = h->u.weakdef->non_got_ref; 6017 return TRUE; 6018 } 6019 6020 /* If we are creating a shared library, we must presume that the 6021 only references to the symbol are via the global offset table. 6022 For such cases we need not do anything here; the relocations will 6023 be handled correctly by relocate_section. */ 6024 if (info->shared) 6025 return TRUE; 6026 6027 /* If there are no references to this symbol that do not use the 6028 GOT, we don't need to generate a copy reloc. */ 6029 if (!h->non_got_ref) 6030 return TRUE; 6031 6032 /* Don't generate a copy reloc for symbols defined in the executable. */ 6033 if (!h->def_dynamic || !h->ref_regular || h->def_regular) 6034 return TRUE; 6035 6036 if (ELIMINATE_COPY_RELOCS) 6037 { 6038 struct ppc_link_hash_entry * eh; 6039 struct ppc_dyn_relocs *p; 6040 6041 eh = (struct ppc_link_hash_entry *) h; 6042 for (p = eh->dyn_relocs; p != NULL; p = p->next) 6043 { 6044 s = p->sec->output_section; 6045 if (s != NULL && (s->flags & SEC_READONLY) != 0) 6046 break; 6047 } 6048 6049 /* If we didn't find any dynamic relocs in read-only sections, then 6050 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 6051 if (p == NULL) 6052 { 6053 h->non_got_ref = 0; 6054 return TRUE; 6055 } 6056 } 6057 6058 if (h->plt.plist != NULL) 6059 { 6060 /* We should never get here, but unfortunately there are versions 6061 of gcc out there that improperly (for this ABI) put initialized 6062 function pointers, vtable refs and suchlike in read-only 6063 sections. Allow them to proceed, but warn that this might 6064 break at runtime. */ 6065 (*_bfd_error_handler) 6066 (_("copy reloc against `%s' requires lazy plt linking; " 6067 "avoid setting LD_BIND_NOW=1 or upgrade gcc"), 6068 h->root.root.string); 6069 } 6070 6071 /* This is a reference to a symbol defined by a dynamic object which 6072 is not a function. */ 6073 6074 if (h->size == 0) 6075 { 6076 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 6077 h->root.root.string); 6078 return TRUE; 6079 } 6080 6081 /* We must allocate the symbol in our .dynbss section, which will 6082 become part of the .bss section of the executable. There will be 6083 an entry for this symbol in the .dynsym section. The dynamic 6084 object will contain position independent code, so all references 6085 from the dynamic object to this symbol will go through the global 6086 offset table. The dynamic linker will use the .dynsym entry to 6087 determine the address it must put in the global offset table, so 6088 both the dynamic object and the regular object will refer to the 6089 same memory location for the variable. */ 6090 6091 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker 6092 to copy the initial value out of the dynamic object and into the 6093 runtime process image. We need to remember the offset into the 6094 .rela.bss section we are going to use. */ 6095 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 6096 { 6097 htab->relbss->size += sizeof (Elf64_External_Rela); 6098 h->needs_copy = 1; 6099 } 6100 6101 s = htab->dynbss; 6102 6103 return _bfd_elf_adjust_dynamic_copy (h, s); 6104 } 6105 6106 /* If given a function descriptor symbol, hide both the function code 6107 sym and the descriptor. */ 6108 static void 6109 ppc64_elf_hide_symbol (struct bfd_link_info *info, 6110 struct elf_link_hash_entry *h, 6111 bfd_boolean force_local) 6112 { 6113 struct ppc_link_hash_entry *eh; 6114 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 6115 6116 eh = (struct ppc_link_hash_entry *) h; 6117 if (eh->is_func_descriptor) 6118 { 6119 struct ppc_link_hash_entry *fh = eh->oh; 6120 6121 if (fh == NULL) 6122 { 6123 const char *p, *q; 6124 struct ppc_link_hash_table *htab; 6125 char save; 6126 6127 /* We aren't supposed to use alloca in BFD because on 6128 systems which do not have alloca the version in libiberty 6129 calls xmalloc, which might cause the program to crash 6130 when it runs out of memory. This function doesn't have a 6131 return status, so there's no way to gracefully return an 6132 error. So cheat. We know that string[-1] can be safely 6133 accessed; It's either a string in an ELF string table, 6134 or allocated in an objalloc structure. */ 6135 6136 p = eh->elf.root.root.string - 1; 6137 save = *p; 6138 *(char *) p = '.'; 6139 htab = ppc_hash_table (info); 6140 fh = (struct ppc_link_hash_entry *) 6141 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE); 6142 *(char *) p = save; 6143 6144 /* Unfortunately, if it so happens that the string we were 6145 looking for was allocated immediately before this string, 6146 then we overwrote the string terminator. That's the only 6147 reason the lookup should fail. */ 6148 if (fh == NULL) 6149 { 6150 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string); 6151 while (q >= eh->elf.root.root.string && *q == *p) 6152 --q, --p; 6153 if (q < eh->elf.root.root.string && *p == '.') 6154 fh = (struct ppc_link_hash_entry *) 6155 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE); 6156 } 6157 if (fh != NULL) 6158 { 6159 eh->oh = fh; 6160 fh->oh = eh; 6161 } 6162 } 6163 if (fh != NULL) 6164 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local); 6165 } 6166 } 6167 6168 static bfd_boolean 6169 get_sym_h (struct elf_link_hash_entry **hp, 6170 Elf_Internal_Sym **symp, 6171 asection **symsecp, 6172 char **tls_maskp, 6173 Elf_Internal_Sym **locsymsp, 6174 unsigned long r_symndx, 6175 bfd *ibfd) 6176 { 6177 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 6178 6179 if (r_symndx >= symtab_hdr->sh_info) 6180 { 6181 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 6182 struct elf_link_hash_entry *h; 6183 6184 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6185 while (h->root.type == bfd_link_hash_indirect 6186 || h->root.type == bfd_link_hash_warning) 6187 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6188 6189 if (hp != NULL) 6190 *hp = h; 6191 6192 if (symp != NULL) 6193 *symp = NULL; 6194 6195 if (symsecp != NULL) 6196 { 6197 asection *symsec = NULL; 6198 if (h->root.type == bfd_link_hash_defined 6199 || h->root.type == bfd_link_hash_defweak) 6200 symsec = h->root.u.def.section; 6201 *symsecp = symsec; 6202 } 6203 6204 if (tls_maskp != NULL) 6205 { 6206 struct ppc_link_hash_entry *eh; 6207 6208 eh = (struct ppc_link_hash_entry *) h; 6209 *tls_maskp = &eh->tls_mask; 6210 } 6211 } 6212 else 6213 { 6214 Elf_Internal_Sym *sym; 6215 Elf_Internal_Sym *locsyms = *locsymsp; 6216 6217 if (locsyms == NULL) 6218 { 6219 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 6220 if (locsyms == NULL) 6221 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 6222 symtab_hdr->sh_info, 6223 0, NULL, NULL, NULL); 6224 if (locsyms == NULL) 6225 return FALSE; 6226 *locsymsp = locsyms; 6227 } 6228 sym = locsyms + r_symndx; 6229 6230 if (hp != NULL) 6231 *hp = NULL; 6232 6233 if (symp != NULL) 6234 *symp = sym; 6235 6236 if (symsecp != NULL) 6237 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx); 6238 6239 if (tls_maskp != NULL) 6240 { 6241 struct got_entry **lgot_ents; 6242 char *tls_mask; 6243 6244 tls_mask = NULL; 6245 lgot_ents = elf_local_got_ents (ibfd); 6246 if (lgot_ents != NULL) 6247 { 6248 char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info); 6249 tls_mask = &lgot_masks[r_symndx]; 6250 } 6251 *tls_maskp = tls_mask; 6252 } 6253 } 6254 return TRUE; 6255 } 6256 6257 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on 6258 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD 6259 type suitable for optimization, and 1 otherwise. */ 6260 6261 static int 6262 get_tls_mask (char **tls_maskp, 6263 unsigned long *toc_symndx, 6264 bfd_vma *toc_addend, 6265 Elf_Internal_Sym **locsymsp, 6266 const Elf_Internal_Rela *rel, 6267 bfd *ibfd) 6268 { 6269 unsigned long r_symndx; 6270 int next_r; 6271 struct elf_link_hash_entry *h; 6272 Elf_Internal_Sym *sym; 6273 asection *sec; 6274 bfd_vma off; 6275 6276 r_symndx = ELF64_R_SYM (rel->r_info); 6277 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd)) 6278 return 0; 6279 6280 if ((*tls_maskp != NULL && **tls_maskp != 0) 6281 || sec == NULL 6282 || ppc64_elf_section_data (sec)->sec_type != sec_toc) 6283 return 1; 6284 6285 /* Look inside a TOC section too. */ 6286 if (h != NULL) 6287 { 6288 BFD_ASSERT (h->root.type == bfd_link_hash_defined); 6289 off = h->root.u.def.value; 6290 } 6291 else 6292 off = sym->st_value; 6293 off += rel->r_addend; 6294 BFD_ASSERT (off % 8 == 0); 6295 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8]; 6296 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1]; 6297 if (toc_symndx != NULL) 6298 *toc_symndx = r_symndx; 6299 if (toc_addend != NULL) 6300 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8]; 6301 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd)) 6302 return 0; 6303 if ((h == NULL 6304 || ((h->root.type == bfd_link_hash_defined 6305 || h->root.type == bfd_link_hash_defweak) 6306 && !h->def_dynamic)) 6307 && (next_r == -1 || next_r == -2)) 6308 return 1 - next_r; 6309 return 1; 6310 } 6311 6312 /* Adjust all global syms defined in opd sections. In gcc generated 6313 code for the old ABI, these will already have been done. */ 6314 6315 static bfd_boolean 6316 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 6317 { 6318 struct ppc_link_hash_entry *eh; 6319 asection *sym_sec; 6320 struct _opd_sec_data *opd; 6321 6322 if (h->root.type == bfd_link_hash_indirect) 6323 return TRUE; 6324 6325 if (h->root.type == bfd_link_hash_warning) 6326 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6327 6328 if (h->root.type != bfd_link_hash_defined 6329 && h->root.type != bfd_link_hash_defweak) 6330 return TRUE; 6331 6332 eh = (struct ppc_link_hash_entry *) h; 6333 if (eh->adjust_done) 6334 return TRUE; 6335 6336 sym_sec = eh->elf.root.u.def.section; 6337 opd = get_opd_info (sym_sec); 6338 if (opd != NULL && opd->adjust != NULL) 6339 { 6340 long adjust = opd->adjust[eh->elf.root.u.def.value / 8]; 6341 if (adjust == -1) 6342 { 6343 /* This entry has been deleted. */ 6344 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section; 6345 if (dsec == NULL) 6346 { 6347 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next) 6348 if (elf_discarded_section (dsec)) 6349 { 6350 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec; 6351 break; 6352 } 6353 } 6354 eh->elf.root.u.def.value = 0; 6355 eh->elf.root.u.def.section = dsec; 6356 } 6357 else 6358 eh->elf.root.u.def.value += adjust; 6359 eh->adjust_done = 1; 6360 } 6361 return TRUE; 6362 } 6363 6364 /* Handles decrementing dynamic reloc counts for the reloc specified by 6365 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC 6366 have already been determined. */ 6367 6368 static bfd_boolean 6369 dec_dynrel_count (bfd_vma r_info, 6370 asection *sec, 6371 struct bfd_link_info *info, 6372 Elf_Internal_Sym **local_syms, 6373 struct elf_link_hash_entry *h, 6374 asection *sym_sec) 6375 { 6376 enum elf_ppc64_reloc_type r_type; 6377 struct ppc_dyn_relocs *p; 6378 struct ppc_dyn_relocs **pp; 6379 6380 /* Can this reloc be dynamic? This switch, and later tests here 6381 should be kept in sync with the code in check_relocs. */ 6382 r_type = ELF64_R_TYPE (r_info); 6383 switch (r_type) 6384 { 6385 default: 6386 return TRUE; 6387 6388 case R_PPC64_TPREL16: 6389 case R_PPC64_TPREL16_LO: 6390 case R_PPC64_TPREL16_HI: 6391 case R_PPC64_TPREL16_HA: 6392 case R_PPC64_TPREL16_DS: 6393 case R_PPC64_TPREL16_LO_DS: 6394 case R_PPC64_TPREL16_HIGHER: 6395 case R_PPC64_TPREL16_HIGHERA: 6396 case R_PPC64_TPREL16_HIGHEST: 6397 case R_PPC64_TPREL16_HIGHESTA: 6398 if (!info->shared) 6399 return TRUE; 6400 6401 case R_PPC64_TPREL64: 6402 case R_PPC64_DTPMOD64: 6403 case R_PPC64_DTPREL64: 6404 case R_PPC64_ADDR64: 6405 case R_PPC64_REL30: 6406 case R_PPC64_REL32: 6407 case R_PPC64_REL64: 6408 case R_PPC64_ADDR14: 6409 case R_PPC64_ADDR14_BRNTAKEN: 6410 case R_PPC64_ADDR14_BRTAKEN: 6411 case R_PPC64_ADDR16: 6412 case R_PPC64_ADDR16_DS: 6413 case R_PPC64_ADDR16_HA: 6414 case R_PPC64_ADDR16_HI: 6415 case R_PPC64_ADDR16_HIGHER: 6416 case R_PPC64_ADDR16_HIGHERA: 6417 case R_PPC64_ADDR16_HIGHEST: 6418 case R_PPC64_ADDR16_HIGHESTA: 6419 case R_PPC64_ADDR16_LO: 6420 case R_PPC64_ADDR16_LO_DS: 6421 case R_PPC64_ADDR24: 6422 case R_PPC64_ADDR32: 6423 case R_PPC64_UADDR16: 6424 case R_PPC64_UADDR32: 6425 case R_PPC64_UADDR64: 6426 case R_PPC64_TOC: 6427 break; 6428 } 6429 6430 if (local_syms != NULL) 6431 { 6432 unsigned long r_symndx; 6433 Elf_Internal_Sym *sym; 6434 bfd *ibfd = sec->owner; 6435 6436 r_symndx = ELF64_R_SYM (r_info); 6437 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd)) 6438 return FALSE; 6439 } 6440 6441 if ((info->shared 6442 && (must_be_dyn_reloc (info, r_type) 6443 || (h != NULL 6444 && (!info->symbolic 6445 || h->root.type == bfd_link_hash_defweak 6446 || !h->def_regular)))) 6447 || (ELIMINATE_COPY_RELOCS 6448 && !info->shared 6449 && h != NULL 6450 && (h->root.type == bfd_link_hash_defweak 6451 || !h->def_regular))) 6452 ; 6453 else 6454 return TRUE; 6455 6456 if (h != NULL) 6457 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs; 6458 else 6459 { 6460 if (sym_sec != NULL) 6461 { 6462 void *vpp = &elf_section_data (sym_sec)->local_dynrel; 6463 pp = (struct ppc_dyn_relocs **) vpp; 6464 } 6465 else 6466 { 6467 void *vpp = &elf_section_data (sec)->local_dynrel; 6468 pp = (struct ppc_dyn_relocs **) vpp; 6469 } 6470 6471 /* elf_gc_sweep may have already removed all dyn relocs associated 6472 with local syms for a given section. Don't report a dynreloc 6473 miscount. */ 6474 if (*pp == NULL) 6475 return TRUE; 6476 } 6477 6478 while ((p = *pp) != NULL) 6479 { 6480 if (p->sec == sec) 6481 { 6482 if (!must_be_dyn_reloc (info, r_type)) 6483 p->pc_count -= 1; 6484 p->count -= 1; 6485 if (p->count == 0) 6486 *pp = p->next; 6487 return TRUE; 6488 } 6489 pp = &p->next; 6490 } 6491 6492 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"), 6493 sec->owner, sec); 6494 bfd_set_error (bfd_error_bad_value); 6495 return FALSE; 6496 } 6497 6498 /* Remove unused Official Procedure Descriptor entries. Currently we 6499 only remove those associated with functions in discarded link-once 6500 sections, or weakly defined functions that have been overridden. It 6501 would be possible to remove many more entries for statically linked 6502 applications. */ 6503 6504 bfd_boolean 6505 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info, 6506 bfd_boolean non_overlapping) 6507 { 6508 bfd *ibfd; 6509 bfd_boolean some_edited = FALSE; 6510 asection *need_pad = NULL; 6511 6512 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 6513 { 6514 asection *sec; 6515 Elf_Internal_Rela *relstart, *rel, *relend; 6516 Elf_Internal_Shdr *symtab_hdr; 6517 Elf_Internal_Sym *local_syms; 6518 struct elf_link_hash_entry **sym_hashes; 6519 bfd_vma offset; 6520 struct _opd_sec_data *opd; 6521 bfd_boolean need_edit, add_aux_fields; 6522 bfd_size_type cnt_16b = 0; 6523 6524 sec = bfd_get_section_by_name (ibfd, ".opd"); 6525 if (sec == NULL || sec->size == 0) 6526 continue; 6527 6528 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS) 6529 continue; 6530 6531 if (sec->output_section == bfd_abs_section_ptr) 6532 continue; 6533 6534 /* Look through the section relocs. */ 6535 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0) 6536 continue; 6537 6538 local_syms = NULL; 6539 symtab_hdr = &elf_symtab_hdr (ibfd); 6540 sym_hashes = elf_sym_hashes (ibfd); 6541 6542 /* Read the relocations. */ 6543 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 6544 info->keep_memory); 6545 if (relstart == NULL) 6546 return FALSE; 6547 6548 /* First run through the relocs to check they are sane, and to 6549 determine whether we need to edit this opd section. */ 6550 need_edit = FALSE; 6551 need_pad = sec; 6552 offset = 0; 6553 relend = relstart + sec->reloc_count; 6554 for (rel = relstart; rel < relend; ) 6555 { 6556 enum elf_ppc64_reloc_type r_type; 6557 unsigned long r_symndx; 6558 asection *sym_sec; 6559 struct elf_link_hash_entry *h; 6560 Elf_Internal_Sym *sym; 6561 6562 /* .opd contains a regular array of 16 or 24 byte entries. We're 6563 only interested in the reloc pointing to a function entry 6564 point. */ 6565 if (rel->r_offset != offset 6566 || rel + 1 >= relend 6567 || (rel + 1)->r_offset != offset + 8) 6568 { 6569 /* If someone messes with .opd alignment then after a 6570 "ld -r" we might have padding in the middle of .opd. 6571 Also, there's nothing to prevent someone putting 6572 something silly in .opd with the assembler. No .opd 6573 optimization for them! */ 6574 broken_opd: 6575 (*_bfd_error_handler) 6576 (_("%B: .opd is not a regular array of opd entries"), ibfd); 6577 need_edit = FALSE; 6578 break; 6579 } 6580 6581 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64 6582 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC) 6583 { 6584 (*_bfd_error_handler) 6585 (_("%B: unexpected reloc type %u in .opd section"), 6586 ibfd, r_type); 6587 need_edit = FALSE; 6588 break; 6589 } 6590 6591 r_symndx = ELF64_R_SYM (rel->r_info); 6592 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 6593 r_symndx, ibfd)) 6594 goto error_ret; 6595 6596 if (sym_sec == NULL || sym_sec->owner == NULL) 6597 { 6598 const char *sym_name; 6599 if (h != NULL) 6600 sym_name = h->root.root.string; 6601 else 6602 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym, 6603 sym_sec); 6604 6605 (*_bfd_error_handler) 6606 (_("%B: undefined sym `%s' in .opd section"), 6607 ibfd, sym_name); 6608 need_edit = FALSE; 6609 break; 6610 } 6611 6612 /* opd entries are always for functions defined in the 6613 current input bfd. If the symbol isn't defined in the 6614 input bfd, then we won't be using the function in this 6615 bfd; It must be defined in a linkonce section in another 6616 bfd, or is weak. It's also possible that we are 6617 discarding the function due to a linker script /DISCARD/, 6618 which we test for via the output_section. */ 6619 if (sym_sec->owner != ibfd 6620 || sym_sec->output_section == bfd_abs_section_ptr) 6621 need_edit = TRUE; 6622 6623 rel += 2; 6624 if (rel == relend 6625 || (rel + 1 == relend && rel->r_offset == offset + 16)) 6626 { 6627 if (sec->size == offset + 24) 6628 { 6629 need_pad = NULL; 6630 break; 6631 } 6632 if (rel == relend && sec->size == offset + 16) 6633 { 6634 cnt_16b++; 6635 break; 6636 } 6637 goto broken_opd; 6638 } 6639 6640 if (rel->r_offset == offset + 24) 6641 offset += 24; 6642 else if (rel->r_offset != offset + 16) 6643 goto broken_opd; 6644 else if (rel + 1 < relend 6645 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64 6646 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC) 6647 { 6648 offset += 16; 6649 cnt_16b++; 6650 } 6651 else if (rel + 2 < relend 6652 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64 6653 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC) 6654 { 6655 offset += 24; 6656 rel += 1; 6657 } 6658 else 6659 goto broken_opd; 6660 } 6661 6662 add_aux_fields = non_overlapping && cnt_16b > 0; 6663 6664 if (need_edit || add_aux_fields) 6665 { 6666 Elf_Internal_Rela *write_rel; 6667 bfd_byte *rptr, *wptr; 6668 bfd_byte *new_contents = NULL; 6669 bfd_boolean skip; 6670 long opd_ent_size; 6671 bfd_size_type amt; 6672 6673 amt = sec->size * sizeof (long) / 8; 6674 opd = &ppc64_elf_section_data (sec)->u.opd; 6675 opd->adjust = bfd_zalloc (obfd, amt); 6676 if (opd->adjust == NULL) 6677 return FALSE; 6678 ppc64_elf_section_data (sec)->sec_type = sec_opd; 6679 6680 /* This seems a waste of time as input .opd sections are all 6681 zeros as generated by gcc, but I suppose there's no reason 6682 this will always be so. We might start putting something in 6683 the third word of .opd entries. */ 6684 if ((sec->flags & SEC_IN_MEMORY) == 0) 6685 { 6686 bfd_byte *loc; 6687 if (!bfd_malloc_and_get_section (ibfd, sec, &loc)) 6688 { 6689 if (loc != NULL) 6690 free (loc); 6691 error_ret: 6692 if (local_syms != NULL 6693 && symtab_hdr->contents != (unsigned char *) local_syms) 6694 free (local_syms); 6695 if (elf_section_data (sec)->relocs != relstart) 6696 free (relstart); 6697 return FALSE; 6698 } 6699 sec->contents = loc; 6700 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS); 6701 } 6702 6703 elf_section_data (sec)->relocs = relstart; 6704 6705 new_contents = sec->contents; 6706 if (add_aux_fields) 6707 { 6708 new_contents = bfd_malloc (sec->size + cnt_16b * 8); 6709 if (new_contents == NULL) 6710 return FALSE; 6711 need_pad = FALSE; 6712 } 6713 wptr = new_contents; 6714 rptr = sec->contents; 6715 6716 write_rel = relstart; 6717 skip = FALSE; 6718 offset = 0; 6719 opd_ent_size = 0; 6720 for (rel = relstart; rel < relend; rel++) 6721 { 6722 unsigned long r_symndx; 6723 asection *sym_sec; 6724 struct elf_link_hash_entry *h; 6725 Elf_Internal_Sym *sym; 6726 6727 r_symndx = ELF64_R_SYM (rel->r_info); 6728 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 6729 r_symndx, ibfd)) 6730 goto error_ret; 6731 6732 if (rel->r_offset == offset) 6733 { 6734 struct ppc_link_hash_entry *fdh = NULL; 6735 6736 /* See if the .opd entry is full 24 byte or 6737 16 byte (with fd_aux entry overlapped with next 6738 fd_func). */ 6739 opd_ent_size = 24; 6740 if ((rel + 2 == relend && sec->size == offset + 16) 6741 || (rel + 3 < relend 6742 && rel[2].r_offset == offset + 16 6743 && rel[3].r_offset == offset + 24 6744 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64 6745 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC)) 6746 opd_ent_size = 16; 6747 6748 if (h != NULL 6749 && h->root.root.string[0] == '.') 6750 { 6751 fdh = get_fdh ((struct ppc_link_hash_entry *) h, 6752 ppc_hash_table (info)); 6753 if (fdh != NULL 6754 && fdh->elf.root.type != bfd_link_hash_defined 6755 && fdh->elf.root.type != bfd_link_hash_defweak) 6756 fdh = NULL; 6757 } 6758 6759 skip = (sym_sec->owner != ibfd 6760 || sym_sec->output_section == bfd_abs_section_ptr); 6761 if (skip) 6762 { 6763 if (fdh != NULL && sym_sec->owner == ibfd) 6764 { 6765 /* Arrange for the function descriptor sym 6766 to be dropped. */ 6767 fdh->elf.root.u.def.value = 0; 6768 fdh->elf.root.u.def.section = sym_sec; 6769 } 6770 opd->adjust[rel->r_offset / 8] = -1; 6771 } 6772 else 6773 { 6774 /* We'll be keeping this opd entry. */ 6775 6776 if (fdh != NULL) 6777 { 6778 /* Redefine the function descriptor symbol to 6779 this location in the opd section. It is 6780 necessary to update the value here rather 6781 than using an array of adjustments as we do 6782 for local symbols, because various places 6783 in the generic ELF code use the value 6784 stored in u.def.value. */ 6785 fdh->elf.root.u.def.value = wptr - new_contents; 6786 fdh->adjust_done = 1; 6787 } 6788 6789 /* Local syms are a bit tricky. We could 6790 tweak them as they can be cached, but 6791 we'd need to look through the local syms 6792 for the function descriptor sym which we 6793 don't have at the moment. So keep an 6794 array of adjustments. */ 6795 opd->adjust[rel->r_offset / 8] 6796 = (wptr - new_contents) - (rptr - sec->contents); 6797 6798 if (wptr != rptr) 6799 memcpy (wptr, rptr, opd_ent_size); 6800 wptr += opd_ent_size; 6801 if (add_aux_fields && opd_ent_size == 16) 6802 { 6803 memset (wptr, '\0', 8); 6804 wptr += 8; 6805 } 6806 } 6807 rptr += opd_ent_size; 6808 offset += opd_ent_size; 6809 } 6810 6811 if (skip) 6812 { 6813 if (!NO_OPD_RELOCS 6814 && !info->relocatable 6815 && !dec_dynrel_count (rel->r_info, sec, info, 6816 NULL, h, sym_sec)) 6817 goto error_ret; 6818 } 6819 else 6820 { 6821 /* We need to adjust any reloc offsets to point to the 6822 new opd entries. While we're at it, we may as well 6823 remove redundant relocs. */ 6824 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8]; 6825 if (write_rel != rel) 6826 memcpy (write_rel, rel, sizeof (*rel)); 6827 ++write_rel; 6828 } 6829 } 6830 6831 sec->size = wptr - new_contents; 6832 sec->reloc_count = write_rel - relstart; 6833 if (add_aux_fields) 6834 { 6835 free (sec->contents); 6836 sec->contents = new_contents; 6837 } 6838 6839 /* Fudge the header size too, as this is used later in 6840 elf_bfd_final_link if we are emitting relocs. */ 6841 elf_section_data (sec)->rel_hdr.sh_size 6842 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize; 6843 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL); 6844 some_edited = TRUE; 6845 } 6846 else if (elf_section_data (sec)->relocs != relstart) 6847 free (relstart); 6848 6849 if (local_syms != NULL 6850 && symtab_hdr->contents != (unsigned char *) local_syms) 6851 { 6852 if (!info->keep_memory) 6853 free (local_syms); 6854 else 6855 symtab_hdr->contents = (unsigned char *) local_syms; 6856 } 6857 } 6858 6859 if (some_edited) 6860 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL); 6861 6862 /* If we are doing a final link and the last .opd entry is just 16 byte 6863 long, add a 8 byte padding after it. */ 6864 if (need_pad != NULL && !info->relocatable) 6865 { 6866 bfd_byte *p; 6867 6868 if ((need_pad->flags & SEC_IN_MEMORY) == 0) 6869 { 6870 BFD_ASSERT (need_pad->size > 0); 6871 6872 p = bfd_malloc (need_pad->size + 8); 6873 if (p == NULL) 6874 return FALSE; 6875 6876 if (! bfd_get_section_contents (need_pad->owner, need_pad, 6877 p, 0, need_pad->size)) 6878 return FALSE; 6879 6880 need_pad->contents = p; 6881 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS); 6882 } 6883 else 6884 { 6885 p = bfd_realloc (need_pad->contents, need_pad->size + 8); 6886 if (p == NULL) 6887 return FALSE; 6888 6889 need_pad->contents = p; 6890 } 6891 6892 memset (need_pad->contents + need_pad->size, 0, 8); 6893 need_pad->size += 8; 6894 } 6895 6896 return TRUE; 6897 } 6898 6899 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */ 6900 6901 asection * 6902 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) 6903 { 6904 struct ppc_link_hash_table *htab; 6905 6906 htab = ppc_hash_table (info); 6907 htab->tls_get_addr = ((struct ppc_link_hash_entry *) 6908 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr", 6909 FALSE, FALSE, TRUE)); 6910 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *) 6911 elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 6912 FALSE, FALSE, TRUE)); 6913 return _bfd_elf_tls_setup (obfd, info); 6914 } 6915 6916 /* Return TRUE iff REL is a branch reloc with a global symbol matching 6917 HASH1 or HASH2. */ 6918 6919 static bfd_boolean 6920 branch_reloc_hash_match (const bfd *ibfd, 6921 const Elf_Internal_Rela *rel, 6922 const struct ppc_link_hash_entry *hash1, 6923 const struct ppc_link_hash_entry *hash2) 6924 { 6925 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 6926 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info); 6927 unsigned int r_symndx = ELF64_R_SYM (rel->r_info); 6928 6929 if (r_symndx >= symtab_hdr->sh_info 6930 && (r_type == R_PPC64_REL24 6931 || r_type == R_PPC64_REL14 6932 || r_type == R_PPC64_REL14_BRTAKEN 6933 || r_type == R_PPC64_REL14_BRNTAKEN 6934 || r_type == R_PPC64_ADDR24 6935 || r_type == R_PPC64_ADDR14 6936 || r_type == R_PPC64_ADDR14_BRTAKEN 6937 || r_type == R_PPC64_ADDR14_BRNTAKEN)) 6938 { 6939 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 6940 struct elf_link_hash_entry *h; 6941 6942 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6943 while (h->root.type == bfd_link_hash_indirect 6944 || h->root.type == bfd_link_hash_warning) 6945 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6946 if (h == &hash1->elf || h == &hash2->elf) 6947 return TRUE; 6948 } 6949 return FALSE; 6950 } 6951 6952 /* Run through all the TLS relocs looking for optimization 6953 opportunities. The linker has been hacked (see ppc64elf.em) to do 6954 a preliminary section layout so that we know the TLS segment 6955 offsets. We can't optimize earlier because some optimizations need 6956 to know the tp offset, and we need to optimize before allocating 6957 dynamic relocations. */ 6958 6959 bfd_boolean 6960 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) 6961 { 6962 bfd *ibfd; 6963 asection *sec; 6964 struct ppc_link_hash_table *htab; 6965 int pass; 6966 6967 if (info->relocatable || !info->executable) 6968 return TRUE; 6969 6970 htab = ppc_hash_table (info); 6971 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 6972 { 6973 Elf_Internal_Sym *locsyms = NULL; 6974 asection *toc = bfd_get_section_by_name (ibfd, ".toc"); 6975 unsigned char *toc_ref = NULL; 6976 6977 /* Look at all the sections for this file. Make two passes over 6978 the relocs. On the first pass, mark toc entries involved 6979 with tls relocs, and check that tls relocs involved in 6980 setting up a tls_get_addr call are indeed followed by such a 6981 call. If they are not, exclude them from the optimizations 6982 done on the second pass. */ 6983 for (pass = 0; pass < 2; ++pass) 6984 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 6985 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section)) 6986 { 6987 Elf_Internal_Rela *relstart, *rel, *relend; 6988 6989 /* Read the relocations. */ 6990 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 6991 info->keep_memory); 6992 if (relstart == NULL) 6993 return FALSE; 6994 6995 relend = relstart + sec->reloc_count; 6996 for (rel = relstart; rel < relend; rel++) 6997 { 6998 enum elf_ppc64_reloc_type r_type; 6999 unsigned long r_symndx; 7000 struct elf_link_hash_entry *h; 7001 Elf_Internal_Sym *sym; 7002 asection *sym_sec; 7003 char *tls_mask; 7004 char tls_set, tls_clear, tls_type = 0; 7005 bfd_vma value; 7006 bfd_boolean ok_tprel, is_local; 7007 long toc_ref_index = 0; 7008 int expecting_tls_get_addr = 0; 7009 7010 r_symndx = ELF64_R_SYM (rel->r_info); 7011 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms, 7012 r_symndx, ibfd)) 7013 { 7014 err_free_rel: 7015 if (elf_section_data (sec)->relocs != relstart) 7016 free (relstart); 7017 if (toc_ref != NULL) 7018 free (toc_ref); 7019 if (locsyms != NULL 7020 && (elf_symtab_hdr (ibfd).contents 7021 != (unsigned char *) locsyms)) 7022 free (locsyms); 7023 return FALSE; 7024 } 7025 7026 if (h != NULL) 7027 { 7028 if (h->root.type != bfd_link_hash_defined 7029 && h->root.type != bfd_link_hash_defweak) 7030 continue; 7031 value = h->root.u.def.value; 7032 } 7033 else 7034 /* Symbols referenced by TLS relocs must be of type 7035 STT_TLS. So no need for .opd local sym adjust. */ 7036 value = sym->st_value; 7037 7038 ok_tprel = FALSE; 7039 is_local = FALSE; 7040 if (h == NULL 7041 || !h->def_dynamic) 7042 { 7043 is_local = TRUE; 7044 value += sym_sec->output_offset; 7045 value += sym_sec->output_section->vma; 7046 value -= htab->elf.tls_sec->vma; 7047 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31) 7048 < (bfd_vma) 1 << 32); 7049 } 7050 7051 r_type = ELF64_R_TYPE (rel->r_info); 7052 switch (r_type) 7053 { 7054 case R_PPC64_GOT_TLSLD16: 7055 case R_PPC64_GOT_TLSLD16_LO: 7056 expecting_tls_get_addr = 1; 7057 /* Fall thru */ 7058 7059 case R_PPC64_GOT_TLSLD16_HI: 7060 case R_PPC64_GOT_TLSLD16_HA: 7061 /* These relocs should never be against a symbol 7062 defined in a shared lib. Leave them alone if 7063 that turns out to be the case. */ 7064 if (!is_local) 7065 continue; 7066 7067 /* LD -> LE */ 7068 tls_set = 0; 7069 tls_clear = TLS_LD; 7070 tls_type = TLS_TLS | TLS_LD; 7071 break; 7072 7073 case R_PPC64_GOT_TLSGD16: 7074 case R_PPC64_GOT_TLSGD16_LO: 7075 expecting_tls_get_addr = 1; 7076 /* Fall thru */ 7077 7078 case R_PPC64_GOT_TLSGD16_HI: 7079 case R_PPC64_GOT_TLSGD16_HA: 7080 if (ok_tprel) 7081 /* GD -> LE */ 7082 tls_set = 0; 7083 else 7084 /* GD -> IE */ 7085 tls_set = TLS_TLS | TLS_TPRELGD; 7086 tls_clear = TLS_GD; 7087 tls_type = TLS_TLS | TLS_GD; 7088 break; 7089 7090 case R_PPC64_GOT_TPREL16_DS: 7091 case R_PPC64_GOT_TPREL16_LO_DS: 7092 case R_PPC64_GOT_TPREL16_HI: 7093 case R_PPC64_GOT_TPREL16_HA: 7094 if (ok_tprel) 7095 { 7096 /* IE -> LE */ 7097 tls_set = 0; 7098 tls_clear = TLS_TPREL; 7099 tls_type = TLS_TLS | TLS_TPREL; 7100 break; 7101 } 7102 continue; 7103 7104 case R_PPC64_TOC16: 7105 case R_PPC64_TOC16_LO: 7106 case R_PPC64_TLS: 7107 if (sym_sec == NULL || sym_sec != toc) 7108 continue; 7109 7110 /* Mark this toc entry as referenced by a TLS 7111 code sequence. We can do that now in the 7112 case of R_PPC64_TLS, and after checking for 7113 tls_get_addr for the TOC16 relocs. */ 7114 if (toc_ref == NULL) 7115 { 7116 toc_ref = bfd_zmalloc (toc->size / 8); 7117 if (toc_ref == NULL) 7118 goto err_free_rel; 7119 } 7120 if (h != NULL) 7121 value = h->root.u.def.value; 7122 else 7123 value = sym->st_value; 7124 value += rel->r_addend; 7125 BFD_ASSERT (value < toc->size && value % 8 == 0); 7126 toc_ref_index = value / 8; 7127 if (r_type == R_PPC64_TLS) 7128 { 7129 toc_ref[toc_ref_index] = 1; 7130 continue; 7131 } 7132 7133 if (pass != 0 && toc_ref[toc_ref_index] == 0) 7134 continue; 7135 7136 tls_set = 0; 7137 tls_clear = 0; 7138 expecting_tls_get_addr = 2; 7139 break; 7140 7141 case R_PPC64_TPREL64: 7142 if (pass == 0 7143 || sec != toc 7144 || toc_ref == NULL 7145 || !toc_ref[rel->r_offset / 8]) 7146 continue; 7147 if (ok_tprel) 7148 { 7149 /* IE -> LE */ 7150 tls_set = TLS_EXPLICIT; 7151 tls_clear = TLS_TPREL; 7152 break; 7153 } 7154 continue; 7155 7156 case R_PPC64_DTPMOD64: 7157 if (pass == 0 7158 || sec != toc 7159 || toc_ref == NULL 7160 || !toc_ref[rel->r_offset / 8]) 7161 continue; 7162 if (rel + 1 < relend 7163 && (rel[1].r_info 7164 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)) 7165 && rel[1].r_offset == rel->r_offset + 8) 7166 { 7167 if (ok_tprel) 7168 /* GD -> LE */ 7169 tls_set = TLS_EXPLICIT | TLS_GD; 7170 else 7171 /* GD -> IE */ 7172 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD; 7173 tls_clear = TLS_GD; 7174 } 7175 else 7176 { 7177 if (!is_local) 7178 continue; 7179 7180 /* LD -> LE */ 7181 tls_set = TLS_EXPLICIT; 7182 tls_clear = TLS_LD; 7183 } 7184 break; 7185 7186 default: 7187 continue; 7188 } 7189 7190 if (pass == 0) 7191 { 7192 if (!expecting_tls_get_addr) 7193 continue; 7194 7195 if (rel + 1 < relend 7196 && branch_reloc_hash_match (ibfd, rel + 1, 7197 htab->tls_get_addr, 7198 htab->tls_get_addr_fd)) 7199 { 7200 if (expecting_tls_get_addr == 2) 7201 { 7202 /* Check for toc tls entries. */ 7203 char *toc_tls; 7204 int retval; 7205 7206 retval = get_tls_mask (&toc_tls, NULL, NULL, 7207 &locsyms, 7208 rel, ibfd); 7209 if (retval == 0) 7210 goto err_free_rel; 7211 if (retval > 1 && toc_tls != NULL) 7212 toc_ref[toc_ref_index] = 1; 7213 } 7214 continue; 7215 } 7216 7217 if (expecting_tls_get_addr != 1) 7218 continue; 7219 7220 /* Uh oh, we didn't find the expected call. We 7221 could just mark this symbol to exclude it 7222 from tls optimization but it's safer to skip 7223 the entire section. */ 7224 sec->has_tls_reloc = 0; 7225 break; 7226 } 7227 7228 if (expecting_tls_get_addr && htab->tls_get_addr != NULL) 7229 { 7230 struct plt_entry *ent; 7231 for (ent = htab->tls_get_addr->elf.plt.plist; 7232 ent != NULL; 7233 ent = ent->next) 7234 if (ent->addend == 0) 7235 { 7236 if (ent->plt.refcount > 0) 7237 { 7238 ent->plt.refcount -= 1; 7239 expecting_tls_get_addr = 0; 7240 } 7241 break; 7242 } 7243 } 7244 7245 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL) 7246 { 7247 struct plt_entry *ent; 7248 for (ent = htab->tls_get_addr_fd->elf.plt.plist; 7249 ent != NULL; 7250 ent = ent->next) 7251 if (ent->addend == 0) 7252 { 7253 if (ent->plt.refcount > 0) 7254 ent->plt.refcount -= 1; 7255 break; 7256 } 7257 } 7258 7259 if (tls_clear == 0) 7260 continue; 7261 7262 if ((tls_set & TLS_EXPLICIT) == 0) 7263 { 7264 struct got_entry *ent; 7265 7266 /* Adjust got entry for this reloc. */ 7267 if (h != NULL) 7268 ent = h->got.glist; 7269 else 7270 ent = elf_local_got_ents (ibfd)[r_symndx]; 7271 7272 for (; ent != NULL; ent = ent->next) 7273 if (ent->addend == rel->r_addend 7274 && ent->owner == ibfd 7275 && ent->tls_type == tls_type) 7276 break; 7277 if (ent == NULL) 7278 abort (); 7279 7280 if (tls_set == 0) 7281 { 7282 /* We managed to get rid of a got entry. */ 7283 if (ent->got.refcount > 0) 7284 ent->got.refcount -= 1; 7285 } 7286 } 7287 else 7288 { 7289 /* If we got rid of a DTPMOD/DTPREL reloc pair then 7290 we'll lose one or two dyn relocs. */ 7291 if (!dec_dynrel_count (rel->r_info, sec, info, 7292 NULL, h, sym_sec)) 7293 return FALSE; 7294 7295 if (tls_set == (TLS_EXPLICIT | TLS_GD)) 7296 { 7297 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info, 7298 NULL, h, sym_sec)) 7299 return FALSE; 7300 } 7301 } 7302 7303 *tls_mask |= tls_set; 7304 *tls_mask &= ~tls_clear; 7305 } 7306 7307 if (elf_section_data (sec)->relocs != relstart) 7308 free (relstart); 7309 } 7310 7311 if (toc_ref != NULL) 7312 free (toc_ref); 7313 7314 if (locsyms != NULL 7315 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms)) 7316 { 7317 if (!info->keep_memory) 7318 free (locsyms); 7319 else 7320 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms; 7321 } 7322 } 7323 return TRUE; 7324 } 7325 7326 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust 7327 the values of any global symbols in a toc section that has been 7328 edited. Globals in toc sections should be a rarity, so this function 7329 sets a flag if any are found in toc sections other than the one just 7330 edited, so that futher hash table traversals can be avoided. */ 7331 7332 struct adjust_toc_info 7333 { 7334 asection *toc; 7335 unsigned long *skip; 7336 bfd_boolean global_toc_syms; 7337 }; 7338 7339 static bfd_boolean 7340 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf) 7341 { 7342 struct ppc_link_hash_entry *eh; 7343 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf; 7344 7345 if (h->root.type == bfd_link_hash_indirect) 7346 return TRUE; 7347 7348 if (h->root.type == bfd_link_hash_warning) 7349 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7350 7351 if (h->root.type != bfd_link_hash_defined 7352 && h->root.type != bfd_link_hash_defweak) 7353 return TRUE; 7354 7355 eh = (struct ppc_link_hash_entry *) h; 7356 if (eh->adjust_done) 7357 return TRUE; 7358 7359 if (eh->elf.root.u.def.section == toc_inf->toc) 7360 { 7361 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3]; 7362 if (skip != (unsigned long) -1) 7363 eh->elf.root.u.def.value -= skip; 7364 else 7365 { 7366 (*_bfd_error_handler) 7367 (_("%s defined in removed toc entry"), eh->elf.root.root.string); 7368 eh->elf.root.u.def.section = &bfd_abs_section; 7369 eh->elf.root.u.def.value = 0; 7370 } 7371 eh->adjust_done = 1; 7372 } 7373 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0) 7374 toc_inf->global_toc_syms = TRUE; 7375 7376 return TRUE; 7377 } 7378 7379 /* Examine all relocs referencing .toc sections in order to remove 7380 unused .toc entries. */ 7381 7382 bfd_boolean 7383 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) 7384 { 7385 bfd *ibfd; 7386 struct adjust_toc_info toc_inf; 7387 7388 toc_inf.global_toc_syms = TRUE; 7389 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 7390 { 7391 asection *toc, *sec; 7392 Elf_Internal_Shdr *symtab_hdr; 7393 Elf_Internal_Sym *local_syms; 7394 struct elf_link_hash_entry **sym_hashes; 7395 Elf_Internal_Rela *relstart, *rel; 7396 unsigned long *skip, *drop; 7397 unsigned char *used; 7398 unsigned char *keep, last, some_unused; 7399 7400 toc = bfd_get_section_by_name (ibfd, ".toc"); 7401 if (toc == NULL 7402 || toc->size == 0 7403 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS 7404 || elf_discarded_section (toc)) 7405 continue; 7406 7407 local_syms = NULL; 7408 symtab_hdr = &elf_symtab_hdr (ibfd); 7409 sym_hashes = elf_sym_hashes (ibfd); 7410 7411 /* Look at sections dropped from the final link. */ 7412 skip = NULL; 7413 relstart = NULL; 7414 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 7415 { 7416 if (sec->reloc_count == 0 7417 || !elf_discarded_section (sec) 7418 || get_opd_info (sec) 7419 || (sec->flags & SEC_ALLOC) == 0 7420 || (sec->flags & SEC_DEBUGGING) != 0) 7421 continue; 7422 7423 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE); 7424 if (relstart == NULL) 7425 goto error_ret; 7426 7427 /* Run through the relocs to see which toc entries might be 7428 unused. */ 7429 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 7430 { 7431 enum elf_ppc64_reloc_type r_type; 7432 unsigned long r_symndx; 7433 asection *sym_sec; 7434 struct elf_link_hash_entry *h; 7435 Elf_Internal_Sym *sym; 7436 bfd_vma val; 7437 7438 r_type = ELF64_R_TYPE (rel->r_info); 7439 switch (r_type) 7440 { 7441 default: 7442 continue; 7443 7444 case R_PPC64_TOC16: 7445 case R_PPC64_TOC16_LO: 7446 case R_PPC64_TOC16_HI: 7447 case R_PPC64_TOC16_HA: 7448 case R_PPC64_TOC16_DS: 7449 case R_PPC64_TOC16_LO_DS: 7450 break; 7451 } 7452 7453 r_symndx = ELF64_R_SYM (rel->r_info); 7454 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 7455 r_symndx, ibfd)) 7456 goto error_ret; 7457 7458 if (sym_sec != toc) 7459 continue; 7460 7461 if (h != NULL) 7462 val = h->root.u.def.value; 7463 else 7464 val = sym->st_value; 7465 val += rel->r_addend; 7466 7467 if (val >= toc->size) 7468 continue; 7469 7470 /* Anything in the toc ought to be aligned to 8 bytes. 7471 If not, don't mark as unused. */ 7472 if (val & 7) 7473 continue; 7474 7475 if (skip == NULL) 7476 { 7477 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8); 7478 if (skip == NULL) 7479 goto error_ret; 7480 } 7481 7482 skip[val >> 3] = 1; 7483 } 7484 7485 if (elf_section_data (sec)->relocs != relstart) 7486 free (relstart); 7487 } 7488 7489 if (skip == NULL) 7490 continue; 7491 7492 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8); 7493 if (used == NULL) 7494 { 7495 error_ret: 7496 if (local_syms != NULL 7497 && symtab_hdr->contents != (unsigned char *) local_syms) 7498 free (local_syms); 7499 if (sec != NULL 7500 && relstart != NULL 7501 && elf_section_data (sec)->relocs != relstart) 7502 free (relstart); 7503 if (skip != NULL) 7504 free (skip); 7505 return FALSE; 7506 } 7507 7508 /* Now check all kept sections that might reference the toc. 7509 Check the toc itself last. */ 7510 for (sec = (ibfd->sections == toc && toc->next ? toc->next 7511 : ibfd->sections); 7512 sec != NULL; 7513 sec = (sec == toc ? NULL 7514 : sec->next == NULL ? toc 7515 : sec->next == toc && toc->next ? toc->next 7516 : sec->next)) 7517 { 7518 int repeat; 7519 7520 if (sec->reloc_count == 0 7521 || elf_discarded_section (sec) 7522 || get_opd_info (sec) 7523 || (sec->flags & SEC_ALLOC) == 0 7524 || (sec->flags & SEC_DEBUGGING) != 0) 7525 continue; 7526 7527 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE); 7528 if (relstart == NULL) 7529 goto error_ret; 7530 7531 /* Mark toc entries referenced as used. */ 7532 repeat = 0; 7533 do 7534 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 7535 { 7536 enum elf_ppc64_reloc_type r_type; 7537 unsigned long r_symndx; 7538 asection *sym_sec; 7539 struct elf_link_hash_entry *h; 7540 Elf_Internal_Sym *sym; 7541 bfd_vma val; 7542 7543 r_type = ELF64_R_TYPE (rel->r_info); 7544 switch (r_type) 7545 { 7546 case R_PPC64_TOC16: 7547 case R_PPC64_TOC16_LO: 7548 case R_PPC64_TOC16_HI: 7549 case R_PPC64_TOC16_HA: 7550 case R_PPC64_TOC16_DS: 7551 case R_PPC64_TOC16_LO_DS: 7552 /* In case we're taking addresses of toc entries. */ 7553 case R_PPC64_ADDR64: 7554 break; 7555 7556 default: 7557 continue; 7558 } 7559 7560 r_symndx = ELF64_R_SYM (rel->r_info); 7561 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 7562 r_symndx, ibfd)) 7563 { 7564 free (used); 7565 goto error_ret; 7566 } 7567 7568 if (sym_sec != toc) 7569 continue; 7570 7571 if (h != NULL) 7572 val = h->root.u.def.value; 7573 else 7574 val = sym->st_value; 7575 val += rel->r_addend; 7576 7577 if (val >= toc->size) 7578 continue; 7579 7580 /* For the toc section, we only mark as used if 7581 this entry itself isn't unused. */ 7582 if (sec == toc 7583 && !used[val >> 3] 7584 && (used[rel->r_offset >> 3] 7585 || !skip[rel->r_offset >> 3])) 7586 /* Do all the relocs again, to catch reference 7587 chains. */ 7588 repeat = 1; 7589 7590 used[val >> 3] = 1; 7591 } 7592 while (repeat); 7593 } 7594 7595 /* Merge the used and skip arrays. Assume that TOC 7596 doublewords not appearing as either used or unused belong 7597 to to an entry more than one doubleword in size. */ 7598 for (drop = skip, keep = used, last = 0, some_unused = 0; 7599 drop < skip + (toc->size + 7) / 8; 7600 ++drop, ++keep) 7601 { 7602 if (*keep) 7603 { 7604 *drop = 0; 7605 last = 0; 7606 } 7607 else if (*drop) 7608 { 7609 some_unused = 1; 7610 last = 1; 7611 } 7612 else 7613 *drop = last; 7614 } 7615 7616 free (used); 7617 7618 if (some_unused) 7619 { 7620 bfd_byte *contents, *src; 7621 unsigned long off; 7622 7623 /* Shuffle the toc contents, and at the same time convert the 7624 skip array from booleans into offsets. */ 7625 if (!bfd_malloc_and_get_section (ibfd, toc, &contents)) 7626 goto error_ret; 7627 7628 elf_section_data (toc)->this_hdr.contents = contents; 7629 7630 for (src = contents, off = 0, drop = skip; 7631 src < contents + toc->size; 7632 src += 8, ++drop) 7633 { 7634 if (*drop) 7635 { 7636 *drop = (unsigned long) -1; 7637 off += 8; 7638 } 7639 else if (off != 0) 7640 { 7641 *drop = off; 7642 memcpy (src - off, src, 8); 7643 } 7644 } 7645 toc->rawsize = toc->size; 7646 toc->size = src - contents - off; 7647 7648 if (toc->reloc_count != 0) 7649 { 7650 Elf_Internal_Rela *wrel; 7651 bfd_size_type sz; 7652 7653 /* Read toc relocs. */ 7654 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL, 7655 TRUE); 7656 if (relstart == NULL) 7657 goto error_ret; 7658 7659 /* Remove unused toc relocs, and adjust those we keep. */ 7660 wrel = relstart; 7661 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel) 7662 if (skip[rel->r_offset >> 3] != (unsigned long) -1) 7663 { 7664 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3]; 7665 wrel->r_info = rel->r_info; 7666 wrel->r_addend = rel->r_addend; 7667 ++wrel; 7668 } 7669 else if (!dec_dynrel_count (rel->r_info, toc, info, 7670 &local_syms, NULL, NULL)) 7671 goto error_ret; 7672 7673 toc->reloc_count = wrel - relstart; 7674 sz = elf_section_data (toc)->rel_hdr.sh_entsize; 7675 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz; 7676 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL); 7677 } 7678 7679 /* Adjust addends for relocs against the toc section sym. */ 7680 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 7681 { 7682 if (sec->reloc_count == 0 7683 || elf_discarded_section (sec)) 7684 continue; 7685 7686 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 7687 TRUE); 7688 if (relstart == NULL) 7689 goto error_ret; 7690 7691 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 7692 { 7693 enum elf_ppc64_reloc_type r_type; 7694 unsigned long r_symndx; 7695 asection *sym_sec; 7696 struct elf_link_hash_entry *h; 7697 Elf_Internal_Sym *sym; 7698 7699 r_type = ELF64_R_TYPE (rel->r_info); 7700 switch (r_type) 7701 { 7702 default: 7703 continue; 7704 7705 case R_PPC64_TOC16: 7706 case R_PPC64_TOC16_LO: 7707 case R_PPC64_TOC16_HI: 7708 case R_PPC64_TOC16_HA: 7709 case R_PPC64_TOC16_DS: 7710 case R_PPC64_TOC16_LO_DS: 7711 case R_PPC64_ADDR64: 7712 break; 7713 } 7714 7715 r_symndx = ELF64_R_SYM (rel->r_info); 7716 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 7717 r_symndx, ibfd)) 7718 goto error_ret; 7719 7720 if (sym_sec != toc || h != NULL || sym->st_value != 0) 7721 continue; 7722 7723 rel->r_addend -= skip[rel->r_addend >> 3]; 7724 } 7725 } 7726 7727 /* We shouldn't have local or global symbols defined in the TOC, 7728 but handle them anyway. */ 7729 if (local_syms != NULL) 7730 { 7731 Elf_Internal_Sym *sym; 7732 7733 for (sym = local_syms; 7734 sym < local_syms + symtab_hdr->sh_info; 7735 ++sym) 7736 if (sym->st_value != 0 7737 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc) 7738 { 7739 if (skip[sym->st_value >> 3] != (unsigned long) -1) 7740 sym->st_value -= skip[sym->st_value >> 3]; 7741 else 7742 { 7743 (*_bfd_error_handler) 7744 (_("%s defined in removed toc entry"), 7745 bfd_elf_sym_name (ibfd, symtab_hdr, sym, 7746 NULL)); 7747 sym->st_value = 0; 7748 sym->st_shndx = SHN_ABS; 7749 } 7750 symtab_hdr->contents = (unsigned char *) local_syms; 7751 } 7752 } 7753 7754 /* Finally, adjust any global syms defined in the toc. */ 7755 if (toc_inf.global_toc_syms) 7756 { 7757 toc_inf.toc = toc; 7758 toc_inf.skip = skip; 7759 toc_inf.global_toc_syms = FALSE; 7760 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms, 7761 &toc_inf); 7762 } 7763 } 7764 7765 if (local_syms != NULL 7766 && symtab_hdr->contents != (unsigned char *) local_syms) 7767 { 7768 if (!info->keep_memory) 7769 free (local_syms); 7770 else 7771 symtab_hdr->contents = (unsigned char *) local_syms; 7772 } 7773 free (skip); 7774 } 7775 7776 return TRUE; 7777 } 7778 7779 /* Allocate space in .plt, .got and associated reloc sections for 7780 dynamic relocs. */ 7781 7782 static bfd_boolean 7783 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 7784 { 7785 struct bfd_link_info *info; 7786 struct ppc_link_hash_table *htab; 7787 asection *s; 7788 struct ppc_link_hash_entry *eh; 7789 struct ppc_dyn_relocs *p; 7790 struct got_entry *gent; 7791 7792 if (h->root.type == bfd_link_hash_indirect) 7793 return TRUE; 7794 7795 if (h->root.type == bfd_link_hash_warning) 7796 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7797 7798 info = (struct bfd_link_info *) inf; 7799 htab = ppc_hash_table (info); 7800 7801 if (htab->elf.dynamic_sections_created 7802 && h->dynindx != -1 7803 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)) 7804 { 7805 struct plt_entry *pent; 7806 bfd_boolean doneone = FALSE; 7807 for (pent = h->plt.plist; pent != NULL; pent = pent->next) 7808 if (pent->plt.refcount > 0) 7809 { 7810 /* If this is the first .plt entry, make room for the special 7811 first entry. */ 7812 s = htab->plt; 7813 if (s->size == 0) 7814 s->size += PLT_INITIAL_ENTRY_SIZE; 7815 7816 pent->plt.offset = s->size; 7817 7818 /* Make room for this entry. */ 7819 s->size += PLT_ENTRY_SIZE; 7820 7821 /* Make room for the .glink code. */ 7822 s = htab->glink; 7823 if (s->size == 0) 7824 s->size += GLINK_CALL_STUB_SIZE; 7825 /* We need bigger stubs past index 32767. */ 7826 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4) 7827 s->size += 4; 7828 s->size += 2*4; 7829 7830 /* We also need to make an entry in the .rela.plt section. */ 7831 s = htab->relplt; 7832 s->size += sizeof (Elf64_External_Rela); 7833 doneone = TRUE; 7834 } 7835 else 7836 pent->plt.offset = (bfd_vma) -1; 7837 if (!doneone) 7838 { 7839 h->plt.plist = NULL; 7840 h->needs_plt = 0; 7841 } 7842 } 7843 else 7844 { 7845 h->plt.plist = NULL; 7846 h->needs_plt = 0; 7847 } 7848 7849 eh = (struct ppc_link_hash_entry *) h; 7850 /* Run through the TLS GD got entries first if we're changing them 7851 to TPREL. */ 7852 if ((eh->tls_mask & TLS_TPRELGD) != 0) 7853 for (gent = h->got.glist; gent != NULL; gent = gent->next) 7854 if (gent->got.refcount > 0 7855 && (gent->tls_type & TLS_GD) != 0) 7856 { 7857 /* This was a GD entry that has been converted to TPREL. If 7858 there happens to be a TPREL entry we can use that one. */ 7859 struct got_entry *ent; 7860 for (ent = h->got.glist; ent != NULL; ent = ent->next) 7861 if (ent->got.refcount > 0 7862 && (ent->tls_type & TLS_TPREL) != 0 7863 && ent->addend == gent->addend 7864 && ent->owner == gent->owner) 7865 { 7866 gent->got.refcount = 0; 7867 break; 7868 } 7869 7870 /* If not, then we'll be using our own TPREL entry. */ 7871 if (gent->got.refcount != 0) 7872 gent->tls_type = TLS_TLS | TLS_TPREL; 7873 } 7874 7875 for (gent = h->got.glist; gent != NULL; gent = gent->next) 7876 if (gent->got.refcount > 0) 7877 { 7878 bfd_boolean dyn; 7879 7880 /* Make sure this symbol is output as a dynamic symbol. 7881 Undefined weak syms won't yet be marked as dynamic, 7882 nor will all TLS symbols. */ 7883 if (h->dynindx == -1 7884 && !h->forced_local 7885 && htab->elf.dynamic_sections_created) 7886 { 7887 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 7888 return FALSE; 7889 } 7890 7891 if ((gent->tls_type & TLS_LD) != 0 7892 && !h->def_dynamic) 7893 { 7894 ppc64_tlsld_got (gent->owner)->refcount += 1; 7895 gent->got.offset = (bfd_vma) -1; 7896 continue; 7897 } 7898 7899 if (!is_ppc64_elf (gent->owner)) 7900 continue; 7901 7902 s = ppc64_elf_tdata (gent->owner)->got; 7903 gent->got.offset = s->size; 7904 s->size 7905 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8; 7906 dyn = htab->elf.dynamic_sections_created; 7907 if ((info->shared 7908 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)) 7909 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 7910 || h->root.type != bfd_link_hash_undefweak)) 7911 ppc64_elf_tdata (gent->owner)->relgot->size 7912 += (gent->tls_type & eh->tls_mask & TLS_GD 7913 ? 2 * sizeof (Elf64_External_Rela) 7914 : sizeof (Elf64_External_Rela)); 7915 } 7916 else 7917 gent->got.offset = (bfd_vma) -1; 7918 7919 if (eh->dyn_relocs == NULL 7920 || !htab->elf.dynamic_sections_created) 7921 return TRUE; 7922 7923 /* In the shared -Bsymbolic case, discard space allocated for 7924 dynamic pc-relative relocs against symbols which turn out to be 7925 defined in regular objects. For the normal shared case, discard 7926 space for relocs that have become local due to symbol visibility 7927 changes. */ 7928 7929 if (info->shared) 7930 { 7931 /* Relocs that use pc_count are those that appear on a call insn, 7932 or certain REL relocs (see must_be_dyn_reloc) that can be 7933 generated via assembly. We want calls to protected symbols to 7934 resolve directly to the function rather than going via the plt. 7935 If people want function pointer comparisons to work as expected 7936 then they should avoid writing weird assembly. */ 7937 if (SYMBOL_CALLS_LOCAL (info, h)) 7938 { 7939 struct ppc_dyn_relocs **pp; 7940 7941 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 7942 { 7943 p->count -= p->pc_count; 7944 p->pc_count = 0; 7945 if (p->count == 0) 7946 *pp = p->next; 7947 else 7948 pp = &p->next; 7949 } 7950 } 7951 7952 /* Also discard relocs on undefined weak syms with non-default 7953 visibility. */ 7954 if (eh->dyn_relocs != NULL 7955 && h->root.type == bfd_link_hash_undefweak) 7956 { 7957 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 7958 eh->dyn_relocs = NULL; 7959 7960 /* Make sure this symbol is output as a dynamic symbol. 7961 Undefined weak syms won't yet be marked as dynamic. */ 7962 else if (h->dynindx == -1 7963 && !h->forced_local) 7964 { 7965 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 7966 return FALSE; 7967 } 7968 } 7969 } 7970 else if (ELIMINATE_COPY_RELOCS) 7971 { 7972 /* For the non-shared case, discard space for relocs against 7973 symbols which turn out to need copy relocs or are not 7974 dynamic. */ 7975 7976 if (!h->non_got_ref 7977 && !h->def_regular) 7978 { 7979 /* Make sure this symbol is output as a dynamic symbol. 7980 Undefined weak syms won't yet be marked as dynamic. */ 7981 if (h->dynindx == -1 7982 && !h->forced_local) 7983 { 7984 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 7985 return FALSE; 7986 } 7987 7988 /* If that succeeded, we know we'll be keeping all the 7989 relocs. */ 7990 if (h->dynindx != -1) 7991 goto keep; 7992 } 7993 7994 eh->dyn_relocs = NULL; 7995 7996 keep: ; 7997 } 7998 7999 /* Finally, allocate space. */ 8000 for (p = eh->dyn_relocs; p != NULL; p = p->next) 8001 { 8002 asection *sreloc = elf_section_data (p->sec)->sreloc; 8003 sreloc->size += p->count * sizeof (Elf64_External_Rela); 8004 } 8005 8006 return TRUE; 8007 } 8008 8009 /* Find any dynamic relocs that apply to read-only sections. */ 8010 8011 static bfd_boolean 8012 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf) 8013 { 8014 struct ppc_link_hash_entry *eh; 8015 struct ppc_dyn_relocs *p; 8016 8017 if (h->root.type == bfd_link_hash_warning) 8018 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8019 8020 eh = (struct ppc_link_hash_entry *) h; 8021 for (p = eh->dyn_relocs; p != NULL; p = p->next) 8022 { 8023 asection *s = p->sec->output_section; 8024 8025 if (s != NULL && (s->flags & SEC_READONLY) != 0) 8026 { 8027 struct bfd_link_info *info = inf; 8028 8029 if (info->warn_shared_textrel) 8030 (*_bfd_error_handler) 8031 (_("warning: dynamic relocation in readonly section `%s'"), 8032 h->root.root.string); 8033 info->flags |= DF_TEXTREL; 8034 8035 /* Not an error, just cut short the traversal. */ 8036 return FALSE; 8037 } 8038 } 8039 return TRUE; 8040 } 8041 8042 /* Set the sizes of the dynamic sections. */ 8043 8044 static bfd_boolean 8045 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 8046 struct bfd_link_info *info) 8047 { 8048 struct ppc_link_hash_table *htab; 8049 bfd *dynobj; 8050 asection *s; 8051 bfd_boolean relocs; 8052 bfd *ibfd; 8053 8054 htab = ppc_hash_table (info); 8055 dynobj = htab->elf.dynobj; 8056 if (dynobj == NULL) 8057 abort (); 8058 8059 if (htab->elf.dynamic_sections_created) 8060 { 8061 /* Set the contents of the .interp section to the interpreter. */ 8062 if (info->executable) 8063 { 8064 s = bfd_get_section_by_name (dynobj, ".interp"); 8065 if (s == NULL) 8066 abort (); 8067 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 8068 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 8069 } 8070 } 8071 8072 /* Set up .got offsets for local syms, and space for local dynamic 8073 relocs. */ 8074 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 8075 { 8076 struct got_entry **lgot_ents; 8077 struct got_entry **end_lgot_ents; 8078 char *lgot_masks; 8079 bfd_size_type locsymcount; 8080 Elf_Internal_Shdr *symtab_hdr; 8081 asection *srel; 8082 8083 if (!is_ppc64_elf (ibfd)) 8084 continue; 8085 8086 for (s = ibfd->sections; s != NULL; s = s->next) 8087 { 8088 struct ppc_dyn_relocs *p; 8089 8090 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 8091 { 8092 if (!bfd_is_abs_section (p->sec) 8093 && bfd_is_abs_section (p->sec->output_section)) 8094 { 8095 /* Input section has been discarded, either because 8096 it is a copy of a linkonce section or due to 8097 linker script /DISCARD/, so we'll be discarding 8098 the relocs too. */ 8099 } 8100 else if (p->count != 0) 8101 { 8102 srel = elf_section_data (p->sec)->sreloc; 8103 srel->size += p->count * sizeof (Elf64_External_Rela); 8104 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 8105 info->flags |= DF_TEXTREL; 8106 } 8107 } 8108 } 8109 8110 lgot_ents = elf_local_got_ents (ibfd); 8111 if (!lgot_ents) 8112 continue; 8113 8114 symtab_hdr = &elf_symtab_hdr (ibfd); 8115 locsymcount = symtab_hdr->sh_info; 8116 end_lgot_ents = lgot_ents + locsymcount; 8117 lgot_masks = (char *) end_lgot_ents; 8118 s = ppc64_elf_tdata (ibfd)->got; 8119 srel = ppc64_elf_tdata (ibfd)->relgot; 8120 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks) 8121 { 8122 struct got_entry *ent; 8123 8124 for (ent = *lgot_ents; ent != NULL; ent = ent->next) 8125 if (ent->got.refcount > 0) 8126 { 8127 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0) 8128 { 8129 ppc64_tlsld_got (ibfd)->refcount += 1; 8130 ent->got.offset = (bfd_vma) -1; 8131 } 8132 else 8133 { 8134 ent->got.offset = s->size; 8135 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0) 8136 { 8137 s->size += 16; 8138 if (info->shared) 8139 srel->size += 2 * sizeof (Elf64_External_Rela); 8140 } 8141 else 8142 { 8143 s->size += 8; 8144 if (info->shared) 8145 srel->size += sizeof (Elf64_External_Rela); 8146 } 8147 } 8148 } 8149 else 8150 ent->got.offset = (bfd_vma) -1; 8151 } 8152 } 8153 8154 /* Allocate global sym .plt and .got entries, and space for global 8155 sym dynamic relocs. */ 8156 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 8157 8158 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 8159 { 8160 if (!is_ppc64_elf (ibfd)) 8161 continue; 8162 8163 if (ppc64_tlsld_got (ibfd)->refcount > 0) 8164 { 8165 s = ppc64_elf_tdata (ibfd)->got; 8166 ppc64_tlsld_got (ibfd)->offset = s->size; 8167 s->size += 16; 8168 if (info->shared) 8169 { 8170 asection *srel = ppc64_elf_tdata (ibfd)->relgot; 8171 srel->size += sizeof (Elf64_External_Rela); 8172 } 8173 } 8174 else 8175 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1; 8176 } 8177 8178 /* We now have determined the sizes of the various dynamic sections. 8179 Allocate memory for them. */ 8180 relocs = FALSE; 8181 for (s = dynobj->sections; s != NULL; s = s->next) 8182 { 8183 if ((s->flags & SEC_LINKER_CREATED) == 0) 8184 continue; 8185 8186 if (s == htab->brlt || s == htab->relbrlt) 8187 /* These haven't been allocated yet; don't strip. */ 8188 continue; 8189 else if (s == htab->got 8190 || s == htab->plt 8191 || s == htab->glink 8192 || s == htab->dynbss) 8193 { 8194 /* Strip this section if we don't need it; see the 8195 comment below. */ 8196 } 8197 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 8198 { 8199 if (s->size != 0) 8200 { 8201 if (s != htab->relplt) 8202 relocs = TRUE; 8203 8204 /* We use the reloc_count field as a counter if we need 8205 to copy relocs into the output file. */ 8206 s->reloc_count = 0; 8207 } 8208 } 8209 else 8210 { 8211 /* It's not one of our sections, so don't allocate space. */ 8212 continue; 8213 } 8214 8215 if (s->size == 0) 8216 { 8217 /* If we don't need this section, strip it from the 8218 output file. This is mostly to handle .rela.bss and 8219 .rela.plt. We must create both sections in 8220 create_dynamic_sections, because they must be created 8221 before the linker maps input sections to output 8222 sections. The linker does that before 8223 adjust_dynamic_symbol is called, and it is that 8224 function which decides whether anything needs to go 8225 into these sections. */ 8226 s->flags |= SEC_EXCLUDE; 8227 continue; 8228 } 8229 8230 if ((s->flags & SEC_HAS_CONTENTS) == 0) 8231 continue; 8232 8233 /* Allocate memory for the section contents. We use bfd_zalloc 8234 here in case unused entries are not reclaimed before the 8235 section's contents are written out. This should not happen, 8236 but this way if it does we get a R_PPC64_NONE reloc in .rela 8237 sections instead of garbage. 8238 We also rely on the section contents being zero when writing 8239 the GOT. */ 8240 s->contents = bfd_zalloc (dynobj, s->size); 8241 if (s->contents == NULL) 8242 return FALSE; 8243 } 8244 8245 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 8246 { 8247 if (!is_ppc64_elf (ibfd)) 8248 continue; 8249 8250 s = ppc64_elf_tdata (ibfd)->got; 8251 if (s != NULL && s != htab->got) 8252 { 8253 if (s->size == 0) 8254 s->flags |= SEC_EXCLUDE; 8255 else 8256 { 8257 s->contents = bfd_zalloc (ibfd, s->size); 8258 if (s->contents == NULL) 8259 return FALSE; 8260 } 8261 } 8262 s = ppc64_elf_tdata (ibfd)->relgot; 8263 if (s != NULL) 8264 { 8265 if (s->size == 0) 8266 s->flags |= SEC_EXCLUDE; 8267 else 8268 { 8269 s->contents = bfd_zalloc (ibfd, s->size); 8270 if (s->contents == NULL) 8271 return FALSE; 8272 relocs = TRUE; 8273 s->reloc_count = 0; 8274 } 8275 } 8276 } 8277 8278 if (htab->elf.dynamic_sections_created) 8279 { 8280 /* Add some entries to the .dynamic section. We fill in the 8281 values later, in ppc64_elf_finish_dynamic_sections, but we 8282 must add the entries now so that we get the correct size for 8283 the .dynamic section. The DT_DEBUG entry is filled in by the 8284 dynamic linker and used by the debugger. */ 8285 #define add_dynamic_entry(TAG, VAL) \ 8286 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 8287 8288 if (info->executable) 8289 { 8290 if (!add_dynamic_entry (DT_DEBUG, 0)) 8291 return FALSE; 8292 } 8293 8294 if (htab->plt != NULL && htab->plt->size != 0) 8295 { 8296 if (!add_dynamic_entry (DT_PLTGOT, 0) 8297 || !add_dynamic_entry (DT_PLTRELSZ, 0) 8298 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 8299 || !add_dynamic_entry (DT_JMPREL, 0) 8300 || !add_dynamic_entry (DT_PPC64_GLINK, 0)) 8301 return FALSE; 8302 } 8303 8304 if (NO_OPD_RELOCS) 8305 { 8306 if (!add_dynamic_entry (DT_PPC64_OPD, 0) 8307 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0)) 8308 return FALSE; 8309 } 8310 8311 if (relocs) 8312 { 8313 if (!add_dynamic_entry (DT_RELA, 0) 8314 || !add_dynamic_entry (DT_RELASZ, 0) 8315 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 8316 return FALSE; 8317 8318 /* If any dynamic relocs apply to a read-only section, 8319 then we need a DT_TEXTREL entry. */ 8320 if ((info->flags & DF_TEXTREL) == 0) 8321 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info); 8322 8323 if ((info->flags & DF_TEXTREL) != 0) 8324 { 8325 if (!add_dynamic_entry (DT_TEXTREL, 0)) 8326 return FALSE; 8327 } 8328 } 8329 } 8330 #undef add_dynamic_entry 8331 8332 return TRUE; 8333 } 8334 8335 /* Determine the type of stub needed, if any, for a call. */ 8336 8337 static inline enum ppc_stub_type 8338 ppc_type_of_stub (asection *input_sec, 8339 const Elf_Internal_Rela *rel, 8340 struct ppc_link_hash_entry **hash, 8341 bfd_vma destination) 8342 { 8343 struct ppc_link_hash_entry *h = *hash; 8344 bfd_vma location; 8345 bfd_vma branch_offset; 8346 bfd_vma max_branch_offset; 8347 enum elf_ppc64_reloc_type r_type; 8348 8349 if (h != NULL) 8350 { 8351 struct ppc_link_hash_entry *fdh = h; 8352 if (fdh->oh != NULL 8353 && fdh->oh->is_func_descriptor) 8354 fdh = fdh->oh; 8355 8356 if (fdh->elf.dynindx != -1) 8357 { 8358 struct plt_entry *ent; 8359 8360 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next) 8361 if (ent->addend == rel->r_addend 8362 && ent->plt.offset != (bfd_vma) -1) 8363 { 8364 *hash = fdh; 8365 return ppc_stub_plt_call; 8366 } 8367 } 8368 8369 /* Here, we know we don't have a plt entry. If we don't have a 8370 either a defined function descriptor or a defined entry symbol 8371 in a regular object file, then it is pointless trying to make 8372 any other type of stub. */ 8373 if (!((fdh->elf.root.type == bfd_link_hash_defined 8374 || fdh->elf.root.type == bfd_link_hash_defweak) 8375 && fdh->elf.root.u.def.section->output_section != NULL) 8376 && !((h->elf.root.type == bfd_link_hash_defined 8377 || h->elf.root.type == bfd_link_hash_defweak) 8378 && h->elf.root.u.def.section->output_section != NULL)) 8379 return ppc_stub_none; 8380 } 8381 8382 /* Determine where the call point is. */ 8383 location = (input_sec->output_offset 8384 + input_sec->output_section->vma 8385 + rel->r_offset); 8386 8387 branch_offset = destination - location; 8388 r_type = ELF64_R_TYPE (rel->r_info); 8389 8390 /* Determine if a long branch stub is needed. */ 8391 max_branch_offset = 1 << 25; 8392 if (r_type != R_PPC64_REL24) 8393 max_branch_offset = 1 << 15; 8394 8395 if (branch_offset + max_branch_offset >= 2 * max_branch_offset) 8396 /* We need a stub. Figure out whether a long_branch or plt_branch 8397 is needed later. */ 8398 return ppc_stub_long_branch; 8399 8400 return ppc_stub_none; 8401 } 8402 8403 /* Build a .plt call stub. */ 8404 8405 static inline bfd_byte * 8406 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r) 8407 { 8408 #define PPC_LO(v) ((v) & 0xffff) 8409 #define PPC_HI(v) (((v) >> 16) & 0xffff) 8410 #define PPC_HA(v) PPC_HI ((v) + 0x8000) 8411 8412 if (PPC_HA (offset) != 0) 8413 { 8414 if (r != NULL) 8415 { 8416 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA); 8417 r[1].r_offset = r[0].r_offset + 8; 8418 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 8419 r[1].r_addend = r[0].r_addend; 8420 if (PPC_HA (offset + 16) != PPC_HA (offset)) 8421 { 8422 r[2].r_offset = r[1].r_offset + 4; 8423 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO); 8424 r[2].r_addend = r[0].r_addend; 8425 } 8426 else 8427 { 8428 r[2].r_offset = r[1].r_offset + 8; 8429 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 8430 r[2].r_addend = r[0].r_addend + 8; 8431 r[3].r_offset = r[2].r_offset + 4; 8432 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 8433 r[3].r_addend = r[0].r_addend + 16; 8434 } 8435 } 8436 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4; 8437 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4; 8438 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4; 8439 if (PPC_HA (offset + 16) != PPC_HA (offset)) 8440 { 8441 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4; 8442 offset = 0; 8443 } 8444 bfd_put_32 (obfd, MTCTR_R11, p), p += 4; 8445 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4; 8446 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4; 8447 bfd_put_32 (obfd, BCTR, p), p += 4; 8448 } 8449 else 8450 { 8451 if (r != NULL) 8452 { 8453 r[0].r_offset += 4; 8454 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 8455 if (PPC_HA (offset + 16) != PPC_HA (offset)) 8456 { 8457 r[1].r_offset = r[0].r_offset + 4; 8458 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16); 8459 r[1].r_addend = r[0].r_addend; 8460 } 8461 else 8462 { 8463 r[1].r_offset = r[0].r_offset + 8; 8464 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 8465 r[1].r_addend = r[0].r_addend + 16; 8466 r[2].r_offset = r[1].r_offset + 4; 8467 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 8468 r[2].r_addend = r[0].r_addend + 8; 8469 } 8470 } 8471 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4; 8472 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4; 8473 if (PPC_HA (offset + 16) != PPC_HA (offset)) 8474 { 8475 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4; 8476 offset = 0; 8477 } 8478 bfd_put_32 (obfd, MTCTR_R11, p), p += 4; 8479 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4; 8480 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4; 8481 bfd_put_32 (obfd, BCTR, p), p += 4; 8482 } 8483 return p; 8484 } 8485 8486 static Elf_Internal_Rela * 8487 get_relocs (asection *sec, int count) 8488 { 8489 Elf_Internal_Rela *relocs; 8490 struct bfd_elf_section_data *elfsec_data; 8491 8492 elfsec_data = elf_section_data (sec); 8493 relocs = elfsec_data->relocs; 8494 if (relocs == NULL) 8495 { 8496 bfd_size_type relsize; 8497 relsize = sec->reloc_count * sizeof (*relocs); 8498 relocs = bfd_alloc (sec->owner, relsize); 8499 if (relocs == NULL) 8500 return NULL; 8501 elfsec_data->relocs = relocs; 8502 elfsec_data->rel_hdr.sh_size = (sec->reloc_count 8503 * sizeof (Elf64_External_Rela)); 8504 elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela); 8505 sec->reloc_count = 0; 8506 } 8507 relocs += sec->reloc_count; 8508 sec->reloc_count += count; 8509 return relocs; 8510 } 8511 8512 static bfd_boolean 8513 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 8514 { 8515 struct ppc_stub_hash_entry *stub_entry; 8516 struct ppc_branch_hash_entry *br_entry; 8517 struct bfd_link_info *info; 8518 struct ppc_link_hash_table *htab; 8519 bfd_byte *loc; 8520 bfd_byte *p; 8521 struct plt_entry *ent; 8522 bfd_vma dest, off; 8523 int size; 8524 Elf_Internal_Rela *r; 8525 8526 /* Massage our args to the form they really have. */ 8527 stub_entry = (struct ppc_stub_hash_entry *) gen_entry; 8528 info = in_arg; 8529 8530 htab = ppc_hash_table (info); 8531 8532 /* Make a note of the offset within the stubs for this entry. */ 8533 stub_entry->stub_offset = stub_entry->stub_sec->size; 8534 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset; 8535 8536 htab->stub_count[stub_entry->stub_type - 1] += 1; 8537 switch (stub_entry->stub_type) 8538 { 8539 case ppc_stub_long_branch: 8540 case ppc_stub_long_branch_r2off: 8541 /* Branches are relative. This is where we are going to. */ 8542 off = dest = (stub_entry->target_value 8543 + stub_entry->target_section->output_offset 8544 + stub_entry->target_section->output_section->vma); 8545 8546 /* And this is where we are coming from. */ 8547 off -= (stub_entry->stub_offset 8548 + stub_entry->stub_sec->output_offset 8549 + stub_entry->stub_sec->output_section->vma); 8550 8551 size = 4; 8552 if (stub_entry->stub_type == ppc_stub_long_branch_r2off) 8553 { 8554 bfd_vma r2off; 8555 8556 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off 8557 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8558 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc); 8559 loc += 4; 8560 size = 12; 8561 if (PPC_HA (r2off) != 0) 8562 { 8563 size = 16; 8564 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc); 8565 loc += 4; 8566 } 8567 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc); 8568 loc += 4; 8569 off -= size - 4; 8570 } 8571 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc); 8572 8573 if (off + (1 << 25) >= (bfd_vma) (1 << 26)) 8574 { 8575 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"), 8576 stub_entry->root.string); 8577 htab->stub_error = TRUE; 8578 return FALSE; 8579 } 8580 8581 if (info->emitrelocations) 8582 { 8583 r = get_relocs (stub_entry->stub_sec, 1); 8584 if (r == NULL) 8585 return FALSE; 8586 r->r_offset = loc - stub_entry->stub_sec->contents; 8587 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24); 8588 r->r_addend = dest; 8589 if (stub_entry->h != NULL) 8590 { 8591 struct elf_link_hash_entry **hashes; 8592 unsigned long symndx; 8593 struct ppc_link_hash_entry *h; 8594 8595 hashes = elf_sym_hashes (htab->stub_bfd); 8596 if (hashes == NULL) 8597 { 8598 bfd_size_type hsize; 8599 8600 hsize = (htab->stub_globals + 1) * sizeof (*hashes); 8601 hashes = bfd_zalloc (htab->stub_bfd, hsize); 8602 if (hashes == NULL) 8603 return FALSE; 8604 elf_sym_hashes (htab->stub_bfd) = hashes; 8605 htab->stub_globals = 1; 8606 } 8607 symndx = htab->stub_globals++; 8608 h = stub_entry->h; 8609 hashes[symndx] = &h->elf; 8610 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24); 8611 if (h->oh != NULL && h->oh->is_func) 8612 h = h->oh; 8613 if (h->elf.root.u.def.section != stub_entry->target_section) 8614 /* H is an opd symbol. The addend must be zero. */ 8615 r->r_addend = 0; 8616 else 8617 { 8618 off = (h->elf.root.u.def.value 8619 + h->elf.root.u.def.section->output_offset 8620 + h->elf.root.u.def.section->output_section->vma); 8621 r->r_addend -= off; 8622 } 8623 } 8624 } 8625 break; 8626 8627 case ppc_stub_plt_branch: 8628 case ppc_stub_plt_branch_r2off: 8629 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table, 8630 stub_entry->root.string + 9, 8631 FALSE, FALSE); 8632 if (br_entry == NULL) 8633 { 8634 (*_bfd_error_handler) (_("can't find branch stub `%s'"), 8635 stub_entry->root.string); 8636 htab->stub_error = TRUE; 8637 return FALSE; 8638 } 8639 8640 dest = (stub_entry->target_value 8641 + stub_entry->target_section->output_offset 8642 + stub_entry->target_section->output_section->vma); 8643 8644 bfd_put_64 (htab->brlt->owner, dest, 8645 htab->brlt->contents + br_entry->offset); 8646 8647 if (br_entry->iter == htab->stub_iteration) 8648 { 8649 br_entry->iter = 0; 8650 8651 if (htab->relbrlt != NULL) 8652 { 8653 /* Create a reloc for the branch lookup table entry. */ 8654 Elf_Internal_Rela rela; 8655 bfd_byte *rl; 8656 8657 rela.r_offset = (br_entry->offset 8658 + htab->brlt->output_offset 8659 + htab->brlt->output_section->vma); 8660 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 8661 rela.r_addend = dest; 8662 8663 rl = htab->relbrlt->contents; 8664 rl += (htab->relbrlt->reloc_count++ 8665 * sizeof (Elf64_External_Rela)); 8666 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl); 8667 } 8668 else if (info->emitrelocations) 8669 { 8670 r = get_relocs (htab->brlt, 1); 8671 if (r == NULL) 8672 return FALSE; 8673 /* brlt, being SEC_LINKER_CREATED does not go through the 8674 normal reloc processing. Symbols and offsets are not 8675 translated from input file to output file form, so 8676 set up the offset per the output file. */ 8677 r->r_offset = (br_entry->offset 8678 + htab->brlt->output_offset 8679 + htab->brlt->output_section->vma); 8680 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 8681 r->r_addend = dest; 8682 } 8683 } 8684 8685 dest = (br_entry->offset 8686 + htab->brlt->output_offset 8687 + htab->brlt->output_section->vma); 8688 8689 off = (dest 8690 - elf_gp (htab->brlt->output_section->owner) 8691 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8692 8693 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0) 8694 { 8695 (*_bfd_error_handler) 8696 (_("linkage table error against `%s'"), 8697 stub_entry->root.string); 8698 bfd_set_error (bfd_error_bad_value); 8699 htab->stub_error = TRUE; 8700 return FALSE; 8701 } 8702 8703 if (info->emitrelocations) 8704 { 8705 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0)); 8706 if (r == NULL) 8707 return FALSE; 8708 r[0].r_offset = loc - stub_entry->stub_sec->contents; 8709 if (bfd_big_endian (info->output_bfd)) 8710 r[0].r_offset += 2; 8711 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off) 8712 r[0].r_offset += 4; 8713 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 8714 r[0].r_addend = dest; 8715 if (PPC_HA (off) != 0) 8716 { 8717 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA); 8718 r[1].r_offset = r[0].r_offset + 4; 8719 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 8720 r[1].r_addend = r[0].r_addend; 8721 } 8722 } 8723 8724 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off) 8725 { 8726 if (PPC_HA (off) != 0) 8727 { 8728 size = 16; 8729 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc); 8730 loc += 4; 8731 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc); 8732 } 8733 else 8734 { 8735 size = 12; 8736 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc); 8737 } 8738 } 8739 else 8740 { 8741 bfd_vma r2off; 8742 8743 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off 8744 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8745 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc); 8746 loc += 4; 8747 size = 20; 8748 if (PPC_HA (off) != 0) 8749 { 8750 size += 4; 8751 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc); 8752 loc += 4; 8753 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc); 8754 loc += 4; 8755 } 8756 else 8757 { 8758 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc); 8759 loc += 4; 8760 } 8761 8762 if (PPC_HA (r2off) != 0) 8763 { 8764 size += 4; 8765 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc); 8766 loc += 4; 8767 } 8768 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc); 8769 } 8770 loc += 4; 8771 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc); 8772 loc += 4; 8773 bfd_put_32 (htab->stub_bfd, BCTR, loc); 8774 break; 8775 8776 case ppc_stub_plt_call: 8777 /* Do the best we can for shared libraries built without 8778 exporting ".foo" for each "foo". This can happen when symbol 8779 versioning scripts strip all bar a subset of symbols. */ 8780 if (stub_entry->h->oh != NULL 8781 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined 8782 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak) 8783 { 8784 /* Point the symbol at the stub. There may be multiple stubs, 8785 we don't really care; The main thing is to make this sym 8786 defined somewhere. Maybe defining the symbol in the stub 8787 section is a silly idea. If we didn't do this, htab->top_id 8788 could disappear. */ 8789 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined; 8790 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec; 8791 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset; 8792 } 8793 8794 /* Now build the stub. */ 8795 dest = (bfd_vma) -1; 8796 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next) 8797 if (ent->addend == stub_entry->addend) 8798 { 8799 dest = ent->plt.offset; 8800 break; 8801 } 8802 if (dest >= (bfd_vma) -2) 8803 abort (); 8804 8805 dest &= ~ (bfd_vma) 1; 8806 dest += (htab->plt->output_offset 8807 + htab->plt->output_section->vma); 8808 8809 off = (dest 8810 - elf_gp (htab->plt->output_section->owner) 8811 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8812 8813 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0) 8814 { 8815 (*_bfd_error_handler) 8816 (_("linkage table error against `%s'"), 8817 stub_entry->h->elf.root.root.string); 8818 bfd_set_error (bfd_error_bad_value); 8819 htab->stub_error = TRUE; 8820 return FALSE; 8821 } 8822 8823 r = NULL; 8824 if (info->emitrelocations) 8825 { 8826 r = get_relocs (stub_entry->stub_sec, 8827 (2 + (PPC_HA (off) != 0) 8828 + (PPC_HA (off + 16) == PPC_HA (off)))); 8829 if (r == NULL) 8830 return FALSE; 8831 r[0].r_offset = loc - stub_entry->stub_sec->contents; 8832 if (bfd_big_endian (info->output_bfd)) 8833 r[0].r_offset += 2; 8834 r[0].r_addend = dest; 8835 } 8836 p = build_plt_stub (htab->stub_bfd, loc, off, r); 8837 size = p - loc; 8838 break; 8839 8840 default: 8841 BFD_FAIL (); 8842 return FALSE; 8843 } 8844 8845 stub_entry->stub_sec->size += size; 8846 8847 if (htab->emit_stub_syms) 8848 { 8849 struct elf_link_hash_entry *h; 8850 size_t len1, len2; 8851 char *name; 8852 const char *const stub_str[] = { "long_branch", 8853 "long_branch_r2off", 8854 "plt_branch", 8855 "plt_branch_r2off", 8856 "plt_call" }; 8857 8858 len1 = strlen (stub_str[stub_entry->stub_type - 1]); 8859 len2 = strlen (stub_entry->root.string); 8860 name = bfd_malloc (len1 + len2 + 2); 8861 if (name == NULL) 8862 return FALSE; 8863 memcpy (name, stub_entry->root.string, 9); 8864 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1); 8865 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1); 8866 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); 8867 if (h == NULL) 8868 return FALSE; 8869 if (h->root.type == bfd_link_hash_new) 8870 { 8871 h->root.type = bfd_link_hash_defined; 8872 h->root.u.def.section = stub_entry->stub_sec; 8873 h->root.u.def.value = stub_entry->stub_offset; 8874 h->ref_regular = 1; 8875 h->def_regular = 1; 8876 h->ref_regular_nonweak = 1; 8877 h->forced_local = 1; 8878 h->non_elf = 0; 8879 } 8880 } 8881 8882 return TRUE; 8883 } 8884 8885 /* As above, but don't actually build the stub. Just bump offset so 8886 we know stub section sizes, and select plt_branch stubs where 8887 long_branch stubs won't do. */ 8888 8889 static bfd_boolean 8890 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 8891 { 8892 struct ppc_stub_hash_entry *stub_entry; 8893 struct bfd_link_info *info; 8894 struct ppc_link_hash_table *htab; 8895 bfd_vma off; 8896 int size; 8897 8898 /* Massage our args to the form they really have. */ 8899 stub_entry = (struct ppc_stub_hash_entry *) gen_entry; 8900 info = in_arg; 8901 8902 htab = ppc_hash_table (info); 8903 8904 if (stub_entry->stub_type == ppc_stub_plt_call) 8905 { 8906 struct plt_entry *ent; 8907 off = (bfd_vma) -1; 8908 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next) 8909 if (ent->addend == stub_entry->addend) 8910 { 8911 off = ent->plt.offset & ~(bfd_vma) 1; 8912 break; 8913 } 8914 if (off >= (bfd_vma) -2) 8915 abort (); 8916 off += (htab->plt->output_offset 8917 + htab->plt->output_section->vma 8918 - elf_gp (htab->plt->output_section->owner) 8919 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8920 8921 size = PLT_CALL_STUB_SIZE; 8922 if (PPC_HA (off) == 0) 8923 size -= 4; 8924 if (PPC_HA (off + 16) != PPC_HA (off)) 8925 size += 4; 8926 if (info->emitrelocations) 8927 { 8928 stub_entry->stub_sec->reloc_count 8929 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off)); 8930 stub_entry->stub_sec->flags |= SEC_RELOC; 8931 } 8932 } 8933 else 8934 { 8935 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off 8936 variants. */ 8937 bfd_vma r2off = 0; 8938 8939 off = (stub_entry->target_value 8940 + stub_entry->target_section->output_offset 8941 + stub_entry->target_section->output_section->vma); 8942 off -= (stub_entry->stub_sec->size 8943 + stub_entry->stub_sec->output_offset 8944 + stub_entry->stub_sec->output_section->vma); 8945 8946 /* Reset the stub type from the plt variant in case we now 8947 can reach with a shorter stub. */ 8948 if (stub_entry->stub_type >= ppc_stub_plt_branch) 8949 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch; 8950 8951 size = 4; 8952 if (stub_entry->stub_type == ppc_stub_long_branch_r2off) 8953 { 8954 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off 8955 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8956 size = 12; 8957 if (PPC_HA (r2off) != 0) 8958 size = 16; 8959 off -= size - 4; 8960 } 8961 8962 /* If the branch offset if too big, use a ppc_stub_plt_branch. */ 8963 if (off + (1 << 25) >= (bfd_vma) (1 << 26)) 8964 { 8965 struct ppc_branch_hash_entry *br_entry; 8966 8967 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table, 8968 stub_entry->root.string + 9, 8969 TRUE, FALSE); 8970 if (br_entry == NULL) 8971 { 8972 (*_bfd_error_handler) (_("can't build branch stub `%s'"), 8973 stub_entry->root.string); 8974 htab->stub_error = TRUE; 8975 return FALSE; 8976 } 8977 8978 if (br_entry->iter != htab->stub_iteration) 8979 { 8980 br_entry->iter = htab->stub_iteration; 8981 br_entry->offset = htab->brlt->size; 8982 htab->brlt->size += 8; 8983 8984 if (htab->relbrlt != NULL) 8985 htab->relbrlt->size += sizeof (Elf64_External_Rela); 8986 else if (info->emitrelocations) 8987 { 8988 htab->brlt->reloc_count += 1; 8989 htab->brlt->flags |= SEC_RELOC; 8990 } 8991 } 8992 8993 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch; 8994 off = (br_entry->offset 8995 + htab->brlt->output_offset 8996 + htab->brlt->output_section->vma 8997 - elf_gp (htab->brlt->output_section->owner) 8998 - htab->stub_group[stub_entry->id_sec->id].toc_off); 8999 9000 if (info->emitrelocations) 9001 { 9002 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0); 9003 stub_entry->stub_sec->flags |= SEC_RELOC; 9004 } 9005 9006 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off) 9007 { 9008 size = 12; 9009 if (PPC_HA (off) != 0) 9010 size = 16; 9011 } 9012 else 9013 { 9014 size = 20; 9015 if (PPC_HA (off) != 0) 9016 size += 4; 9017 9018 if (PPC_HA (r2off) != 0) 9019 size += 4; 9020 } 9021 } 9022 else if (info->emitrelocations) 9023 { 9024 stub_entry->stub_sec->reloc_count += 1; 9025 stub_entry->stub_sec->flags |= SEC_RELOC; 9026 } 9027 } 9028 9029 stub_entry->stub_sec->size += size; 9030 return TRUE; 9031 } 9032 9033 /* Set up various things so that we can make a list of input sections 9034 for each output section included in the link. Returns -1 on error, 9035 0 when no stubs will be needed, and 1 on success. */ 9036 9037 int 9038 ppc64_elf_setup_section_lists (bfd *output_bfd, 9039 struct bfd_link_info *info, 9040 int no_multi_toc) 9041 { 9042 bfd *input_bfd; 9043 int top_id, top_index, id; 9044 asection *section; 9045 asection **input_list; 9046 bfd_size_type amt; 9047 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9048 9049 htab->no_multi_toc = no_multi_toc; 9050 9051 if (htab->brlt == NULL) 9052 return 0; 9053 9054 /* Find the top input section id. */ 9055 for (input_bfd = info->input_bfds, top_id = 3; 9056 input_bfd != NULL; 9057 input_bfd = input_bfd->link_next) 9058 { 9059 for (section = input_bfd->sections; 9060 section != NULL; 9061 section = section->next) 9062 { 9063 if (top_id < section->id) 9064 top_id = section->id; 9065 } 9066 } 9067 9068 htab->top_id = top_id; 9069 amt = sizeof (struct map_stub) * (top_id + 1); 9070 htab->stub_group = bfd_zmalloc (amt); 9071 if (htab->stub_group == NULL) 9072 return -1; 9073 9074 /* Set toc_off for com, und, abs and ind sections. */ 9075 for (id = 0; id < 3; id++) 9076 htab->stub_group[id].toc_off = TOC_BASE_OFF; 9077 9078 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd); 9079 9080 /* We can't use output_bfd->section_count here to find the top output 9081 section index as some sections may have been removed, and 9082 strip_excluded_output_sections doesn't renumber the indices. */ 9083 for (section = output_bfd->sections, top_index = 0; 9084 section != NULL; 9085 section = section->next) 9086 { 9087 if (top_index < section->index) 9088 top_index = section->index; 9089 } 9090 9091 htab->top_index = top_index; 9092 amt = sizeof (asection *) * (top_index + 1); 9093 input_list = bfd_zmalloc (amt); 9094 htab->input_list = input_list; 9095 if (input_list == NULL) 9096 return -1; 9097 9098 return 1; 9099 } 9100 9101 /* The linker repeatedly calls this function for each TOC input section 9102 and linker generated GOT section. Group input bfds such that the toc 9103 within a group is less than 64k in size. Will break with cute linker 9104 scripts that play games with dot in the output toc section. */ 9105 9106 void 9107 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec) 9108 { 9109 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9110 9111 if (!htab->no_multi_toc) 9112 { 9113 bfd_vma addr = isec->output_offset + isec->output_section->vma; 9114 bfd_vma off = addr - htab->toc_curr; 9115 9116 if (off + isec->size > 0x10000) 9117 htab->toc_curr = addr; 9118 9119 elf_gp (isec->owner) = (htab->toc_curr 9120 - elf_gp (isec->output_section->owner) 9121 + TOC_BASE_OFF); 9122 } 9123 } 9124 9125 /* Called after the last call to the above function. */ 9126 9127 void 9128 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info) 9129 { 9130 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9131 9132 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd); 9133 9134 /* toc_curr tracks the TOC offset used for code sections below in 9135 ppc64_elf_next_input_section. Start off at 0x8000. */ 9136 htab->toc_curr = TOC_BASE_OFF; 9137 } 9138 9139 /* No toc references were found in ISEC. If the code in ISEC makes no 9140 calls, then there's no need to use toc adjusting stubs when branching 9141 into ISEC. Actually, indirect calls from ISEC are OK as they will 9142 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub 9143 needed, and 2 if a cyclical call-graph was found but no other reason 9144 for a stub was detected. If called from the top level, a return of 9145 2 means the same as a return of 0. */ 9146 9147 static int 9148 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec) 9149 { 9150 Elf_Internal_Rela *relstart, *rel; 9151 Elf_Internal_Sym *local_syms; 9152 int ret; 9153 struct ppc_link_hash_table *htab; 9154 9155 /* We know none of our code bearing sections will need toc stubs. */ 9156 if ((isec->flags & SEC_LINKER_CREATED) != 0) 9157 return 0; 9158 9159 if (isec->size == 0) 9160 return 0; 9161 9162 if (isec->output_section == NULL) 9163 return 0; 9164 9165 if (isec->reloc_count == 0) 9166 return 0; 9167 9168 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL, 9169 info->keep_memory); 9170 if (relstart == NULL) 9171 return -1; 9172 9173 /* Look for branches to outside of this section. */ 9174 local_syms = NULL; 9175 ret = 0; 9176 htab = ppc_hash_table (info); 9177 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel) 9178 { 9179 enum elf_ppc64_reloc_type r_type; 9180 unsigned long r_symndx; 9181 struct elf_link_hash_entry *h; 9182 struct ppc_link_hash_entry *eh; 9183 Elf_Internal_Sym *sym; 9184 asection *sym_sec; 9185 struct _opd_sec_data *opd; 9186 bfd_vma sym_value; 9187 bfd_vma dest; 9188 9189 r_type = ELF64_R_TYPE (rel->r_info); 9190 if (r_type != R_PPC64_REL24 9191 && r_type != R_PPC64_REL14 9192 && r_type != R_PPC64_REL14_BRTAKEN 9193 && r_type != R_PPC64_REL14_BRNTAKEN) 9194 continue; 9195 9196 r_symndx = ELF64_R_SYM (rel->r_info); 9197 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx, 9198 isec->owner)) 9199 { 9200 ret = -1; 9201 break; 9202 } 9203 9204 /* Calls to dynamic lib functions go through a plt call stub 9205 that uses r2. */ 9206 eh = (struct ppc_link_hash_entry *) h; 9207 if (eh != NULL 9208 && (eh->elf.plt.plist != NULL 9209 || (eh->oh != NULL 9210 && eh->oh->elf.plt.plist != NULL))) 9211 { 9212 ret = 1; 9213 break; 9214 } 9215 9216 if (sym_sec == NULL) 9217 /* Ignore other undefined symbols. */ 9218 continue; 9219 9220 /* Assume branches to other sections not included in the link need 9221 stubs too, to cover -R and absolute syms. */ 9222 if (sym_sec->output_section == NULL) 9223 { 9224 ret = 1; 9225 break; 9226 } 9227 9228 if (h == NULL) 9229 sym_value = sym->st_value; 9230 else 9231 { 9232 if (h->root.type != bfd_link_hash_defined 9233 && h->root.type != bfd_link_hash_defweak) 9234 abort (); 9235 sym_value = h->root.u.def.value; 9236 } 9237 sym_value += rel->r_addend; 9238 9239 /* If this branch reloc uses an opd sym, find the code section. */ 9240 opd = get_opd_info (sym_sec); 9241 if (opd != NULL) 9242 { 9243 if (h == NULL && opd->adjust != NULL) 9244 { 9245 long adjust; 9246 9247 adjust = opd->adjust[sym->st_value / 8]; 9248 if (adjust == -1) 9249 /* Assume deleted functions won't ever be called. */ 9250 continue; 9251 sym_value += adjust; 9252 } 9253 9254 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL); 9255 if (dest == (bfd_vma) -1) 9256 continue; 9257 } 9258 else 9259 dest = (sym_value 9260 + sym_sec->output_offset 9261 + sym_sec->output_section->vma); 9262 9263 /* Ignore branch to self. */ 9264 if (sym_sec == isec) 9265 continue; 9266 9267 /* If the called function uses the toc, we need a stub. */ 9268 if (sym_sec->has_toc_reloc 9269 || sym_sec->makes_toc_func_call) 9270 { 9271 ret = 1; 9272 break; 9273 } 9274 9275 /* Assume any branch that needs a long branch stub might in fact 9276 need a plt_branch stub. A plt_branch stub uses r2. */ 9277 else if (dest - (isec->output_offset 9278 + isec->output_section->vma 9279 + rel->r_offset) + (1 << 25) >= (2 << 25)) 9280 { 9281 ret = 1; 9282 break; 9283 } 9284 9285 /* If calling back to a section in the process of being tested, we 9286 can't say for sure that no toc adjusting stubs are needed, so 9287 don't return zero. */ 9288 else if (sym_sec->call_check_in_progress) 9289 ret = 2; 9290 9291 /* Branches to another section that itself doesn't have any TOC 9292 references are OK. Recursively call ourselves to check. */ 9293 else if (sym_sec->id <= htab->top_id 9294 && htab->stub_group[sym_sec->id].toc_off == 0) 9295 { 9296 int recur; 9297 9298 /* Mark current section as indeterminate, so that other 9299 sections that call back to current won't be marked as 9300 known. */ 9301 isec->call_check_in_progress = 1; 9302 recur = toc_adjusting_stub_needed (info, sym_sec); 9303 isec->call_check_in_progress = 0; 9304 9305 if (recur < 0) 9306 { 9307 /* An error. Exit. */ 9308 ret = -1; 9309 break; 9310 } 9311 else if (recur <= 1) 9312 { 9313 /* Known result. Mark as checked and set section flag. */ 9314 htab->stub_group[sym_sec->id].toc_off = 1; 9315 if (recur != 0) 9316 { 9317 sym_sec->makes_toc_func_call = 1; 9318 ret = 1; 9319 break; 9320 } 9321 } 9322 else 9323 { 9324 /* Unknown result. Continue checking. */ 9325 ret = 2; 9326 } 9327 } 9328 } 9329 9330 if (local_syms != NULL 9331 && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms)) 9332 free (local_syms); 9333 if (elf_section_data (isec)->relocs != relstart) 9334 free (relstart); 9335 9336 return ret; 9337 } 9338 9339 /* The linker repeatedly calls this function for each input section, 9340 in the order that input sections are linked into output sections. 9341 Build lists of input sections to determine groupings between which 9342 we may insert linker stubs. */ 9343 9344 bfd_boolean 9345 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec) 9346 { 9347 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9348 9349 if ((isec->output_section->flags & SEC_CODE) != 0 9350 && isec->output_section->index <= htab->top_index) 9351 { 9352 asection **list = htab->input_list + isec->output_section->index; 9353 /* Steal the link_sec pointer for our list. */ 9354 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec) 9355 /* This happens to make the list in reverse order, 9356 which is what we want. */ 9357 PREV_SEC (isec) = *list; 9358 *list = isec; 9359 } 9360 9361 if (htab->multi_toc_needed) 9362 { 9363 /* If a code section has a function that uses the TOC then we need 9364 to use the right TOC (obviously). Also, make sure that .opd gets 9365 the correct TOC value for R_PPC64_TOC relocs that don't have or 9366 can't find their function symbol (shouldn't ever happen now). 9367 Also specially treat .fixup for the linux kernel. .fixup 9368 contains branches, but only back to the function that hit an 9369 exception. */ 9370 if (isec->has_toc_reloc 9371 || (isec->flags & SEC_CODE) == 0 9372 || strcmp (isec->name, ".fixup") == 0) 9373 { 9374 if (elf_gp (isec->owner) != 0) 9375 htab->toc_curr = elf_gp (isec->owner); 9376 } 9377 else if (htab->stub_group[isec->id].toc_off == 0) 9378 { 9379 int ret = toc_adjusting_stub_needed (info, isec); 9380 if (ret < 0) 9381 return FALSE; 9382 else 9383 isec->makes_toc_func_call = ret & 1; 9384 } 9385 } 9386 9387 /* Functions that don't use the TOC can belong in any TOC group. 9388 Use the last TOC base. This happens to make _init and _fini 9389 pasting work. */ 9390 htab->stub_group[isec->id].toc_off = htab->toc_curr; 9391 return TRUE; 9392 } 9393 9394 /* See whether we can group stub sections together. Grouping stub 9395 sections may result in fewer stubs. More importantly, we need to 9396 put all .init* and .fini* stubs at the beginning of the .init or 9397 .fini output sections respectively, because glibc splits the 9398 _init and _fini functions into multiple parts. Putting a stub in 9399 the middle of a function is not a good idea. */ 9400 9401 static void 9402 group_sections (struct ppc_link_hash_table *htab, 9403 bfd_size_type stub_group_size, 9404 bfd_boolean stubs_always_before_branch) 9405 { 9406 asection **list; 9407 bfd_size_type stub14_group_size; 9408 bfd_boolean suppress_size_errors; 9409 9410 suppress_size_errors = FALSE; 9411 stub14_group_size = stub_group_size; 9412 if (stub_group_size == 1) 9413 { 9414 /* Default values. */ 9415 if (stubs_always_before_branch) 9416 { 9417 stub_group_size = 0x1e00000; 9418 stub14_group_size = 0x7800; 9419 } 9420 else 9421 { 9422 stub_group_size = 0x1c00000; 9423 stub14_group_size = 0x7000; 9424 } 9425 suppress_size_errors = TRUE; 9426 } 9427 9428 list = htab->input_list + htab->top_index; 9429 do 9430 { 9431 asection *tail = *list; 9432 while (tail != NULL) 9433 { 9434 asection *curr; 9435 asection *prev; 9436 bfd_size_type total; 9437 bfd_boolean big_sec; 9438 bfd_vma curr_toc; 9439 9440 curr = tail; 9441 total = tail->size; 9442 big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch 9443 ? stub14_group_size : stub_group_size); 9444 if (big_sec && !suppress_size_errors) 9445 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"), 9446 tail->owner, tail); 9447 curr_toc = htab->stub_group[tail->id].toc_off; 9448 9449 while ((prev = PREV_SEC (curr)) != NULL 9450 && ((total += curr->output_offset - prev->output_offset) 9451 < (ppc64_elf_section_data (prev)->has_14bit_branch 9452 ? stub14_group_size : stub_group_size)) 9453 && htab->stub_group[prev->id].toc_off == curr_toc) 9454 curr = prev; 9455 9456 /* OK, the size from the start of CURR to the end is less 9457 than stub_group_size and thus can be handled by one stub 9458 section. (or the tail section is itself larger than 9459 stub_group_size, in which case we may be toast.) We 9460 should really be keeping track of the total size of stubs 9461 added here, as stubs contribute to the final output 9462 section size. That's a little tricky, and this way will 9463 only break if stubs added make the total size more than 9464 2^25, ie. for the default stub_group_size, if stubs total 9465 more than 2097152 bytes, or nearly 75000 plt call stubs. */ 9466 do 9467 { 9468 prev = PREV_SEC (tail); 9469 /* Set up this stub group. */ 9470 htab->stub_group[tail->id].link_sec = curr; 9471 } 9472 while (tail != curr && (tail = prev) != NULL); 9473 9474 /* But wait, there's more! Input sections up to stub_group_size 9475 bytes before the stub section can be handled by it too. 9476 Don't do this if we have a really large section after the 9477 stubs, as adding more stubs increases the chance that 9478 branches may not reach into the stub section. */ 9479 if (!stubs_always_before_branch && !big_sec) 9480 { 9481 total = 0; 9482 while (prev != NULL 9483 && ((total += tail->output_offset - prev->output_offset) 9484 < (ppc64_elf_section_data (prev)->has_14bit_branch 9485 ? stub14_group_size : stub_group_size)) 9486 && htab->stub_group[prev->id].toc_off == curr_toc) 9487 { 9488 tail = prev; 9489 prev = PREV_SEC (tail); 9490 htab->stub_group[tail->id].link_sec = curr; 9491 } 9492 } 9493 tail = prev; 9494 } 9495 } 9496 while (list-- != htab->input_list); 9497 free (htab->input_list); 9498 #undef PREV_SEC 9499 } 9500 9501 /* Determine and set the size of the stub section for a final link. 9502 9503 The basic idea here is to examine all the relocations looking for 9504 PC-relative calls to a target that is unreachable with a "bl" 9505 instruction. */ 9506 9507 bfd_boolean 9508 ppc64_elf_size_stubs (bfd *output_bfd, 9509 struct bfd_link_info *info, 9510 bfd_signed_vma group_size, 9511 asection *(*add_stub_section) (const char *, asection *), 9512 void (*layout_sections_again) (void)) 9513 { 9514 bfd_size_type stub_group_size; 9515 bfd_boolean stubs_always_before_branch; 9516 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9517 9518 /* Stash our params away. */ 9519 htab->add_stub_section = add_stub_section; 9520 htab->layout_sections_again = layout_sections_again; 9521 stubs_always_before_branch = group_size < 0; 9522 if (group_size < 0) 9523 stub_group_size = -group_size; 9524 else 9525 stub_group_size = group_size; 9526 9527 group_sections (htab, stub_group_size, stubs_always_before_branch); 9528 9529 while (1) 9530 { 9531 bfd *input_bfd; 9532 unsigned int bfd_indx; 9533 asection *stub_sec; 9534 9535 htab->stub_iteration += 1; 9536 9537 for (input_bfd = info->input_bfds, bfd_indx = 0; 9538 input_bfd != NULL; 9539 input_bfd = input_bfd->link_next, bfd_indx++) 9540 { 9541 Elf_Internal_Shdr *symtab_hdr; 9542 asection *section; 9543 Elf_Internal_Sym *local_syms = NULL; 9544 9545 if (!is_ppc64_elf (input_bfd)) 9546 continue; 9547 9548 /* We'll need the symbol table in a second. */ 9549 symtab_hdr = &elf_symtab_hdr (input_bfd); 9550 if (symtab_hdr->sh_info == 0) 9551 continue; 9552 9553 /* Walk over each section attached to the input bfd. */ 9554 for (section = input_bfd->sections; 9555 section != NULL; 9556 section = section->next) 9557 { 9558 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 9559 9560 /* If there aren't any relocs, then there's nothing more 9561 to do. */ 9562 if ((section->flags & SEC_RELOC) == 0 9563 || (section->flags & SEC_ALLOC) == 0 9564 || (section->flags & SEC_LOAD) == 0 9565 || (section->flags & SEC_CODE) == 0 9566 || section->reloc_count == 0) 9567 continue; 9568 9569 /* If this section is a link-once section that will be 9570 discarded, then don't create any stubs. */ 9571 if (section->output_section == NULL 9572 || section->output_section->owner != output_bfd) 9573 continue; 9574 9575 /* Get the relocs. */ 9576 internal_relocs 9577 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL, 9578 info->keep_memory); 9579 if (internal_relocs == NULL) 9580 goto error_ret_free_local; 9581 9582 /* Now examine each relocation. */ 9583 irela = internal_relocs; 9584 irelaend = irela + section->reloc_count; 9585 for (; irela < irelaend; irela++) 9586 { 9587 enum elf_ppc64_reloc_type r_type; 9588 unsigned int r_indx; 9589 enum ppc_stub_type stub_type; 9590 struct ppc_stub_hash_entry *stub_entry; 9591 asection *sym_sec, *code_sec; 9592 bfd_vma sym_value; 9593 bfd_vma destination; 9594 bfd_boolean ok_dest; 9595 struct ppc_link_hash_entry *hash; 9596 struct ppc_link_hash_entry *fdh; 9597 struct elf_link_hash_entry *h; 9598 Elf_Internal_Sym *sym; 9599 char *stub_name; 9600 const asection *id_sec; 9601 struct _opd_sec_data *opd; 9602 9603 r_type = ELF64_R_TYPE (irela->r_info); 9604 r_indx = ELF64_R_SYM (irela->r_info); 9605 9606 if (r_type >= R_PPC64_max) 9607 { 9608 bfd_set_error (bfd_error_bad_value); 9609 goto error_ret_free_internal; 9610 } 9611 9612 /* Only look for stubs on branch instructions. */ 9613 if (r_type != R_PPC64_REL24 9614 && r_type != R_PPC64_REL14 9615 && r_type != R_PPC64_REL14_BRTAKEN 9616 && r_type != R_PPC64_REL14_BRNTAKEN) 9617 continue; 9618 9619 /* Now determine the call target, its name, value, 9620 section. */ 9621 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 9622 r_indx, input_bfd)) 9623 goto error_ret_free_internal; 9624 hash = (struct ppc_link_hash_entry *) h; 9625 9626 ok_dest = FALSE; 9627 fdh = NULL; 9628 sym_value = 0; 9629 if (hash == NULL) 9630 { 9631 sym_value = sym->st_value; 9632 ok_dest = TRUE; 9633 } 9634 else if (hash->elf.root.type == bfd_link_hash_defined 9635 || hash->elf.root.type == bfd_link_hash_defweak) 9636 { 9637 sym_value = hash->elf.root.u.def.value; 9638 if (sym_sec->output_section != NULL) 9639 ok_dest = TRUE; 9640 } 9641 else if (hash->elf.root.type == bfd_link_hash_undefweak 9642 || hash->elf.root.type == bfd_link_hash_undefined) 9643 { 9644 /* Recognise an old ABI func code entry sym, and 9645 use the func descriptor sym instead if it is 9646 defined. */ 9647 if (hash->elf.root.root.string[0] == '.' 9648 && (fdh = get_fdh (hash, htab)) != NULL) 9649 { 9650 if (fdh->elf.root.type == bfd_link_hash_defined 9651 || fdh->elf.root.type == bfd_link_hash_defweak) 9652 { 9653 sym_sec = fdh->elf.root.u.def.section; 9654 sym_value = fdh->elf.root.u.def.value; 9655 if (sym_sec->output_section != NULL) 9656 ok_dest = TRUE; 9657 } 9658 else 9659 fdh = NULL; 9660 } 9661 } 9662 else 9663 { 9664 bfd_set_error (bfd_error_bad_value); 9665 goto error_ret_free_internal; 9666 } 9667 9668 destination = 0; 9669 if (ok_dest) 9670 { 9671 sym_value += irela->r_addend; 9672 destination = (sym_value 9673 + sym_sec->output_offset 9674 + sym_sec->output_section->vma); 9675 } 9676 9677 code_sec = sym_sec; 9678 opd = get_opd_info (sym_sec); 9679 if (opd != NULL) 9680 { 9681 bfd_vma dest; 9682 9683 if (hash == NULL && opd->adjust != NULL) 9684 { 9685 long adjust = opd->adjust[sym_value / 8]; 9686 if (adjust == -1) 9687 continue; 9688 sym_value += adjust; 9689 } 9690 dest = opd_entry_value (sym_sec, sym_value, 9691 &code_sec, &sym_value); 9692 if (dest != (bfd_vma) -1) 9693 { 9694 destination = dest; 9695 if (fdh != NULL) 9696 { 9697 /* Fixup old ABI sym to point at code 9698 entry. */ 9699 hash->elf.root.type = bfd_link_hash_defweak; 9700 hash->elf.root.u.def.section = code_sec; 9701 hash->elf.root.u.def.value = sym_value; 9702 } 9703 } 9704 } 9705 9706 /* Determine what (if any) linker stub is needed. */ 9707 stub_type = ppc_type_of_stub (section, irela, &hash, 9708 destination); 9709 9710 if (stub_type != ppc_stub_plt_call) 9711 { 9712 /* Check whether we need a TOC adjusting stub. 9713 Since the linker pastes together pieces from 9714 different object files when creating the 9715 _init and _fini functions, it may be that a 9716 call to what looks like a local sym is in 9717 fact a call needing a TOC adjustment. */ 9718 if (code_sec != NULL 9719 && code_sec->output_section != NULL 9720 && (htab->stub_group[code_sec->id].toc_off 9721 != htab->stub_group[section->id].toc_off) 9722 && (code_sec->has_toc_reloc 9723 || code_sec->makes_toc_func_call)) 9724 stub_type = ppc_stub_long_branch_r2off; 9725 } 9726 9727 if (stub_type == ppc_stub_none) 9728 continue; 9729 9730 /* __tls_get_addr calls might be eliminated. */ 9731 if (stub_type != ppc_stub_plt_call 9732 && hash != NULL 9733 && (hash == htab->tls_get_addr 9734 || hash == htab->tls_get_addr_fd) 9735 && section->has_tls_reloc 9736 && irela != internal_relocs) 9737 { 9738 /* Get tls info. */ 9739 char *tls_mask; 9740 9741 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms, 9742 irela - 1, input_bfd)) 9743 goto error_ret_free_internal; 9744 if (*tls_mask != 0) 9745 continue; 9746 } 9747 9748 /* Support for grouping stub sections. */ 9749 id_sec = htab->stub_group[section->id].link_sec; 9750 9751 /* Get the name of this stub. */ 9752 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela); 9753 if (!stub_name) 9754 goto error_ret_free_internal; 9755 9756 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, 9757 stub_name, FALSE, FALSE); 9758 if (stub_entry != NULL) 9759 { 9760 /* The proper stub has already been created. */ 9761 free (stub_name); 9762 continue; 9763 } 9764 9765 stub_entry = ppc_add_stub (stub_name, section, htab); 9766 if (stub_entry == NULL) 9767 { 9768 free (stub_name); 9769 error_ret_free_internal: 9770 if (elf_section_data (section)->relocs == NULL) 9771 free (internal_relocs); 9772 error_ret_free_local: 9773 if (local_syms != NULL 9774 && (symtab_hdr->contents 9775 != (unsigned char *) local_syms)) 9776 free (local_syms); 9777 return FALSE; 9778 } 9779 9780 stub_entry->stub_type = stub_type; 9781 stub_entry->target_value = sym_value; 9782 stub_entry->target_section = code_sec; 9783 stub_entry->h = hash; 9784 stub_entry->addend = irela->r_addend; 9785 9786 if (stub_entry->h != NULL) 9787 htab->stub_globals += 1; 9788 } 9789 9790 /* We're done with the internal relocs, free them. */ 9791 if (elf_section_data (section)->relocs != internal_relocs) 9792 free (internal_relocs); 9793 } 9794 9795 if (local_syms != NULL 9796 && symtab_hdr->contents != (unsigned char *) local_syms) 9797 { 9798 if (!info->keep_memory) 9799 free (local_syms); 9800 else 9801 symtab_hdr->contents = (unsigned char *) local_syms; 9802 } 9803 } 9804 9805 /* We may have added some stubs. Find out the new size of the 9806 stub sections. */ 9807 for (stub_sec = htab->stub_bfd->sections; 9808 stub_sec != NULL; 9809 stub_sec = stub_sec->next) 9810 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 9811 { 9812 stub_sec->rawsize = stub_sec->size; 9813 stub_sec->size = 0; 9814 stub_sec->reloc_count = 0; 9815 stub_sec->flags &= ~SEC_RELOC; 9816 } 9817 9818 htab->brlt->size = 0; 9819 htab->brlt->reloc_count = 0; 9820 htab->brlt->flags &= ~SEC_RELOC; 9821 if (htab->relbrlt != NULL) 9822 htab->relbrlt->size = 0; 9823 9824 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info); 9825 9826 if (info->emitrelocations 9827 && htab->glink != NULL && htab->glink->size != 0) 9828 { 9829 htab->glink->reloc_count = 1; 9830 htab->glink->flags |= SEC_RELOC; 9831 } 9832 9833 for (stub_sec = htab->stub_bfd->sections; 9834 stub_sec != NULL; 9835 stub_sec = stub_sec->next) 9836 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0 9837 && stub_sec->rawsize != stub_sec->size) 9838 break; 9839 9840 /* Exit from this loop when no stubs have been added, and no stubs 9841 have changed size. */ 9842 if (stub_sec == NULL) 9843 break; 9844 9845 /* Ask the linker to do its stuff. */ 9846 (*htab->layout_sections_again) (); 9847 } 9848 9849 /* It would be nice to strip htab->brlt from the output if the 9850 section is empty, but it's too late. If we strip sections here, 9851 the dynamic symbol table is corrupted since the section symbol 9852 for the stripped section isn't written. */ 9853 9854 return TRUE; 9855 } 9856 9857 /* Called after we have determined section placement. If sections 9858 move, we'll be called again. Provide a value for TOCstart. */ 9859 9860 bfd_vma 9861 ppc64_elf_toc (bfd *obfd) 9862 { 9863 asection *s; 9864 bfd_vma TOCstart; 9865 9866 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that 9867 order. The TOC starts where the first of these sections starts. */ 9868 s = bfd_get_section_by_name (obfd, ".got"); 9869 if (s == NULL) 9870 s = bfd_get_section_by_name (obfd, ".toc"); 9871 if (s == NULL) 9872 s = bfd_get_section_by_name (obfd, ".tocbss"); 9873 if (s == NULL) 9874 s = bfd_get_section_by_name (obfd, ".plt"); 9875 if (s == NULL) 9876 { 9877 /* This may happen for 9878 o references to TOC base (SYM@toc / TOC[tc0]) without a 9879 .toc directive 9880 o bad linker script 9881 o --gc-sections and empty TOC sections 9882 9883 FIXME: Warn user? */ 9884 9885 /* Look for a likely section. We probably won't even be 9886 using TOCstart. */ 9887 for (s = obfd->sections; s != NULL; s = s->next) 9888 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY)) 9889 == (SEC_ALLOC | SEC_SMALL_DATA)) 9890 break; 9891 if (s == NULL) 9892 for (s = obfd->sections; s != NULL; s = s->next) 9893 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA)) 9894 == (SEC_ALLOC | SEC_SMALL_DATA)) 9895 break; 9896 if (s == NULL) 9897 for (s = obfd->sections; s != NULL; s = s->next) 9898 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC) 9899 break; 9900 if (s == NULL) 9901 for (s = obfd->sections; s != NULL; s = s->next) 9902 if ((s->flags & SEC_ALLOC) == SEC_ALLOC) 9903 break; 9904 } 9905 9906 TOCstart = 0; 9907 if (s != NULL) 9908 TOCstart = s->output_section->vma + s->output_offset; 9909 9910 return TOCstart; 9911 } 9912 9913 /* Build all the stubs associated with the current output file. 9914 The stubs are kept in a hash table attached to the main linker 9915 hash table. This function is called via gldelf64ppc_finish. */ 9916 9917 bfd_boolean 9918 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms, 9919 struct bfd_link_info *info, 9920 char **stats) 9921 { 9922 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9923 asection *stub_sec; 9924 bfd_byte *p; 9925 int stub_sec_count = 0; 9926 9927 htab->emit_stub_syms = emit_stub_syms; 9928 9929 /* Allocate memory to hold the linker stubs. */ 9930 for (stub_sec = htab->stub_bfd->sections; 9931 stub_sec != NULL; 9932 stub_sec = stub_sec->next) 9933 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0 9934 && stub_sec->size != 0) 9935 { 9936 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size); 9937 if (stub_sec->contents == NULL) 9938 return FALSE; 9939 /* We want to check that built size is the same as calculated 9940 size. rawsize is a convenient location to use. */ 9941 stub_sec->rawsize = stub_sec->size; 9942 stub_sec->size = 0; 9943 } 9944 9945 if (htab->glink != NULL && htab->glink->size != 0) 9946 { 9947 unsigned int indx; 9948 bfd_vma plt0; 9949 9950 /* Build the .glink plt call stub. */ 9951 if (htab->emit_stub_syms) 9952 { 9953 struct elf_link_hash_entry *h; 9954 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve", 9955 TRUE, FALSE, FALSE); 9956 if (h == NULL) 9957 return FALSE; 9958 if (h->root.type == bfd_link_hash_new) 9959 { 9960 h->root.type = bfd_link_hash_defined; 9961 h->root.u.def.section = htab->glink; 9962 h->root.u.def.value = 8; 9963 h->ref_regular = 1; 9964 h->def_regular = 1; 9965 h->ref_regular_nonweak = 1; 9966 h->forced_local = 1; 9967 h->non_elf = 0; 9968 } 9969 } 9970 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16; 9971 if (info->emitrelocations) 9972 { 9973 Elf_Internal_Rela *r = get_relocs (htab->glink, 1); 9974 if (r == NULL) 9975 return FALSE; 9976 r->r_offset = (htab->glink->output_offset 9977 + htab->glink->output_section->vma); 9978 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64); 9979 r->r_addend = plt0; 9980 } 9981 p = htab->glink->contents; 9982 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset; 9983 bfd_put_64 (htab->glink->owner, plt0, p); 9984 p += 8; 9985 bfd_put_32 (htab->glink->owner, MFLR_R12, p); 9986 p += 4; 9987 bfd_put_32 (htab->glink->owner, BCL_20_31, p); 9988 p += 4; 9989 bfd_put_32 (htab->glink->owner, MFLR_R11, p); 9990 p += 4; 9991 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p); 9992 p += 4; 9993 bfd_put_32 (htab->glink->owner, MTLR_R12, p); 9994 p += 4; 9995 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p); 9996 p += 4; 9997 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p); 9998 p += 4; 9999 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p); 10000 p += 4; 10001 bfd_put_32 (htab->glink->owner, MTCTR_R11, p); 10002 p += 4; 10003 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p); 10004 p += 4; 10005 bfd_put_32 (htab->glink->owner, BCTR, p); 10006 p += 4; 10007 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE) 10008 { 10009 bfd_put_32 (htab->glink->owner, NOP, p); 10010 p += 4; 10011 } 10012 10013 /* Build the .glink lazy link call stubs. */ 10014 indx = 0; 10015 while (p < htab->glink->contents + htab->glink->size) 10016 { 10017 if (indx < 0x8000) 10018 { 10019 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p); 10020 p += 4; 10021 } 10022 else 10023 { 10024 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p); 10025 p += 4; 10026 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p); 10027 p += 4; 10028 } 10029 bfd_put_32 (htab->glink->owner, 10030 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p); 10031 indx++; 10032 p += 4; 10033 } 10034 htab->glink->rawsize = p - htab->glink->contents; 10035 } 10036 10037 if (htab->brlt->size != 0) 10038 { 10039 htab->brlt->contents = bfd_zalloc (htab->brlt->owner, 10040 htab->brlt->size); 10041 if (htab->brlt->contents == NULL) 10042 return FALSE; 10043 } 10044 if (htab->relbrlt != NULL && htab->relbrlt->size != 0) 10045 { 10046 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner, 10047 htab->relbrlt->size); 10048 if (htab->relbrlt->contents == NULL) 10049 return FALSE; 10050 } 10051 10052 /* Build the stubs as directed by the stub hash table. */ 10053 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info); 10054 10055 if (htab->relbrlt != NULL) 10056 htab->relbrlt->reloc_count = 0; 10057 10058 for (stub_sec = htab->stub_bfd->sections; 10059 stub_sec != NULL; 10060 stub_sec = stub_sec->next) 10061 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 10062 { 10063 stub_sec_count += 1; 10064 if (stub_sec->rawsize != stub_sec->size) 10065 break; 10066 } 10067 10068 if (stub_sec != NULL 10069 || htab->glink->rawsize != htab->glink->size) 10070 { 10071 htab->stub_error = TRUE; 10072 (*_bfd_error_handler) (_("stubs don't match calculated size")); 10073 } 10074 10075 if (htab->stub_error) 10076 return FALSE; 10077 10078 if (stats != NULL) 10079 { 10080 *stats = bfd_malloc (500); 10081 if (*stats == NULL) 10082 return FALSE; 10083 10084 sprintf (*stats, _("linker stubs in %u group%s\n" 10085 " branch %lu\n" 10086 " toc adjust %lu\n" 10087 " long branch %lu\n" 10088 " long toc adj %lu\n" 10089 " plt call %lu"), 10090 stub_sec_count, 10091 stub_sec_count == 1 ? "" : "s", 10092 htab->stub_count[ppc_stub_long_branch - 1], 10093 htab->stub_count[ppc_stub_long_branch_r2off - 1], 10094 htab->stub_count[ppc_stub_plt_branch - 1], 10095 htab->stub_count[ppc_stub_plt_branch_r2off - 1], 10096 htab->stub_count[ppc_stub_plt_call - 1]); 10097 } 10098 return TRUE; 10099 } 10100 10101 /* This function undoes the changes made by add_symbol_adjust. */ 10102 10103 static bfd_boolean 10104 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 10105 { 10106 struct ppc_link_hash_entry *eh; 10107 10108 if (h->root.type == bfd_link_hash_indirect) 10109 return TRUE; 10110 10111 if (h->root.type == bfd_link_hash_warning) 10112 h = (struct elf_link_hash_entry *) h->root.u.i.link; 10113 10114 eh = (struct ppc_link_hash_entry *) h; 10115 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined) 10116 return TRUE; 10117 10118 eh->elf.root.type = bfd_link_hash_undefined; 10119 return TRUE; 10120 } 10121 10122 void 10123 ppc64_elf_restore_symbols (struct bfd_link_info *info) 10124 { 10125 struct ppc_link_hash_table *htab = ppc_hash_table (info); 10126 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info); 10127 } 10128 10129 /* What to do when ld finds relocations against symbols defined in 10130 discarded sections. */ 10131 10132 static unsigned int 10133 ppc64_elf_action_discarded (asection *sec) 10134 { 10135 if (strcmp (".opd", sec->name) == 0) 10136 return 0; 10137 10138 if (strcmp (".toc", sec->name) == 0) 10139 return 0; 10140 10141 if (strcmp (".toc1", sec->name) == 0) 10142 return 0; 10143 10144 return _bfd_elf_default_action_discarded (sec); 10145 } 10146 10147 /* The RELOCATE_SECTION function is called by the ELF backend linker 10148 to handle the relocations for a section. 10149 10150 The relocs are always passed as Rela structures; if the section 10151 actually uses Rel structures, the r_addend field will always be 10152 zero. 10153 10154 This function is responsible for adjust the section contents as 10155 necessary, and (if using Rela relocs and generating a 10156 relocatable output file) adjusting the reloc addend as 10157 necessary. 10158 10159 This function does not have to worry about setting the reloc 10160 address or the reloc symbol index. 10161 10162 LOCAL_SYMS is a pointer to the swapped in local symbols. 10163 10164 LOCAL_SECTIONS is an array giving the section in the input file 10165 corresponding to the st_shndx field of each local symbol. 10166 10167 The global hash table entry for the global symbols can be found 10168 via elf_sym_hashes (input_bfd). 10169 10170 When generating relocatable output, this function must handle 10171 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 10172 going to be the section symbol corresponding to the output 10173 section, which means that the addend must be adjusted 10174 accordingly. */ 10175 10176 static bfd_boolean 10177 ppc64_elf_relocate_section (bfd *output_bfd, 10178 struct bfd_link_info *info, 10179 bfd *input_bfd, 10180 asection *input_section, 10181 bfd_byte *contents, 10182 Elf_Internal_Rela *relocs, 10183 Elf_Internal_Sym *local_syms, 10184 asection **local_sections) 10185 { 10186 struct ppc_link_hash_table *htab; 10187 Elf_Internal_Shdr *symtab_hdr; 10188 struct elf_link_hash_entry **sym_hashes; 10189 Elf_Internal_Rela *rel; 10190 Elf_Internal_Rela *relend; 10191 Elf_Internal_Rela outrel; 10192 bfd_byte *loc; 10193 struct got_entry **local_got_ents; 10194 bfd_vma TOCstart; 10195 bfd_boolean ret = TRUE; 10196 bfd_boolean is_opd; 10197 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */ 10198 bfd_boolean is_power4 = FALSE; 10199 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0); 10200 10201 /* Initialize howto table if needed. */ 10202 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 10203 ppc_howto_init (); 10204 10205 htab = ppc_hash_table (info); 10206 10207 /* Don't relocate stub sections. */ 10208 if (input_section->owner == htab->stub_bfd) 10209 return TRUE; 10210 10211 BFD_ASSERT (is_ppc64_elf (input_bfd)); 10212 10213 local_got_ents = elf_local_got_ents (input_bfd); 10214 TOCstart = elf_gp (output_bfd); 10215 symtab_hdr = &elf_symtab_hdr (input_bfd); 10216 sym_hashes = elf_sym_hashes (input_bfd); 10217 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd; 10218 10219 rel = relocs; 10220 relend = relocs + input_section->reloc_count; 10221 for (; rel < relend; rel++) 10222 { 10223 enum elf_ppc64_reloc_type r_type; 10224 bfd_vma addend, orig_addend; 10225 bfd_reloc_status_type r; 10226 Elf_Internal_Sym *sym; 10227 asection *sec; 10228 struct elf_link_hash_entry *h_elf; 10229 struct ppc_link_hash_entry *h; 10230 struct ppc_link_hash_entry *fdh; 10231 const char *sym_name; 10232 unsigned long r_symndx, toc_symndx; 10233 bfd_vma toc_addend; 10234 char tls_mask, tls_gd, tls_type; 10235 char sym_type; 10236 bfd_vma relocation; 10237 bfd_boolean unresolved_reloc; 10238 bfd_boolean warned; 10239 unsigned long insn, mask; 10240 struct ppc_stub_hash_entry *stub_entry; 10241 bfd_vma max_br_offset; 10242 bfd_vma from; 10243 10244 r_type = ELF64_R_TYPE (rel->r_info); 10245 r_symndx = ELF64_R_SYM (rel->r_info); 10246 10247 /* For old style R_PPC64_TOC relocs with a zero symbol, use the 10248 symbol of the previous ADDR64 reloc. The symbol gives us the 10249 proper TOC base to use. */ 10250 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC) 10251 && rel != relocs 10252 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64 10253 && is_opd) 10254 r_symndx = ELF64_R_SYM (rel[-1].r_info); 10255 10256 sym = NULL; 10257 sec = NULL; 10258 h_elf = NULL; 10259 sym_name = NULL; 10260 unresolved_reloc = FALSE; 10261 warned = FALSE; 10262 orig_addend = rel->r_addend; 10263 10264 if (r_symndx < symtab_hdr->sh_info) 10265 { 10266 /* It's a local symbol. */ 10267 struct _opd_sec_data *opd; 10268 10269 sym = local_syms + r_symndx; 10270 sec = local_sections[r_symndx]; 10271 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); 10272 sym_type = ELF64_ST_TYPE (sym->st_info); 10273 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 10274 opd = get_opd_info (sec); 10275 if (opd != NULL && opd->adjust != NULL) 10276 { 10277 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8]; 10278 if (adjust == -1) 10279 relocation = 0; 10280 else 10281 { 10282 /* If this is a relocation against the opd section sym 10283 and we have edited .opd, adjust the reloc addend so 10284 that ld -r and ld --emit-relocs output is correct. 10285 If it is a reloc against some other .opd symbol, 10286 then the symbol value will be adjusted later. */ 10287 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 10288 rel->r_addend += adjust; 10289 else 10290 relocation += adjust; 10291 } 10292 } 10293 } 10294 else 10295 { 10296 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 10297 r_symndx, symtab_hdr, sym_hashes, 10298 h_elf, sec, relocation, 10299 unresolved_reloc, warned); 10300 sym_name = h_elf->root.root.string; 10301 sym_type = h_elf->type; 10302 } 10303 h = (struct ppc_link_hash_entry *) h_elf; 10304 10305 if (sec != NULL && elf_discarded_section (sec)) 10306 { 10307 /* For relocs against symbols from removed linkonce sections, 10308 or sections discarded by a linker script, we just want the 10309 section contents zeroed. Avoid any special processing. */ 10310 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd, 10311 contents + rel->r_offset); 10312 rel->r_info = 0; 10313 rel->r_addend = 0; 10314 continue; 10315 } 10316 10317 if (info->relocatable) 10318 continue; 10319 10320 /* TLS optimizations. Replace instruction sequences and relocs 10321 based on information we collected in tls_optimize. We edit 10322 RELOCS so that --emit-relocs will output something sensible 10323 for the final instruction stream. */ 10324 tls_mask = 0; 10325 tls_gd = 0; 10326 toc_symndx = 0; 10327 if (IS_PPC64_TLS_RELOC (r_type)) 10328 { 10329 if (h != NULL) 10330 tls_mask = h->tls_mask; 10331 else if (local_got_ents != NULL) 10332 { 10333 char *lgot_masks; 10334 lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info); 10335 tls_mask = lgot_masks[r_symndx]; 10336 } 10337 if (tls_mask == 0 && r_type == R_PPC64_TLS) 10338 { 10339 /* Check for toc tls entries. */ 10340 char *toc_tls; 10341 10342 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend, 10343 &local_syms, rel, input_bfd)) 10344 return FALSE; 10345 10346 if (toc_tls) 10347 tls_mask = *toc_tls; 10348 } 10349 } 10350 10351 /* Check that tls relocs are used with tls syms, and non-tls 10352 relocs are used with non-tls syms. */ 10353 if (r_symndx != 0 10354 && r_type != R_PPC64_NONE 10355 && (h == NULL 10356 || h->elf.root.type == bfd_link_hash_defined 10357 || h->elf.root.type == bfd_link_hash_defweak) 10358 && (IS_PPC64_TLS_RELOC (r_type) 10359 != (sym_type == STT_TLS 10360 || (sym_type == STT_SECTION 10361 && (sec->flags & SEC_THREAD_LOCAL) != 0)))) 10362 { 10363 if (r_type == R_PPC64_TLS && tls_mask != 0) 10364 /* R_PPC64_TLS is OK against a symbol in the TOC. */ 10365 ; 10366 else 10367 (*_bfd_error_handler) 10368 (!IS_PPC64_TLS_RELOC (r_type) 10369 ? _("%B(%A+0x%lx): %s used with TLS symbol %s") 10370 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"), 10371 input_bfd, 10372 input_section, 10373 (long) rel->r_offset, 10374 ppc64_elf_howto_table[r_type]->name, 10375 sym_name); 10376 } 10377 10378 /* Ensure reloc mapping code below stays sane. */ 10379 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1 10380 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1 10381 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3) 10382 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3) 10383 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3) 10384 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3) 10385 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3) 10386 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3) 10387 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3) 10388 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3)) 10389 abort (); 10390 10391 switch (r_type) 10392 { 10393 default: 10394 break; 10395 10396 case R_PPC64_TOC16: 10397 case R_PPC64_TOC16_LO: 10398 case R_PPC64_TOC16_DS: 10399 case R_PPC64_TOC16_LO_DS: 10400 { 10401 /* Check for toc tls entries. */ 10402 char *toc_tls; 10403 int retval; 10404 10405 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend, 10406 &local_syms, rel, input_bfd); 10407 if (retval == 0) 10408 return FALSE; 10409 10410 if (toc_tls) 10411 { 10412 tls_mask = *toc_tls; 10413 if (r_type == R_PPC64_TOC16_DS 10414 || r_type == R_PPC64_TOC16_LO_DS) 10415 { 10416 if (tls_mask != 0 10417 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0) 10418 goto toctprel; 10419 } 10420 else 10421 { 10422 /* If we found a GD reloc pair, then we might be 10423 doing a GD->IE transition. */ 10424 if (retval == 2) 10425 { 10426 tls_gd = TLS_TPRELGD; 10427 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 10428 goto tls_ldgd_opt; 10429 } 10430 else if (retval == 3) 10431 { 10432 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 10433 goto tls_ldgd_opt; 10434 } 10435 } 10436 } 10437 } 10438 break; 10439 10440 case R_PPC64_GOT_TPREL16_DS: 10441 case R_PPC64_GOT_TPREL16_LO_DS: 10442 if (tls_mask != 0 10443 && (tls_mask & TLS_TPREL) == 0) 10444 { 10445 toctprel: 10446 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset); 10447 insn &= 31 << 21; 10448 insn |= 0x3c0d0000; /* addis 0,13,0 */ 10449 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset); 10450 r_type = R_PPC64_TPREL16_HA; 10451 if (toc_symndx != 0) 10452 { 10453 rel->r_info = ELF64_R_INFO (toc_symndx, r_type); 10454 rel->r_addend = toc_addend; 10455 /* We changed the symbol. Start over in order to 10456 get h, sym, sec etc. right. */ 10457 rel--; 10458 continue; 10459 } 10460 else 10461 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10462 } 10463 break; 10464 10465 case R_PPC64_TLS: 10466 if (tls_mask != 0 10467 && (tls_mask & TLS_TPREL) == 0) 10468 { 10469 bfd_vma rtra; 10470 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 10471 if ((insn & ((0x3f << 26) | (31 << 11))) 10472 == ((31 << 26) | (13 << 11))) 10473 rtra = insn & ((1 << 26) - (1 << 16)); 10474 else if ((insn & ((0x3f << 26) | (31 << 16))) 10475 == ((31 << 26) | (13 << 16))) 10476 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5); 10477 else 10478 abort (); 10479 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1) 10480 /* add -> addi. */ 10481 insn = 14 << 26; 10482 else if ((insn & (31 << 1)) == 23 << 1 10483 && ((insn & (31 << 6)) < 14 << 6 10484 || ((insn & (31 << 6)) >= 16 << 6 10485 && (insn & (31 << 6)) < 24 << 6))) 10486 /* load and store indexed -> dform. */ 10487 insn = (32 | ((insn >> 6) & 31)) << 26; 10488 else if ((insn & (31 << 1)) == 21 << 1 10489 && (insn & (0x1a << 6)) == 0) 10490 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */ 10491 insn = (((58 | ((insn >> 6) & 4)) << 26) 10492 | ((insn >> 6) & 1)); 10493 else if ((insn & (31 << 1)) == 21 << 1 10494 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1) 10495 /* lwax -> lwa. */ 10496 insn = (58 << 26) | 2; 10497 else 10498 abort (); 10499 insn |= rtra; 10500 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 10501 /* Was PPC64_TLS which sits on insn boundary, now 10502 PPC64_TPREL16_LO which is at low-order half-word. */ 10503 rel->r_offset += d_offset; 10504 r_type = R_PPC64_TPREL16_LO; 10505 if (toc_symndx != 0) 10506 { 10507 rel->r_info = ELF64_R_INFO (toc_symndx, r_type); 10508 rel->r_addend = toc_addend; 10509 /* We changed the symbol. Start over in order to 10510 get h, sym, sec etc. right. */ 10511 rel--; 10512 continue; 10513 } 10514 else 10515 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10516 } 10517 break; 10518 10519 case R_PPC64_GOT_TLSGD16_HI: 10520 case R_PPC64_GOT_TLSGD16_HA: 10521 tls_gd = TLS_TPRELGD; 10522 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 10523 goto tls_gdld_hi; 10524 break; 10525 10526 case R_PPC64_GOT_TLSLD16_HI: 10527 case R_PPC64_GOT_TLSLD16_HA: 10528 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 10529 { 10530 tls_gdld_hi: 10531 if ((tls_mask & tls_gd) != 0) 10532 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3) 10533 + R_PPC64_GOT_TPREL16_DS); 10534 else 10535 { 10536 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset); 10537 rel->r_offset -= d_offset; 10538 r_type = R_PPC64_NONE; 10539 } 10540 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10541 } 10542 break; 10543 10544 case R_PPC64_GOT_TLSGD16: 10545 case R_PPC64_GOT_TLSGD16_LO: 10546 tls_gd = TLS_TPRELGD; 10547 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 10548 goto tls_ldgd_opt; 10549 break; 10550 10551 case R_PPC64_GOT_TLSLD16: 10552 case R_PPC64_GOT_TLSLD16_LO: 10553 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 10554 { 10555 unsigned int insn1, insn2, insn3; 10556 bfd_vma offset; 10557 10558 tls_ldgd_opt: 10559 /* We know that the next reloc is on a tls_get_addr 10560 call, since ppc64_elf_tls_optimize checks this. */ 10561 offset = rel[1].r_offset; 10562 if ((tls_mask & tls_gd) != 0) 10563 { 10564 /* IE */ 10565 insn1 = bfd_get_32 (output_bfd, 10566 contents + rel->r_offset - d_offset); 10567 insn1 &= (1 << 26) - (1 << 2); 10568 insn1 |= 58 << 26; /* ld */ 10569 insn2 = 0x7c636a14; /* add 3,3,13 */ 10570 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info), 10571 R_PPC64_NONE); 10572 if ((tls_mask & TLS_EXPLICIT) == 0) 10573 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3) 10574 + R_PPC64_GOT_TPREL16_DS); 10575 else 10576 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16; 10577 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10578 } 10579 else 10580 { 10581 /* LE */ 10582 insn1 = 0x3c6d0000; /* addis 3,13,0 */ 10583 insn2 = 0x38630000; /* addi 3,3,0 */ 10584 if (tls_gd == 0) 10585 { 10586 /* Was an LD reloc. */ 10587 if (toc_symndx) 10588 sec = local_sections[toc_symndx]; 10589 for (r_symndx = 0; 10590 r_symndx < symtab_hdr->sh_info; 10591 r_symndx++) 10592 if (local_sections[r_symndx] == sec) 10593 break; 10594 if (r_symndx >= symtab_hdr->sh_info) 10595 r_symndx = 0; 10596 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 10597 if (r_symndx != 0) 10598 rel->r_addend -= (local_syms[r_symndx].st_value 10599 + sec->output_offset 10600 + sec->output_section->vma); 10601 } 10602 else if (toc_symndx != 0) 10603 { 10604 r_symndx = toc_symndx; 10605 rel->r_addend = toc_addend; 10606 } 10607 r_type = R_PPC64_TPREL16_HA; 10608 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10609 rel[1].r_info = ELF64_R_INFO (r_symndx, 10610 R_PPC64_TPREL16_LO); 10611 rel[1].r_offset += d_offset; 10612 rel[1].r_addend = rel->r_addend; 10613 } 10614 bfd_put_32 (output_bfd, insn1, 10615 contents + rel->r_offset - d_offset); 10616 insn3 = bfd_get_32 (output_bfd, 10617 contents + offset + 4); 10618 if (insn3 == NOP 10619 || insn3 == CROR_151515 || insn3 == CROR_313131) 10620 { 10621 rel[1].r_offset += 4; 10622 bfd_put_32 (output_bfd, insn2, contents + offset + 4); 10623 insn2 = NOP; 10624 } 10625 bfd_put_32 (output_bfd, insn2, contents + offset); 10626 if ((tls_mask & tls_gd) == 0 10627 && (tls_gd == 0 || toc_symndx != 0)) 10628 { 10629 /* We changed the symbol. Start over in order 10630 to get h, sym, sec etc. right. */ 10631 rel--; 10632 continue; 10633 } 10634 } 10635 break; 10636 10637 case R_PPC64_DTPMOD64: 10638 if (rel + 1 < relend 10639 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64) 10640 && rel[1].r_offset == rel->r_offset + 8) 10641 { 10642 if ((tls_mask & TLS_GD) == 0) 10643 { 10644 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE); 10645 if ((tls_mask & TLS_TPRELGD) != 0) 10646 r_type = R_PPC64_TPREL64; 10647 else 10648 { 10649 bfd_put_64 (output_bfd, 1, contents + rel->r_offset); 10650 r_type = R_PPC64_NONE; 10651 } 10652 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10653 } 10654 } 10655 else 10656 { 10657 if ((tls_mask & TLS_LD) == 0) 10658 { 10659 bfd_put_64 (output_bfd, 1, contents + rel->r_offset); 10660 r_type = R_PPC64_NONE; 10661 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10662 } 10663 } 10664 break; 10665 10666 case R_PPC64_TPREL64: 10667 if ((tls_mask & TLS_TPREL) == 0) 10668 { 10669 r_type = R_PPC64_NONE; 10670 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 10671 } 10672 break; 10673 } 10674 10675 /* Handle other relocations that tweak non-addend part of insn. */ 10676 insn = 0; 10677 max_br_offset = 1 << 25; 10678 addend = rel->r_addend; 10679 switch (r_type) 10680 { 10681 default: 10682 break; 10683 10684 /* Branch taken prediction relocations. */ 10685 case R_PPC64_ADDR14_BRTAKEN: 10686 case R_PPC64_REL14_BRTAKEN: 10687 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */ 10688 /* Fall thru. */ 10689 10690 /* Branch not taken prediction relocations. */ 10691 case R_PPC64_ADDR14_BRNTAKEN: 10692 case R_PPC64_REL14_BRNTAKEN: 10693 insn |= bfd_get_32 (output_bfd, 10694 contents + rel->r_offset) & ~(0x01 << 21); 10695 /* Fall thru. */ 10696 10697 case R_PPC64_REL14: 10698 max_br_offset = 1 << 15; 10699 /* Fall thru. */ 10700 10701 case R_PPC64_REL24: 10702 /* Calls to functions with a different TOC, such as calls to 10703 shared objects, need to alter the TOC pointer. This is 10704 done using a linkage stub. A REL24 branching to these 10705 linkage stubs needs to be followed by a nop, as the nop 10706 will be replaced with an instruction to restore the TOC 10707 base pointer. */ 10708 stub_entry = NULL; 10709 fdh = h; 10710 if (((h != NULL 10711 && (((fdh = h->oh) != NULL 10712 && fdh->elf.plt.plist != NULL) 10713 || (fdh = h)->elf.plt.plist != NULL)) 10714 || (sec != NULL 10715 && sec->output_section != NULL 10716 && sec->id <= htab->top_id 10717 && (htab->stub_group[sec->id].toc_off 10718 != htab->stub_group[input_section->id].toc_off))) 10719 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh, 10720 rel, htab)) != NULL 10721 && (stub_entry->stub_type == ppc_stub_plt_call 10722 || stub_entry->stub_type == ppc_stub_plt_branch_r2off 10723 || stub_entry->stub_type == ppc_stub_long_branch_r2off)) 10724 { 10725 bfd_boolean can_plt_call = FALSE; 10726 10727 if (rel->r_offset + 8 <= input_section->size) 10728 { 10729 unsigned long nop; 10730 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 10731 if (nop == NOP 10732 || nop == CROR_151515 || nop == CROR_313131) 10733 { 10734 bfd_put_32 (input_bfd, LD_R2_40R1, 10735 contents + rel->r_offset + 4); 10736 can_plt_call = TRUE; 10737 } 10738 } 10739 10740 if (!can_plt_call) 10741 { 10742 if (stub_entry->stub_type == ppc_stub_plt_call) 10743 { 10744 /* If this is a plain branch rather than a branch 10745 and link, don't require a nop. However, don't 10746 allow tail calls in a shared library as they 10747 will result in r2 being corrupted. */ 10748 unsigned long br; 10749 br = bfd_get_32 (input_bfd, contents + rel->r_offset); 10750 if (info->executable && (br & 1) == 0) 10751 can_plt_call = TRUE; 10752 else 10753 stub_entry = NULL; 10754 } 10755 else if (h != NULL 10756 && strcmp (h->elf.root.root.string, 10757 ".__libc_start_main") == 0) 10758 { 10759 /* Allow crt1 branch to go via a toc adjusting stub. */ 10760 can_plt_call = TRUE; 10761 } 10762 else 10763 { 10764 if (strcmp (input_section->output_section->name, 10765 ".init") == 0 10766 || strcmp (input_section->output_section->name, 10767 ".fini") == 0) 10768 (*_bfd_error_handler) 10769 (_("%B(%A+0x%lx): automatic multiple TOCs " 10770 "not supported using your crt files; " 10771 "recompile with -mminimal-toc or upgrade gcc"), 10772 input_bfd, 10773 input_section, 10774 (long) rel->r_offset); 10775 else 10776 (*_bfd_error_handler) 10777 (_("%B(%A+0x%lx): sibling call optimization to `%s' " 10778 "does not allow automatic multiple TOCs; " 10779 "recompile with -mminimal-toc or " 10780 "-fno-optimize-sibling-calls, " 10781 "or make `%s' extern"), 10782 input_bfd, 10783 input_section, 10784 (long) rel->r_offset, 10785 sym_name, 10786 sym_name); 10787 bfd_set_error (bfd_error_bad_value); 10788 ret = FALSE; 10789 } 10790 } 10791 10792 if (can_plt_call 10793 && stub_entry->stub_type == ppc_stub_plt_call) 10794 unresolved_reloc = FALSE; 10795 } 10796 10797 if (stub_entry == NULL 10798 && get_opd_info (sec) != NULL) 10799 { 10800 /* The branch destination is the value of the opd entry. */ 10801 bfd_vma off = (relocation + addend 10802 - sec->output_section->vma 10803 - sec->output_offset); 10804 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL); 10805 if (dest != (bfd_vma) -1) 10806 { 10807 relocation = dest; 10808 addend = 0; 10809 } 10810 } 10811 10812 /* If the branch is out of reach we ought to have a long 10813 branch stub. */ 10814 from = (rel->r_offset 10815 + input_section->output_offset 10816 + input_section->output_section->vma); 10817 10818 if (stub_entry == NULL 10819 && (relocation + addend - from + max_br_offset 10820 >= 2 * max_br_offset) 10821 && r_type != R_PPC64_ADDR14_BRTAKEN 10822 && r_type != R_PPC64_ADDR14_BRNTAKEN) 10823 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel, 10824 htab); 10825 10826 if (stub_entry != NULL) 10827 { 10828 /* Munge up the value and addend so that we call the stub 10829 rather than the procedure directly. */ 10830 relocation = (stub_entry->stub_offset 10831 + stub_entry->stub_sec->output_offset 10832 + stub_entry->stub_sec->output_section->vma); 10833 addend = 0; 10834 } 10835 10836 if (insn != 0) 10837 { 10838 if (is_power4) 10839 { 10840 /* Set 'a' bit. This is 0b00010 in BO field for branch 10841 on CR(BI) insns (BO == 001at or 011at), and 0b01000 10842 for branch on CTR insns (BO == 1a00t or 1a01t). */ 10843 if ((insn & (0x14 << 21)) == (0x04 << 21)) 10844 insn |= 0x02 << 21; 10845 else if ((insn & (0x14 << 21)) == (0x10 << 21)) 10846 insn |= 0x08 << 21; 10847 else 10848 break; 10849 } 10850 else 10851 { 10852 /* Invert 'y' bit if not the default. */ 10853 if ((bfd_signed_vma) (relocation + addend - from) < 0) 10854 insn ^= 0x01 << 21; 10855 } 10856 10857 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 10858 } 10859 10860 /* NOP out calls to undefined weak functions. 10861 We can thus call a weak function without first 10862 checking whether the function is defined. */ 10863 else if (h != NULL 10864 && h->elf.root.type == bfd_link_hash_undefweak 10865 && r_type == R_PPC64_REL24 10866 && relocation == 0 10867 && addend == 0) 10868 { 10869 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset); 10870 continue; 10871 } 10872 break; 10873 } 10874 10875 /* Set `addend'. */ 10876 tls_type = 0; 10877 switch (r_type) 10878 { 10879 default: 10880 (*_bfd_error_handler) 10881 (_("%B: unknown relocation type %d for symbol %s"), 10882 input_bfd, (int) r_type, sym_name); 10883 10884 bfd_set_error (bfd_error_bad_value); 10885 ret = FALSE; 10886 continue; 10887 10888 case R_PPC64_NONE: 10889 case R_PPC64_TLS: 10890 case R_PPC64_GNU_VTINHERIT: 10891 case R_PPC64_GNU_VTENTRY: 10892 continue; 10893 10894 /* GOT16 relocations. Like an ADDR16 using the symbol's 10895 address in the GOT as relocation value instead of the 10896 symbol's value itself. Also, create a GOT entry for the 10897 symbol and put the symbol value there. */ 10898 case R_PPC64_GOT_TLSGD16: 10899 case R_PPC64_GOT_TLSGD16_LO: 10900 case R_PPC64_GOT_TLSGD16_HI: 10901 case R_PPC64_GOT_TLSGD16_HA: 10902 tls_type = TLS_TLS | TLS_GD; 10903 goto dogot; 10904 10905 case R_PPC64_GOT_TLSLD16: 10906 case R_PPC64_GOT_TLSLD16_LO: 10907 case R_PPC64_GOT_TLSLD16_HI: 10908 case R_PPC64_GOT_TLSLD16_HA: 10909 tls_type = TLS_TLS | TLS_LD; 10910 goto dogot; 10911 10912 case R_PPC64_GOT_TPREL16_DS: 10913 case R_PPC64_GOT_TPREL16_LO_DS: 10914 case R_PPC64_GOT_TPREL16_HI: 10915 case R_PPC64_GOT_TPREL16_HA: 10916 tls_type = TLS_TLS | TLS_TPREL; 10917 goto dogot; 10918 10919 case R_PPC64_GOT_DTPREL16_DS: 10920 case R_PPC64_GOT_DTPREL16_LO_DS: 10921 case R_PPC64_GOT_DTPREL16_HI: 10922 case R_PPC64_GOT_DTPREL16_HA: 10923 tls_type = TLS_TLS | TLS_DTPREL; 10924 goto dogot; 10925 10926 case R_PPC64_GOT16: 10927 case R_PPC64_GOT16_LO: 10928 case R_PPC64_GOT16_HI: 10929 case R_PPC64_GOT16_HA: 10930 case R_PPC64_GOT16_DS: 10931 case R_PPC64_GOT16_LO_DS: 10932 dogot: 10933 { 10934 /* Relocation is to the entry for this symbol in the global 10935 offset table. */ 10936 asection *got; 10937 bfd_vma *offp; 10938 bfd_vma off; 10939 unsigned long indx = 0; 10940 10941 if (tls_type == (TLS_TLS | TLS_LD) 10942 && (h == NULL 10943 || !h->elf.def_dynamic)) 10944 offp = &ppc64_tlsld_got (input_bfd)->offset; 10945 else 10946 { 10947 struct got_entry *ent; 10948 10949 if (h != NULL) 10950 { 10951 bfd_boolean dyn = htab->elf.dynamic_sections_created; 10952 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, 10953 &h->elf) 10954 || (info->shared 10955 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))) 10956 /* This is actually a static link, or it is a 10957 -Bsymbolic link and the symbol is defined 10958 locally, or the symbol was forced to be local 10959 because of a version file. */ 10960 ; 10961 else 10962 { 10963 indx = h->elf.dynindx; 10964 unresolved_reloc = FALSE; 10965 } 10966 ent = h->elf.got.glist; 10967 } 10968 else 10969 { 10970 if (local_got_ents == NULL) 10971 abort (); 10972 ent = local_got_ents[r_symndx]; 10973 } 10974 10975 for (; ent != NULL; ent = ent->next) 10976 if (ent->addend == orig_addend 10977 && ent->owner == input_bfd 10978 && ent->tls_type == tls_type) 10979 break; 10980 if (ent == NULL) 10981 abort (); 10982 offp = &ent->got.offset; 10983 } 10984 10985 got = ppc64_elf_tdata (input_bfd)->got; 10986 if (got == NULL) 10987 abort (); 10988 10989 /* The offset must always be a multiple of 8. We use the 10990 least significant bit to record whether we have already 10991 processed this entry. */ 10992 off = *offp; 10993 if ((off & 1) != 0) 10994 off &= ~1; 10995 else 10996 { 10997 /* Generate relocs for the dynamic linker, except in 10998 the case of TLSLD where we'll use one entry per 10999 module. */ 11000 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot; 11001 11002 *offp = off | 1; 11003 if ((info->shared || indx != 0) 11004 && (offp == &ppc64_tlsld_got (input_bfd)->offset 11005 || h == NULL 11006 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT 11007 || h->elf.root.type != bfd_link_hash_undefweak)) 11008 { 11009 outrel.r_offset = (got->output_section->vma 11010 + got->output_offset 11011 + off); 11012 outrel.r_addend = addend; 11013 if (tls_type & (TLS_LD | TLS_GD)) 11014 { 11015 outrel.r_addend = 0; 11016 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64); 11017 if (tls_type == (TLS_TLS | TLS_GD)) 11018 { 11019 loc = relgot->contents; 11020 loc += (relgot->reloc_count++ 11021 * sizeof (Elf64_External_Rela)); 11022 bfd_elf64_swap_reloca_out (output_bfd, 11023 &outrel, loc); 11024 outrel.r_offset += 8; 11025 outrel.r_addend = addend; 11026 outrel.r_info 11027 = ELF64_R_INFO (indx, R_PPC64_DTPREL64); 11028 } 11029 } 11030 else if (tls_type == (TLS_TLS | TLS_DTPREL)) 11031 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64); 11032 else if (tls_type == (TLS_TLS | TLS_TPREL)) 11033 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64); 11034 else if (indx == 0) 11035 { 11036 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE); 11037 11038 /* Write the .got section contents for the sake 11039 of prelink. */ 11040 loc = got->contents + off; 11041 bfd_put_64 (output_bfd, outrel.r_addend + relocation, 11042 loc); 11043 } 11044 else 11045 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT); 11046 11047 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD)) 11048 { 11049 outrel.r_addend += relocation; 11050 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL)) 11051 outrel.r_addend -= htab->elf.tls_sec->vma; 11052 } 11053 loc = relgot->contents; 11054 loc += (relgot->reloc_count++ 11055 * sizeof (Elf64_External_Rela)); 11056 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 11057 } 11058 11059 /* Init the .got section contents here if we're not 11060 emitting a reloc. */ 11061 else 11062 { 11063 relocation += addend; 11064 if (tls_type == (TLS_TLS | TLS_LD)) 11065 relocation = 1; 11066 else if (tls_type != 0) 11067 { 11068 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET; 11069 if (tls_type == (TLS_TLS | TLS_TPREL)) 11070 relocation += DTP_OFFSET - TP_OFFSET; 11071 11072 if (tls_type == (TLS_TLS | TLS_GD)) 11073 { 11074 bfd_put_64 (output_bfd, relocation, 11075 got->contents + off + 8); 11076 relocation = 1; 11077 } 11078 } 11079 11080 bfd_put_64 (output_bfd, relocation, 11081 got->contents + off); 11082 } 11083 } 11084 11085 if (off >= (bfd_vma) -2) 11086 abort (); 11087 11088 relocation = got->output_offset + off; 11089 11090 /* TOC base (r2) is TOC start plus 0x8000. */ 11091 addend = -TOC_BASE_OFF; 11092 } 11093 break; 11094 11095 case R_PPC64_PLT16_HA: 11096 case R_PPC64_PLT16_HI: 11097 case R_PPC64_PLT16_LO: 11098 case R_PPC64_PLT32: 11099 case R_PPC64_PLT64: 11100 /* Relocation is to the entry for this symbol in the 11101 procedure linkage table. */ 11102 11103 /* Resolve a PLT reloc against a local symbol directly, 11104 without using the procedure linkage table. */ 11105 if (h == NULL) 11106 break; 11107 11108 /* It's possible that we didn't make a PLT entry for this 11109 symbol. This happens when statically linking PIC code, 11110 or when using -Bsymbolic. Go find a match if there is a 11111 PLT entry. */ 11112 if (htab->plt != NULL) 11113 { 11114 struct plt_entry *ent; 11115 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next) 11116 if (ent->addend == orig_addend 11117 && ent->plt.offset != (bfd_vma) -1) 11118 { 11119 relocation = (htab->plt->output_section->vma 11120 + htab->plt->output_offset 11121 + ent->plt.offset); 11122 unresolved_reloc = FALSE; 11123 } 11124 } 11125 break; 11126 11127 case R_PPC64_TOC: 11128 /* Relocation value is TOC base. */ 11129 relocation = TOCstart; 11130 if (r_symndx == 0) 11131 relocation += htab->stub_group[input_section->id].toc_off; 11132 else if (unresolved_reloc) 11133 ; 11134 else if (sec != NULL && sec->id <= htab->top_id) 11135 relocation += htab->stub_group[sec->id].toc_off; 11136 else 11137 unresolved_reloc = TRUE; 11138 goto dodyn; 11139 11140 /* TOC16 relocs. We want the offset relative to the TOC base, 11141 which is the address of the start of the TOC plus 0x8000. 11142 The TOC consists of sections .got, .toc, .tocbss, and .plt, 11143 in this order. */ 11144 case R_PPC64_TOC16: 11145 case R_PPC64_TOC16_LO: 11146 case R_PPC64_TOC16_HI: 11147 case R_PPC64_TOC16_DS: 11148 case R_PPC64_TOC16_LO_DS: 11149 case R_PPC64_TOC16_HA: 11150 addend -= TOCstart + htab->stub_group[input_section->id].toc_off; 11151 break; 11152 11153 /* Relocate against the beginning of the section. */ 11154 case R_PPC64_SECTOFF: 11155 case R_PPC64_SECTOFF_LO: 11156 case R_PPC64_SECTOFF_HI: 11157 case R_PPC64_SECTOFF_DS: 11158 case R_PPC64_SECTOFF_LO_DS: 11159 case R_PPC64_SECTOFF_HA: 11160 if (sec != NULL) 11161 addend -= sec->output_section->vma; 11162 break; 11163 11164 case R_PPC64_REL14: 11165 case R_PPC64_REL14_BRNTAKEN: 11166 case R_PPC64_REL14_BRTAKEN: 11167 case R_PPC64_REL24: 11168 break; 11169 11170 case R_PPC64_TPREL16: 11171 case R_PPC64_TPREL16_LO: 11172 case R_PPC64_TPREL16_HI: 11173 case R_PPC64_TPREL16_HA: 11174 case R_PPC64_TPREL16_DS: 11175 case R_PPC64_TPREL16_LO_DS: 11176 case R_PPC64_TPREL16_HIGHER: 11177 case R_PPC64_TPREL16_HIGHERA: 11178 case R_PPC64_TPREL16_HIGHEST: 11179 case R_PPC64_TPREL16_HIGHESTA: 11180 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 11181 if (info->shared) 11182 /* The TPREL16 relocs shouldn't really be used in shared 11183 libs as they will result in DT_TEXTREL being set, but 11184 support them anyway. */ 11185 goto dodyn; 11186 break; 11187 11188 case R_PPC64_DTPREL16: 11189 case R_PPC64_DTPREL16_LO: 11190 case R_PPC64_DTPREL16_HI: 11191 case R_PPC64_DTPREL16_HA: 11192 case R_PPC64_DTPREL16_DS: 11193 case R_PPC64_DTPREL16_LO_DS: 11194 case R_PPC64_DTPREL16_HIGHER: 11195 case R_PPC64_DTPREL16_HIGHERA: 11196 case R_PPC64_DTPREL16_HIGHEST: 11197 case R_PPC64_DTPREL16_HIGHESTA: 11198 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 11199 break; 11200 11201 case R_PPC64_DTPMOD64: 11202 relocation = 1; 11203 addend = 0; 11204 goto dodyn; 11205 11206 case R_PPC64_TPREL64: 11207 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 11208 goto dodyn; 11209 11210 case R_PPC64_DTPREL64: 11211 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 11212 /* Fall thru */ 11213 11214 /* Relocations that may need to be propagated if this is a 11215 dynamic object. */ 11216 case R_PPC64_REL30: 11217 case R_PPC64_REL32: 11218 case R_PPC64_REL64: 11219 case R_PPC64_ADDR14: 11220 case R_PPC64_ADDR14_BRNTAKEN: 11221 case R_PPC64_ADDR14_BRTAKEN: 11222 case R_PPC64_ADDR16: 11223 case R_PPC64_ADDR16_DS: 11224 case R_PPC64_ADDR16_HA: 11225 case R_PPC64_ADDR16_HI: 11226 case R_PPC64_ADDR16_HIGHER: 11227 case R_PPC64_ADDR16_HIGHERA: 11228 case R_PPC64_ADDR16_HIGHEST: 11229 case R_PPC64_ADDR16_HIGHESTA: 11230 case R_PPC64_ADDR16_LO: 11231 case R_PPC64_ADDR16_LO_DS: 11232 case R_PPC64_ADDR24: 11233 case R_PPC64_ADDR32: 11234 case R_PPC64_ADDR64: 11235 case R_PPC64_UADDR16: 11236 case R_PPC64_UADDR32: 11237 case R_PPC64_UADDR64: 11238 dodyn: 11239 if ((input_section->flags & SEC_ALLOC) == 0) 11240 break; 11241 11242 if (NO_OPD_RELOCS && is_opd) 11243 break; 11244 11245 if ((info->shared 11246 && (h == NULL 11247 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT 11248 || h->elf.root.type != bfd_link_hash_undefweak) 11249 && (must_be_dyn_reloc (info, r_type) 11250 || !SYMBOL_CALLS_LOCAL (info, &h->elf))) 11251 || (ELIMINATE_COPY_RELOCS 11252 && !info->shared 11253 && h != NULL 11254 && h->elf.dynindx != -1 11255 && !h->elf.non_got_ref 11256 && !h->elf.def_regular)) 11257 { 11258 Elf_Internal_Rela outrel; 11259 bfd_boolean skip, relocate; 11260 asection *sreloc; 11261 bfd_byte *loc; 11262 bfd_vma out_off; 11263 11264 /* When generating a dynamic object, these relocations 11265 are copied into the output file to be resolved at run 11266 time. */ 11267 11268 skip = FALSE; 11269 relocate = FALSE; 11270 11271 out_off = _bfd_elf_section_offset (output_bfd, info, 11272 input_section, rel->r_offset); 11273 if (out_off == (bfd_vma) -1) 11274 skip = TRUE; 11275 else if (out_off == (bfd_vma) -2) 11276 skip = TRUE, relocate = TRUE; 11277 out_off += (input_section->output_section->vma 11278 + input_section->output_offset); 11279 outrel.r_offset = out_off; 11280 outrel.r_addend = rel->r_addend; 11281 11282 /* Optimize unaligned reloc use. */ 11283 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0) 11284 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0)) 11285 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64; 11286 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0) 11287 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0)) 11288 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32; 11289 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0) 11290 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0)) 11291 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16; 11292 11293 if (skip) 11294 memset (&outrel, 0, sizeof outrel); 11295 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf) 11296 && !is_opd 11297 && r_type != R_PPC64_TOC) 11298 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type); 11299 else 11300 { 11301 /* This symbol is local, or marked to become local, 11302 or this is an opd section reloc which must point 11303 at a local function. */ 11304 outrel.r_addend += relocation; 11305 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC) 11306 { 11307 if (is_opd && h != NULL) 11308 { 11309 /* Lie about opd entries. This case occurs 11310 when building shared libraries and we 11311 reference a function in another shared 11312 lib. The same thing happens for a weak 11313 definition in an application that's 11314 overridden by a strong definition in a 11315 shared lib. (I believe this is a generic 11316 bug in binutils handling of weak syms.) 11317 In these cases we won't use the opd 11318 entry in this lib. */ 11319 unresolved_reloc = FALSE; 11320 } 11321 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 11322 11323 /* We need to relocate .opd contents for ld.so. 11324 Prelink also wants simple and consistent rules 11325 for relocs. This make all RELATIVE relocs have 11326 *r_offset equal to r_addend. */ 11327 relocate = TRUE; 11328 } 11329 else 11330 { 11331 long indx = 0; 11332 11333 if (r_symndx == 0 || bfd_is_abs_section (sec)) 11334 ; 11335 else if (sec == NULL || sec->owner == NULL) 11336 { 11337 bfd_set_error (bfd_error_bad_value); 11338 return FALSE; 11339 } 11340 else 11341 { 11342 asection *osec; 11343 11344 osec = sec->output_section; 11345 indx = elf_section_data (osec)->dynindx; 11346 11347 if (indx == 0) 11348 { 11349 if ((osec->flags & SEC_READONLY) == 0 11350 && htab->elf.data_index_section != NULL) 11351 osec = htab->elf.data_index_section; 11352 else 11353 osec = htab->elf.text_index_section; 11354 indx = elf_section_data (osec)->dynindx; 11355 } 11356 BFD_ASSERT (indx != 0); 11357 11358 /* We are turning this relocation into one 11359 against a section symbol, so subtract out 11360 the output section's address but not the 11361 offset of the input section in the output 11362 section. */ 11363 outrel.r_addend -= osec->vma; 11364 } 11365 11366 outrel.r_info = ELF64_R_INFO (indx, r_type); 11367 } 11368 } 11369 11370 sreloc = elf_section_data (input_section)->sreloc; 11371 if (sreloc == NULL) 11372 abort (); 11373 11374 if (sreloc->reloc_count * sizeof (Elf64_External_Rela) 11375 >= sreloc->size) 11376 abort (); 11377 loc = sreloc->contents; 11378 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 11379 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 11380 11381 /* If this reloc is against an external symbol, it will 11382 be computed at runtime, so there's no need to do 11383 anything now. However, for the sake of prelink ensure 11384 that the section contents are a known value. */ 11385 if (! relocate) 11386 { 11387 unresolved_reloc = FALSE; 11388 /* The value chosen here is quite arbitrary as ld.so 11389 ignores section contents except for the special 11390 case of .opd where the contents might be accessed 11391 before relocation. Choose zero, as that won't 11392 cause reloc overflow. */ 11393 relocation = 0; 11394 addend = 0; 11395 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs 11396 to improve backward compatibility with older 11397 versions of ld. */ 11398 if (r_type == R_PPC64_ADDR64) 11399 addend = outrel.r_addend; 11400 /* Adjust pc_relative relocs to have zero in *r_offset. */ 11401 else if (ppc64_elf_howto_table[r_type]->pc_relative) 11402 addend = (input_section->output_section->vma 11403 + input_section->output_offset 11404 + rel->r_offset); 11405 } 11406 } 11407 break; 11408 11409 case R_PPC64_COPY: 11410 case R_PPC64_GLOB_DAT: 11411 case R_PPC64_JMP_SLOT: 11412 case R_PPC64_RELATIVE: 11413 /* We shouldn't ever see these dynamic relocs in relocatable 11414 files. */ 11415 /* Fall through. */ 11416 11417 case R_PPC64_PLTGOT16: 11418 case R_PPC64_PLTGOT16_DS: 11419 case R_PPC64_PLTGOT16_HA: 11420 case R_PPC64_PLTGOT16_HI: 11421 case R_PPC64_PLTGOT16_LO: 11422 case R_PPC64_PLTGOT16_LO_DS: 11423 case R_PPC64_PLTREL32: 11424 case R_PPC64_PLTREL64: 11425 /* These ones haven't been implemented yet. */ 11426 11427 (*_bfd_error_handler) 11428 (_("%B: relocation %s is not supported for symbol %s."), 11429 input_bfd, 11430 ppc64_elf_howto_table[r_type]->name, sym_name); 11431 11432 bfd_set_error (bfd_error_invalid_operation); 11433 ret = FALSE; 11434 continue; 11435 } 11436 11437 /* Do any further special processing. */ 11438 switch (r_type) 11439 { 11440 default: 11441 break; 11442 11443 case R_PPC64_ADDR16_HA: 11444 case R_PPC64_ADDR16_HIGHERA: 11445 case R_PPC64_ADDR16_HIGHESTA: 11446 case R_PPC64_TOC16_HA: 11447 case R_PPC64_SECTOFF_HA: 11448 case R_PPC64_TPREL16_HA: 11449 case R_PPC64_DTPREL16_HA: 11450 case R_PPC64_TPREL16_HIGHER: 11451 case R_PPC64_TPREL16_HIGHERA: 11452 case R_PPC64_TPREL16_HIGHEST: 11453 case R_PPC64_TPREL16_HIGHESTA: 11454 case R_PPC64_DTPREL16_HIGHER: 11455 case R_PPC64_DTPREL16_HIGHERA: 11456 case R_PPC64_DTPREL16_HIGHEST: 11457 case R_PPC64_DTPREL16_HIGHESTA: 11458 /* It's just possible that this symbol is a weak symbol 11459 that's not actually defined anywhere. In that case, 11460 'sec' would be NULL, and we should leave the symbol 11461 alone (it will be set to zero elsewhere in the link). */ 11462 if (sec == NULL) 11463 break; 11464 /* Fall thru */ 11465 11466 case R_PPC64_GOT16_HA: 11467 case R_PPC64_PLTGOT16_HA: 11468 case R_PPC64_PLT16_HA: 11469 case R_PPC64_GOT_TLSGD16_HA: 11470 case R_PPC64_GOT_TLSLD16_HA: 11471 case R_PPC64_GOT_TPREL16_HA: 11472 case R_PPC64_GOT_DTPREL16_HA: 11473 /* Add 0x10000 if sign bit in 0:15 is set. 11474 Bits 0:15 are not used. */ 11475 addend += 0x8000; 11476 break; 11477 11478 case R_PPC64_ADDR16_DS: 11479 case R_PPC64_ADDR16_LO_DS: 11480 case R_PPC64_GOT16_DS: 11481 case R_PPC64_GOT16_LO_DS: 11482 case R_PPC64_PLT16_LO_DS: 11483 case R_PPC64_SECTOFF_DS: 11484 case R_PPC64_SECTOFF_LO_DS: 11485 case R_PPC64_TOC16_DS: 11486 case R_PPC64_TOC16_LO_DS: 11487 case R_PPC64_PLTGOT16_DS: 11488 case R_PPC64_PLTGOT16_LO_DS: 11489 case R_PPC64_GOT_TPREL16_DS: 11490 case R_PPC64_GOT_TPREL16_LO_DS: 11491 case R_PPC64_GOT_DTPREL16_DS: 11492 case R_PPC64_GOT_DTPREL16_LO_DS: 11493 case R_PPC64_TPREL16_DS: 11494 case R_PPC64_TPREL16_LO_DS: 11495 case R_PPC64_DTPREL16_DS: 11496 case R_PPC64_DTPREL16_LO_DS: 11497 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3)); 11498 mask = 3; 11499 /* If this reloc is against an lq insn, then the value must be 11500 a multiple of 16. This is somewhat of a hack, but the 11501 "correct" way to do this by defining _DQ forms of all the 11502 _DS relocs bloats all reloc switches in this file. It 11503 doesn't seem to make much sense to use any of these relocs 11504 in data, so testing the insn should be safe. */ 11505 if ((insn & (0x3f << 26)) == (56u << 26)) 11506 mask = 15; 11507 if (((relocation + addend) & mask) != 0) 11508 { 11509 (*_bfd_error_handler) 11510 (_("%B: error: relocation %s not a multiple of %d"), 11511 input_bfd, 11512 ppc64_elf_howto_table[r_type]->name, 11513 mask + 1); 11514 bfd_set_error (bfd_error_bad_value); 11515 ret = FALSE; 11516 continue; 11517 } 11518 break; 11519 } 11520 11521 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 11522 because such sections are not SEC_ALLOC and thus ld.so will 11523 not process them. */ 11524 if (unresolved_reloc 11525 && !((input_section->flags & SEC_DEBUGGING) != 0 11526 && h->elf.def_dynamic)) 11527 { 11528 (*_bfd_error_handler) 11529 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 11530 input_bfd, 11531 input_section, 11532 (long) rel->r_offset, 11533 ppc64_elf_howto_table[(int) r_type]->name, 11534 h->elf.root.root.string); 11535 ret = FALSE; 11536 } 11537 11538 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type], 11539 input_bfd, 11540 input_section, 11541 contents, 11542 rel->r_offset, 11543 relocation, 11544 addend); 11545 11546 if (r != bfd_reloc_ok) 11547 { 11548 if (sym_name == NULL) 11549 sym_name = "(null)"; 11550 if (r == bfd_reloc_overflow) 11551 { 11552 if (warned) 11553 continue; 11554 if (h != NULL 11555 && h->elf.root.type == bfd_link_hash_undefweak 11556 && ppc64_elf_howto_table[r_type]->pc_relative) 11557 { 11558 /* Assume this is a call protected by other code that 11559 detects the symbol is undefined. If this is the case, 11560 we can safely ignore the overflow. If not, the 11561 program is hosed anyway, and a little warning isn't 11562 going to help. */ 11563 11564 continue; 11565 } 11566 11567 if (!((*info->callbacks->reloc_overflow) 11568 (info, (h ? &h->elf.root : NULL), sym_name, 11569 ppc64_elf_howto_table[r_type]->name, 11570 orig_addend, input_bfd, input_section, rel->r_offset))) 11571 return FALSE; 11572 } 11573 else 11574 { 11575 (*_bfd_error_handler) 11576 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"), 11577 input_bfd, 11578 input_section, 11579 (long) rel->r_offset, 11580 ppc64_elf_howto_table[r_type]->name, 11581 sym_name, 11582 (int) r); 11583 ret = FALSE; 11584 } 11585 } 11586 } 11587 11588 /* If we're emitting relocations, then shortly after this function 11589 returns, reloc offsets and addends for this section will be 11590 adjusted. Worse, reloc symbol indices will be for the output 11591 file rather than the input. Save a copy of the relocs for 11592 opd_entry_value. */ 11593 if (is_opd && (info->emitrelocations || info->relocatable)) 11594 { 11595 bfd_size_type amt; 11596 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela); 11597 rel = bfd_alloc (input_bfd, amt); 11598 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL); 11599 ppc64_elf_tdata (input_bfd)->opd_relocs = rel; 11600 if (rel == NULL) 11601 return FALSE; 11602 memcpy (rel, relocs, amt); 11603 } 11604 return ret; 11605 } 11606 11607 /* Adjust the value of any local symbols in opd sections. */ 11608 11609 static bfd_boolean 11610 ppc64_elf_output_symbol_hook (struct bfd_link_info *info, 11611 const char *name ATTRIBUTE_UNUSED, 11612 Elf_Internal_Sym *elfsym, 11613 asection *input_sec, 11614 struct elf_link_hash_entry *h) 11615 { 11616 struct _opd_sec_data *opd; 11617 long adjust; 11618 bfd_vma value; 11619 11620 if (h != NULL) 11621 return TRUE; 11622 11623 opd = get_opd_info (input_sec); 11624 if (opd == NULL || opd->adjust == NULL) 11625 return TRUE; 11626 11627 value = elfsym->st_value - input_sec->output_offset; 11628 if (!info->relocatable) 11629 value -= input_sec->output_section->vma; 11630 11631 adjust = opd->adjust[value / 8]; 11632 if (adjust == -1) 11633 elfsym->st_value = 0; 11634 else 11635 elfsym->st_value += adjust; 11636 return TRUE; 11637 } 11638 11639 /* Finish up dynamic symbol handling. We set the contents of various 11640 dynamic sections here. */ 11641 11642 static bfd_boolean 11643 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd, 11644 struct bfd_link_info *info, 11645 struct elf_link_hash_entry *h, 11646 Elf_Internal_Sym *sym) 11647 { 11648 struct ppc_link_hash_table *htab; 11649 struct plt_entry *ent; 11650 Elf_Internal_Rela rela; 11651 bfd_byte *loc; 11652 11653 htab = ppc_hash_table (info); 11654 11655 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 11656 if (ent->plt.offset != (bfd_vma) -1) 11657 { 11658 /* This symbol has an entry in the procedure linkage 11659 table. Set it up. */ 11660 11661 if (htab->plt == NULL 11662 || htab->relplt == NULL 11663 || htab->glink == NULL) 11664 abort (); 11665 11666 /* Create a JMP_SLOT reloc to inform the dynamic linker to 11667 fill in the PLT entry. */ 11668 rela.r_offset = (htab->plt->output_section->vma 11669 + htab->plt->output_offset 11670 + ent->plt.offset); 11671 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT); 11672 rela.r_addend = ent->addend; 11673 11674 loc = htab->relplt->contents; 11675 loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE 11676 * sizeof (Elf64_External_Rela)); 11677 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 11678 } 11679 11680 if (h->needs_copy) 11681 { 11682 Elf_Internal_Rela rela; 11683 bfd_byte *loc; 11684 11685 /* This symbol needs a copy reloc. Set it up. */ 11686 11687 if (h->dynindx == -1 11688 || (h->root.type != bfd_link_hash_defined 11689 && h->root.type != bfd_link_hash_defweak) 11690 || htab->relbss == NULL) 11691 abort (); 11692 11693 rela.r_offset = (h->root.u.def.value 11694 + h->root.u.def.section->output_section->vma 11695 + h->root.u.def.section->output_offset); 11696 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY); 11697 rela.r_addend = 0; 11698 loc = htab->relbss->contents; 11699 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela); 11700 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 11701 } 11702 11703 /* Mark some specially defined symbols as absolute. */ 11704 if (strcmp (h->root.root.string, "_DYNAMIC") == 0) 11705 sym->st_shndx = SHN_ABS; 11706 11707 return TRUE; 11708 } 11709 11710 /* Used to decide how to sort relocs in an optimal manner for the 11711 dynamic linker, before writing them out. */ 11712 11713 static enum elf_reloc_type_class 11714 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela) 11715 { 11716 enum elf_ppc64_reloc_type r_type; 11717 11718 r_type = ELF64_R_TYPE (rela->r_info); 11719 switch (r_type) 11720 { 11721 case R_PPC64_RELATIVE: 11722 return reloc_class_relative; 11723 case R_PPC64_JMP_SLOT: 11724 return reloc_class_plt; 11725 case R_PPC64_COPY: 11726 return reloc_class_copy; 11727 default: 11728 return reloc_class_normal; 11729 } 11730 } 11731 11732 /* Finish up the dynamic sections. */ 11733 11734 static bfd_boolean 11735 ppc64_elf_finish_dynamic_sections (bfd *output_bfd, 11736 struct bfd_link_info *info) 11737 { 11738 struct ppc_link_hash_table *htab; 11739 bfd *dynobj; 11740 asection *sdyn; 11741 11742 htab = ppc_hash_table (info); 11743 dynobj = htab->elf.dynobj; 11744 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 11745 11746 if (htab->elf.dynamic_sections_created) 11747 { 11748 Elf64_External_Dyn *dyncon, *dynconend; 11749 11750 if (sdyn == NULL || htab->got == NULL) 11751 abort (); 11752 11753 dyncon = (Elf64_External_Dyn *) sdyn->contents; 11754 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 11755 for (; dyncon < dynconend; dyncon++) 11756 { 11757 Elf_Internal_Dyn dyn; 11758 asection *s; 11759 11760 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 11761 11762 switch (dyn.d_tag) 11763 { 11764 default: 11765 continue; 11766 11767 case DT_PPC64_GLINK: 11768 s = htab->glink; 11769 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11770 /* We stupidly defined DT_PPC64_GLINK to be the start 11771 of glink rather than the first entry point, which is 11772 what ld.so needs, and now have a bigger stub to 11773 support automatic multiple TOCs. */ 11774 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32; 11775 break; 11776 11777 case DT_PPC64_OPD: 11778 s = bfd_get_section_by_name (output_bfd, ".opd"); 11779 if (s == NULL) 11780 continue; 11781 dyn.d_un.d_ptr = s->vma; 11782 break; 11783 11784 case DT_PPC64_OPDSZ: 11785 s = bfd_get_section_by_name (output_bfd, ".opd"); 11786 if (s == NULL) 11787 continue; 11788 dyn.d_un.d_val = s->size; 11789 break; 11790 11791 case DT_PLTGOT: 11792 s = htab->plt; 11793 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11794 break; 11795 11796 case DT_JMPREL: 11797 s = htab->relplt; 11798 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11799 break; 11800 11801 case DT_PLTRELSZ: 11802 dyn.d_un.d_val = htab->relplt->size; 11803 break; 11804 11805 case DT_RELASZ: 11806 /* Don't count procedure linkage table relocs in the 11807 overall reloc count. */ 11808 s = htab->relplt; 11809 if (s == NULL) 11810 continue; 11811 dyn.d_un.d_val -= s->size; 11812 break; 11813 11814 case DT_RELA: 11815 /* We may not be using the standard ELF linker script. 11816 If .rela.plt is the first .rela section, we adjust 11817 DT_RELA to not include it. */ 11818 s = htab->relplt; 11819 if (s == NULL) 11820 continue; 11821 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset) 11822 continue; 11823 dyn.d_un.d_ptr += s->size; 11824 break; 11825 } 11826 11827 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 11828 } 11829 } 11830 11831 if (htab->got != NULL && htab->got->size != 0) 11832 { 11833 /* Fill in the first entry in the global offset table. 11834 We use it to hold the link-time TOCbase. */ 11835 bfd_put_64 (output_bfd, 11836 elf_gp (output_bfd) + TOC_BASE_OFF, 11837 htab->got->contents); 11838 11839 /* Set .got entry size. */ 11840 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8; 11841 } 11842 11843 if (htab->plt != NULL && htab->plt->size != 0) 11844 { 11845 /* Set .plt entry size. */ 11846 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize 11847 = PLT_ENTRY_SIZE; 11848 } 11849 11850 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for 11851 brlt ourselves if emitrelocations. */ 11852 if (htab->brlt != NULL 11853 && htab->brlt->reloc_count != 0 11854 && !_bfd_elf_link_output_relocs (output_bfd, 11855 htab->brlt, 11856 &elf_section_data (htab->brlt)->rel_hdr, 11857 elf_section_data (htab->brlt)->relocs, 11858 NULL)) 11859 return FALSE; 11860 11861 if (htab->glink != NULL 11862 && htab->glink->reloc_count != 0 11863 && !_bfd_elf_link_output_relocs (output_bfd, 11864 htab->glink, 11865 &elf_section_data (htab->glink)->rel_hdr, 11866 elf_section_data (htab->glink)->relocs, 11867 NULL)) 11868 return FALSE; 11869 11870 /* We need to handle writing out multiple GOT sections ourselves, 11871 since we didn't add them to DYNOBJ. We know dynobj is the first 11872 bfd. */ 11873 while ((dynobj = dynobj->link_next) != NULL) 11874 { 11875 asection *s; 11876 11877 if (!is_ppc64_elf (dynobj)) 11878 continue; 11879 11880 s = ppc64_elf_tdata (dynobj)->got; 11881 if (s != NULL 11882 && s->size != 0 11883 && s->output_section != bfd_abs_section_ptr 11884 && !bfd_set_section_contents (output_bfd, s->output_section, 11885 s->contents, s->output_offset, 11886 s->size)) 11887 return FALSE; 11888 s = ppc64_elf_tdata (dynobj)->relgot; 11889 if (s != NULL 11890 && s->size != 0 11891 && s->output_section != bfd_abs_section_ptr 11892 && !bfd_set_section_contents (output_bfd, s->output_section, 11893 s->contents, s->output_offset, 11894 s->size)) 11895 return FALSE; 11896 } 11897 11898 return TRUE; 11899 } 11900 11901 #include "elf64-target.h" 11902