1/* PowerPC64-specific support for 64-bit ELF. 2 Copyright (C) 1999-2017 Free Software Foundation, Inc. 3 Written by Linus Nordberg, Swox AB <info@swox.com>, 4 based on elf32-ppc.c by Ian Lance Taylor. 5 Largely rewritten by Alan Modra. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License along 20 with this program; if not, write to the Free Software Foundation, Inc., 21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23 24/* The 64-bit PowerPC ELF ABI may be found at 25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and 26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */ 27 28#include "sysdep.h" 29#include <stdarg.h> 30#include "bfd.h" 31#include "bfdlink.h" 32#include "libbfd.h" 33#include "elf-bfd.h" 34#include "elf/ppc64.h" 35#include "elf64-ppc.h" 36#include "dwarf2.h" 37 38static bfd_reloc_status_type ppc64_elf_ha_reloc 39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 40static bfd_reloc_status_type ppc64_elf_branch_reloc 41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 42static bfd_reloc_status_type ppc64_elf_brtaken_reloc 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 44static bfd_reloc_status_type ppc64_elf_sectoff_reloc 45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 46static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc 47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 48static bfd_reloc_status_type ppc64_elf_toc_reloc 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 50static bfd_reloc_status_type ppc64_elf_toc_ha_reloc 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 52static bfd_reloc_status_type ppc64_elf_toc64_reloc 53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 54static bfd_reloc_status_type ppc64_elf_unhandled_reloc 55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 56static bfd_vma opd_entry_value 57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean); 58 59#define TARGET_LITTLE_SYM powerpc_elf64_le_vec 60#define TARGET_LITTLE_NAME "elf64-powerpcle" 61#define TARGET_BIG_SYM powerpc_elf64_vec 62#define TARGET_BIG_NAME "elf64-powerpc" 63#define ELF_ARCH bfd_arch_powerpc 64#define ELF_TARGET_ID PPC64_ELF_DATA 65#define ELF_MACHINE_CODE EM_PPC64 66#define ELF_MAXPAGESIZE 0x10000 67#define ELF_COMMONPAGESIZE 0x10000 68#define elf_info_to_howto ppc64_elf_info_to_howto 69 70#define elf_backend_want_got_sym 0 71#define elf_backend_want_plt_sym 0 72#define elf_backend_plt_alignment 3 73#define elf_backend_plt_not_loaded 1 74#define elf_backend_got_header_size 8 75#define elf_backend_want_dynrelro 1 76#define elf_backend_can_gc_sections 1 77#define elf_backend_can_refcount 1 78#define elf_backend_rela_normal 1 79#define elf_backend_dtrel_excludes_plt 1 80#define elf_backend_default_execstack 0 81 82#define bfd_elf64_mkobject ppc64_elf_mkobject 83#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup 84#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup 85#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data 86#define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data 87#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook 88#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create 89#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab 90#define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms 91#define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections 92 93#define elf_backend_object_p ppc64_elf_object_p 94#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus 95#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo 96#define elf_backend_write_core_note ppc64_elf_write_core_note 97#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections 98#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol 99#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook 100#define elf_backend_check_directives ppc64_elf_before_check_relocs 101#define elf_backend_notice_as_needed ppc64_elf_notice_as_needed 102#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup 103#define elf_backend_check_relocs ppc64_elf_check_relocs 104#define elf_backend_gc_keep ppc64_elf_gc_keep 105#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref 106#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook 107#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook 108#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol 109#define elf_backend_hide_symbol ppc64_elf_hide_symbol 110#define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym 111#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust 112#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections 113#define elf_backend_hash_symbol ppc64_elf_hash_symbol 114#define elf_backend_init_index_section _bfd_elf_init_2_index_sections 115#define elf_backend_action_discarded ppc64_elf_action_discarded 116#define elf_backend_relocate_section ppc64_elf_relocate_section 117#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol 118#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class 119#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections 120#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook 121#define elf_backend_special_sections ppc64_elf_special_sections 122#define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute 123#define elf_backend_merge_symbol ppc64_elf_merge_symbol 124 125/* The name of the dynamic interpreter. This is put in the .interp 126 section. */ 127#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 128 129/* The size in bytes of an entry in the procedure linkage table. */ 130#define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8) 131 132/* The initial size of the plt reserved for the dynamic linker. */ 133#define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16) 134 135/* Offsets to some stack save slots. */ 136#define STK_LR 16 137#define STK_TOC(htab) (htab->opd_abi ? 40 : 24) 138/* This one is dodgy. ELFv2 does not have a linker word, so use the 139 CR save slot. Used only by optimised __tls_get_addr call stub, 140 relying on __tls_get_addr_opt not saving CR.. */ 141#define STK_LINKER(htab) (htab->opd_abi ? 32 : 8) 142 143/* TOC base pointers offset from start of TOC. */ 144#define TOC_BASE_OFF 0x8000 145/* TOC base alignment. */ 146#define TOC_BASE_ALIGN 256 147 148/* Offset of tp and dtp pointers from start of TLS block. */ 149#define TP_OFFSET 0x7000 150#define DTP_OFFSET 0x8000 151 152/* .plt call stub instructions. The normal stub is like this, but 153 sometimes the .plt entry crosses a 64k boundary and we need to 154 insert an addi to adjust r11. */ 155#define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */ 156#define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */ 157#define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */ 158#define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */ 159#define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */ 160#define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */ 161#define BCTR 0x4e800420 /* bctr */ 162 163#define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */ 164#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */ 165#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */ 166 167#define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */ 168#define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */ 169#define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */ 170#define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */ 171#define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */ 172#define BNECTR 0x4ca20420 /* bnectr+ */ 173#define BNECTR_P4 0x4ce20420 /* bnectr+ */ 174 175#define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */ 176#define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */ 177#define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */ 178 179#define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */ 180#define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */ 181#define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */ 182 183#define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */ 184#define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */ 185#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */ 186#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */ 187#define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */ 188 189/* glink call stub instructions. We enter with the index in R0. */ 190#define GLINK_CALL_STUB_SIZE (16*4) 191 /* 0: */ 192 /* .quad plt0-1f */ 193 /* __glink: */ 194#define MFLR_R12 0x7d8802a6 /* mflr %12 */ 195#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */ 196 /* 1: */ 197#define MFLR_R11 0x7d6802a6 /* mflr %11 */ 198 /* ld %2,(0b-1b)(%11) */ 199#define MTLR_R12 0x7d8803a6 /* mtlr %12 */ 200#define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */ 201 /* ld %12,0(%11) */ 202 /* ld %2,8(%11) */ 203 /* mtctr %12 */ 204 /* ld %11,16(%11) */ 205 /* bctr */ 206#define MFLR_R0 0x7c0802a6 /* mflr %r0 */ 207#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */ 208#define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */ 209#define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */ 210#define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */ 211 212/* Pad with this. */ 213#define NOP 0x60000000 214 215/* Some other nops. */ 216#define CROR_151515 0x4def7b82 217#define CROR_313131 0x4ffffb82 218 219/* .glink entries for the first 32k functions are two instructions. */ 220#define LI_R0_0 0x38000000 /* li %r0,0 */ 221#define B_DOT 0x48000000 /* b . */ 222 223/* After that, we need two instructions to load the index, followed by 224 a branch. */ 225#define LIS_R0_0 0x3c000000 /* lis %r0,0 */ 226#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */ 227 228/* Instructions used by the save and restore reg functions. */ 229#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */ 230#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */ 231#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */ 232#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */ 233#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */ 234#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */ 235#define LI_R12_0 0x39800000 /* li %r12,0 */ 236#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */ 237#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */ 238#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */ 239#define BLR 0x4e800020 /* blr */ 240 241/* Since .opd is an array of descriptors and each entry will end up 242 with identical R_PPC64_RELATIVE relocs, there is really no need to 243 propagate .opd relocs; The dynamic linker should be taught to 244 relocate .opd without reloc entries. */ 245#ifndef NO_OPD_RELOCS 246#define NO_OPD_RELOCS 0 247#endif 248 249#ifndef ARRAY_SIZE 250#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) 251#endif 252 253static inline int 254abiversion (bfd *abfd) 255{ 256 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI; 257} 258 259static inline void 260set_abiversion (bfd *abfd, int ver) 261{ 262 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI; 263 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI; 264} 265 266#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1) 267 268/* Relocation HOWTO's. */ 269static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max]; 270 271static reloc_howto_type ppc64_elf_howto_raw[] = { 272 /* This reloc does nothing. */ 273 HOWTO (R_PPC64_NONE, /* type */ 274 0, /* rightshift */ 275 3, /* size (0 = byte, 1 = short, 2 = long) */ 276 0, /* bitsize */ 277 FALSE, /* pc_relative */ 278 0, /* bitpos */ 279 complain_overflow_dont, /* complain_on_overflow */ 280 bfd_elf_generic_reloc, /* special_function */ 281 "R_PPC64_NONE", /* name */ 282 FALSE, /* partial_inplace */ 283 0, /* src_mask */ 284 0, /* dst_mask */ 285 FALSE), /* pcrel_offset */ 286 287 /* A standard 32 bit relocation. */ 288 HOWTO (R_PPC64_ADDR32, /* type */ 289 0, /* rightshift */ 290 2, /* size (0 = byte, 1 = short, 2 = long) */ 291 32, /* bitsize */ 292 FALSE, /* pc_relative */ 293 0, /* bitpos */ 294 complain_overflow_bitfield, /* complain_on_overflow */ 295 bfd_elf_generic_reloc, /* special_function */ 296 "R_PPC64_ADDR32", /* name */ 297 FALSE, /* partial_inplace */ 298 0, /* src_mask */ 299 0xffffffff, /* dst_mask */ 300 FALSE), /* pcrel_offset */ 301 302 /* An absolute 26 bit branch; the lower two bits must be zero. 303 FIXME: we don't check that, we just clear them. */ 304 HOWTO (R_PPC64_ADDR24, /* type */ 305 0, /* rightshift */ 306 2, /* size (0 = byte, 1 = short, 2 = long) */ 307 26, /* bitsize */ 308 FALSE, /* pc_relative */ 309 0, /* bitpos */ 310 complain_overflow_bitfield, /* complain_on_overflow */ 311 bfd_elf_generic_reloc, /* special_function */ 312 "R_PPC64_ADDR24", /* name */ 313 FALSE, /* partial_inplace */ 314 0, /* src_mask */ 315 0x03fffffc, /* dst_mask */ 316 FALSE), /* pcrel_offset */ 317 318 /* A standard 16 bit relocation. */ 319 HOWTO (R_PPC64_ADDR16, /* type */ 320 0, /* rightshift */ 321 1, /* size (0 = byte, 1 = short, 2 = long) */ 322 16, /* bitsize */ 323 FALSE, /* pc_relative */ 324 0, /* bitpos */ 325 complain_overflow_bitfield, /* complain_on_overflow */ 326 bfd_elf_generic_reloc, /* special_function */ 327 "R_PPC64_ADDR16", /* name */ 328 FALSE, /* partial_inplace */ 329 0, /* src_mask */ 330 0xffff, /* dst_mask */ 331 FALSE), /* pcrel_offset */ 332 333 /* A 16 bit relocation without overflow. */ 334 HOWTO (R_PPC64_ADDR16_LO, /* type */ 335 0, /* rightshift */ 336 1, /* size (0 = byte, 1 = short, 2 = long) */ 337 16, /* bitsize */ 338 FALSE, /* pc_relative */ 339 0, /* bitpos */ 340 complain_overflow_dont,/* complain_on_overflow */ 341 bfd_elf_generic_reloc, /* special_function */ 342 "R_PPC64_ADDR16_LO", /* name */ 343 FALSE, /* partial_inplace */ 344 0, /* src_mask */ 345 0xffff, /* dst_mask */ 346 FALSE), /* pcrel_offset */ 347 348 /* Bits 16-31 of an address. */ 349 HOWTO (R_PPC64_ADDR16_HI, /* type */ 350 16, /* rightshift */ 351 1, /* size (0 = byte, 1 = short, 2 = long) */ 352 16, /* bitsize */ 353 FALSE, /* pc_relative */ 354 0, /* bitpos */ 355 complain_overflow_signed, /* complain_on_overflow */ 356 bfd_elf_generic_reloc, /* special_function */ 357 "R_PPC64_ADDR16_HI", /* name */ 358 FALSE, /* partial_inplace */ 359 0, /* src_mask */ 360 0xffff, /* dst_mask */ 361 FALSE), /* pcrel_offset */ 362 363 /* Bits 16-31 of an address, plus 1 if the contents of the low 16 364 bits, treated as a signed number, is negative. */ 365 HOWTO (R_PPC64_ADDR16_HA, /* type */ 366 16, /* rightshift */ 367 1, /* size (0 = byte, 1 = short, 2 = long) */ 368 16, /* bitsize */ 369 FALSE, /* pc_relative */ 370 0, /* bitpos */ 371 complain_overflow_signed, /* complain_on_overflow */ 372 ppc64_elf_ha_reloc, /* special_function */ 373 "R_PPC64_ADDR16_HA", /* name */ 374 FALSE, /* partial_inplace */ 375 0, /* src_mask */ 376 0xffff, /* dst_mask */ 377 FALSE), /* pcrel_offset */ 378 379 /* An absolute 16 bit branch; the lower two bits must be zero. 380 FIXME: we don't check that, we just clear them. */ 381 HOWTO (R_PPC64_ADDR14, /* type */ 382 0, /* rightshift */ 383 2, /* size (0 = byte, 1 = short, 2 = long) */ 384 16, /* bitsize */ 385 FALSE, /* pc_relative */ 386 0, /* bitpos */ 387 complain_overflow_signed, /* complain_on_overflow */ 388 ppc64_elf_branch_reloc, /* special_function */ 389 "R_PPC64_ADDR14", /* name */ 390 FALSE, /* partial_inplace */ 391 0, /* src_mask */ 392 0x0000fffc, /* dst_mask */ 393 FALSE), /* pcrel_offset */ 394 395 /* An absolute 16 bit branch, for which bit 10 should be set to 396 indicate that the branch is expected to be taken. The lower two 397 bits must be zero. */ 398 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */ 399 0, /* rightshift */ 400 2, /* size (0 = byte, 1 = short, 2 = long) */ 401 16, /* bitsize */ 402 FALSE, /* pc_relative */ 403 0, /* bitpos */ 404 complain_overflow_signed, /* complain_on_overflow */ 405 ppc64_elf_brtaken_reloc, /* special_function */ 406 "R_PPC64_ADDR14_BRTAKEN",/* name */ 407 FALSE, /* partial_inplace */ 408 0, /* src_mask */ 409 0x0000fffc, /* dst_mask */ 410 FALSE), /* pcrel_offset */ 411 412 /* An absolute 16 bit branch, for which bit 10 should be set to 413 indicate that the branch is not expected to be taken. The lower 414 two bits must be zero. */ 415 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */ 416 0, /* rightshift */ 417 2, /* size (0 = byte, 1 = short, 2 = long) */ 418 16, /* bitsize */ 419 FALSE, /* pc_relative */ 420 0, /* bitpos */ 421 complain_overflow_signed, /* complain_on_overflow */ 422 ppc64_elf_brtaken_reloc, /* special_function */ 423 "R_PPC64_ADDR14_BRNTAKEN",/* name */ 424 FALSE, /* partial_inplace */ 425 0, /* src_mask */ 426 0x0000fffc, /* dst_mask */ 427 FALSE), /* pcrel_offset */ 428 429 /* A relative 26 bit branch; the lower two bits must be zero. */ 430 HOWTO (R_PPC64_REL24, /* type */ 431 0, /* rightshift */ 432 2, /* size (0 = byte, 1 = short, 2 = long) */ 433 26, /* bitsize */ 434 TRUE, /* pc_relative */ 435 0, /* bitpos */ 436 complain_overflow_signed, /* complain_on_overflow */ 437 ppc64_elf_branch_reloc, /* special_function */ 438 "R_PPC64_REL24", /* name */ 439 FALSE, /* partial_inplace */ 440 0, /* src_mask */ 441 0x03fffffc, /* dst_mask */ 442 TRUE), /* pcrel_offset */ 443 444 /* A relative 16 bit branch; the lower two bits must be zero. */ 445 HOWTO (R_PPC64_REL14, /* type */ 446 0, /* rightshift */ 447 2, /* size (0 = byte, 1 = short, 2 = long) */ 448 16, /* bitsize */ 449 TRUE, /* pc_relative */ 450 0, /* bitpos */ 451 complain_overflow_signed, /* complain_on_overflow */ 452 ppc64_elf_branch_reloc, /* special_function */ 453 "R_PPC64_REL14", /* name */ 454 FALSE, /* partial_inplace */ 455 0, /* src_mask */ 456 0x0000fffc, /* dst_mask */ 457 TRUE), /* pcrel_offset */ 458 459 /* A relative 16 bit branch. Bit 10 should be set to indicate that 460 the branch is expected to be taken. The lower two bits must be 461 zero. */ 462 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */ 463 0, /* rightshift */ 464 2, /* size (0 = byte, 1 = short, 2 = long) */ 465 16, /* bitsize */ 466 TRUE, /* pc_relative */ 467 0, /* bitpos */ 468 complain_overflow_signed, /* complain_on_overflow */ 469 ppc64_elf_brtaken_reloc, /* special_function */ 470 "R_PPC64_REL14_BRTAKEN", /* name */ 471 FALSE, /* partial_inplace */ 472 0, /* src_mask */ 473 0x0000fffc, /* dst_mask */ 474 TRUE), /* pcrel_offset */ 475 476 /* A relative 16 bit branch. Bit 10 should be set to indicate that 477 the branch is not expected to be taken. The lower two bits must 478 be zero. */ 479 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */ 480 0, /* rightshift */ 481 2, /* size (0 = byte, 1 = short, 2 = long) */ 482 16, /* bitsize */ 483 TRUE, /* pc_relative */ 484 0, /* bitpos */ 485 complain_overflow_signed, /* complain_on_overflow */ 486 ppc64_elf_brtaken_reloc, /* special_function */ 487 "R_PPC64_REL14_BRNTAKEN",/* name */ 488 FALSE, /* partial_inplace */ 489 0, /* src_mask */ 490 0x0000fffc, /* dst_mask */ 491 TRUE), /* pcrel_offset */ 492 493 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the 494 symbol. */ 495 HOWTO (R_PPC64_GOT16, /* type */ 496 0, /* rightshift */ 497 1, /* size (0 = byte, 1 = short, 2 = long) */ 498 16, /* bitsize */ 499 FALSE, /* pc_relative */ 500 0, /* bitpos */ 501 complain_overflow_signed, /* complain_on_overflow */ 502 ppc64_elf_unhandled_reloc, /* special_function */ 503 "R_PPC64_GOT16", /* name */ 504 FALSE, /* partial_inplace */ 505 0, /* src_mask */ 506 0xffff, /* dst_mask */ 507 FALSE), /* pcrel_offset */ 508 509 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for 510 the symbol. */ 511 HOWTO (R_PPC64_GOT16_LO, /* type */ 512 0, /* rightshift */ 513 1, /* size (0 = byte, 1 = short, 2 = long) */ 514 16, /* bitsize */ 515 FALSE, /* pc_relative */ 516 0, /* bitpos */ 517 complain_overflow_dont, /* complain_on_overflow */ 518 ppc64_elf_unhandled_reloc, /* special_function */ 519 "R_PPC64_GOT16_LO", /* name */ 520 FALSE, /* partial_inplace */ 521 0, /* src_mask */ 522 0xffff, /* dst_mask */ 523 FALSE), /* pcrel_offset */ 524 525 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for 526 the symbol. */ 527 HOWTO (R_PPC64_GOT16_HI, /* type */ 528 16, /* rightshift */ 529 1, /* size (0 = byte, 1 = short, 2 = long) */ 530 16, /* bitsize */ 531 FALSE, /* pc_relative */ 532 0, /* bitpos */ 533 complain_overflow_signed,/* complain_on_overflow */ 534 ppc64_elf_unhandled_reloc, /* special_function */ 535 "R_PPC64_GOT16_HI", /* name */ 536 FALSE, /* partial_inplace */ 537 0, /* src_mask */ 538 0xffff, /* dst_mask */ 539 FALSE), /* pcrel_offset */ 540 541 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for 542 the symbol. */ 543 HOWTO (R_PPC64_GOT16_HA, /* type */ 544 16, /* rightshift */ 545 1, /* size (0 = byte, 1 = short, 2 = long) */ 546 16, /* bitsize */ 547 FALSE, /* pc_relative */ 548 0, /* bitpos */ 549 complain_overflow_signed,/* complain_on_overflow */ 550 ppc64_elf_unhandled_reloc, /* special_function */ 551 "R_PPC64_GOT16_HA", /* name */ 552 FALSE, /* partial_inplace */ 553 0, /* src_mask */ 554 0xffff, /* dst_mask */ 555 FALSE), /* pcrel_offset */ 556 557 /* This is used only by the dynamic linker. The symbol should exist 558 both in the object being run and in some shared library. The 559 dynamic linker copies the data addressed by the symbol from the 560 shared library into the object, because the object being 561 run has to have the data at some particular address. */ 562 HOWTO (R_PPC64_COPY, /* type */ 563 0, /* rightshift */ 564 0, /* this one is variable size */ 565 0, /* bitsize */ 566 FALSE, /* pc_relative */ 567 0, /* bitpos */ 568 complain_overflow_dont, /* complain_on_overflow */ 569 ppc64_elf_unhandled_reloc, /* special_function */ 570 "R_PPC64_COPY", /* name */ 571 FALSE, /* partial_inplace */ 572 0, /* src_mask */ 573 0, /* dst_mask */ 574 FALSE), /* pcrel_offset */ 575 576 /* Like R_PPC64_ADDR64, but used when setting global offset table 577 entries. */ 578 HOWTO (R_PPC64_GLOB_DAT, /* type */ 579 0, /* rightshift */ 580 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 581 64, /* bitsize */ 582 FALSE, /* pc_relative */ 583 0, /* bitpos */ 584 complain_overflow_dont, /* complain_on_overflow */ 585 ppc64_elf_unhandled_reloc, /* special_function */ 586 "R_PPC64_GLOB_DAT", /* name */ 587 FALSE, /* partial_inplace */ 588 0, /* src_mask */ 589 ONES (64), /* dst_mask */ 590 FALSE), /* pcrel_offset */ 591 592 /* Created by the link editor. Marks a procedure linkage table 593 entry for a symbol. */ 594 HOWTO (R_PPC64_JMP_SLOT, /* type */ 595 0, /* rightshift */ 596 0, /* size (0 = byte, 1 = short, 2 = long) */ 597 0, /* bitsize */ 598 FALSE, /* pc_relative */ 599 0, /* bitpos */ 600 complain_overflow_dont, /* complain_on_overflow */ 601 ppc64_elf_unhandled_reloc, /* special_function */ 602 "R_PPC64_JMP_SLOT", /* name */ 603 FALSE, /* partial_inplace */ 604 0, /* src_mask */ 605 0, /* dst_mask */ 606 FALSE), /* pcrel_offset */ 607 608 /* Used only by the dynamic linker. When the object is run, this 609 doubleword64 is set to the load address of the object, plus the 610 addend. */ 611 HOWTO (R_PPC64_RELATIVE, /* type */ 612 0, /* rightshift */ 613 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 614 64, /* bitsize */ 615 FALSE, /* pc_relative */ 616 0, /* bitpos */ 617 complain_overflow_dont, /* complain_on_overflow */ 618 bfd_elf_generic_reloc, /* special_function */ 619 "R_PPC64_RELATIVE", /* name */ 620 FALSE, /* partial_inplace */ 621 0, /* src_mask */ 622 ONES (64), /* dst_mask */ 623 FALSE), /* pcrel_offset */ 624 625 /* Like R_PPC64_ADDR32, but may be unaligned. */ 626 HOWTO (R_PPC64_UADDR32, /* type */ 627 0, /* rightshift */ 628 2, /* size (0 = byte, 1 = short, 2 = long) */ 629 32, /* bitsize */ 630 FALSE, /* pc_relative */ 631 0, /* bitpos */ 632 complain_overflow_bitfield, /* complain_on_overflow */ 633 bfd_elf_generic_reloc, /* special_function */ 634 "R_PPC64_UADDR32", /* name */ 635 FALSE, /* partial_inplace */ 636 0, /* src_mask */ 637 0xffffffff, /* dst_mask */ 638 FALSE), /* pcrel_offset */ 639 640 /* Like R_PPC64_ADDR16, but may be unaligned. */ 641 HOWTO (R_PPC64_UADDR16, /* type */ 642 0, /* rightshift */ 643 1, /* size (0 = byte, 1 = short, 2 = long) */ 644 16, /* bitsize */ 645 FALSE, /* pc_relative */ 646 0, /* bitpos */ 647 complain_overflow_bitfield, /* complain_on_overflow */ 648 bfd_elf_generic_reloc, /* special_function */ 649 "R_PPC64_UADDR16", /* name */ 650 FALSE, /* partial_inplace */ 651 0, /* src_mask */ 652 0xffff, /* dst_mask */ 653 FALSE), /* pcrel_offset */ 654 655 /* 32-bit PC relative. */ 656 HOWTO (R_PPC64_REL32, /* type */ 657 0, /* rightshift */ 658 2, /* size (0 = byte, 1 = short, 2 = long) */ 659 32, /* bitsize */ 660 TRUE, /* pc_relative */ 661 0, /* bitpos */ 662 complain_overflow_signed, /* complain_on_overflow */ 663 bfd_elf_generic_reloc, /* special_function */ 664 "R_PPC64_REL32", /* name */ 665 FALSE, /* partial_inplace */ 666 0, /* src_mask */ 667 0xffffffff, /* dst_mask */ 668 TRUE), /* pcrel_offset */ 669 670 /* 32-bit relocation to the symbol's procedure linkage table. */ 671 HOWTO (R_PPC64_PLT32, /* type */ 672 0, /* rightshift */ 673 2, /* size (0 = byte, 1 = short, 2 = long) */ 674 32, /* bitsize */ 675 FALSE, /* pc_relative */ 676 0, /* bitpos */ 677 complain_overflow_bitfield, /* complain_on_overflow */ 678 ppc64_elf_unhandled_reloc, /* special_function */ 679 "R_PPC64_PLT32", /* name */ 680 FALSE, /* partial_inplace */ 681 0, /* src_mask */ 682 0xffffffff, /* dst_mask */ 683 FALSE), /* pcrel_offset */ 684 685 /* 32-bit PC relative relocation to the symbol's procedure linkage table. 686 FIXME: R_PPC64_PLTREL32 not supported. */ 687 HOWTO (R_PPC64_PLTREL32, /* type */ 688 0, /* rightshift */ 689 2, /* size (0 = byte, 1 = short, 2 = long) */ 690 32, /* bitsize */ 691 TRUE, /* pc_relative */ 692 0, /* bitpos */ 693 complain_overflow_signed, /* complain_on_overflow */ 694 ppc64_elf_unhandled_reloc, /* special_function */ 695 "R_PPC64_PLTREL32", /* name */ 696 FALSE, /* partial_inplace */ 697 0, /* src_mask */ 698 0xffffffff, /* dst_mask */ 699 TRUE), /* pcrel_offset */ 700 701 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for 702 the symbol. */ 703 HOWTO (R_PPC64_PLT16_LO, /* type */ 704 0, /* rightshift */ 705 1, /* size (0 = byte, 1 = short, 2 = long) */ 706 16, /* bitsize */ 707 FALSE, /* pc_relative */ 708 0, /* bitpos */ 709 complain_overflow_dont, /* complain_on_overflow */ 710 ppc64_elf_unhandled_reloc, /* special_function */ 711 "R_PPC64_PLT16_LO", /* name */ 712 FALSE, /* partial_inplace */ 713 0, /* src_mask */ 714 0xffff, /* dst_mask */ 715 FALSE), /* pcrel_offset */ 716 717 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for 718 the symbol. */ 719 HOWTO (R_PPC64_PLT16_HI, /* type */ 720 16, /* rightshift */ 721 1, /* size (0 = byte, 1 = short, 2 = long) */ 722 16, /* bitsize */ 723 FALSE, /* pc_relative */ 724 0, /* bitpos */ 725 complain_overflow_signed, /* complain_on_overflow */ 726 ppc64_elf_unhandled_reloc, /* special_function */ 727 "R_PPC64_PLT16_HI", /* name */ 728 FALSE, /* partial_inplace */ 729 0, /* src_mask */ 730 0xffff, /* dst_mask */ 731 FALSE), /* pcrel_offset */ 732 733 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for 734 the symbol. */ 735 HOWTO (R_PPC64_PLT16_HA, /* type */ 736 16, /* rightshift */ 737 1, /* size (0 = byte, 1 = short, 2 = long) */ 738 16, /* bitsize */ 739 FALSE, /* pc_relative */ 740 0, /* bitpos */ 741 complain_overflow_signed, /* complain_on_overflow */ 742 ppc64_elf_unhandled_reloc, /* special_function */ 743 "R_PPC64_PLT16_HA", /* name */ 744 FALSE, /* partial_inplace */ 745 0, /* src_mask */ 746 0xffff, /* dst_mask */ 747 FALSE), /* pcrel_offset */ 748 749 /* 16-bit section relative relocation. */ 750 HOWTO (R_PPC64_SECTOFF, /* type */ 751 0, /* rightshift */ 752 1, /* size (0 = byte, 1 = short, 2 = long) */ 753 16, /* bitsize */ 754 FALSE, /* pc_relative */ 755 0, /* bitpos */ 756 complain_overflow_signed, /* complain_on_overflow */ 757 ppc64_elf_sectoff_reloc, /* special_function */ 758 "R_PPC64_SECTOFF", /* name */ 759 FALSE, /* partial_inplace */ 760 0, /* src_mask */ 761 0xffff, /* dst_mask */ 762 FALSE), /* pcrel_offset */ 763 764 /* Like R_PPC64_SECTOFF, but no overflow warning. */ 765 HOWTO (R_PPC64_SECTOFF_LO, /* type */ 766 0, /* rightshift */ 767 1, /* size (0 = byte, 1 = short, 2 = long) */ 768 16, /* bitsize */ 769 FALSE, /* pc_relative */ 770 0, /* bitpos */ 771 complain_overflow_dont, /* complain_on_overflow */ 772 ppc64_elf_sectoff_reloc, /* special_function */ 773 "R_PPC64_SECTOFF_LO", /* name */ 774 FALSE, /* partial_inplace */ 775 0, /* src_mask */ 776 0xffff, /* dst_mask */ 777 FALSE), /* pcrel_offset */ 778 779 /* 16-bit upper half section relative relocation. */ 780 HOWTO (R_PPC64_SECTOFF_HI, /* type */ 781 16, /* rightshift */ 782 1, /* size (0 = byte, 1 = short, 2 = long) */ 783 16, /* bitsize */ 784 FALSE, /* pc_relative */ 785 0, /* bitpos */ 786 complain_overflow_signed, /* complain_on_overflow */ 787 ppc64_elf_sectoff_reloc, /* special_function */ 788 "R_PPC64_SECTOFF_HI", /* name */ 789 FALSE, /* partial_inplace */ 790 0, /* src_mask */ 791 0xffff, /* dst_mask */ 792 FALSE), /* pcrel_offset */ 793 794 /* 16-bit upper half adjusted section relative relocation. */ 795 HOWTO (R_PPC64_SECTOFF_HA, /* type */ 796 16, /* rightshift */ 797 1, /* size (0 = byte, 1 = short, 2 = long) */ 798 16, /* bitsize */ 799 FALSE, /* pc_relative */ 800 0, /* bitpos */ 801 complain_overflow_signed, /* complain_on_overflow */ 802 ppc64_elf_sectoff_ha_reloc, /* special_function */ 803 "R_PPC64_SECTOFF_HA", /* name */ 804 FALSE, /* partial_inplace */ 805 0, /* src_mask */ 806 0xffff, /* dst_mask */ 807 FALSE), /* pcrel_offset */ 808 809 /* Like R_PPC64_REL24 without touching the two least significant bits. */ 810 HOWTO (R_PPC64_REL30, /* type */ 811 2, /* rightshift */ 812 2, /* size (0 = byte, 1 = short, 2 = long) */ 813 30, /* bitsize */ 814 TRUE, /* pc_relative */ 815 0, /* bitpos */ 816 complain_overflow_dont, /* complain_on_overflow */ 817 bfd_elf_generic_reloc, /* special_function */ 818 "R_PPC64_REL30", /* name */ 819 FALSE, /* partial_inplace */ 820 0, /* src_mask */ 821 0xfffffffc, /* dst_mask */ 822 TRUE), /* pcrel_offset */ 823 824 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */ 825 826 /* A standard 64-bit relocation. */ 827 HOWTO (R_PPC64_ADDR64, /* type */ 828 0, /* rightshift */ 829 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 830 64, /* bitsize */ 831 FALSE, /* pc_relative */ 832 0, /* bitpos */ 833 complain_overflow_dont, /* complain_on_overflow */ 834 bfd_elf_generic_reloc, /* special_function */ 835 "R_PPC64_ADDR64", /* name */ 836 FALSE, /* partial_inplace */ 837 0, /* src_mask */ 838 ONES (64), /* dst_mask */ 839 FALSE), /* pcrel_offset */ 840 841 /* The bits 32-47 of an address. */ 842 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */ 843 32, /* rightshift */ 844 1, /* size (0 = byte, 1 = short, 2 = long) */ 845 16, /* bitsize */ 846 FALSE, /* pc_relative */ 847 0, /* bitpos */ 848 complain_overflow_dont, /* complain_on_overflow */ 849 bfd_elf_generic_reloc, /* special_function */ 850 "R_PPC64_ADDR16_HIGHER", /* name */ 851 FALSE, /* partial_inplace */ 852 0, /* src_mask */ 853 0xffff, /* dst_mask */ 854 FALSE), /* pcrel_offset */ 855 856 /* The bits 32-47 of an address, plus 1 if the contents of the low 857 16 bits, treated as a signed number, is negative. */ 858 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */ 859 32, /* rightshift */ 860 1, /* size (0 = byte, 1 = short, 2 = long) */ 861 16, /* bitsize */ 862 FALSE, /* pc_relative */ 863 0, /* bitpos */ 864 complain_overflow_dont, /* complain_on_overflow */ 865 ppc64_elf_ha_reloc, /* special_function */ 866 "R_PPC64_ADDR16_HIGHERA", /* name */ 867 FALSE, /* partial_inplace */ 868 0, /* src_mask */ 869 0xffff, /* dst_mask */ 870 FALSE), /* pcrel_offset */ 871 872 /* The bits 48-63 of an address. */ 873 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */ 874 48, /* rightshift */ 875 1, /* size (0 = byte, 1 = short, 2 = long) */ 876 16, /* bitsize */ 877 FALSE, /* pc_relative */ 878 0, /* bitpos */ 879 complain_overflow_dont, /* complain_on_overflow */ 880 bfd_elf_generic_reloc, /* special_function */ 881 "R_PPC64_ADDR16_HIGHEST", /* name */ 882 FALSE, /* partial_inplace */ 883 0, /* src_mask */ 884 0xffff, /* dst_mask */ 885 FALSE), /* pcrel_offset */ 886 887 /* The bits 48-63 of an address, plus 1 if the contents of the low 888 16 bits, treated as a signed number, is negative. */ 889 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */ 890 48, /* rightshift */ 891 1, /* size (0 = byte, 1 = short, 2 = long) */ 892 16, /* bitsize */ 893 FALSE, /* pc_relative */ 894 0, /* bitpos */ 895 complain_overflow_dont, /* complain_on_overflow */ 896 ppc64_elf_ha_reloc, /* special_function */ 897 "R_PPC64_ADDR16_HIGHESTA", /* name */ 898 FALSE, /* partial_inplace */ 899 0, /* src_mask */ 900 0xffff, /* dst_mask */ 901 FALSE), /* pcrel_offset */ 902 903 /* Like ADDR64, but may be unaligned. */ 904 HOWTO (R_PPC64_UADDR64, /* type */ 905 0, /* rightshift */ 906 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 907 64, /* bitsize */ 908 FALSE, /* pc_relative */ 909 0, /* bitpos */ 910 complain_overflow_dont, /* complain_on_overflow */ 911 bfd_elf_generic_reloc, /* special_function */ 912 "R_PPC64_UADDR64", /* name */ 913 FALSE, /* partial_inplace */ 914 0, /* src_mask */ 915 ONES (64), /* dst_mask */ 916 FALSE), /* pcrel_offset */ 917 918 /* 64-bit relative relocation. */ 919 HOWTO (R_PPC64_REL64, /* type */ 920 0, /* rightshift */ 921 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 922 64, /* bitsize */ 923 TRUE, /* pc_relative */ 924 0, /* bitpos */ 925 complain_overflow_dont, /* complain_on_overflow */ 926 bfd_elf_generic_reloc, /* special_function */ 927 "R_PPC64_REL64", /* name */ 928 FALSE, /* partial_inplace */ 929 0, /* src_mask */ 930 ONES (64), /* dst_mask */ 931 TRUE), /* pcrel_offset */ 932 933 /* 64-bit relocation to the symbol's procedure linkage table. */ 934 HOWTO (R_PPC64_PLT64, /* type */ 935 0, /* rightshift */ 936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 937 64, /* bitsize */ 938 FALSE, /* pc_relative */ 939 0, /* bitpos */ 940 complain_overflow_dont, /* complain_on_overflow */ 941 ppc64_elf_unhandled_reloc, /* special_function */ 942 "R_PPC64_PLT64", /* name */ 943 FALSE, /* partial_inplace */ 944 0, /* src_mask */ 945 ONES (64), /* dst_mask */ 946 FALSE), /* pcrel_offset */ 947 948 /* 64-bit PC relative relocation to the symbol's procedure linkage 949 table. */ 950 /* FIXME: R_PPC64_PLTREL64 not supported. */ 951 HOWTO (R_PPC64_PLTREL64, /* type */ 952 0, /* rightshift */ 953 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 954 64, /* bitsize */ 955 TRUE, /* pc_relative */ 956 0, /* bitpos */ 957 complain_overflow_dont, /* complain_on_overflow */ 958 ppc64_elf_unhandled_reloc, /* special_function */ 959 "R_PPC64_PLTREL64", /* name */ 960 FALSE, /* partial_inplace */ 961 0, /* src_mask */ 962 ONES (64), /* dst_mask */ 963 TRUE), /* pcrel_offset */ 964 965 /* 16 bit TOC-relative relocation. */ 966 967 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */ 968 HOWTO (R_PPC64_TOC16, /* type */ 969 0, /* rightshift */ 970 1, /* size (0 = byte, 1 = short, 2 = long) */ 971 16, /* bitsize */ 972 FALSE, /* pc_relative */ 973 0, /* bitpos */ 974 complain_overflow_signed, /* complain_on_overflow */ 975 ppc64_elf_toc_reloc, /* special_function */ 976 "R_PPC64_TOC16", /* name */ 977 FALSE, /* partial_inplace */ 978 0, /* src_mask */ 979 0xffff, /* dst_mask */ 980 FALSE), /* pcrel_offset */ 981 982 /* 16 bit TOC-relative relocation without overflow. */ 983 984 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */ 985 HOWTO (R_PPC64_TOC16_LO, /* type */ 986 0, /* rightshift */ 987 1, /* size (0 = byte, 1 = short, 2 = long) */ 988 16, /* bitsize */ 989 FALSE, /* pc_relative */ 990 0, /* bitpos */ 991 complain_overflow_dont, /* complain_on_overflow */ 992 ppc64_elf_toc_reloc, /* special_function */ 993 "R_PPC64_TOC16_LO", /* name */ 994 FALSE, /* partial_inplace */ 995 0, /* src_mask */ 996 0xffff, /* dst_mask */ 997 FALSE), /* pcrel_offset */ 998 999 /* 16 bit TOC-relative relocation, high 16 bits. */ 1000 1001 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */ 1002 HOWTO (R_PPC64_TOC16_HI, /* type */ 1003 16, /* rightshift */ 1004 1, /* size (0 = byte, 1 = short, 2 = long) */ 1005 16, /* bitsize */ 1006 FALSE, /* pc_relative */ 1007 0, /* bitpos */ 1008 complain_overflow_signed, /* complain_on_overflow */ 1009 ppc64_elf_toc_reloc, /* special_function */ 1010 "R_PPC64_TOC16_HI", /* name */ 1011 FALSE, /* partial_inplace */ 1012 0, /* src_mask */ 1013 0xffff, /* dst_mask */ 1014 FALSE), /* pcrel_offset */ 1015 1016 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the 1017 contents of the low 16 bits, treated as a signed number, is 1018 negative. */ 1019 1020 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */ 1021 HOWTO (R_PPC64_TOC16_HA, /* type */ 1022 16, /* rightshift */ 1023 1, /* size (0 = byte, 1 = short, 2 = long) */ 1024 16, /* bitsize */ 1025 FALSE, /* pc_relative */ 1026 0, /* bitpos */ 1027 complain_overflow_signed, /* complain_on_overflow */ 1028 ppc64_elf_toc_ha_reloc, /* special_function */ 1029 "R_PPC64_TOC16_HA", /* name */ 1030 FALSE, /* partial_inplace */ 1031 0, /* src_mask */ 1032 0xffff, /* dst_mask */ 1033 FALSE), /* pcrel_offset */ 1034 1035 /* 64-bit relocation; insert value of TOC base (.TOC.). */ 1036 1037 /* R_PPC64_TOC 51 doubleword64 .TOC. */ 1038 HOWTO (R_PPC64_TOC, /* type */ 1039 0, /* rightshift */ 1040 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 1041 64, /* bitsize */ 1042 FALSE, /* pc_relative */ 1043 0, /* bitpos */ 1044 complain_overflow_dont, /* complain_on_overflow */ 1045 ppc64_elf_toc64_reloc, /* special_function */ 1046 "R_PPC64_TOC", /* name */ 1047 FALSE, /* partial_inplace */ 1048 0, /* src_mask */ 1049 ONES (64), /* dst_mask */ 1050 FALSE), /* pcrel_offset */ 1051 1052 /* Like R_PPC64_GOT16, but also informs the link editor that the 1053 value to relocate may (!) refer to a PLT entry which the link 1054 editor (a) may replace with the symbol value. If the link editor 1055 is unable to fully resolve the symbol, it may (b) create a PLT 1056 entry and store the address to the new PLT entry in the GOT. 1057 This permits lazy resolution of function symbols at run time. 1058 The link editor may also skip all of this and just (c) emit a 1059 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */ 1060 /* FIXME: R_PPC64_PLTGOT16 not implemented. */ 1061 HOWTO (R_PPC64_PLTGOT16, /* type */ 1062 0, /* rightshift */ 1063 1, /* size (0 = byte, 1 = short, 2 = long) */ 1064 16, /* bitsize */ 1065 FALSE, /* pc_relative */ 1066 0, /* bitpos */ 1067 complain_overflow_signed, /* complain_on_overflow */ 1068 ppc64_elf_unhandled_reloc, /* special_function */ 1069 "R_PPC64_PLTGOT16", /* name */ 1070 FALSE, /* partial_inplace */ 1071 0, /* src_mask */ 1072 0xffff, /* dst_mask */ 1073 FALSE), /* pcrel_offset */ 1074 1075 /* Like R_PPC64_PLTGOT16, but without overflow. */ 1076 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */ 1077 HOWTO (R_PPC64_PLTGOT16_LO, /* type */ 1078 0, /* rightshift */ 1079 1, /* size (0 = byte, 1 = short, 2 = long) */ 1080 16, /* bitsize */ 1081 FALSE, /* pc_relative */ 1082 0, /* bitpos */ 1083 complain_overflow_dont, /* complain_on_overflow */ 1084 ppc64_elf_unhandled_reloc, /* special_function */ 1085 "R_PPC64_PLTGOT16_LO", /* name */ 1086 FALSE, /* partial_inplace */ 1087 0, /* src_mask */ 1088 0xffff, /* dst_mask */ 1089 FALSE), /* pcrel_offset */ 1090 1091 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */ 1092 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */ 1093 HOWTO (R_PPC64_PLTGOT16_HI, /* type */ 1094 16, /* rightshift */ 1095 1, /* size (0 = byte, 1 = short, 2 = long) */ 1096 16, /* bitsize */ 1097 FALSE, /* pc_relative */ 1098 0, /* bitpos */ 1099 complain_overflow_signed, /* complain_on_overflow */ 1100 ppc64_elf_unhandled_reloc, /* special_function */ 1101 "R_PPC64_PLTGOT16_HI", /* name */ 1102 FALSE, /* partial_inplace */ 1103 0, /* src_mask */ 1104 0xffff, /* dst_mask */ 1105 FALSE), /* pcrel_offset */ 1106 1107 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus 1108 1 if the contents of the low 16 bits, treated as a signed number, 1109 is negative. */ 1110 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */ 1111 HOWTO (R_PPC64_PLTGOT16_HA, /* type */ 1112 16, /* rightshift */ 1113 1, /* size (0 = byte, 1 = short, 2 = long) */ 1114 16, /* bitsize */ 1115 FALSE, /* pc_relative */ 1116 0, /* bitpos */ 1117 complain_overflow_signed, /* complain_on_overflow */ 1118 ppc64_elf_unhandled_reloc, /* special_function */ 1119 "R_PPC64_PLTGOT16_HA", /* name */ 1120 FALSE, /* partial_inplace */ 1121 0, /* src_mask */ 1122 0xffff, /* dst_mask */ 1123 FALSE), /* pcrel_offset */ 1124 1125 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */ 1126 HOWTO (R_PPC64_ADDR16_DS, /* type */ 1127 0, /* rightshift */ 1128 1, /* size (0 = byte, 1 = short, 2 = long) */ 1129 16, /* bitsize */ 1130 FALSE, /* pc_relative */ 1131 0, /* bitpos */ 1132 complain_overflow_signed, /* complain_on_overflow */ 1133 bfd_elf_generic_reloc, /* special_function */ 1134 "R_PPC64_ADDR16_DS", /* name */ 1135 FALSE, /* partial_inplace */ 1136 0, /* src_mask */ 1137 0xfffc, /* dst_mask */ 1138 FALSE), /* pcrel_offset */ 1139 1140 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */ 1141 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */ 1142 0, /* rightshift */ 1143 1, /* size (0 = byte, 1 = short, 2 = long) */ 1144 16, /* bitsize */ 1145 FALSE, /* pc_relative */ 1146 0, /* bitpos */ 1147 complain_overflow_dont,/* complain_on_overflow */ 1148 bfd_elf_generic_reloc, /* special_function */ 1149 "R_PPC64_ADDR16_LO_DS",/* name */ 1150 FALSE, /* partial_inplace */ 1151 0, /* src_mask */ 1152 0xfffc, /* dst_mask */ 1153 FALSE), /* pcrel_offset */ 1154 1155 /* Like R_PPC64_GOT16, but for instructions with a DS field. */ 1156 HOWTO (R_PPC64_GOT16_DS, /* type */ 1157 0, /* rightshift */ 1158 1, /* size (0 = byte, 1 = short, 2 = long) */ 1159 16, /* bitsize */ 1160 FALSE, /* pc_relative */ 1161 0, /* bitpos */ 1162 complain_overflow_signed, /* complain_on_overflow */ 1163 ppc64_elf_unhandled_reloc, /* special_function */ 1164 "R_PPC64_GOT16_DS", /* name */ 1165 FALSE, /* partial_inplace */ 1166 0, /* src_mask */ 1167 0xfffc, /* dst_mask */ 1168 FALSE), /* pcrel_offset */ 1169 1170 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */ 1171 HOWTO (R_PPC64_GOT16_LO_DS, /* type */ 1172 0, /* rightshift */ 1173 1, /* size (0 = byte, 1 = short, 2 = long) */ 1174 16, /* bitsize */ 1175 FALSE, /* pc_relative */ 1176 0, /* bitpos */ 1177 complain_overflow_dont, /* complain_on_overflow */ 1178 ppc64_elf_unhandled_reloc, /* special_function */ 1179 "R_PPC64_GOT16_LO_DS", /* name */ 1180 FALSE, /* partial_inplace */ 1181 0, /* src_mask */ 1182 0xfffc, /* dst_mask */ 1183 FALSE), /* pcrel_offset */ 1184 1185 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */ 1186 HOWTO (R_PPC64_PLT16_LO_DS, /* type */ 1187 0, /* rightshift */ 1188 1, /* size (0 = byte, 1 = short, 2 = long) */ 1189 16, /* bitsize */ 1190 FALSE, /* pc_relative */ 1191 0, /* bitpos */ 1192 complain_overflow_dont, /* complain_on_overflow */ 1193 ppc64_elf_unhandled_reloc, /* special_function */ 1194 "R_PPC64_PLT16_LO_DS", /* name */ 1195 FALSE, /* partial_inplace */ 1196 0, /* src_mask */ 1197 0xfffc, /* dst_mask */ 1198 FALSE), /* pcrel_offset */ 1199 1200 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */ 1201 HOWTO (R_PPC64_SECTOFF_DS, /* type */ 1202 0, /* rightshift */ 1203 1, /* size (0 = byte, 1 = short, 2 = long) */ 1204 16, /* bitsize */ 1205 FALSE, /* pc_relative */ 1206 0, /* bitpos */ 1207 complain_overflow_signed, /* complain_on_overflow */ 1208 ppc64_elf_sectoff_reloc, /* special_function */ 1209 "R_PPC64_SECTOFF_DS", /* name */ 1210 FALSE, /* partial_inplace */ 1211 0, /* src_mask */ 1212 0xfffc, /* dst_mask */ 1213 FALSE), /* pcrel_offset */ 1214 1215 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */ 1216 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */ 1217 0, /* rightshift */ 1218 1, /* size (0 = byte, 1 = short, 2 = long) */ 1219 16, /* bitsize */ 1220 FALSE, /* pc_relative */ 1221 0, /* bitpos */ 1222 complain_overflow_dont, /* complain_on_overflow */ 1223 ppc64_elf_sectoff_reloc, /* special_function */ 1224 "R_PPC64_SECTOFF_LO_DS",/* name */ 1225 FALSE, /* partial_inplace */ 1226 0, /* src_mask */ 1227 0xfffc, /* dst_mask */ 1228 FALSE), /* pcrel_offset */ 1229 1230 /* Like R_PPC64_TOC16, but for instructions with a DS field. */ 1231 HOWTO (R_PPC64_TOC16_DS, /* type */ 1232 0, /* rightshift */ 1233 1, /* size (0 = byte, 1 = short, 2 = long) */ 1234 16, /* bitsize */ 1235 FALSE, /* pc_relative */ 1236 0, /* bitpos */ 1237 complain_overflow_signed, /* complain_on_overflow */ 1238 ppc64_elf_toc_reloc, /* special_function */ 1239 "R_PPC64_TOC16_DS", /* name */ 1240 FALSE, /* partial_inplace */ 1241 0, /* src_mask */ 1242 0xfffc, /* dst_mask */ 1243 FALSE), /* pcrel_offset */ 1244 1245 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */ 1246 HOWTO (R_PPC64_TOC16_LO_DS, /* type */ 1247 0, /* rightshift */ 1248 1, /* size (0 = byte, 1 = short, 2 = long) */ 1249 16, /* bitsize */ 1250 FALSE, /* pc_relative */ 1251 0, /* bitpos */ 1252 complain_overflow_dont, /* complain_on_overflow */ 1253 ppc64_elf_toc_reloc, /* special_function */ 1254 "R_PPC64_TOC16_LO_DS", /* name */ 1255 FALSE, /* partial_inplace */ 1256 0, /* src_mask */ 1257 0xfffc, /* dst_mask */ 1258 FALSE), /* pcrel_offset */ 1259 1260 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */ 1261 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */ 1262 HOWTO (R_PPC64_PLTGOT16_DS, /* type */ 1263 0, /* rightshift */ 1264 1, /* size (0 = byte, 1 = short, 2 = long) */ 1265 16, /* bitsize */ 1266 FALSE, /* pc_relative */ 1267 0, /* bitpos */ 1268 complain_overflow_signed, /* complain_on_overflow */ 1269 ppc64_elf_unhandled_reloc, /* special_function */ 1270 "R_PPC64_PLTGOT16_DS", /* name */ 1271 FALSE, /* partial_inplace */ 1272 0, /* src_mask */ 1273 0xfffc, /* dst_mask */ 1274 FALSE), /* pcrel_offset */ 1275 1276 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */ 1277 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */ 1278 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */ 1279 0, /* rightshift */ 1280 1, /* size (0 = byte, 1 = short, 2 = long) */ 1281 16, /* bitsize */ 1282 FALSE, /* pc_relative */ 1283 0, /* bitpos */ 1284 complain_overflow_dont, /* complain_on_overflow */ 1285 ppc64_elf_unhandled_reloc, /* special_function */ 1286 "R_PPC64_PLTGOT16_LO_DS",/* name */ 1287 FALSE, /* partial_inplace */ 1288 0, /* src_mask */ 1289 0xfffc, /* dst_mask */ 1290 FALSE), /* pcrel_offset */ 1291 1292 /* Marker relocs for TLS. */ 1293 HOWTO (R_PPC64_TLS, 1294 0, /* rightshift */ 1295 2, /* size (0 = byte, 1 = short, 2 = long) */ 1296 32, /* bitsize */ 1297 FALSE, /* pc_relative */ 1298 0, /* bitpos */ 1299 complain_overflow_dont, /* complain_on_overflow */ 1300 bfd_elf_generic_reloc, /* special_function */ 1301 "R_PPC64_TLS", /* name */ 1302 FALSE, /* partial_inplace */ 1303 0, /* src_mask */ 1304 0, /* dst_mask */ 1305 FALSE), /* pcrel_offset */ 1306 1307 HOWTO (R_PPC64_TLSGD, 1308 0, /* rightshift */ 1309 2, /* size (0 = byte, 1 = short, 2 = long) */ 1310 32, /* bitsize */ 1311 FALSE, /* pc_relative */ 1312 0, /* bitpos */ 1313 complain_overflow_dont, /* complain_on_overflow */ 1314 bfd_elf_generic_reloc, /* special_function */ 1315 "R_PPC64_TLSGD", /* name */ 1316 FALSE, /* partial_inplace */ 1317 0, /* src_mask */ 1318 0, /* dst_mask */ 1319 FALSE), /* pcrel_offset */ 1320 1321 HOWTO (R_PPC64_TLSLD, 1322 0, /* rightshift */ 1323 2, /* size (0 = byte, 1 = short, 2 = long) */ 1324 32, /* bitsize */ 1325 FALSE, /* pc_relative */ 1326 0, /* bitpos */ 1327 complain_overflow_dont, /* complain_on_overflow */ 1328 bfd_elf_generic_reloc, /* special_function */ 1329 "R_PPC64_TLSLD", /* name */ 1330 FALSE, /* partial_inplace */ 1331 0, /* src_mask */ 1332 0, /* dst_mask */ 1333 FALSE), /* pcrel_offset */ 1334 1335 HOWTO (R_PPC64_TOCSAVE, 1336 0, /* rightshift */ 1337 2, /* size (0 = byte, 1 = short, 2 = long) */ 1338 32, /* bitsize */ 1339 FALSE, /* pc_relative */ 1340 0, /* bitpos */ 1341 complain_overflow_dont, /* complain_on_overflow */ 1342 bfd_elf_generic_reloc, /* special_function */ 1343 "R_PPC64_TOCSAVE", /* name */ 1344 FALSE, /* partial_inplace */ 1345 0, /* src_mask */ 1346 0, /* dst_mask */ 1347 FALSE), /* pcrel_offset */ 1348 1349 /* Computes the load module index of the load module that contains the 1350 definition of its TLS sym. */ 1351 HOWTO (R_PPC64_DTPMOD64, 1352 0, /* rightshift */ 1353 4, /* size (0 = byte, 1 = short, 2 = long) */ 1354 64, /* bitsize */ 1355 FALSE, /* pc_relative */ 1356 0, /* bitpos */ 1357 complain_overflow_dont, /* complain_on_overflow */ 1358 ppc64_elf_unhandled_reloc, /* special_function */ 1359 "R_PPC64_DTPMOD64", /* name */ 1360 FALSE, /* partial_inplace */ 1361 0, /* src_mask */ 1362 ONES (64), /* dst_mask */ 1363 FALSE), /* pcrel_offset */ 1364 1365 /* Computes a dtv-relative displacement, the difference between the value 1366 of sym+add and the base address of the thread-local storage block that 1367 contains the definition of sym, minus 0x8000. */ 1368 HOWTO (R_PPC64_DTPREL64, 1369 0, /* rightshift */ 1370 4, /* size (0 = byte, 1 = short, 2 = long) */ 1371 64, /* bitsize */ 1372 FALSE, /* pc_relative */ 1373 0, /* bitpos */ 1374 complain_overflow_dont, /* complain_on_overflow */ 1375 ppc64_elf_unhandled_reloc, /* special_function */ 1376 "R_PPC64_DTPREL64", /* name */ 1377 FALSE, /* partial_inplace */ 1378 0, /* src_mask */ 1379 ONES (64), /* dst_mask */ 1380 FALSE), /* pcrel_offset */ 1381 1382 /* A 16 bit dtprel reloc. */ 1383 HOWTO (R_PPC64_DTPREL16, 1384 0, /* rightshift */ 1385 1, /* size (0 = byte, 1 = short, 2 = long) */ 1386 16, /* bitsize */ 1387 FALSE, /* pc_relative */ 1388 0, /* bitpos */ 1389 complain_overflow_signed, /* complain_on_overflow */ 1390 ppc64_elf_unhandled_reloc, /* special_function */ 1391 "R_PPC64_DTPREL16", /* name */ 1392 FALSE, /* partial_inplace */ 1393 0, /* src_mask */ 1394 0xffff, /* dst_mask */ 1395 FALSE), /* pcrel_offset */ 1396 1397 /* Like DTPREL16, but no overflow. */ 1398 HOWTO (R_PPC64_DTPREL16_LO, 1399 0, /* rightshift */ 1400 1, /* size (0 = byte, 1 = short, 2 = long) */ 1401 16, /* bitsize */ 1402 FALSE, /* pc_relative */ 1403 0, /* bitpos */ 1404 complain_overflow_dont, /* complain_on_overflow */ 1405 ppc64_elf_unhandled_reloc, /* special_function */ 1406 "R_PPC64_DTPREL16_LO", /* name */ 1407 FALSE, /* partial_inplace */ 1408 0, /* src_mask */ 1409 0xffff, /* dst_mask */ 1410 FALSE), /* pcrel_offset */ 1411 1412 /* Like DTPREL16_LO, but next higher group of 16 bits. */ 1413 HOWTO (R_PPC64_DTPREL16_HI, 1414 16, /* rightshift */ 1415 1, /* size (0 = byte, 1 = short, 2 = long) */ 1416 16, /* bitsize */ 1417 FALSE, /* pc_relative */ 1418 0, /* bitpos */ 1419 complain_overflow_signed, /* complain_on_overflow */ 1420 ppc64_elf_unhandled_reloc, /* special_function */ 1421 "R_PPC64_DTPREL16_HI", /* name */ 1422 FALSE, /* partial_inplace */ 1423 0, /* src_mask */ 1424 0xffff, /* dst_mask */ 1425 FALSE), /* pcrel_offset */ 1426 1427 /* Like DTPREL16_HI, but adjust for low 16 bits. */ 1428 HOWTO (R_PPC64_DTPREL16_HA, 1429 16, /* rightshift */ 1430 1, /* size (0 = byte, 1 = short, 2 = long) */ 1431 16, /* bitsize */ 1432 FALSE, /* pc_relative */ 1433 0, /* bitpos */ 1434 complain_overflow_signed, /* complain_on_overflow */ 1435 ppc64_elf_unhandled_reloc, /* special_function */ 1436 "R_PPC64_DTPREL16_HA", /* name */ 1437 FALSE, /* partial_inplace */ 1438 0, /* src_mask */ 1439 0xffff, /* dst_mask */ 1440 FALSE), /* pcrel_offset */ 1441 1442 /* Like DTPREL16_HI, but next higher group of 16 bits. */ 1443 HOWTO (R_PPC64_DTPREL16_HIGHER, 1444 32, /* rightshift */ 1445 1, /* size (0 = byte, 1 = short, 2 = long) */ 1446 16, /* bitsize */ 1447 FALSE, /* pc_relative */ 1448 0, /* bitpos */ 1449 complain_overflow_dont, /* complain_on_overflow */ 1450 ppc64_elf_unhandled_reloc, /* special_function */ 1451 "R_PPC64_DTPREL16_HIGHER", /* name */ 1452 FALSE, /* partial_inplace */ 1453 0, /* src_mask */ 1454 0xffff, /* dst_mask */ 1455 FALSE), /* pcrel_offset */ 1456 1457 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */ 1458 HOWTO (R_PPC64_DTPREL16_HIGHERA, 1459 32, /* rightshift */ 1460 1, /* size (0 = byte, 1 = short, 2 = long) */ 1461 16, /* bitsize */ 1462 FALSE, /* pc_relative */ 1463 0, /* bitpos */ 1464 complain_overflow_dont, /* complain_on_overflow */ 1465 ppc64_elf_unhandled_reloc, /* special_function */ 1466 "R_PPC64_DTPREL16_HIGHERA", /* name */ 1467 FALSE, /* partial_inplace */ 1468 0, /* src_mask */ 1469 0xffff, /* dst_mask */ 1470 FALSE), /* pcrel_offset */ 1471 1472 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */ 1473 HOWTO (R_PPC64_DTPREL16_HIGHEST, 1474 48, /* rightshift */ 1475 1, /* size (0 = byte, 1 = short, 2 = long) */ 1476 16, /* bitsize */ 1477 FALSE, /* pc_relative */ 1478 0, /* bitpos */ 1479 complain_overflow_dont, /* complain_on_overflow */ 1480 ppc64_elf_unhandled_reloc, /* special_function */ 1481 "R_PPC64_DTPREL16_HIGHEST", /* name */ 1482 FALSE, /* partial_inplace */ 1483 0, /* src_mask */ 1484 0xffff, /* dst_mask */ 1485 FALSE), /* pcrel_offset */ 1486 1487 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */ 1488 HOWTO (R_PPC64_DTPREL16_HIGHESTA, 1489 48, /* rightshift */ 1490 1, /* size (0 = byte, 1 = short, 2 = long) */ 1491 16, /* bitsize */ 1492 FALSE, /* pc_relative */ 1493 0, /* bitpos */ 1494 complain_overflow_dont, /* complain_on_overflow */ 1495 ppc64_elf_unhandled_reloc, /* special_function */ 1496 "R_PPC64_DTPREL16_HIGHESTA", /* name */ 1497 FALSE, /* partial_inplace */ 1498 0, /* src_mask */ 1499 0xffff, /* dst_mask */ 1500 FALSE), /* pcrel_offset */ 1501 1502 /* Like DTPREL16, but for insns with a DS field. */ 1503 HOWTO (R_PPC64_DTPREL16_DS, 1504 0, /* rightshift */ 1505 1, /* size (0 = byte, 1 = short, 2 = long) */ 1506 16, /* bitsize */ 1507 FALSE, /* pc_relative */ 1508 0, /* bitpos */ 1509 complain_overflow_signed, /* complain_on_overflow */ 1510 ppc64_elf_unhandled_reloc, /* special_function */ 1511 "R_PPC64_DTPREL16_DS", /* name */ 1512 FALSE, /* partial_inplace */ 1513 0, /* src_mask */ 1514 0xfffc, /* dst_mask */ 1515 FALSE), /* pcrel_offset */ 1516 1517 /* Like DTPREL16_DS, but no overflow. */ 1518 HOWTO (R_PPC64_DTPREL16_LO_DS, 1519 0, /* rightshift */ 1520 1, /* size (0 = byte, 1 = short, 2 = long) */ 1521 16, /* bitsize */ 1522 FALSE, /* pc_relative */ 1523 0, /* bitpos */ 1524 complain_overflow_dont, /* complain_on_overflow */ 1525 ppc64_elf_unhandled_reloc, /* special_function */ 1526 "R_PPC64_DTPREL16_LO_DS", /* name */ 1527 FALSE, /* partial_inplace */ 1528 0, /* src_mask */ 1529 0xfffc, /* dst_mask */ 1530 FALSE), /* pcrel_offset */ 1531 1532 /* Computes a tp-relative displacement, the difference between the value of 1533 sym+add and the value of the thread pointer (r13). */ 1534 HOWTO (R_PPC64_TPREL64, 1535 0, /* rightshift */ 1536 4, /* size (0 = byte, 1 = short, 2 = long) */ 1537 64, /* bitsize */ 1538 FALSE, /* pc_relative */ 1539 0, /* bitpos */ 1540 complain_overflow_dont, /* complain_on_overflow */ 1541 ppc64_elf_unhandled_reloc, /* special_function */ 1542 "R_PPC64_TPREL64", /* name */ 1543 FALSE, /* partial_inplace */ 1544 0, /* src_mask */ 1545 ONES (64), /* dst_mask */ 1546 FALSE), /* pcrel_offset */ 1547 1548 /* A 16 bit tprel reloc. */ 1549 HOWTO (R_PPC64_TPREL16, 1550 0, /* rightshift */ 1551 1, /* size (0 = byte, 1 = short, 2 = long) */ 1552 16, /* bitsize */ 1553 FALSE, /* pc_relative */ 1554 0, /* bitpos */ 1555 complain_overflow_signed, /* complain_on_overflow */ 1556 ppc64_elf_unhandled_reloc, /* special_function */ 1557 "R_PPC64_TPREL16", /* name */ 1558 FALSE, /* partial_inplace */ 1559 0, /* src_mask */ 1560 0xffff, /* dst_mask */ 1561 FALSE), /* pcrel_offset */ 1562 1563 /* Like TPREL16, but no overflow. */ 1564 HOWTO (R_PPC64_TPREL16_LO, 1565 0, /* rightshift */ 1566 1, /* size (0 = byte, 1 = short, 2 = long) */ 1567 16, /* bitsize */ 1568 FALSE, /* pc_relative */ 1569 0, /* bitpos */ 1570 complain_overflow_dont, /* complain_on_overflow */ 1571 ppc64_elf_unhandled_reloc, /* special_function */ 1572 "R_PPC64_TPREL16_LO", /* name */ 1573 FALSE, /* partial_inplace */ 1574 0, /* src_mask */ 1575 0xffff, /* dst_mask */ 1576 FALSE), /* pcrel_offset */ 1577 1578 /* Like TPREL16_LO, but next higher group of 16 bits. */ 1579 HOWTO (R_PPC64_TPREL16_HI, 1580 16, /* rightshift */ 1581 1, /* size (0 = byte, 1 = short, 2 = long) */ 1582 16, /* bitsize */ 1583 FALSE, /* pc_relative */ 1584 0, /* bitpos */ 1585 complain_overflow_signed, /* complain_on_overflow */ 1586 ppc64_elf_unhandled_reloc, /* special_function */ 1587 "R_PPC64_TPREL16_HI", /* name */ 1588 FALSE, /* partial_inplace */ 1589 0, /* src_mask */ 1590 0xffff, /* dst_mask */ 1591 FALSE), /* pcrel_offset */ 1592 1593 /* Like TPREL16_HI, but adjust for low 16 bits. */ 1594 HOWTO (R_PPC64_TPREL16_HA, 1595 16, /* rightshift */ 1596 1, /* size (0 = byte, 1 = short, 2 = long) */ 1597 16, /* bitsize */ 1598 FALSE, /* pc_relative */ 1599 0, /* bitpos */ 1600 complain_overflow_signed, /* complain_on_overflow */ 1601 ppc64_elf_unhandled_reloc, /* special_function */ 1602 "R_PPC64_TPREL16_HA", /* name */ 1603 FALSE, /* partial_inplace */ 1604 0, /* src_mask */ 1605 0xffff, /* dst_mask */ 1606 FALSE), /* pcrel_offset */ 1607 1608 /* Like TPREL16_HI, but next higher group of 16 bits. */ 1609 HOWTO (R_PPC64_TPREL16_HIGHER, 1610 32, /* rightshift */ 1611 1, /* size (0 = byte, 1 = short, 2 = long) */ 1612 16, /* bitsize */ 1613 FALSE, /* pc_relative */ 1614 0, /* bitpos */ 1615 complain_overflow_dont, /* complain_on_overflow */ 1616 ppc64_elf_unhandled_reloc, /* special_function */ 1617 "R_PPC64_TPREL16_HIGHER", /* name */ 1618 FALSE, /* partial_inplace */ 1619 0, /* src_mask */ 1620 0xffff, /* dst_mask */ 1621 FALSE), /* pcrel_offset */ 1622 1623 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */ 1624 HOWTO (R_PPC64_TPREL16_HIGHERA, 1625 32, /* rightshift */ 1626 1, /* size (0 = byte, 1 = short, 2 = long) */ 1627 16, /* bitsize */ 1628 FALSE, /* pc_relative */ 1629 0, /* bitpos */ 1630 complain_overflow_dont, /* complain_on_overflow */ 1631 ppc64_elf_unhandled_reloc, /* special_function */ 1632 "R_PPC64_TPREL16_HIGHERA", /* name */ 1633 FALSE, /* partial_inplace */ 1634 0, /* src_mask */ 1635 0xffff, /* dst_mask */ 1636 FALSE), /* pcrel_offset */ 1637 1638 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */ 1639 HOWTO (R_PPC64_TPREL16_HIGHEST, 1640 48, /* rightshift */ 1641 1, /* size (0 = byte, 1 = short, 2 = long) */ 1642 16, /* bitsize */ 1643 FALSE, /* pc_relative */ 1644 0, /* bitpos */ 1645 complain_overflow_dont, /* complain_on_overflow */ 1646 ppc64_elf_unhandled_reloc, /* special_function */ 1647 "R_PPC64_TPREL16_HIGHEST", /* name */ 1648 FALSE, /* partial_inplace */ 1649 0, /* src_mask */ 1650 0xffff, /* dst_mask */ 1651 FALSE), /* pcrel_offset */ 1652 1653 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */ 1654 HOWTO (R_PPC64_TPREL16_HIGHESTA, 1655 48, /* rightshift */ 1656 1, /* size (0 = byte, 1 = short, 2 = long) */ 1657 16, /* bitsize */ 1658 FALSE, /* pc_relative */ 1659 0, /* bitpos */ 1660 complain_overflow_dont, /* complain_on_overflow */ 1661 ppc64_elf_unhandled_reloc, /* special_function */ 1662 "R_PPC64_TPREL16_HIGHESTA", /* name */ 1663 FALSE, /* partial_inplace */ 1664 0, /* src_mask */ 1665 0xffff, /* dst_mask */ 1666 FALSE), /* pcrel_offset */ 1667 1668 /* Like TPREL16, but for insns with a DS field. */ 1669 HOWTO (R_PPC64_TPREL16_DS, 1670 0, /* rightshift */ 1671 1, /* size (0 = byte, 1 = short, 2 = long) */ 1672 16, /* bitsize */ 1673 FALSE, /* pc_relative */ 1674 0, /* bitpos */ 1675 complain_overflow_signed, /* complain_on_overflow */ 1676 ppc64_elf_unhandled_reloc, /* special_function */ 1677 "R_PPC64_TPREL16_DS", /* name */ 1678 FALSE, /* partial_inplace */ 1679 0, /* src_mask */ 1680 0xfffc, /* dst_mask */ 1681 FALSE), /* pcrel_offset */ 1682 1683 /* Like TPREL16_DS, but no overflow. */ 1684 HOWTO (R_PPC64_TPREL16_LO_DS, 1685 0, /* rightshift */ 1686 1, /* size (0 = byte, 1 = short, 2 = long) */ 1687 16, /* bitsize */ 1688 FALSE, /* pc_relative */ 1689 0, /* bitpos */ 1690 complain_overflow_dont, /* complain_on_overflow */ 1691 ppc64_elf_unhandled_reloc, /* special_function */ 1692 "R_PPC64_TPREL16_LO_DS", /* name */ 1693 FALSE, /* partial_inplace */ 1694 0, /* src_mask */ 1695 0xfffc, /* dst_mask */ 1696 FALSE), /* pcrel_offset */ 1697 1698 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 1699 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset 1700 to the first entry relative to the TOC base (r2). */ 1701 HOWTO (R_PPC64_GOT_TLSGD16, 1702 0, /* rightshift */ 1703 1, /* size (0 = byte, 1 = short, 2 = long) */ 1704 16, /* bitsize */ 1705 FALSE, /* pc_relative */ 1706 0, /* bitpos */ 1707 complain_overflow_signed, /* complain_on_overflow */ 1708 ppc64_elf_unhandled_reloc, /* special_function */ 1709 "R_PPC64_GOT_TLSGD16", /* name */ 1710 FALSE, /* partial_inplace */ 1711 0, /* src_mask */ 1712 0xffff, /* dst_mask */ 1713 FALSE), /* pcrel_offset */ 1714 1715 /* Like GOT_TLSGD16, but no overflow. */ 1716 HOWTO (R_PPC64_GOT_TLSGD16_LO, 1717 0, /* rightshift */ 1718 1, /* size (0 = byte, 1 = short, 2 = long) */ 1719 16, /* bitsize */ 1720 FALSE, /* pc_relative */ 1721 0, /* bitpos */ 1722 complain_overflow_dont, /* complain_on_overflow */ 1723 ppc64_elf_unhandled_reloc, /* special_function */ 1724 "R_PPC64_GOT_TLSGD16_LO", /* name */ 1725 FALSE, /* partial_inplace */ 1726 0, /* src_mask */ 1727 0xffff, /* dst_mask */ 1728 FALSE), /* pcrel_offset */ 1729 1730 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */ 1731 HOWTO (R_PPC64_GOT_TLSGD16_HI, 1732 16, /* rightshift */ 1733 1, /* size (0 = byte, 1 = short, 2 = long) */ 1734 16, /* bitsize */ 1735 FALSE, /* pc_relative */ 1736 0, /* bitpos */ 1737 complain_overflow_signed, /* complain_on_overflow */ 1738 ppc64_elf_unhandled_reloc, /* special_function */ 1739 "R_PPC64_GOT_TLSGD16_HI", /* name */ 1740 FALSE, /* partial_inplace */ 1741 0, /* src_mask */ 1742 0xffff, /* dst_mask */ 1743 FALSE), /* pcrel_offset */ 1744 1745 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */ 1746 HOWTO (R_PPC64_GOT_TLSGD16_HA, 1747 16, /* rightshift */ 1748 1, /* size (0 = byte, 1 = short, 2 = long) */ 1749 16, /* bitsize */ 1750 FALSE, /* pc_relative */ 1751 0, /* bitpos */ 1752 complain_overflow_signed, /* complain_on_overflow */ 1753 ppc64_elf_unhandled_reloc, /* special_function */ 1754 "R_PPC64_GOT_TLSGD16_HA", /* name */ 1755 FALSE, /* partial_inplace */ 1756 0, /* src_mask */ 1757 0xffff, /* dst_mask */ 1758 FALSE), /* pcrel_offset */ 1759 1760 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 1761 with values (sym+add)@dtpmod and zero, and computes the offset to the 1762 first entry relative to the TOC base (r2). */ 1763 HOWTO (R_PPC64_GOT_TLSLD16, 1764 0, /* rightshift */ 1765 1, /* size (0 = byte, 1 = short, 2 = long) */ 1766 16, /* bitsize */ 1767 FALSE, /* pc_relative */ 1768 0, /* bitpos */ 1769 complain_overflow_signed, /* complain_on_overflow */ 1770 ppc64_elf_unhandled_reloc, /* special_function */ 1771 "R_PPC64_GOT_TLSLD16", /* name */ 1772 FALSE, /* partial_inplace */ 1773 0, /* src_mask */ 1774 0xffff, /* dst_mask */ 1775 FALSE), /* pcrel_offset */ 1776 1777 /* Like GOT_TLSLD16, but no overflow. */ 1778 HOWTO (R_PPC64_GOT_TLSLD16_LO, 1779 0, /* rightshift */ 1780 1, /* size (0 = byte, 1 = short, 2 = long) */ 1781 16, /* bitsize */ 1782 FALSE, /* pc_relative */ 1783 0, /* bitpos */ 1784 complain_overflow_dont, /* complain_on_overflow */ 1785 ppc64_elf_unhandled_reloc, /* special_function */ 1786 "R_PPC64_GOT_TLSLD16_LO", /* name */ 1787 FALSE, /* partial_inplace */ 1788 0, /* src_mask */ 1789 0xffff, /* dst_mask */ 1790 FALSE), /* pcrel_offset */ 1791 1792 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */ 1793 HOWTO (R_PPC64_GOT_TLSLD16_HI, 1794 16, /* rightshift */ 1795 1, /* size (0 = byte, 1 = short, 2 = long) */ 1796 16, /* bitsize */ 1797 FALSE, /* pc_relative */ 1798 0, /* bitpos */ 1799 complain_overflow_signed, /* complain_on_overflow */ 1800 ppc64_elf_unhandled_reloc, /* special_function */ 1801 "R_PPC64_GOT_TLSLD16_HI", /* name */ 1802 FALSE, /* partial_inplace */ 1803 0, /* src_mask */ 1804 0xffff, /* dst_mask */ 1805 FALSE), /* pcrel_offset */ 1806 1807 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */ 1808 HOWTO (R_PPC64_GOT_TLSLD16_HA, 1809 16, /* rightshift */ 1810 1, /* size (0 = byte, 1 = short, 2 = long) */ 1811 16, /* bitsize */ 1812 FALSE, /* pc_relative */ 1813 0, /* bitpos */ 1814 complain_overflow_signed, /* complain_on_overflow */ 1815 ppc64_elf_unhandled_reloc, /* special_function */ 1816 "R_PPC64_GOT_TLSLD16_HA", /* name */ 1817 FALSE, /* partial_inplace */ 1818 0, /* src_mask */ 1819 0xffff, /* dst_mask */ 1820 FALSE), /* pcrel_offset */ 1821 1822 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes 1823 the offset to the entry relative to the TOC base (r2). */ 1824 HOWTO (R_PPC64_GOT_DTPREL16_DS, 1825 0, /* rightshift */ 1826 1, /* size (0 = byte, 1 = short, 2 = long) */ 1827 16, /* bitsize */ 1828 FALSE, /* pc_relative */ 1829 0, /* bitpos */ 1830 complain_overflow_signed, /* complain_on_overflow */ 1831 ppc64_elf_unhandled_reloc, /* special_function */ 1832 "R_PPC64_GOT_DTPREL16_DS", /* name */ 1833 FALSE, /* partial_inplace */ 1834 0, /* src_mask */ 1835 0xfffc, /* dst_mask */ 1836 FALSE), /* pcrel_offset */ 1837 1838 /* Like GOT_DTPREL16_DS, but no overflow. */ 1839 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS, 1840 0, /* rightshift */ 1841 1, /* size (0 = byte, 1 = short, 2 = long) */ 1842 16, /* bitsize */ 1843 FALSE, /* pc_relative */ 1844 0, /* bitpos */ 1845 complain_overflow_dont, /* complain_on_overflow */ 1846 ppc64_elf_unhandled_reloc, /* special_function */ 1847 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */ 1848 FALSE, /* partial_inplace */ 1849 0, /* src_mask */ 1850 0xfffc, /* dst_mask */ 1851 FALSE), /* pcrel_offset */ 1852 1853 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */ 1854 HOWTO (R_PPC64_GOT_DTPREL16_HI, 1855 16, /* rightshift */ 1856 1, /* size (0 = byte, 1 = short, 2 = long) */ 1857 16, /* bitsize */ 1858 FALSE, /* pc_relative */ 1859 0, /* bitpos */ 1860 complain_overflow_signed, /* complain_on_overflow */ 1861 ppc64_elf_unhandled_reloc, /* special_function */ 1862 "R_PPC64_GOT_DTPREL16_HI", /* name */ 1863 FALSE, /* partial_inplace */ 1864 0, /* src_mask */ 1865 0xffff, /* dst_mask */ 1866 FALSE), /* pcrel_offset */ 1867 1868 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */ 1869 HOWTO (R_PPC64_GOT_DTPREL16_HA, 1870 16, /* rightshift */ 1871 1, /* size (0 = byte, 1 = short, 2 = long) */ 1872 16, /* bitsize */ 1873 FALSE, /* pc_relative */ 1874 0, /* bitpos */ 1875 complain_overflow_signed, /* complain_on_overflow */ 1876 ppc64_elf_unhandled_reloc, /* special_function */ 1877 "R_PPC64_GOT_DTPREL16_HA", /* name */ 1878 FALSE, /* partial_inplace */ 1879 0, /* src_mask */ 1880 0xffff, /* dst_mask */ 1881 FALSE), /* pcrel_offset */ 1882 1883 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the 1884 offset to the entry relative to the TOC base (r2). */ 1885 HOWTO (R_PPC64_GOT_TPREL16_DS, 1886 0, /* rightshift */ 1887 1, /* size (0 = byte, 1 = short, 2 = long) */ 1888 16, /* bitsize */ 1889 FALSE, /* pc_relative */ 1890 0, /* bitpos */ 1891 complain_overflow_signed, /* complain_on_overflow */ 1892 ppc64_elf_unhandled_reloc, /* special_function */ 1893 "R_PPC64_GOT_TPREL16_DS", /* name */ 1894 FALSE, /* partial_inplace */ 1895 0, /* src_mask */ 1896 0xfffc, /* dst_mask */ 1897 FALSE), /* pcrel_offset */ 1898 1899 /* Like GOT_TPREL16_DS, but no overflow. */ 1900 HOWTO (R_PPC64_GOT_TPREL16_LO_DS, 1901 0, /* rightshift */ 1902 1, /* size (0 = byte, 1 = short, 2 = long) */ 1903 16, /* bitsize */ 1904 FALSE, /* pc_relative */ 1905 0, /* bitpos */ 1906 complain_overflow_dont, /* complain_on_overflow */ 1907 ppc64_elf_unhandled_reloc, /* special_function */ 1908 "R_PPC64_GOT_TPREL16_LO_DS", /* name */ 1909 FALSE, /* partial_inplace */ 1910 0, /* src_mask */ 1911 0xfffc, /* dst_mask */ 1912 FALSE), /* pcrel_offset */ 1913 1914 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */ 1915 HOWTO (R_PPC64_GOT_TPREL16_HI, 1916 16, /* rightshift */ 1917 1, /* size (0 = byte, 1 = short, 2 = long) */ 1918 16, /* bitsize */ 1919 FALSE, /* pc_relative */ 1920 0, /* bitpos */ 1921 complain_overflow_signed, /* complain_on_overflow */ 1922 ppc64_elf_unhandled_reloc, /* special_function */ 1923 "R_PPC64_GOT_TPREL16_HI", /* name */ 1924 FALSE, /* partial_inplace */ 1925 0, /* src_mask */ 1926 0xffff, /* dst_mask */ 1927 FALSE), /* pcrel_offset */ 1928 1929 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */ 1930 HOWTO (R_PPC64_GOT_TPREL16_HA, 1931 16, /* rightshift */ 1932 1, /* size (0 = byte, 1 = short, 2 = long) */ 1933 16, /* bitsize */ 1934 FALSE, /* pc_relative */ 1935 0, /* bitpos */ 1936 complain_overflow_signed, /* complain_on_overflow */ 1937 ppc64_elf_unhandled_reloc, /* special_function */ 1938 "R_PPC64_GOT_TPREL16_HA", /* name */ 1939 FALSE, /* partial_inplace */ 1940 0, /* src_mask */ 1941 0xffff, /* dst_mask */ 1942 FALSE), /* pcrel_offset */ 1943 1944 HOWTO (R_PPC64_JMP_IREL, /* type */ 1945 0, /* rightshift */ 1946 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 1947 0, /* bitsize */ 1948 FALSE, /* pc_relative */ 1949 0, /* bitpos */ 1950 complain_overflow_dont, /* complain_on_overflow */ 1951 ppc64_elf_unhandled_reloc, /* special_function */ 1952 "R_PPC64_JMP_IREL", /* name */ 1953 FALSE, /* partial_inplace */ 1954 0, /* src_mask */ 1955 0, /* dst_mask */ 1956 FALSE), /* pcrel_offset */ 1957 1958 HOWTO (R_PPC64_IRELATIVE, /* type */ 1959 0, /* rightshift */ 1960 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 1961 64, /* bitsize */ 1962 FALSE, /* pc_relative */ 1963 0, /* bitpos */ 1964 complain_overflow_dont, /* complain_on_overflow */ 1965 bfd_elf_generic_reloc, /* special_function */ 1966 "R_PPC64_IRELATIVE", /* name */ 1967 FALSE, /* partial_inplace */ 1968 0, /* src_mask */ 1969 ONES (64), /* dst_mask */ 1970 FALSE), /* pcrel_offset */ 1971 1972 /* A 16 bit relative relocation. */ 1973 HOWTO (R_PPC64_REL16, /* type */ 1974 0, /* rightshift */ 1975 1, /* size (0 = byte, 1 = short, 2 = long) */ 1976 16, /* bitsize */ 1977 TRUE, /* pc_relative */ 1978 0, /* bitpos */ 1979 complain_overflow_signed, /* complain_on_overflow */ 1980 bfd_elf_generic_reloc, /* special_function */ 1981 "R_PPC64_REL16", /* name */ 1982 FALSE, /* partial_inplace */ 1983 0, /* src_mask */ 1984 0xffff, /* dst_mask */ 1985 TRUE), /* pcrel_offset */ 1986 1987 /* A 16 bit relative relocation without overflow. */ 1988 HOWTO (R_PPC64_REL16_LO, /* type */ 1989 0, /* rightshift */ 1990 1, /* size (0 = byte, 1 = short, 2 = long) */ 1991 16, /* bitsize */ 1992 TRUE, /* pc_relative */ 1993 0, /* bitpos */ 1994 complain_overflow_dont,/* complain_on_overflow */ 1995 bfd_elf_generic_reloc, /* special_function */ 1996 "R_PPC64_REL16_LO", /* name */ 1997 FALSE, /* partial_inplace */ 1998 0, /* src_mask */ 1999 0xffff, /* dst_mask */ 2000 TRUE), /* pcrel_offset */ 2001 2002 /* The high order 16 bits of a relative address. */ 2003 HOWTO (R_PPC64_REL16_HI, /* type */ 2004 16, /* rightshift */ 2005 1, /* size (0 = byte, 1 = short, 2 = long) */ 2006 16, /* bitsize */ 2007 TRUE, /* pc_relative */ 2008 0, /* bitpos */ 2009 complain_overflow_signed, /* complain_on_overflow */ 2010 bfd_elf_generic_reloc, /* special_function */ 2011 "R_PPC64_REL16_HI", /* name */ 2012 FALSE, /* partial_inplace */ 2013 0, /* src_mask */ 2014 0xffff, /* dst_mask */ 2015 TRUE), /* pcrel_offset */ 2016 2017 /* The high order 16 bits of a relative address, plus 1 if the contents of 2018 the low 16 bits, treated as a signed number, is negative. */ 2019 HOWTO (R_PPC64_REL16_HA, /* type */ 2020 16, /* rightshift */ 2021 1, /* size (0 = byte, 1 = short, 2 = long) */ 2022 16, /* bitsize */ 2023 TRUE, /* pc_relative */ 2024 0, /* bitpos */ 2025 complain_overflow_signed, /* complain_on_overflow */ 2026 ppc64_elf_ha_reloc, /* special_function */ 2027 "R_PPC64_REL16_HA", /* name */ 2028 FALSE, /* partial_inplace */ 2029 0, /* src_mask */ 2030 0xffff, /* dst_mask */ 2031 TRUE), /* pcrel_offset */ 2032 2033 /* Like R_PPC64_REL16_HA but for split field in addpcis. */ 2034 HOWTO (R_PPC64_REL16DX_HA, /* type */ 2035 16, /* rightshift */ 2036 2, /* size (0 = byte, 1 = short, 2 = long) */ 2037 16, /* bitsize */ 2038 TRUE, /* pc_relative */ 2039 0, /* bitpos */ 2040 complain_overflow_signed, /* complain_on_overflow */ 2041 ppc64_elf_ha_reloc, /* special_function */ 2042 "R_PPC64_REL16DX_HA", /* name */ 2043 FALSE, /* partial_inplace */ 2044 0, /* src_mask */ 2045 0x1fffc1, /* dst_mask */ 2046 TRUE), /* pcrel_offset */ 2047 2048 /* A split-field reloc for addpcis, non-relative (gas internal use only). */ 2049 HOWTO (R_PPC64_16DX_HA, /* type */ 2050 16, /* rightshift */ 2051 2, /* size (0 = byte, 1 = short, 2 = long) */ 2052 16, /* bitsize */ 2053 FALSE, /* pc_relative */ 2054 0, /* bitpos */ 2055 complain_overflow_signed, /* complain_on_overflow */ 2056 ppc64_elf_ha_reloc, /* special_function */ 2057 "R_PPC64_16DX_HA", /* name */ 2058 FALSE, /* partial_inplace */ 2059 0, /* src_mask */ 2060 0x1fffc1, /* dst_mask */ 2061 FALSE), /* pcrel_offset */ 2062 2063 /* Like R_PPC64_ADDR16_HI, but no overflow. */ 2064 HOWTO (R_PPC64_ADDR16_HIGH, /* type */ 2065 16, /* rightshift */ 2066 1, /* size (0 = byte, 1 = short, 2 = long) */ 2067 16, /* bitsize */ 2068 FALSE, /* pc_relative */ 2069 0, /* bitpos */ 2070 complain_overflow_dont, /* complain_on_overflow */ 2071 bfd_elf_generic_reloc, /* special_function */ 2072 "R_PPC64_ADDR16_HIGH", /* name */ 2073 FALSE, /* partial_inplace */ 2074 0, /* src_mask */ 2075 0xffff, /* dst_mask */ 2076 FALSE), /* pcrel_offset */ 2077 2078 /* Like R_PPC64_ADDR16_HA, but no overflow. */ 2079 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */ 2080 16, /* rightshift */ 2081 1, /* size (0 = byte, 1 = short, 2 = long) */ 2082 16, /* bitsize */ 2083 FALSE, /* pc_relative */ 2084 0, /* bitpos */ 2085 complain_overflow_dont, /* complain_on_overflow */ 2086 ppc64_elf_ha_reloc, /* special_function */ 2087 "R_PPC64_ADDR16_HIGHA", /* name */ 2088 FALSE, /* partial_inplace */ 2089 0, /* src_mask */ 2090 0xffff, /* dst_mask */ 2091 FALSE), /* pcrel_offset */ 2092 2093 /* Like R_PPC64_DTPREL16_HI, but no overflow. */ 2094 HOWTO (R_PPC64_DTPREL16_HIGH, 2095 16, /* rightshift */ 2096 1, /* size (0 = byte, 1 = short, 2 = long) */ 2097 16, /* bitsize */ 2098 FALSE, /* pc_relative */ 2099 0, /* bitpos */ 2100 complain_overflow_dont, /* complain_on_overflow */ 2101 ppc64_elf_unhandled_reloc, /* special_function */ 2102 "R_PPC64_DTPREL16_HIGH", /* name */ 2103 FALSE, /* partial_inplace */ 2104 0, /* src_mask */ 2105 0xffff, /* dst_mask */ 2106 FALSE), /* pcrel_offset */ 2107 2108 /* Like R_PPC64_DTPREL16_HA, but no overflow. */ 2109 HOWTO (R_PPC64_DTPREL16_HIGHA, 2110 16, /* rightshift */ 2111 1, /* size (0 = byte, 1 = short, 2 = long) */ 2112 16, /* bitsize */ 2113 FALSE, /* pc_relative */ 2114 0, /* bitpos */ 2115 complain_overflow_dont, /* complain_on_overflow */ 2116 ppc64_elf_unhandled_reloc, /* special_function */ 2117 "R_PPC64_DTPREL16_HIGHA", /* name */ 2118 FALSE, /* partial_inplace */ 2119 0, /* src_mask */ 2120 0xffff, /* dst_mask */ 2121 FALSE), /* pcrel_offset */ 2122 2123 /* Like R_PPC64_TPREL16_HI, but no overflow. */ 2124 HOWTO (R_PPC64_TPREL16_HIGH, 2125 16, /* rightshift */ 2126 1, /* size (0 = byte, 1 = short, 2 = long) */ 2127 16, /* bitsize */ 2128 FALSE, /* pc_relative */ 2129 0, /* bitpos */ 2130 complain_overflow_dont, /* complain_on_overflow */ 2131 ppc64_elf_unhandled_reloc, /* special_function */ 2132 "R_PPC64_TPREL16_HIGH", /* name */ 2133 FALSE, /* partial_inplace */ 2134 0, /* src_mask */ 2135 0xffff, /* dst_mask */ 2136 FALSE), /* pcrel_offset */ 2137 2138 /* Like R_PPC64_TPREL16_HA, but no overflow. */ 2139 HOWTO (R_PPC64_TPREL16_HIGHA, 2140 16, /* rightshift */ 2141 1, /* size (0 = byte, 1 = short, 2 = long) */ 2142 16, /* bitsize */ 2143 FALSE, /* pc_relative */ 2144 0, /* bitpos */ 2145 complain_overflow_dont, /* complain_on_overflow */ 2146 ppc64_elf_unhandled_reloc, /* special_function */ 2147 "R_PPC64_TPREL16_HIGHA", /* name */ 2148 FALSE, /* partial_inplace */ 2149 0, /* src_mask */ 2150 0xffff, /* dst_mask */ 2151 FALSE), /* pcrel_offset */ 2152 2153 /* Marker reloc on ELFv2 large-model function entry. */ 2154 HOWTO (R_PPC64_ENTRY, 2155 0, /* rightshift */ 2156 2, /* size (0 = byte, 1 = short, 2 = long) */ 2157 32, /* bitsize */ 2158 FALSE, /* pc_relative */ 2159 0, /* bitpos */ 2160 complain_overflow_dont, /* complain_on_overflow */ 2161 bfd_elf_generic_reloc, /* special_function */ 2162 "R_PPC64_ENTRY", /* name */ 2163 FALSE, /* partial_inplace */ 2164 0, /* src_mask */ 2165 0, /* dst_mask */ 2166 FALSE), /* pcrel_offset */ 2167 2168 /* Like ADDR64, but use local entry point of function. */ 2169 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */ 2170 0, /* rightshift */ 2171 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */ 2172 64, /* bitsize */ 2173 FALSE, /* pc_relative */ 2174 0, /* bitpos */ 2175 complain_overflow_dont, /* complain_on_overflow */ 2176 bfd_elf_generic_reloc, /* special_function */ 2177 "R_PPC64_ADDR64_LOCAL", /* name */ 2178 FALSE, /* partial_inplace */ 2179 0, /* src_mask */ 2180 ONES (64), /* dst_mask */ 2181 FALSE), /* pcrel_offset */ 2182 2183 /* GNU extension to record C++ vtable hierarchy. */ 2184 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */ 2185 0, /* rightshift */ 2186 0, /* size (0 = byte, 1 = short, 2 = long) */ 2187 0, /* bitsize */ 2188 FALSE, /* pc_relative */ 2189 0, /* bitpos */ 2190 complain_overflow_dont, /* complain_on_overflow */ 2191 NULL, /* special_function */ 2192 "R_PPC64_GNU_VTINHERIT", /* name */ 2193 FALSE, /* partial_inplace */ 2194 0, /* src_mask */ 2195 0, /* dst_mask */ 2196 FALSE), /* pcrel_offset */ 2197 2198 /* GNU extension to record C++ vtable member usage. */ 2199 HOWTO (R_PPC64_GNU_VTENTRY, /* type */ 2200 0, /* rightshift */ 2201 0, /* size (0 = byte, 1 = short, 2 = long) */ 2202 0, /* bitsize */ 2203 FALSE, /* pc_relative */ 2204 0, /* bitpos */ 2205 complain_overflow_dont, /* complain_on_overflow */ 2206 NULL, /* special_function */ 2207 "R_PPC64_GNU_VTENTRY", /* name */ 2208 FALSE, /* partial_inplace */ 2209 0, /* src_mask */ 2210 0, /* dst_mask */ 2211 FALSE), /* pcrel_offset */ 2212}; 2213 2214 2215/* Initialize the ppc64_elf_howto_table, so that linear accesses can 2216 be done. */ 2217 2218static void 2219ppc_howto_init (void) 2220{ 2221 unsigned int i, type; 2222 2223 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++) 2224 { 2225 type = ppc64_elf_howto_raw[i].type; 2226 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table)); 2227 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i]; 2228 } 2229} 2230 2231static reloc_howto_type * 2232ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 2233 bfd_reloc_code_real_type code) 2234{ 2235 enum elf_ppc64_reloc_type r = R_PPC64_NONE; 2236 2237 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 2238 /* Initialize howto table if needed. */ 2239 ppc_howto_init (); 2240 2241 switch (code) 2242 { 2243 default: 2244 return NULL; 2245 2246 case BFD_RELOC_NONE: r = R_PPC64_NONE; 2247 break; 2248 case BFD_RELOC_32: r = R_PPC64_ADDR32; 2249 break; 2250 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24; 2251 break; 2252 case BFD_RELOC_16: r = R_PPC64_ADDR16; 2253 break; 2254 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO; 2255 break; 2256 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI; 2257 break; 2258 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH; 2259 break; 2260 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA; 2261 break; 2262 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA; 2263 break; 2264 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14; 2265 break; 2266 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN; 2267 break; 2268 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN; 2269 break; 2270 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24; 2271 break; 2272 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14; 2273 break; 2274 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN; 2275 break; 2276 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN; 2277 break; 2278 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16; 2279 break; 2280 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO; 2281 break; 2282 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI; 2283 break; 2284 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA; 2285 break; 2286 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY; 2287 break; 2288 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT; 2289 break; 2290 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32; 2291 break; 2292 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32; 2293 break; 2294 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32; 2295 break; 2296 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO; 2297 break; 2298 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI; 2299 break; 2300 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA; 2301 break; 2302 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF; 2303 break; 2304 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO; 2305 break; 2306 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI; 2307 break; 2308 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA; 2309 break; 2310 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64; 2311 break; 2312 case BFD_RELOC_64: r = R_PPC64_ADDR64; 2313 break; 2314 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER; 2315 break; 2316 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA; 2317 break; 2318 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST; 2319 break; 2320 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA; 2321 break; 2322 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64; 2323 break; 2324 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64; 2325 break; 2326 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64; 2327 break; 2328 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16; 2329 break; 2330 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO; 2331 break; 2332 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI; 2333 break; 2334 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA; 2335 break; 2336 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC; 2337 break; 2338 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16; 2339 break; 2340 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO; 2341 break; 2342 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI; 2343 break; 2344 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA; 2345 break; 2346 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS; 2347 break; 2348 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS; 2349 break; 2350 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS; 2351 break; 2352 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS; 2353 break; 2354 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS; 2355 break; 2356 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS; 2357 break; 2358 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS; 2359 break; 2360 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS; 2361 break; 2362 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS; 2363 break; 2364 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS; 2365 break; 2366 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS; 2367 break; 2368 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS; 2369 break; 2370 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD; 2371 break; 2372 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD; 2373 break; 2374 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64; 2375 break; 2376 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16; 2377 break; 2378 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO; 2379 break; 2380 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI; 2381 break; 2382 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH; 2383 break; 2384 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA; 2385 break; 2386 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA; 2387 break; 2388 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64; 2389 break; 2390 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16; 2391 break; 2392 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO; 2393 break; 2394 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI; 2395 break; 2396 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH; 2397 break; 2398 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA; 2399 break; 2400 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA; 2401 break; 2402 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64; 2403 break; 2404 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16; 2405 break; 2406 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO; 2407 break; 2408 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI; 2409 break; 2410 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA; 2411 break; 2412 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16; 2413 break; 2414 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO; 2415 break; 2416 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI; 2417 break; 2418 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA; 2419 break; 2420 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS; 2421 break; 2422 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS; 2423 break; 2424 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI; 2425 break; 2426 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA; 2427 break; 2428 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS; 2429 break; 2430 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS; 2431 break; 2432 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI; 2433 break; 2434 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA; 2435 break; 2436 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS; 2437 break; 2438 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS; 2439 break; 2440 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER; 2441 break; 2442 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA; 2443 break; 2444 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST; 2445 break; 2446 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA; 2447 break; 2448 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS; 2449 break; 2450 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS; 2451 break; 2452 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER; 2453 break; 2454 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA; 2455 break; 2456 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST; 2457 break; 2458 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA; 2459 break; 2460 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16; 2461 break; 2462 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO; 2463 break; 2464 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI; 2465 break; 2466 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA; 2467 break; 2468 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA; 2469 break; 2470 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA; 2471 break; 2472 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY; 2473 break; 2474 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL; 2475 break; 2476 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT; 2477 break; 2478 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY; 2479 break; 2480 } 2481 2482 return ppc64_elf_howto_table[r]; 2483}; 2484 2485static reloc_howto_type * 2486ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 2487 const char *r_name) 2488{ 2489 unsigned int i; 2490 2491 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++) 2492 if (ppc64_elf_howto_raw[i].name != NULL 2493 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0) 2494 return &ppc64_elf_howto_raw[i]; 2495 2496 return NULL; 2497} 2498 2499/* Set the howto pointer for a PowerPC ELF reloc. */ 2500 2501static void 2502ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, 2503 Elf_Internal_Rela *dst) 2504{ 2505 unsigned int type; 2506 2507 /* Initialize howto table if needed. */ 2508 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 2509 ppc_howto_init (); 2510 2511 type = ELF64_R_TYPE (dst->r_info); 2512 if (type >= ARRAY_SIZE (ppc64_elf_howto_table)) 2513 { 2514 /* xgettext:c-format */ 2515 _bfd_error_handler (_("%B: invalid relocation type %d"), 2516 abfd, (int) type); 2517 type = R_PPC64_NONE; 2518 } 2519 cache_ptr->howto = ppc64_elf_howto_table[type]; 2520} 2521 2522/* Handle the R_PPC64_ADDR16_HA and similar relocs. */ 2523 2524static bfd_reloc_status_type 2525ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2526 void *data, asection *input_section, 2527 bfd *output_bfd, char **error_message) 2528{ 2529 enum elf_ppc64_reloc_type r_type; 2530 long insn; 2531 bfd_size_type octets; 2532 bfd_vma value, field; 2533 2534 /* If this is a relocatable link (output_bfd test tells us), just 2535 call the generic function. Any adjustment will be done at final 2536 link time. */ 2537 if (output_bfd != NULL) 2538 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2539 input_section, output_bfd, error_message); 2540 2541 /* Adjust the addend for sign extension of the low 16 bits. 2542 We won't actually be using the low 16 bits, so trashing them 2543 doesn't matter. */ 2544 reloc_entry->addend += 0x8000; 2545 r_type = reloc_entry->howto->type; 2546 if (r_type != R_PPC64_REL16DX_HA) 2547 return bfd_reloc_continue; 2548 2549 value = 0; 2550 if (!bfd_is_com_section (symbol->section)) 2551 value = symbol->value; 2552 value += (reloc_entry->addend 2553 + symbol->section->output_offset 2554 + symbol->section->output_section->vma); 2555 value -= (reloc_entry->address 2556 + input_section->output_offset 2557 + input_section->output_section->vma); 2558 field = (bfd_signed_vma) value >> 16; 2559 2560 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2561 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets); 2562 insn &= ~0x1fffc1; 2563 insn |= (field & 0xffc1) | ((field & 0x3e) << 15); 2564 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets); 2565 if (value + 0x80000000 > 0xffffffff) 2566 return bfd_reloc_overflow; 2567 return bfd_reloc_ok; 2568} 2569 2570static bfd_reloc_status_type 2571ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2572 void *data, asection *input_section, 2573 bfd *output_bfd, char **error_message) 2574{ 2575 if (output_bfd != NULL) 2576 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2577 input_section, output_bfd, error_message); 2578 2579 if (strcmp (symbol->section->name, ".opd") == 0 2580 && (symbol->section->owner->flags & DYNAMIC) == 0) 2581 { 2582 bfd_vma dest = opd_entry_value (symbol->section, 2583 symbol->value + reloc_entry->addend, 2584 NULL, NULL, FALSE); 2585 if (dest != (bfd_vma) -1) 2586 reloc_entry->addend = dest - (symbol->value 2587 + symbol->section->output_section->vma 2588 + symbol->section->output_offset); 2589 } 2590 else 2591 { 2592 elf_symbol_type *elfsym = (elf_symbol_type *) symbol; 2593 2594 if (symbol->section->owner != abfd 2595 && symbol->section->owner != NULL 2596 && abiversion (symbol->section->owner) >= 2) 2597 { 2598 unsigned int i; 2599 2600 for (i = 0; i < symbol->section->owner->symcount; ++i) 2601 { 2602 asymbol *symdef = symbol->section->owner->outsymbols[i]; 2603 2604 if (strcmp (symdef->name, symbol->name) == 0) 2605 { 2606 elfsym = (elf_symbol_type *) symdef; 2607 break; 2608 } 2609 } 2610 } 2611 reloc_entry->addend 2612 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other); 2613 } 2614 return bfd_reloc_continue; 2615} 2616 2617static bfd_reloc_status_type 2618ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2619 void *data, asection *input_section, 2620 bfd *output_bfd, char **error_message) 2621{ 2622 long insn; 2623 enum elf_ppc64_reloc_type r_type; 2624 bfd_size_type octets; 2625 /* Assume 'at' branch hints. */ 2626 bfd_boolean is_isa_v2 = TRUE; 2627 2628 /* If this is a relocatable link (output_bfd test tells us), just 2629 call the generic function. Any adjustment will be done at final 2630 link time. */ 2631 if (output_bfd != NULL) 2632 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2633 input_section, output_bfd, error_message); 2634 2635 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2636 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets); 2637 insn &= ~(0x01 << 21); 2638 r_type = reloc_entry->howto->type; 2639 if (r_type == R_PPC64_ADDR14_BRTAKEN 2640 || r_type == R_PPC64_REL14_BRTAKEN) 2641 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */ 2642 2643 if (is_isa_v2) 2644 { 2645 /* Set 'a' bit. This is 0b00010 in BO field for branch 2646 on CR(BI) insns (BO == 001at or 011at), and 0b01000 2647 for branch on CTR insns (BO == 1a00t or 1a01t). */ 2648 if ((insn & (0x14 << 21)) == (0x04 << 21)) 2649 insn |= 0x02 << 21; 2650 else if ((insn & (0x14 << 21)) == (0x10 << 21)) 2651 insn |= 0x08 << 21; 2652 else 2653 goto out; 2654 } 2655 else 2656 { 2657 bfd_vma target = 0; 2658 bfd_vma from; 2659 2660 if (!bfd_is_com_section (symbol->section)) 2661 target = symbol->value; 2662 target += symbol->section->output_section->vma; 2663 target += symbol->section->output_offset; 2664 target += reloc_entry->addend; 2665 2666 from = (reloc_entry->address 2667 + input_section->output_offset 2668 + input_section->output_section->vma); 2669 2670 /* Invert 'y' bit if not the default. */ 2671 if ((bfd_signed_vma) (target - from) < 0) 2672 insn ^= 0x01 << 21; 2673 } 2674 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets); 2675 out: 2676 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data, 2677 input_section, output_bfd, error_message); 2678} 2679 2680static bfd_reloc_status_type 2681ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2682 void *data, asection *input_section, 2683 bfd *output_bfd, char **error_message) 2684{ 2685 /* If this is a relocatable link (output_bfd test tells us), just 2686 call the generic function. Any adjustment will be done at final 2687 link time. */ 2688 if (output_bfd != NULL) 2689 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2690 input_section, output_bfd, error_message); 2691 2692 /* Subtract the symbol section base address. */ 2693 reloc_entry->addend -= symbol->section->output_section->vma; 2694 return bfd_reloc_continue; 2695} 2696 2697static bfd_reloc_status_type 2698ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2699 void *data, asection *input_section, 2700 bfd *output_bfd, char **error_message) 2701{ 2702 /* If this is a relocatable link (output_bfd test tells us), just 2703 call the generic function. Any adjustment will be done at final 2704 link time. */ 2705 if (output_bfd != NULL) 2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2707 input_section, output_bfd, error_message); 2708 2709 /* Subtract the symbol section base address. */ 2710 reloc_entry->addend -= symbol->section->output_section->vma; 2711 2712 /* Adjust the addend for sign extension of the low 16 bits. */ 2713 reloc_entry->addend += 0x8000; 2714 return bfd_reloc_continue; 2715} 2716 2717static bfd_reloc_status_type 2718ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2719 void *data, asection *input_section, 2720 bfd *output_bfd, char **error_message) 2721{ 2722 bfd_vma TOCstart; 2723 2724 /* If this is a relocatable link (output_bfd test tells us), just 2725 call the generic function. Any adjustment will be done at final 2726 link time. */ 2727 if (output_bfd != NULL) 2728 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2729 input_section, output_bfd, error_message); 2730 2731 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2732 if (TOCstart == 0) 2733 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner); 2734 2735 /* Subtract the TOC base address. */ 2736 reloc_entry->addend -= TOCstart + TOC_BASE_OFF; 2737 return bfd_reloc_continue; 2738} 2739 2740static bfd_reloc_status_type 2741ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2742 void *data, asection *input_section, 2743 bfd *output_bfd, char **error_message) 2744{ 2745 bfd_vma TOCstart; 2746 2747 /* If this is a relocatable link (output_bfd test tells us), just 2748 call the generic function. Any adjustment will be done at final 2749 link time. */ 2750 if (output_bfd != NULL) 2751 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2752 input_section, output_bfd, error_message); 2753 2754 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2755 if (TOCstart == 0) 2756 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner); 2757 2758 /* Subtract the TOC base address. */ 2759 reloc_entry->addend -= TOCstart + TOC_BASE_OFF; 2760 2761 /* Adjust the addend for sign extension of the low 16 bits. */ 2762 reloc_entry->addend += 0x8000; 2763 return bfd_reloc_continue; 2764} 2765 2766static bfd_reloc_status_type 2767ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2768 void *data, asection *input_section, 2769 bfd *output_bfd, char **error_message) 2770{ 2771 bfd_vma TOCstart; 2772 bfd_size_type octets; 2773 2774 /* If this is a relocatable link (output_bfd test tells us), just 2775 call the generic function. Any adjustment will be done at final 2776 link time. */ 2777 if (output_bfd != NULL) 2778 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2779 input_section, output_bfd, error_message); 2780 2781 TOCstart = _bfd_get_gp_value (input_section->output_section->owner); 2782 if (TOCstart == 0) 2783 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner); 2784 2785 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2786 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets); 2787 return bfd_reloc_ok; 2788} 2789 2790static bfd_reloc_status_type 2791ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2792 void *data, asection *input_section, 2793 bfd *output_bfd, char **error_message) 2794{ 2795 /* If this is a relocatable link (output_bfd test tells us), just 2796 call the generic function. Any adjustment will be done at final 2797 link time. */ 2798 if (output_bfd != NULL) 2799 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2800 input_section, output_bfd, error_message); 2801 2802 if (error_message != NULL) 2803 { 2804 static char buf[60]; 2805 sprintf (buf, "generic linker can't handle %s", 2806 reloc_entry->howto->name); 2807 *error_message = buf; 2808 } 2809 return bfd_reloc_dangerous; 2810} 2811 2812/* Track GOT entries needed for a given symbol. We might need more 2813 than one got entry per symbol. */ 2814struct got_entry 2815{ 2816 struct got_entry *next; 2817 2818 /* The symbol addend that we'll be placing in the GOT. */ 2819 bfd_vma addend; 2820 2821 /* Unlike other ELF targets, we use separate GOT entries for the same 2822 symbol referenced from different input files. This is to support 2823 automatic multiple TOC/GOT sections, where the TOC base can vary 2824 from one input file to another. After partitioning into TOC groups 2825 we merge entries within the group. 2826 2827 Point to the BFD owning this GOT entry. */ 2828 bfd *owner; 2829 2830 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD, 2831 TLS_TPREL or TLS_DTPREL for tls entries. */ 2832 unsigned char tls_type; 2833 2834 /* Non-zero if got.ent points to real entry. */ 2835 unsigned char is_indirect; 2836 2837 /* Reference count until size_dynamic_sections, GOT offset thereafter. */ 2838 union 2839 { 2840 bfd_signed_vma refcount; 2841 bfd_vma offset; 2842 struct got_entry *ent; 2843 } got; 2844}; 2845 2846/* The same for PLT. */ 2847struct plt_entry 2848{ 2849 struct plt_entry *next; 2850 2851 bfd_vma addend; 2852 2853 union 2854 { 2855 bfd_signed_vma refcount; 2856 bfd_vma offset; 2857 } plt; 2858}; 2859 2860struct ppc64_elf_obj_tdata 2861{ 2862 struct elf_obj_tdata elf; 2863 2864 /* Shortcuts to dynamic linker sections. */ 2865 asection *got; 2866 asection *relgot; 2867 2868 /* Used during garbage collection. We attach global symbols defined 2869 on removed .opd entries to this section so that the sym is removed. */ 2870 asection *deleted_section; 2871 2872 /* TLS local dynamic got entry handling. Support for multiple GOT 2873 sections means we potentially need one of these for each input bfd. */ 2874 struct got_entry tlsld_got; 2875 2876 union { 2877 /* A copy of relocs before they are modified for --emit-relocs. */ 2878 Elf_Internal_Rela *relocs; 2879 2880 /* Section contents. */ 2881 bfd_byte *contents; 2882 } opd; 2883 2884 /* Nonzero if this bfd has small toc/got relocs, ie. that expect 2885 the reloc to be in the range -32768 to 32767. */ 2886 unsigned int has_small_toc_reloc : 1; 2887 2888 /* Set if toc/got ha relocs detected not using r2, or lo reloc 2889 instruction not one we handle. */ 2890 unsigned int unexpected_toc_insn : 1; 2891}; 2892 2893#define ppc64_elf_tdata(bfd) \ 2894 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any) 2895 2896#define ppc64_tlsld_got(bfd) \ 2897 (&ppc64_elf_tdata (bfd)->tlsld_got) 2898 2899#define is_ppc64_elf(bfd) \ 2900 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 2901 && elf_object_id (bfd) == PPC64_ELF_DATA) 2902 2903/* Override the generic function because we store some extras. */ 2904 2905static bfd_boolean 2906ppc64_elf_mkobject (bfd *abfd) 2907{ 2908 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata), 2909 PPC64_ELF_DATA); 2910} 2911 2912/* Fix bad default arch selected for a 64 bit input bfd when the 2913 default is 32 bit. Also select arch based on apuinfo. */ 2914 2915static bfd_boolean 2916ppc64_elf_object_p (bfd *abfd) 2917{ 2918 if (!abfd->arch_info->the_default) 2919 return TRUE; 2920 2921 if (abfd->arch_info->bits_per_word == 32) 2922 { 2923 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd); 2924 2925 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64) 2926 { 2927 /* Relies on arch after 32 bit default being 64 bit default. */ 2928 abfd->arch_info = abfd->arch_info->next; 2929 BFD_ASSERT (abfd->arch_info->bits_per_word == 64); 2930 } 2931 } 2932 return _bfd_elf_ppc_set_arch (abfd); 2933} 2934 2935/* Support for core dump NOTE sections. */ 2936 2937static bfd_boolean 2938ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2939{ 2940 size_t offset, size; 2941 2942 if (note->descsz != 504) 2943 return FALSE; 2944 2945 /* pr_cursig */ 2946 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 2947 2948 /* pr_pid */ 2949 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32); 2950 2951 /* pr_reg */ 2952 offset = 112; 2953 size = 384; 2954 2955 /* Make a ".reg/999" section. */ 2956 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2957 size, note->descpos + offset); 2958} 2959 2960static bfd_boolean 2961ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 2962{ 2963 if (note->descsz != 136) 2964 return FALSE; 2965 2966 elf_tdata (abfd)->core->pid 2967 = bfd_get_32 (abfd, note->descdata + 24); 2968 elf_tdata (abfd)->core->program 2969 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 2970 elf_tdata (abfd)->core->command 2971 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 2972 2973 return TRUE; 2974} 2975 2976static char * 2977ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, 2978 ...) 2979{ 2980 switch (note_type) 2981 { 2982 default: 2983 return NULL; 2984 2985 case NT_PRPSINFO: 2986 { 2987 char data[136]; 2988 va_list ap; 2989 2990 va_start (ap, note_type); 2991 memset (data, 0, sizeof (data)); 2992 strncpy (data + 40, va_arg (ap, const char *), 16); 2993 strncpy (data + 56, va_arg (ap, const char *), 80); 2994 va_end (ap); 2995 return elfcore_write_note (abfd, buf, bufsiz, 2996 "CORE", note_type, data, sizeof (data)); 2997 } 2998 2999 case NT_PRSTATUS: 3000 { 3001 char data[504]; 3002 va_list ap; 3003 long pid; 3004 int cursig; 3005 const void *greg; 3006 3007 va_start (ap, note_type); 3008 memset (data, 0, 112); 3009 pid = va_arg (ap, long); 3010 bfd_put_32 (abfd, pid, data + 32); 3011 cursig = va_arg (ap, int); 3012 bfd_put_16 (abfd, cursig, data + 12); 3013 greg = va_arg (ap, const void *); 3014 memcpy (data + 112, greg, 384); 3015 memset (data + 496, 0, 8); 3016 va_end (ap); 3017 return elfcore_write_note (abfd, buf, bufsiz, 3018 "CORE", note_type, data, sizeof (data)); 3019 } 3020 } 3021} 3022 3023/* Add extra PPC sections. */ 3024 3025static const struct bfd_elf_special_section ppc64_elf_special_sections[]= 3026{ 3027 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 }, 3028 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 3029 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3030 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3031 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3032 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 3033 { NULL, 0, 0, 0, 0 } 3034}; 3035 3036enum _ppc64_sec_type { 3037 sec_normal = 0, 3038 sec_opd = 1, 3039 sec_toc = 2 3040}; 3041 3042struct _ppc64_elf_section_data 3043{ 3044 struct bfd_elf_section_data elf; 3045 3046 union 3047 { 3048 /* An array with one entry for each opd function descriptor, 3049 and some spares since opd entries may be either 16 or 24 bytes. */ 3050#define OPD_NDX(OFF) ((OFF) >> 4) 3051 struct _opd_sec_data 3052 { 3053 /* Points to the function code section for local opd entries. */ 3054 asection **func_sec; 3055 3056 /* After editing .opd, adjust references to opd local syms. */ 3057 long *adjust; 3058 } opd; 3059 3060 /* An array for toc sections, indexed by offset/8. */ 3061 struct _toc_sec_data 3062 { 3063 /* Specifies the relocation symbol index used at a given toc offset. */ 3064 unsigned *symndx; 3065 3066 /* And the relocation addend. */ 3067 bfd_vma *add; 3068 } toc; 3069 } u; 3070 3071 enum _ppc64_sec_type sec_type:2; 3072 3073 /* Flag set when small branches are detected. Used to 3074 select suitable defaults for the stub group size. */ 3075 unsigned int has_14bit_branch:1; 3076}; 3077 3078#define ppc64_elf_section_data(sec) \ 3079 ((struct _ppc64_elf_section_data *) elf_section_data (sec)) 3080 3081static bfd_boolean 3082ppc64_elf_new_section_hook (bfd *abfd, asection *sec) 3083{ 3084 if (!sec->used_by_bfd) 3085 { 3086 struct _ppc64_elf_section_data *sdata; 3087 bfd_size_type amt = sizeof (*sdata); 3088 3089 sdata = bfd_zalloc (abfd, amt); 3090 if (sdata == NULL) 3091 return FALSE; 3092 sec->used_by_bfd = sdata; 3093 } 3094 3095 return _bfd_elf_new_section_hook (abfd, sec); 3096} 3097 3098static struct _opd_sec_data * 3099get_opd_info (asection * sec) 3100{ 3101 if (sec != NULL 3102 && ppc64_elf_section_data (sec) != NULL 3103 && ppc64_elf_section_data (sec)->sec_type == sec_opd) 3104 return &ppc64_elf_section_data (sec)->u.opd; 3105 return NULL; 3106} 3107 3108/* Parameters for the qsort hook. */ 3109static bfd_boolean synthetic_relocatable; 3110static asection *synthetic_opd; 3111 3112/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */ 3113 3114static int 3115compare_symbols (const void *ap, const void *bp) 3116{ 3117 const asymbol *a = * (const asymbol **) ap; 3118 const asymbol *b = * (const asymbol **) bp; 3119 3120 /* Section symbols first. */ 3121 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM)) 3122 return -1; 3123 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM)) 3124 return 1; 3125 3126 /* then .opd symbols. */ 3127 if (synthetic_opd != NULL) 3128 { 3129 if (strcmp (a->section->name, ".opd") == 0 3130 && strcmp (b->section->name, ".opd") != 0) 3131 return -1; 3132 if (strcmp (a->section->name, ".opd") != 0 3133 && strcmp (b->section->name, ".opd") == 0) 3134 return 1; 3135 } 3136 3137 /* then other code symbols. */ 3138 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3139 == (SEC_CODE | SEC_ALLOC) 3140 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3141 != (SEC_CODE | SEC_ALLOC)) 3142 return -1; 3143 3144 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3145 != (SEC_CODE | SEC_ALLOC) 3146 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3147 == (SEC_CODE | SEC_ALLOC)) 3148 return 1; 3149 3150 if (synthetic_relocatable) 3151 { 3152 if (a->section->id < b->section->id) 3153 return -1; 3154 3155 if (a->section->id > b->section->id) 3156 return 1; 3157 } 3158 3159 if (a->value + a->section->vma < b->value + b->section->vma) 3160 return -1; 3161 3162 if (a->value + a->section->vma > b->value + b->section->vma) 3163 return 1; 3164 3165 /* For syms with the same value, prefer strong dynamic global function 3166 syms over other syms. */ 3167 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0) 3168 return -1; 3169 3170 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0) 3171 return 1; 3172 3173 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0) 3174 return -1; 3175 3176 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0) 3177 return 1; 3178 3179 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0) 3180 return -1; 3181 3182 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0) 3183 return 1; 3184 3185 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0) 3186 return -1; 3187 3188 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0) 3189 return 1; 3190 3191 return 0; 3192} 3193 3194/* Search SYMS for a symbol of the given VALUE. */ 3195 3196static asymbol * 3197sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value) 3198{ 3199 long mid; 3200 3201 if (id == (unsigned) -1) 3202 { 3203 while (lo < hi) 3204 { 3205 mid = (lo + hi) >> 1; 3206 if (syms[mid]->value + syms[mid]->section->vma < value) 3207 lo = mid + 1; 3208 else if (syms[mid]->value + syms[mid]->section->vma > value) 3209 hi = mid; 3210 else 3211 return syms[mid]; 3212 } 3213 } 3214 else 3215 { 3216 while (lo < hi) 3217 { 3218 mid = (lo + hi) >> 1; 3219 if (syms[mid]->section->id < id) 3220 lo = mid + 1; 3221 else if (syms[mid]->section->id > id) 3222 hi = mid; 3223 else if (syms[mid]->value < value) 3224 lo = mid + 1; 3225 else if (syms[mid]->value > value) 3226 hi = mid; 3227 else 3228 return syms[mid]; 3229 } 3230 } 3231 return NULL; 3232} 3233 3234static bfd_boolean 3235section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr) 3236{ 3237 bfd_vma vma = *(bfd_vma *) ptr; 3238 return ((section->flags & SEC_ALLOC) != 0 3239 && section->vma <= vma 3240 && vma < section->vma + section->size); 3241} 3242 3243/* Create synthetic symbols, effectively restoring "dot-symbol" function 3244 entry syms. Also generate @plt symbols for the glink branch table. 3245 Returns count of synthetic symbols in RET or -1 on error. */ 3246 3247static long 3248ppc64_elf_get_synthetic_symtab (bfd *abfd, 3249 long static_count, asymbol **static_syms, 3250 long dyn_count, asymbol **dyn_syms, 3251 asymbol **ret) 3252{ 3253 asymbol *s; 3254 long i; 3255 long count; 3256 char *names; 3257 long symcount, codesecsym, codesecsymend, secsymend, opdsymend; 3258 asection *opd = NULL; 3259 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0; 3260 asymbol **syms; 3261 int abi = abiversion (abfd); 3262 3263 *ret = NULL; 3264 3265 if (abi < 2) 3266 { 3267 opd = bfd_get_section_by_name (abfd, ".opd"); 3268 if (opd == NULL && abi == 1) 3269 return 0; 3270 } 3271 3272 symcount = static_count; 3273 if (!relocatable) 3274 symcount += dyn_count; 3275 if (symcount == 0) 3276 return 0; 3277 3278 syms = bfd_malloc ((symcount + 1) * sizeof (*syms)); 3279 if (syms == NULL) 3280 return -1; 3281 3282 if (!relocatable && static_count != 0 && dyn_count != 0) 3283 { 3284 /* Use both symbol tables. */ 3285 memcpy (syms, static_syms, static_count * sizeof (*syms)); 3286 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms)); 3287 } 3288 else if (!relocatable && static_count == 0) 3289 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms)); 3290 else 3291 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms)); 3292 3293 synthetic_relocatable = relocatable; 3294 synthetic_opd = opd; 3295 qsort (syms, symcount, sizeof (*syms), compare_symbols); 3296 3297 if (!relocatable && symcount > 1) 3298 { 3299 long j; 3300 /* Trim duplicate syms, since we may have merged the normal and 3301 dynamic symbols. Actually, we only care about syms that have 3302 different values, so trim any with the same value. */ 3303 for (i = 1, j = 1; i < symcount; ++i) 3304 if (syms[i - 1]->value + syms[i - 1]->section->vma 3305 != syms[i]->value + syms[i]->section->vma) 3306 syms[j++] = syms[i]; 3307 symcount = j; 3308 } 3309 3310 i = 0; 3311 /* Note that here and in compare_symbols we can't compare opd and 3312 sym->section directly. With separate debug info files, the 3313 symbols will be extracted from the debug file while abfd passed 3314 to this function is the real binary. */ 3315 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0) 3316 ++i; 3317 codesecsym = i; 3318 3319 for (; i < symcount; ++i) 3320 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3321 != (SEC_CODE | SEC_ALLOC)) 3322 || (syms[i]->flags & BSF_SECTION_SYM) == 0) 3323 break; 3324 codesecsymend = i; 3325 3326 for (; i < symcount; ++i) 3327 if ((syms[i]->flags & BSF_SECTION_SYM) == 0) 3328 break; 3329 secsymend = i; 3330 3331 if (opd != NULL) 3332 for (; i < symcount; ++i) 3333 if (strcmp (syms[i]->section->name, ".opd") != 0) 3334 break; 3335 opdsymend = i; 3336 3337 for (; i < symcount; ++i) 3338 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)) 3339 != (SEC_CODE | SEC_ALLOC)) 3340 break; 3341 symcount = i; 3342 3343 count = 0; 3344 3345 if (relocatable) 3346 { 3347 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 3348 arelent *r; 3349 size_t size; 3350 long relcount; 3351 3352 if (opdsymend == secsymend) 3353 goto done; 3354 3355 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3356 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0; 3357 if (relcount == 0) 3358 goto done; 3359 3360 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE)) 3361 { 3362 count = -1; 3363 goto done; 3364 } 3365 3366 size = 0; 3367 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i) 3368 { 3369 asymbol *sym; 3370 3371 while (r < opd->relocation + relcount 3372 && r->address < syms[i]->value + opd->vma) 3373 ++r; 3374 3375 if (r == opd->relocation + relcount) 3376 break; 3377 3378 if (r->address != syms[i]->value + opd->vma) 3379 continue; 3380 3381 if (r->howto->type != R_PPC64_ADDR64) 3382 continue; 3383 3384 sym = *r->sym_ptr_ptr; 3385 if (!sym_exists_at (syms, opdsymend, symcount, 3386 sym->section->id, sym->value + r->addend)) 3387 { 3388 ++count; 3389 size += sizeof (asymbol); 3390 size += strlen (syms[i]->name) + 2; 3391 } 3392 } 3393 3394 if (size == 0) 3395 goto done; 3396 s = *ret = bfd_malloc (size); 3397 if (s == NULL) 3398 { 3399 count = -1; 3400 goto done; 3401 } 3402 3403 names = (char *) (s + count); 3404 3405 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i) 3406 { 3407 asymbol *sym; 3408 3409 while (r < opd->relocation + relcount 3410 && r->address < syms[i]->value + opd->vma) 3411 ++r; 3412 3413 if (r == opd->relocation + relcount) 3414 break; 3415 3416 if (r->address != syms[i]->value + opd->vma) 3417 continue; 3418 3419 if (r->howto->type != R_PPC64_ADDR64) 3420 continue; 3421 3422 sym = *r->sym_ptr_ptr; 3423 if (!sym_exists_at (syms, opdsymend, symcount, 3424 sym->section->id, sym->value + r->addend)) 3425 { 3426 size_t len; 3427 3428 *s = *syms[i]; 3429 s->flags |= BSF_SYNTHETIC; 3430 s->section = sym->section; 3431 s->value = sym->value + r->addend; 3432 s->name = names; 3433 *names++ = '.'; 3434 len = strlen (syms[i]->name); 3435 memcpy (names, syms[i]->name, len + 1); 3436 names += len + 1; 3437 /* Have udata.p point back to the original symbol this 3438 synthetic symbol was derived from. */ 3439 s->udata.p = syms[i]; 3440 s++; 3441 } 3442 } 3443 } 3444 else 3445 { 3446 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 3447 bfd_byte *contents = NULL; 3448 size_t size; 3449 long plt_count = 0; 3450 bfd_vma glink_vma = 0, resolv_vma = 0; 3451 asection *dynamic, *glink = NULL, *relplt = NULL; 3452 arelent *p; 3453 3454 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents)) 3455 { 3456 free_contents_and_exit_err: 3457 count = -1; 3458 free_contents_and_exit: 3459 if (contents) 3460 free (contents); 3461 goto done; 3462 } 3463 3464 size = 0; 3465 for (i = secsymend; i < opdsymend; ++i) 3466 { 3467 bfd_vma ent; 3468 3469 /* Ignore bogus symbols. */ 3470 if (syms[i]->value > opd->size - 8) 3471 continue; 3472 3473 ent = bfd_get_64 (abfd, contents + syms[i]->value); 3474 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent)) 3475 { 3476 ++count; 3477 size += sizeof (asymbol); 3478 size += strlen (syms[i]->name) + 2; 3479 } 3480 } 3481 3482 /* Get start of .glink stubs from DT_PPC64_GLINK. */ 3483 if (dyn_count != 0 3484 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL) 3485 { 3486 bfd_byte *dynbuf, *extdyn, *extdynend; 3487 size_t extdynsize; 3488 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 3489 3490 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf)) 3491 goto free_contents_and_exit_err; 3492 3493 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 3494 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 3495 3496 extdyn = dynbuf; 3497 extdynend = extdyn + dynamic->size; 3498 for (; extdyn < extdynend; extdyn += extdynsize) 3499 { 3500 Elf_Internal_Dyn dyn; 3501 (*swap_dyn_in) (abfd, extdyn, &dyn); 3502 3503 if (dyn.d_tag == DT_NULL) 3504 break; 3505 3506 if (dyn.d_tag == DT_PPC64_GLINK) 3507 { 3508 /* The first glink stub starts at offset 32; see 3509 comment in ppc64_elf_finish_dynamic_sections. */ 3510 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4; 3511 /* The .glink section usually does not survive the final 3512 link; search for the section (usually .text) where the 3513 glink stubs now reside. */ 3514 glink = bfd_sections_find_if (abfd, section_covers_vma, 3515 &glink_vma); 3516 break; 3517 } 3518 } 3519 3520 free (dynbuf); 3521 } 3522 3523 if (glink != NULL) 3524 { 3525 /* Determine __glink trampoline by reading the relative branch 3526 from the first glink stub. */ 3527 bfd_byte buf[4]; 3528 unsigned int off = 0; 3529 3530 while (bfd_get_section_contents (abfd, glink, buf, 3531 glink_vma + off - glink->vma, 4)) 3532 { 3533 unsigned int insn = bfd_get_32 (abfd, buf); 3534 insn ^= B_DOT; 3535 if ((insn & ~0x3fffffc) == 0) 3536 { 3537 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000; 3538 break; 3539 } 3540 off += 4; 3541 if (off > 4) 3542 break; 3543 } 3544 3545 if (resolv_vma) 3546 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve"); 3547 3548 relplt = bfd_get_section_by_name (abfd, ".rela.plt"); 3549 if (relplt != NULL) 3550 { 3551 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3552 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE)) 3553 goto free_contents_and_exit_err; 3554 3555 plt_count = relplt->size / sizeof (Elf64_External_Rela); 3556 size += plt_count * sizeof (asymbol); 3557 3558 p = relplt->relocation; 3559 for (i = 0; i < plt_count; i++, p++) 3560 { 3561 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 3562 if (p->addend != 0) 3563 size += sizeof ("+0x") - 1 + 16; 3564 } 3565 } 3566 } 3567 3568 if (size == 0) 3569 goto free_contents_and_exit; 3570 s = *ret = bfd_malloc (size); 3571 if (s == NULL) 3572 goto free_contents_and_exit_err; 3573 3574 names = (char *) (s + count + plt_count + (resolv_vma != 0)); 3575 3576 for (i = secsymend; i < opdsymend; ++i) 3577 { 3578 bfd_vma ent; 3579 3580 if (syms[i]->value > opd->size - 8) 3581 continue; 3582 3583 ent = bfd_get_64 (abfd, contents + syms[i]->value); 3584 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent)) 3585 { 3586 long lo, hi; 3587 size_t len; 3588 asection *sec = abfd->sections; 3589 3590 *s = *syms[i]; 3591 lo = codesecsym; 3592 hi = codesecsymend; 3593 while (lo < hi) 3594 { 3595 long mid = (lo + hi) >> 1; 3596 if (syms[mid]->section->vma < ent) 3597 lo = mid + 1; 3598 else if (syms[mid]->section->vma > ent) 3599 hi = mid; 3600 else 3601 { 3602 sec = syms[mid]->section; 3603 break; 3604 } 3605 } 3606 3607 if (lo >= hi && lo > codesecsym) 3608 sec = syms[lo - 1]->section; 3609 3610 for (; sec != NULL; sec = sec->next) 3611 { 3612 if (sec->vma > ent) 3613 break; 3614 /* SEC_LOAD may not be set if SEC is from a separate debug 3615 info file. */ 3616 if ((sec->flags & SEC_ALLOC) == 0) 3617 break; 3618 if ((sec->flags & SEC_CODE) != 0) 3619 s->section = sec; 3620 } 3621 s->flags |= BSF_SYNTHETIC; 3622 s->value = ent - s->section->vma; 3623 s->name = names; 3624 *names++ = '.'; 3625 len = strlen (syms[i]->name); 3626 memcpy (names, syms[i]->name, len + 1); 3627 names += len + 1; 3628 /* Have udata.p point back to the original symbol this 3629 synthetic symbol was derived from. */ 3630 s->udata.p = syms[i]; 3631 s++; 3632 } 3633 } 3634 free (contents); 3635 3636 if (glink != NULL && relplt != NULL) 3637 { 3638 if (resolv_vma) 3639 { 3640 /* Add a symbol for the main glink trampoline. */ 3641 memset (s, 0, sizeof *s); 3642 s->the_bfd = abfd; 3643 s->flags = BSF_GLOBAL | BSF_SYNTHETIC; 3644 s->section = glink; 3645 s->value = resolv_vma - glink->vma; 3646 s->name = names; 3647 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve")); 3648 names += sizeof ("__glink_PLTresolve"); 3649 s++; 3650 count++; 3651 } 3652 3653 /* FIXME: It would be very much nicer to put sym@plt on the 3654 stub rather than on the glink branch table entry. The 3655 objdump disassembler would then use a sensible symbol 3656 name on plt calls. The difficulty in doing so is 3657 a) finding the stubs, and, 3658 b) matching stubs against plt entries, and, 3659 c) there can be multiple stubs for a given plt entry. 3660 3661 Solving (a) could be done by code scanning, but older 3662 ppc64 binaries used different stubs to current code. 3663 (b) is the tricky one since you need to known the toc 3664 pointer for at least one function that uses a pic stub to 3665 be able to calculate the plt address referenced. 3666 (c) means gdb would need to set multiple breakpoints (or 3667 find the glink branch itself) when setting breakpoints 3668 for pending shared library loads. */ 3669 p = relplt->relocation; 3670 for (i = 0; i < plt_count; i++, p++) 3671 { 3672 size_t len; 3673 3674 *s = **p->sym_ptr_ptr; 3675 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 3676 we are defining a symbol, ensure one of them is set. */ 3677 if ((s->flags & BSF_LOCAL) == 0) 3678 s->flags |= BSF_GLOBAL; 3679 s->flags |= BSF_SYNTHETIC; 3680 s->section = glink; 3681 s->value = glink_vma - glink->vma; 3682 s->name = names; 3683 s->udata.p = NULL; 3684 len = strlen ((*p->sym_ptr_ptr)->name); 3685 memcpy (names, (*p->sym_ptr_ptr)->name, len); 3686 names += len; 3687 if (p->addend != 0) 3688 { 3689 memcpy (names, "+0x", sizeof ("+0x") - 1); 3690 names += sizeof ("+0x") - 1; 3691 bfd_sprintf_vma (abfd, names, p->addend); 3692 names += strlen (names); 3693 } 3694 memcpy (names, "@plt", sizeof ("@plt")); 3695 names += sizeof ("@plt"); 3696 s++; 3697 if (abi < 2) 3698 { 3699 glink_vma += 8; 3700 if (i >= 0x8000) 3701 glink_vma += 4; 3702 } 3703 else 3704 glink_vma += 4; 3705 } 3706 count += plt_count; 3707 } 3708 } 3709 3710 done: 3711 free (syms); 3712 return count; 3713} 3714 3715/* The following functions are specific to the ELF linker, while 3716 functions above are used generally. Those named ppc64_elf_* are 3717 called by the main ELF linker code. They appear in this file more 3718 or less in the order in which they are called. eg. 3719 ppc64_elf_check_relocs is called early in the link process, 3720 ppc64_elf_finish_dynamic_sections is one of the last functions 3721 called. 3722 3723 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that 3724 functions have both a function code symbol and a function descriptor 3725 symbol. A call to foo in a relocatable object file looks like: 3726 3727 . .text 3728 . x: 3729 . bl .foo 3730 . nop 3731 3732 The function definition in another object file might be: 3733 3734 . .section .opd 3735 . foo: .quad .foo 3736 . .quad .TOC.@tocbase 3737 . .quad 0 3738 . 3739 . .text 3740 . .foo: blr 3741 3742 When the linker resolves the call during a static link, the branch 3743 unsurprisingly just goes to .foo and the .opd information is unused. 3744 If the function definition is in a shared library, things are a little 3745 different: The call goes via a plt call stub, the opd information gets 3746 copied to the plt, and the linker patches the nop. 3747 3748 . x: 3749 . bl .foo_stub 3750 . ld 2,40(1) 3751 . 3752 . 3753 . .foo_stub: 3754 . std 2,40(1) # in practice, the call stub 3755 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but 3756 . addi 11,11,Lfoo@toc@l # this is the general idea 3757 . ld 12,0(11) 3758 . ld 2,8(11) 3759 . mtctr 12 3760 . ld 11,16(11) 3761 . bctr 3762 . 3763 . .section .plt 3764 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo) 3765 3766 The "reloc ()" notation is supposed to indicate that the linker emits 3767 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd 3768 copying. 3769 3770 What are the difficulties here? Well, firstly, the relocations 3771 examined by the linker in check_relocs are against the function code 3772 sym .foo, while the dynamic relocation in the plt is emitted against 3773 the function descriptor symbol, foo. Somewhere along the line, we need 3774 to carefully copy dynamic link information from one symbol to the other. 3775 Secondly, the generic part of the elf linker will make .foo a dynamic 3776 symbol as is normal for most other backends. We need foo dynamic 3777 instead, at least for an application final link. However, when 3778 creating a shared library containing foo, we need to have both symbols 3779 dynamic so that references to .foo are satisfied during the early 3780 stages of linking. Otherwise the linker might decide to pull in a 3781 definition from some other object, eg. a static library. 3782 3783 Update: As of August 2004, we support a new convention. Function 3784 calls may use the function descriptor symbol, ie. "bl foo". This 3785 behaves exactly as "bl .foo". */ 3786 3787/* Of those relocs that might be copied as dynamic relocs, this function 3788 selects those that must be copied when linking a shared library, 3789 even when the symbol is local. */ 3790 3791static int 3792must_be_dyn_reloc (struct bfd_link_info *info, 3793 enum elf_ppc64_reloc_type r_type) 3794{ 3795 switch (r_type) 3796 { 3797 default: 3798 return 1; 3799 3800 case R_PPC64_REL32: 3801 case R_PPC64_REL64: 3802 case R_PPC64_REL30: 3803 return 0; 3804 3805 case R_PPC64_TPREL16: 3806 case R_PPC64_TPREL16_LO: 3807 case R_PPC64_TPREL16_HI: 3808 case R_PPC64_TPREL16_HA: 3809 case R_PPC64_TPREL16_DS: 3810 case R_PPC64_TPREL16_LO_DS: 3811 case R_PPC64_TPREL16_HIGH: 3812 case R_PPC64_TPREL16_HIGHA: 3813 case R_PPC64_TPREL16_HIGHER: 3814 case R_PPC64_TPREL16_HIGHERA: 3815 case R_PPC64_TPREL16_HIGHEST: 3816 case R_PPC64_TPREL16_HIGHESTA: 3817 case R_PPC64_TPREL64: 3818 return !bfd_link_executable (info); 3819 } 3820} 3821 3822/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 3823 copying dynamic variables from a shared lib into an app's dynbss 3824 section, and instead use a dynamic relocation to point into the 3825 shared lib. With code that gcc generates, it's vital that this be 3826 enabled; In the PowerPC64 ABI, the address of a function is actually 3827 the address of a function descriptor, which resides in the .opd 3828 section. gcc uses the descriptor directly rather than going via the 3829 GOT as some other ABI's do, which means that initialized function 3830 pointers must reference the descriptor. Thus, a function pointer 3831 initialized to the address of a function in a shared library will 3832 either require a copy reloc, or a dynamic reloc. Using a copy reloc 3833 redefines the function descriptor symbol to point to the copy. This 3834 presents a problem as a plt entry for that function is also 3835 initialized from the function descriptor symbol and the copy reloc 3836 may not be initialized first. */ 3837#define ELIMINATE_COPY_RELOCS 1 3838 3839/* Section name for stubs is the associated section name plus this 3840 string. */ 3841#define STUB_SUFFIX ".stub" 3842 3843/* Linker stubs. 3844 ppc_stub_long_branch: 3845 Used when a 14 bit branch (or even a 24 bit branch) can't reach its 3846 destination, but a 24 bit branch in a stub section will reach. 3847 . b dest 3848 3849 ppc_stub_plt_branch: 3850 Similar to the above, but a 24 bit branch in the stub section won't 3851 reach its destination. 3852 . addis %r11,%r2,xxx@toc@ha 3853 . ld %r12,xxx@toc@l(%r11) 3854 . mtctr %r12 3855 . bctr 3856 3857 ppc_stub_plt_call: 3858 Used to call a function in a shared library. If it so happens that 3859 the plt entry referenced crosses a 64k boundary, then an extra 3860 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr". 3861 . std %r2,40(%r1) 3862 . addis %r11,%r2,xxx@toc@ha 3863 . ld %r12,xxx+0@toc@l(%r11) 3864 . mtctr %r12 3865 . ld %r2,xxx+8@toc@l(%r11) 3866 . ld %r11,xxx+16@toc@l(%r11) 3867 . bctr 3868 3869 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional 3870 code to adjust the value and save r2 to support multiple toc sections. 3871 A ppc_stub_long_branch with an r2 offset looks like: 3872 . std %r2,40(%r1) 3873 . addis %r2,%r2,off@ha 3874 . addi %r2,%r2,off@l 3875 . b dest 3876 3877 A ppc_stub_plt_branch with an r2 offset looks like: 3878 . std %r2,40(%r1) 3879 . addis %r11,%r2,xxx@toc@ha 3880 . ld %r12,xxx@toc@l(%r11) 3881 . addis %r2,%r2,off@ha 3882 . addi %r2,%r2,off@l 3883 . mtctr %r12 3884 . bctr 3885 3886 In cases where the "addis" instruction would add zero, the "addis" is 3887 omitted and following instructions modified slightly in some cases. 3888*/ 3889 3890enum ppc_stub_type { 3891 ppc_stub_none, 3892 ppc_stub_long_branch, 3893 ppc_stub_long_branch_r2off, 3894 ppc_stub_plt_branch, 3895 ppc_stub_plt_branch_r2off, 3896 ppc_stub_plt_call, 3897 ppc_stub_plt_call_r2save, 3898 ppc_stub_global_entry, 3899 ppc_stub_save_res 3900}; 3901 3902/* Information on stub grouping. */ 3903struct map_stub 3904{ 3905 /* The stub section. */ 3906 asection *stub_sec; 3907 /* This is the section to which stubs in the group will be attached. */ 3908 asection *link_sec; 3909 /* Next group. */ 3910 struct map_stub *next; 3911 /* Whether to emit a copy of register save/restore functions in this 3912 group. */ 3913 int needs_save_res; 3914}; 3915 3916struct ppc_stub_hash_entry { 3917 3918 /* Base hash table entry structure. */ 3919 struct bfd_hash_entry root; 3920 3921 enum ppc_stub_type stub_type; 3922 3923 /* Group information. */ 3924 struct map_stub *group; 3925 3926 /* Offset within stub_sec of the beginning of this stub. */ 3927 bfd_vma stub_offset; 3928 3929 /* Given the symbol's value and its section we can determine its final 3930 value when building the stubs (so the stub knows where to jump. */ 3931 bfd_vma target_value; 3932 asection *target_section; 3933 3934 /* The symbol table entry, if any, that this was derived from. */ 3935 struct ppc_link_hash_entry *h; 3936 struct plt_entry *plt_ent; 3937 3938 /* Symbol st_other. */ 3939 unsigned char other; 3940}; 3941 3942struct ppc_branch_hash_entry { 3943 3944 /* Base hash table entry structure. */ 3945 struct bfd_hash_entry root; 3946 3947 /* Offset within branch lookup table. */ 3948 unsigned int offset; 3949 3950 /* Generation marker. */ 3951 unsigned int iter; 3952}; 3953 3954/* Used to track dynamic relocations for local symbols. */ 3955struct ppc_dyn_relocs 3956{ 3957 struct ppc_dyn_relocs *next; 3958 3959 /* The input section of the reloc. */ 3960 asection *sec; 3961 3962 /* Total number of relocs copied for the input section. */ 3963 unsigned int count : 31; 3964 3965 /* Whether this entry is for STT_GNU_IFUNC symbols. */ 3966 unsigned int ifunc : 1; 3967}; 3968 3969struct ppc_link_hash_entry 3970{ 3971 struct elf_link_hash_entry elf; 3972 3973 union { 3974 /* A pointer to the most recently used stub hash entry against this 3975 symbol. */ 3976 struct ppc_stub_hash_entry *stub_cache; 3977 3978 /* A pointer to the next symbol starting with a '.' */ 3979 struct ppc_link_hash_entry *next_dot_sym; 3980 } u; 3981 3982 /* Track dynamic relocs copied for this symbol. */ 3983 struct elf_dyn_relocs *dyn_relocs; 3984 3985 /* Chain of aliases referring to a weakdef. */ 3986 struct ppc_link_hash_entry *weakref; 3987 3988 /* Link between function code and descriptor symbols. */ 3989 struct ppc_link_hash_entry *oh; 3990 3991 /* Flag function code and descriptor symbols. */ 3992 unsigned int is_func:1; 3993 unsigned int is_func_descriptor:1; 3994 unsigned int fake:1; 3995 3996 /* Whether global opd/toc sym has been adjusted or not. 3997 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag 3998 should be set for all globals defined in any opd/toc section. */ 3999 unsigned int adjust_done:1; 4000 4001 /* Set if this is an out-of-line register save/restore function, 4002 with non-standard calling convention. */ 4003 unsigned int save_res:1; 4004 4005 /* Contexts in which symbol is used in the GOT (or TOC). 4006 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the 4007 corresponding relocs are encountered during check_relocs. 4008 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to 4009 indicate the corresponding GOT entry type is not needed. 4010 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into 4011 a TPREL one. We use a separate flag rather than setting TPREL 4012 just for convenience in distinguishing the two cases. */ 4013#define TLS_GD 1 /* GD reloc. */ 4014#define TLS_LD 2 /* LD reloc. */ 4015#define TLS_TPREL 4 /* TPREL reloc, => IE. */ 4016#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ 4017#define TLS_TLS 16 /* Any TLS reloc. */ 4018#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */ 4019#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */ 4020#define PLT_IFUNC 128 /* STT_GNU_IFUNC. */ 4021 unsigned char tls_mask; 4022}; 4023 4024/* ppc64 ELF linker hash table. */ 4025 4026struct ppc_link_hash_table 4027{ 4028 struct elf_link_hash_table elf; 4029 4030 /* The stub hash table. */ 4031 struct bfd_hash_table stub_hash_table; 4032 4033 /* Another hash table for plt_branch stubs. */ 4034 struct bfd_hash_table branch_hash_table; 4035 4036 /* Hash table for function prologue tocsave. */ 4037 htab_t tocsave_htab; 4038 4039 /* Various options and other info passed from the linker. */ 4040 struct ppc64_elf_params *params; 4041 4042 /* The size of sec_info below. */ 4043 unsigned int sec_info_arr_size; 4044 4045 /* Per-section array of extra section info. Done this way rather 4046 than as part of ppc64_elf_section_data so we have the info for 4047 non-ppc64 sections. */ 4048 struct 4049 { 4050 /* Along with elf_gp, specifies the TOC pointer used by this section. */ 4051 bfd_vma toc_off; 4052 4053 union 4054 { 4055 /* The section group that this section belongs to. */ 4056 struct map_stub *group; 4057 /* A temp section list pointer. */ 4058 asection *list; 4059 } u; 4060 } *sec_info; 4061 4062 /* Linked list of groups. */ 4063 struct map_stub *group; 4064 4065 /* Temp used when calculating TOC pointers. */ 4066 bfd_vma toc_curr; 4067 bfd *toc_bfd; 4068 asection *toc_first_sec; 4069 4070 /* Used when adding symbols. */ 4071 struct ppc_link_hash_entry *dot_syms; 4072 4073 /* Shortcuts to get to dynamic linker sections. */ 4074 asection *glink; 4075 asection *sfpr; 4076 asection *brlt; 4077 asection *relbrlt; 4078 asection *glink_eh_frame; 4079 4080 /* Shortcut to .__tls_get_addr and __tls_get_addr. */ 4081 struct ppc_link_hash_entry *tls_get_addr; 4082 struct ppc_link_hash_entry *tls_get_addr_fd; 4083 4084 /* The size of reliplt used by got entry relocs. */ 4085 bfd_size_type got_reli_size; 4086 4087 /* Statistics. */ 4088 unsigned long stub_count[ppc_stub_global_entry]; 4089 4090 /* Number of stubs against global syms. */ 4091 unsigned long stub_globals; 4092 4093 /* Set if we're linking code with function descriptors. */ 4094 unsigned int opd_abi:1; 4095 4096 /* Support for multiple toc sections. */ 4097 unsigned int do_multi_toc:1; 4098 unsigned int multi_toc_needed:1; 4099 unsigned int second_toc_pass:1; 4100 unsigned int do_toc_opt:1; 4101 4102 /* Set on error. */ 4103 unsigned int stub_error:1; 4104 4105 /* Whether func_desc_adjust needs to be run over symbols. */ 4106 unsigned int need_func_desc_adj:1; 4107 4108 /* Incremented every time we size stubs. */ 4109 unsigned int stub_iteration; 4110 4111 /* Small local sym cache. */ 4112 struct sym_cache sym_cache; 4113}; 4114 4115/* Rename some of the generic section flags to better document how they 4116 are used here. */ 4117 4118/* Nonzero if this section has TLS related relocations. */ 4119#define has_tls_reloc sec_flg0 4120 4121/* Nonzero if this section has a call to __tls_get_addr. */ 4122#define has_tls_get_addr_call sec_flg1 4123 4124/* Nonzero if this section has any toc or got relocs. */ 4125#define has_toc_reloc sec_flg2 4126 4127/* Nonzero if this section has a call to another section that uses 4128 the toc or got. */ 4129#define makes_toc_func_call sec_flg3 4130 4131/* Recursion protection when determining above flag. */ 4132#define call_check_in_progress sec_flg4 4133#define call_check_done sec_flg5 4134 4135/* Get the ppc64 ELF linker hash table from a link_info structure. */ 4136 4137#define ppc_hash_table(p) \ 4138 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 4139 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL) 4140 4141#define ppc_stub_hash_lookup(table, string, create, copy) \ 4142 ((struct ppc_stub_hash_entry *) \ 4143 bfd_hash_lookup ((table), (string), (create), (copy))) 4144 4145#define ppc_branch_hash_lookup(table, string, create, copy) \ 4146 ((struct ppc_branch_hash_entry *) \ 4147 bfd_hash_lookup ((table), (string), (create), (copy))) 4148 4149/* Create an entry in the stub hash table. */ 4150 4151static struct bfd_hash_entry * 4152stub_hash_newfunc (struct bfd_hash_entry *entry, 4153 struct bfd_hash_table *table, 4154 const char *string) 4155{ 4156 /* Allocate the structure if it has not already been allocated by a 4157 subclass. */ 4158 if (entry == NULL) 4159 { 4160 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry)); 4161 if (entry == NULL) 4162 return entry; 4163 } 4164 4165 /* Call the allocation method of the superclass. */ 4166 entry = bfd_hash_newfunc (entry, table, string); 4167 if (entry != NULL) 4168 { 4169 struct ppc_stub_hash_entry *eh; 4170 4171 /* Initialize the local fields. */ 4172 eh = (struct ppc_stub_hash_entry *) entry; 4173 eh->stub_type = ppc_stub_none; 4174 eh->group = NULL; 4175 eh->stub_offset = 0; 4176 eh->target_value = 0; 4177 eh->target_section = NULL; 4178 eh->h = NULL; 4179 eh->plt_ent = NULL; 4180 eh->other = 0; 4181 } 4182 4183 return entry; 4184} 4185 4186/* Create an entry in the branch hash table. */ 4187 4188static struct bfd_hash_entry * 4189branch_hash_newfunc (struct bfd_hash_entry *entry, 4190 struct bfd_hash_table *table, 4191 const char *string) 4192{ 4193 /* Allocate the structure if it has not already been allocated by a 4194 subclass. */ 4195 if (entry == NULL) 4196 { 4197 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry)); 4198 if (entry == NULL) 4199 return entry; 4200 } 4201 4202 /* Call the allocation method of the superclass. */ 4203 entry = bfd_hash_newfunc (entry, table, string); 4204 if (entry != NULL) 4205 { 4206 struct ppc_branch_hash_entry *eh; 4207 4208 /* Initialize the local fields. */ 4209 eh = (struct ppc_branch_hash_entry *) entry; 4210 eh->offset = 0; 4211 eh->iter = 0; 4212 } 4213 4214 return entry; 4215} 4216 4217/* Create an entry in a ppc64 ELF linker hash table. */ 4218 4219static struct bfd_hash_entry * 4220link_hash_newfunc (struct bfd_hash_entry *entry, 4221 struct bfd_hash_table *table, 4222 const char *string) 4223{ 4224 /* Allocate the structure if it has not already been allocated by a 4225 subclass. */ 4226 if (entry == NULL) 4227 { 4228 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry)); 4229 if (entry == NULL) 4230 return entry; 4231 } 4232 4233 /* Call the allocation method of the superclass. */ 4234 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 4235 if (entry != NULL) 4236 { 4237 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry; 4238 4239 memset (&eh->u.stub_cache, 0, 4240 (sizeof (struct ppc_link_hash_entry) 4241 - offsetof (struct ppc_link_hash_entry, u.stub_cache))); 4242 4243 /* When making function calls, old ABI code references function entry 4244 points (dot symbols), while new ABI code references the function 4245 descriptor symbol. We need to make any combination of reference and 4246 definition work together, without breaking archive linking. 4247 4248 For a defined function "foo" and an undefined call to "bar": 4249 An old object defines "foo" and ".foo", references ".bar" (possibly 4250 "bar" too). 4251 A new object defines "foo" and references "bar". 4252 4253 A new object thus has no problem with its undefined symbols being 4254 satisfied by definitions in an old object. On the other hand, the 4255 old object won't have ".bar" satisfied by a new object. 4256 4257 Keep a list of newly added dot-symbols. */ 4258 4259 if (string[0] == '.') 4260 { 4261 struct ppc_link_hash_table *htab; 4262 4263 htab = (struct ppc_link_hash_table *) table; 4264 eh->u.next_dot_sym = htab->dot_syms; 4265 htab->dot_syms = eh; 4266 } 4267 } 4268 4269 return entry; 4270} 4271 4272struct tocsave_entry { 4273 asection *sec; 4274 bfd_vma offset; 4275}; 4276 4277static hashval_t 4278tocsave_htab_hash (const void *p) 4279{ 4280 const struct tocsave_entry *e = (const struct tocsave_entry *) p; 4281 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3; 4282} 4283 4284static int 4285tocsave_htab_eq (const void *p1, const void *p2) 4286{ 4287 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1; 4288 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2; 4289 return e1->sec == e2->sec && e1->offset == e2->offset; 4290} 4291 4292/* Destroy a ppc64 ELF linker hash table. */ 4293 4294static void 4295ppc64_elf_link_hash_table_free (bfd *obfd) 4296{ 4297 struct ppc_link_hash_table *htab; 4298 4299 htab = (struct ppc_link_hash_table *) obfd->link.hash; 4300 if (htab->tocsave_htab) 4301 htab_delete (htab->tocsave_htab); 4302 bfd_hash_table_free (&htab->branch_hash_table); 4303 bfd_hash_table_free (&htab->stub_hash_table); 4304 _bfd_elf_link_hash_table_free (obfd); 4305} 4306 4307/* Create a ppc64 ELF linker hash table. */ 4308 4309static struct bfd_link_hash_table * 4310ppc64_elf_link_hash_table_create (bfd *abfd) 4311{ 4312 struct ppc_link_hash_table *htab; 4313 bfd_size_type amt = sizeof (struct ppc_link_hash_table); 4314 4315 htab = bfd_zmalloc (amt); 4316 if (htab == NULL) 4317 return NULL; 4318 4319 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc, 4320 sizeof (struct ppc_link_hash_entry), 4321 PPC64_ELF_DATA)) 4322 { 4323 free (htab); 4324 return NULL; 4325 } 4326 4327 /* Init the stub hash table too. */ 4328 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc, 4329 sizeof (struct ppc_stub_hash_entry))) 4330 { 4331 _bfd_elf_link_hash_table_free (abfd); 4332 return NULL; 4333 } 4334 4335 /* And the branch hash table. */ 4336 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc, 4337 sizeof (struct ppc_branch_hash_entry))) 4338 { 4339 bfd_hash_table_free (&htab->stub_hash_table); 4340 _bfd_elf_link_hash_table_free (abfd); 4341 return NULL; 4342 } 4343 4344 htab->tocsave_htab = htab_try_create (1024, 4345 tocsave_htab_hash, 4346 tocsave_htab_eq, 4347 NULL); 4348 if (htab->tocsave_htab == NULL) 4349 { 4350 ppc64_elf_link_hash_table_free (abfd); 4351 return NULL; 4352 } 4353 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free; 4354 4355 /* Initializing two fields of the union is just cosmetic. We really 4356 only care about glist, but when compiled on a 32-bit host the 4357 bfd_vma fields are larger. Setting the bfd_vma to zero makes 4358 debugger inspection of these fields look nicer. */ 4359 htab->elf.init_got_refcount.refcount = 0; 4360 htab->elf.init_got_refcount.glist = NULL; 4361 htab->elf.init_plt_refcount.refcount = 0; 4362 htab->elf.init_plt_refcount.glist = NULL; 4363 htab->elf.init_got_offset.offset = 0; 4364 htab->elf.init_got_offset.glist = NULL; 4365 htab->elf.init_plt_offset.offset = 0; 4366 htab->elf.init_plt_offset.glist = NULL; 4367 4368 return &htab->elf.root; 4369} 4370 4371/* Create sections for linker generated code. */ 4372 4373static bfd_boolean 4374create_linkage_sections (bfd *dynobj, struct bfd_link_info *info) 4375{ 4376 struct ppc_link_hash_table *htab; 4377 flagword flags; 4378 4379 htab = ppc_hash_table (info); 4380 4381 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 4382 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4383 if (htab->params->save_restore_funcs) 4384 { 4385 /* Create .sfpr for code to save and restore fp regs. */ 4386 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr", 4387 flags); 4388 if (htab->sfpr == NULL 4389 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2)) 4390 return FALSE; 4391 } 4392 4393 if (bfd_link_relocatable (info)) 4394 return TRUE; 4395 4396 /* Create .glink for lazy dynamic linking support. */ 4397 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink", 4398 flags); 4399 if (htab->glink == NULL 4400 || ! bfd_set_section_alignment (dynobj, htab->glink, 3)) 4401 return FALSE; 4402 4403 if (!info->no_ld_generated_unwind_info) 4404 { 4405 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS 4406 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4407 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj, 4408 ".eh_frame", 4409 flags); 4410 if (htab->glink_eh_frame == NULL 4411 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2)) 4412 return FALSE; 4413 } 4414 4415 flags = SEC_ALLOC | SEC_LINKER_CREATED; 4416 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags); 4417 if (htab->elf.iplt == NULL 4418 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3)) 4419 return FALSE; 4420 4421 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 4422 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4423 htab->elf.irelplt 4424 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags); 4425 if (htab->elf.irelplt == NULL 4426 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3)) 4427 return FALSE; 4428 4429 /* Create branch lookup table for plt_branch stubs. */ 4430 flags = (SEC_ALLOC | SEC_LOAD 4431 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4432 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt", 4433 flags); 4434 if (htab->brlt == NULL 4435 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3)) 4436 return FALSE; 4437 4438 if (!bfd_link_pic (info)) 4439 return TRUE; 4440 4441 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 4442 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4443 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj, 4444 ".rela.branch_lt", 4445 flags); 4446 if (htab->relbrlt == NULL 4447 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3)) 4448 return FALSE; 4449 4450 return TRUE; 4451} 4452 4453/* Satisfy the ELF linker by filling in some fields in our fake bfd. */ 4454 4455bfd_boolean 4456ppc64_elf_init_stub_bfd (struct bfd_link_info *info, 4457 struct ppc64_elf_params *params) 4458{ 4459 struct ppc_link_hash_table *htab; 4460 4461 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64; 4462 4463/* Always hook our dynamic sections into the first bfd, which is the 4464 linker created stub bfd. This ensures that the GOT header is at 4465 the start of the output TOC section. */ 4466 htab = ppc_hash_table (info); 4467 htab->elf.dynobj = params->stub_bfd; 4468 htab->params = params; 4469 4470 return create_linkage_sections (htab->elf.dynobj, info); 4471} 4472 4473/* Build a name for an entry in the stub hash table. */ 4474 4475static char * 4476ppc_stub_name (const asection *input_section, 4477 const asection *sym_sec, 4478 const struct ppc_link_hash_entry *h, 4479 const Elf_Internal_Rela *rel) 4480{ 4481 char *stub_name; 4482 ssize_t len; 4483 4484 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31 4485 offsets from a sym as a branch target? In fact, we could 4486 probably assume the addend is always zero. */ 4487 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend); 4488 4489 if (h) 4490 { 4491 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1; 4492 stub_name = bfd_malloc (len); 4493 if (stub_name == NULL) 4494 return stub_name; 4495 4496 len = sprintf (stub_name, "%08x.%s+%x", 4497 input_section->id & 0xffffffff, 4498 h->elf.root.root.string, 4499 (int) rel->r_addend & 0xffffffff); 4500 } 4501 else 4502 { 4503 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1; 4504 stub_name = bfd_malloc (len); 4505 if (stub_name == NULL) 4506 return stub_name; 4507 4508 len = sprintf (stub_name, "%08x.%x:%x+%x", 4509 input_section->id & 0xffffffff, 4510 sym_sec->id & 0xffffffff, 4511 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff, 4512 (int) rel->r_addend & 0xffffffff); 4513 } 4514 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0') 4515 stub_name[len - 2] = 0; 4516 return stub_name; 4517} 4518 4519/* Look up an entry in the stub hash. Stub entries are cached because 4520 creating the stub name takes a bit of time. */ 4521 4522static struct ppc_stub_hash_entry * 4523ppc_get_stub_entry (const asection *input_section, 4524 const asection *sym_sec, 4525 struct ppc_link_hash_entry *h, 4526 const Elf_Internal_Rela *rel, 4527 struct ppc_link_hash_table *htab) 4528{ 4529 struct ppc_stub_hash_entry *stub_entry; 4530 struct map_stub *group; 4531 4532 /* If this input section is part of a group of sections sharing one 4533 stub section, then use the id of the first section in the group. 4534 Stub names need to include a section id, as there may well be 4535 more than one stub used to reach say, printf, and we need to 4536 distinguish between them. */ 4537 group = htab->sec_info[input_section->id].u.group; 4538 if (group == NULL) 4539 return NULL; 4540 4541 if (h != NULL && h->u.stub_cache != NULL 4542 && h->u.stub_cache->h == h 4543 && h->u.stub_cache->group == group) 4544 { 4545 stub_entry = h->u.stub_cache; 4546 } 4547 else 4548 { 4549 char *stub_name; 4550 4551 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel); 4552 if (stub_name == NULL) 4553 return NULL; 4554 4555 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, 4556 stub_name, FALSE, FALSE); 4557 if (h != NULL) 4558 h->u.stub_cache = stub_entry; 4559 4560 free (stub_name); 4561 } 4562 4563 return stub_entry; 4564} 4565 4566/* Add a new stub entry to the stub hash. Not all fields of the new 4567 stub entry are initialised. */ 4568 4569static struct ppc_stub_hash_entry * 4570ppc_add_stub (const char *stub_name, 4571 asection *section, 4572 struct bfd_link_info *info) 4573{ 4574 struct ppc_link_hash_table *htab = ppc_hash_table (info); 4575 struct map_stub *group; 4576 asection *link_sec; 4577 asection *stub_sec; 4578 struct ppc_stub_hash_entry *stub_entry; 4579 4580 group = htab->sec_info[section->id].u.group; 4581 link_sec = group->link_sec; 4582 stub_sec = group->stub_sec; 4583 if (stub_sec == NULL) 4584 { 4585 size_t namelen; 4586 bfd_size_type len; 4587 char *s_name; 4588 4589 namelen = strlen (link_sec->name); 4590 len = namelen + sizeof (STUB_SUFFIX); 4591 s_name = bfd_alloc (htab->params->stub_bfd, len); 4592 if (s_name == NULL) 4593 return NULL; 4594 4595 memcpy (s_name, link_sec->name, namelen); 4596 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX)); 4597 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec); 4598 if (stub_sec == NULL) 4599 return NULL; 4600 group->stub_sec = stub_sec; 4601 } 4602 4603 /* Enter this entry into the linker stub hash table. */ 4604 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name, 4605 TRUE, FALSE); 4606 if (stub_entry == NULL) 4607 { 4608 /* xgettext:c-format */ 4609 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"), 4610 section->owner, stub_name); 4611 return NULL; 4612 } 4613 4614 stub_entry->group = group; 4615 stub_entry->stub_offset = 0; 4616 return stub_entry; 4617} 4618 4619/* Create .got and .rela.got sections in ABFD, and .got in dynobj if 4620 not already done. */ 4621 4622static bfd_boolean 4623create_got_section (bfd *abfd, struct bfd_link_info *info) 4624{ 4625 asection *got, *relgot; 4626 flagword flags; 4627 struct ppc_link_hash_table *htab = ppc_hash_table (info); 4628 4629 if (!is_ppc64_elf (abfd)) 4630 return FALSE; 4631 if (htab == NULL) 4632 return FALSE; 4633 4634 if (!htab->elf.sgot 4635 && !_bfd_elf_create_got_section (htab->elf.dynobj, info)) 4636 return FALSE; 4637 4638 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 4639 | SEC_LINKER_CREATED); 4640 4641 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 4642 if (!got 4643 || !bfd_set_section_alignment (abfd, got, 3)) 4644 return FALSE; 4645 4646 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got", 4647 flags | SEC_READONLY); 4648 if (!relgot 4649 || ! bfd_set_section_alignment (abfd, relgot, 3)) 4650 return FALSE; 4651 4652 ppc64_elf_tdata (abfd)->got = got; 4653 ppc64_elf_tdata (abfd)->relgot = relgot; 4654 return TRUE; 4655} 4656 4657/* Follow indirect and warning symbol links. */ 4658 4659static inline struct bfd_link_hash_entry * 4660follow_link (struct bfd_link_hash_entry *h) 4661{ 4662 while (h->type == bfd_link_hash_indirect 4663 || h->type == bfd_link_hash_warning) 4664 h = h->u.i.link; 4665 return h; 4666} 4667 4668static inline struct elf_link_hash_entry * 4669elf_follow_link (struct elf_link_hash_entry *h) 4670{ 4671 return (struct elf_link_hash_entry *) follow_link (&h->root); 4672} 4673 4674static inline struct ppc_link_hash_entry * 4675ppc_follow_link (struct ppc_link_hash_entry *h) 4676{ 4677 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root); 4678} 4679 4680/* Merge PLT info on FROM with that on TO. */ 4681 4682static void 4683move_plt_plist (struct ppc_link_hash_entry *from, 4684 struct ppc_link_hash_entry *to) 4685{ 4686 if (from->elf.plt.plist != NULL) 4687 { 4688 if (to->elf.plt.plist != NULL) 4689 { 4690 struct plt_entry **entp; 4691 struct plt_entry *ent; 4692 4693 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; ) 4694 { 4695 struct plt_entry *dent; 4696 4697 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next) 4698 if (dent->addend == ent->addend) 4699 { 4700 dent->plt.refcount += ent->plt.refcount; 4701 *entp = ent->next; 4702 break; 4703 } 4704 if (dent == NULL) 4705 entp = &ent->next; 4706 } 4707 *entp = to->elf.plt.plist; 4708 } 4709 4710 to->elf.plt.plist = from->elf.plt.plist; 4711 from->elf.plt.plist = NULL; 4712 } 4713} 4714 4715/* Copy the extra info we tack onto an elf_link_hash_entry. */ 4716 4717static void 4718ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info, 4719 struct elf_link_hash_entry *dir, 4720 struct elf_link_hash_entry *ind) 4721{ 4722 struct ppc_link_hash_entry *edir, *eind; 4723 4724 edir = (struct ppc_link_hash_entry *) dir; 4725 eind = (struct ppc_link_hash_entry *) ind; 4726 4727 edir->is_func |= eind->is_func; 4728 edir->is_func_descriptor |= eind->is_func_descriptor; 4729 edir->tls_mask |= eind->tls_mask; 4730 if (eind->oh != NULL) 4731 edir->oh = ppc_follow_link (eind->oh); 4732 4733 /* If called to transfer flags for a weakdef during processing 4734 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF. 4735 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 4736 if (!(ELIMINATE_COPY_RELOCS 4737 && eind->elf.root.type != bfd_link_hash_indirect 4738 && edir->elf.dynamic_adjusted)) 4739 edir->elf.non_got_ref |= eind->elf.non_got_ref; 4740 4741 if (edir->elf.versioned != versioned_hidden) 4742 edir->elf.ref_dynamic |= eind->elf.ref_dynamic; 4743 edir->elf.ref_regular |= eind->elf.ref_regular; 4744 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak; 4745 edir->elf.needs_plt |= eind->elf.needs_plt; 4746 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed; 4747 4748 /* If we were called to copy over info for a weak sym, don't copy 4749 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs 4750 in order to simplify readonly_dynrelocs and save a field in the 4751 symbol hash entry, but that means dyn_relocs can't be used in any 4752 tests about a specific symbol, or affect other symbol flags which 4753 are then tested. 4754 Chain weakdefs so we can get from the weakdef back to an alias. 4755 The list is circular so that we don't need to use u.weakdef as 4756 well as this list to look at all aliases. */ 4757 if (eind->elf.root.type != bfd_link_hash_indirect) 4758 { 4759 struct ppc_link_hash_entry *cur, *add, *next; 4760 4761 add = eind; 4762 do 4763 { 4764 cur = edir->weakref; 4765 if (cur != NULL) 4766 { 4767 do 4768 { 4769 /* We can be called twice for the same symbols. 4770 Don't make multiple loops. */ 4771 if (cur == add) 4772 return; 4773 cur = cur->weakref; 4774 } while (cur != edir); 4775 } 4776 next = add->weakref; 4777 if (cur != add) 4778 { 4779 add->weakref = edir->weakref != NULL ? edir->weakref : edir; 4780 edir->weakref = add; 4781 } 4782 add = next; 4783 } while (add != NULL && add != eind); 4784 return; 4785 } 4786 4787 /* Copy over any dynamic relocs we may have on the indirect sym. */ 4788 if (eind->dyn_relocs != NULL) 4789 { 4790 if (edir->dyn_relocs != NULL) 4791 { 4792 struct elf_dyn_relocs **pp; 4793 struct elf_dyn_relocs *p; 4794 4795 /* Add reloc counts against the indirect sym to the direct sym 4796 list. Merge any entries against the same section. */ 4797 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 4798 { 4799 struct elf_dyn_relocs *q; 4800 4801 for (q = edir->dyn_relocs; q != NULL; q = q->next) 4802 if (q->sec == p->sec) 4803 { 4804 q->pc_count += p->pc_count; 4805 q->count += p->count; 4806 *pp = p->next; 4807 break; 4808 } 4809 if (q == NULL) 4810 pp = &p->next; 4811 } 4812 *pp = edir->dyn_relocs; 4813 } 4814 4815 edir->dyn_relocs = eind->dyn_relocs; 4816 eind->dyn_relocs = NULL; 4817 } 4818 4819 /* Copy over got entries that we may have already seen to the 4820 symbol which just became indirect. */ 4821 if (eind->elf.got.glist != NULL) 4822 { 4823 if (edir->elf.got.glist != NULL) 4824 { 4825 struct got_entry **entp; 4826 struct got_entry *ent; 4827 4828 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; ) 4829 { 4830 struct got_entry *dent; 4831 4832 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next) 4833 if (dent->addend == ent->addend 4834 && dent->owner == ent->owner 4835 && dent->tls_type == ent->tls_type) 4836 { 4837 dent->got.refcount += ent->got.refcount; 4838 *entp = ent->next; 4839 break; 4840 } 4841 if (dent == NULL) 4842 entp = &ent->next; 4843 } 4844 *entp = edir->elf.got.glist; 4845 } 4846 4847 edir->elf.got.glist = eind->elf.got.glist; 4848 eind->elf.got.glist = NULL; 4849 } 4850 4851 /* And plt entries. */ 4852 move_plt_plist (eind, edir); 4853 4854 if (eind->elf.dynindx != -1) 4855 { 4856 if (edir->elf.dynindx != -1) 4857 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 4858 edir->elf.dynstr_index); 4859 edir->elf.dynindx = eind->elf.dynindx; 4860 edir->elf.dynstr_index = eind->elf.dynstr_index; 4861 eind->elf.dynindx = -1; 4862 eind->elf.dynstr_index = 0; 4863 } 4864} 4865 4866/* Find the function descriptor hash entry from the given function code 4867 hash entry FH. Link the entries via their OH fields. */ 4868 4869static struct ppc_link_hash_entry * 4870lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab) 4871{ 4872 struct ppc_link_hash_entry *fdh = fh->oh; 4873 4874 if (fdh == NULL) 4875 { 4876 const char *fd_name = fh->elf.root.root.string + 1; 4877 4878 fdh = (struct ppc_link_hash_entry *) 4879 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE); 4880 if (fdh == NULL) 4881 return fdh; 4882 4883 fdh->is_func_descriptor = 1; 4884 fdh->oh = fh; 4885 fh->is_func = 1; 4886 fh->oh = fdh; 4887 } 4888 4889 fdh = ppc_follow_link (fdh); 4890 fdh->is_func_descriptor = 1; 4891 fdh->oh = fh; 4892 return fdh; 4893} 4894 4895/* Make a fake function descriptor sym for the undefined code sym FH. */ 4896 4897static struct ppc_link_hash_entry * 4898make_fdh (struct bfd_link_info *info, 4899 struct ppc_link_hash_entry *fh) 4900{ 4901 bfd *abfd = fh->elf.root.u.undef.abfd; 4902 struct bfd_link_hash_entry *bh = NULL; 4903 struct ppc_link_hash_entry *fdh; 4904 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak 4905 ? BSF_WEAK 4906 : BSF_GLOBAL); 4907 4908 if (!_bfd_generic_link_add_one_symbol (info, abfd, 4909 fh->elf.root.root.string + 1, 4910 flags, bfd_und_section_ptr, 0, 4911 NULL, FALSE, FALSE, &bh)) 4912 return NULL; 4913 4914 fdh = (struct ppc_link_hash_entry *) bh; 4915 fdh->elf.non_elf = 0; 4916 fdh->fake = 1; 4917 fdh->is_func_descriptor = 1; 4918 fdh->oh = fh; 4919 fh->is_func = 1; 4920 fh->oh = fdh; 4921 return fdh; 4922} 4923 4924/* Fix function descriptor symbols defined in .opd sections to be 4925 function type. */ 4926 4927static bfd_boolean 4928ppc64_elf_add_symbol_hook (bfd *ibfd, 4929 struct bfd_link_info *info, 4930 Elf_Internal_Sym *isym, 4931 const char **name, 4932 flagword *flags ATTRIBUTE_UNUSED, 4933 asection **sec, 4934 bfd_vma *value) 4935{ 4936 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC 4937 && (ibfd->flags & DYNAMIC) == 0 4938 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour) 4939 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc; 4940 4941 if (*sec != NULL 4942 && strcmp ((*sec)->name, ".opd") == 0) 4943 { 4944 asection *code_sec; 4945 4946 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC 4947 || ELF_ST_TYPE (isym->st_info) == STT_FUNC)) 4948 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC); 4949 4950 /* If the symbol is a function defined in .opd, and the function 4951 code is in a discarded group, let it appear to be undefined. */ 4952 if (!bfd_link_relocatable (info) 4953 && (*sec)->reloc_count != 0 4954 && opd_entry_value (*sec, *value, &code_sec, NULL, 4955 FALSE) != (bfd_vma) -1 4956 && discarded_section (code_sec)) 4957 { 4958 *sec = bfd_und_section_ptr; 4959 isym->st_shndx = SHN_UNDEF; 4960 } 4961 } 4962 else if (*sec != NULL 4963 && strcmp ((*sec)->name, ".toc") == 0 4964 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT) 4965 { 4966 struct ppc_link_hash_table *htab = ppc_hash_table (info); 4967 if (htab != NULL) 4968 htab->params->object_in_toc = 1; 4969 } 4970 4971 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0) 4972 { 4973 if (abiversion (ibfd) == 0) 4974 set_abiversion (ibfd, 2); 4975 else if (abiversion (ibfd) == 1) 4976 { 4977 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other" 4978 " for ABI version 1\n"), name); 4979 bfd_set_error (bfd_error_bad_value); 4980 return FALSE; 4981 } 4982 } 4983 4984 return TRUE; 4985} 4986 4987/* Merge non-visibility st_other attributes: local entry point. */ 4988 4989static void 4990ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, 4991 const Elf_Internal_Sym *isym, 4992 bfd_boolean definition, 4993 bfd_boolean dynamic) 4994{ 4995 if (definition && !dynamic) 4996 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) 4997 | ELF_ST_VISIBILITY (h->other)); 4998} 4999 5000/* Hook called on merging a symbol. We use this to clear "fake" since 5001 we now have a real symbol. */ 5002 5003static bfd_boolean 5004ppc64_elf_merge_symbol (struct elf_link_hash_entry *h, 5005 const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED, 5006 asection **psec ATTRIBUTE_UNUSED, 5007 bfd_boolean newdef ATTRIBUTE_UNUSED, 5008 bfd_boolean olddef ATTRIBUTE_UNUSED, 5009 bfd *oldbfd ATTRIBUTE_UNUSED, 5010 const asection *oldsec ATTRIBUTE_UNUSED) 5011{ 5012 ((struct ppc_link_hash_entry *) h)->fake = 0; 5013 return TRUE; 5014} 5015 5016/* This function makes an old ABI object reference to ".bar" cause the 5017 inclusion of a new ABI object archive that defines "bar". 5018 NAME is a symbol defined in an archive. Return a symbol in the hash 5019 table that might be satisfied by the archive symbols. */ 5020 5021static struct elf_link_hash_entry * 5022ppc64_elf_archive_symbol_lookup (bfd *abfd, 5023 struct bfd_link_info *info, 5024 const char *name) 5025{ 5026 struct elf_link_hash_entry *h; 5027 char *dot_name; 5028 size_t len; 5029 5030 h = _bfd_elf_archive_symbol_lookup (abfd, info, name); 5031 if (h != NULL 5032 /* Don't return this sym if it is a fake function descriptor 5033 created by add_symbol_adjust. */ 5034 && !((struct ppc_link_hash_entry *) h)->fake) 5035 return h; 5036 5037 if (name[0] == '.') 5038 return h; 5039 5040 len = strlen (name); 5041 dot_name = bfd_alloc (abfd, len + 2); 5042 if (dot_name == NULL) 5043 return (struct elf_link_hash_entry *) 0 - 1; 5044 dot_name[0] = '.'; 5045 memcpy (dot_name + 1, name, len + 1); 5046 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name); 5047 bfd_release (abfd, dot_name); 5048 return h; 5049} 5050 5051/* This function satisfies all old ABI object references to ".bar" if a 5052 new ABI object defines "bar". Well, at least, undefined dot symbols 5053 are made weak. This stops later archive searches from including an 5054 object if we already have a function descriptor definition. It also 5055 prevents the linker complaining about undefined symbols. 5056 We also check and correct mismatched symbol visibility here. The 5057 most restrictive visibility of the function descriptor and the 5058 function entry symbol is used. */ 5059 5060static bfd_boolean 5061add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info) 5062{ 5063 struct ppc_link_hash_table *htab; 5064 struct ppc_link_hash_entry *fdh; 5065 5066 if (eh->elf.root.type == bfd_link_hash_warning) 5067 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link; 5068 5069 if (eh->elf.root.type == bfd_link_hash_indirect) 5070 return TRUE; 5071 5072 if (eh->elf.root.root.string[0] != '.') 5073 abort (); 5074 5075 htab = ppc_hash_table (info); 5076 if (htab == NULL) 5077 return FALSE; 5078 5079 fdh = lookup_fdh (eh, htab); 5080 if (fdh == NULL 5081 && !bfd_link_relocatable (info) 5082 && (eh->elf.root.type == bfd_link_hash_undefined 5083 || eh->elf.root.type == bfd_link_hash_undefweak) 5084 && eh->elf.ref_regular) 5085 { 5086 /* Make an undefined function descriptor sym, in order to 5087 pull in an --as-needed shared lib. Archives are handled 5088 elsewhere. */ 5089 fdh = make_fdh (info, eh); 5090 if (fdh == NULL) 5091 return FALSE; 5092 } 5093 5094 if (fdh != NULL) 5095 { 5096 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1; 5097 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1; 5098 5099 /* Make both descriptor and entry symbol have the most 5100 constraining visibility of either symbol. */ 5101 if (entry_vis < descr_vis) 5102 fdh->elf.other += entry_vis - descr_vis; 5103 else if (entry_vis > descr_vis) 5104 eh->elf.other += descr_vis - entry_vis; 5105 5106 /* Propagate reference flags from entry symbol to function 5107 descriptor symbol. */ 5108 fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref; 5109 fdh->elf.ref_regular |= eh->elf.ref_regular; 5110 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak; 5111 5112 if (!fdh->elf.forced_local 5113 && fdh->elf.dynindx == -1 5114 && fdh->elf.versioned != versioned_hidden 5115 && (bfd_link_dll (info) 5116 || fdh->elf.def_dynamic 5117 || fdh->elf.ref_dynamic) 5118 && (eh->elf.ref_regular 5119 || eh->elf.def_regular)) 5120 { 5121 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf)) 5122 return FALSE; 5123 } 5124 } 5125 5126 return TRUE; 5127} 5128 5129/* Set up opd section info and abiversion for IBFD, and process list 5130 of dot-symbols we made in link_hash_newfunc. */ 5131 5132static bfd_boolean 5133ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info) 5134{ 5135 struct ppc_link_hash_table *htab; 5136 struct ppc_link_hash_entry **p, *eh; 5137 asection *opd = bfd_get_section_by_name (ibfd, ".opd"); 5138 5139 if (opd != NULL && opd->size != 0) 5140 { 5141 if (abiversion (ibfd) == 0) 5142 set_abiversion (ibfd, 1); 5143 else if (abiversion (ibfd) >= 2) 5144 { 5145 /* xgettext:c-format */ 5146 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI" 5147 " version %d\n"), 5148 ibfd, abiversion (ibfd)); 5149 bfd_set_error (bfd_error_bad_value); 5150 return FALSE; 5151 } 5152 5153 if ((ibfd->flags & DYNAMIC) == 0 5154 && (opd->flags & SEC_RELOC) != 0 5155 && opd->reloc_count != 0 5156 && !bfd_is_abs_section (opd->output_section)) 5157 { 5158 /* Garbage collection needs some extra help with .opd sections. 5159 We don't want to necessarily keep everything referenced by 5160 relocs in .opd, as that would keep all functions. Instead, 5161 if we reference an .opd symbol (a function descriptor), we 5162 want to keep the function code symbol's section. This is 5163 easy for global symbols, but for local syms we need to keep 5164 information about the associated function section. */ 5165 bfd_size_type amt; 5166 asection **opd_sym_map; 5167 5168 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map); 5169 opd_sym_map = bfd_zalloc (ibfd, amt); 5170 if (opd_sym_map == NULL) 5171 return FALSE; 5172 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map; 5173 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal); 5174 ppc64_elf_section_data (opd)->sec_type = sec_opd; 5175 } 5176 } 5177 5178 if (!is_ppc64_elf (info->output_bfd)) 5179 return TRUE; 5180 htab = ppc_hash_table (info); 5181 if (htab == NULL) 5182 return FALSE; 5183 5184 /* For input files without an explicit abiversion in e_flags 5185 we should have flagged any with symbol st_other bits set 5186 as ELFv1 and above flagged those with .opd as ELFv2. 5187 Set the output abiversion if not yet set, and for any input 5188 still ambiguous, take its abiversion from the output. 5189 Differences in ABI are reported later. */ 5190 if (abiversion (info->output_bfd) == 0) 5191 set_abiversion (info->output_bfd, abiversion (ibfd)); 5192 else if (abiversion (ibfd) == 0) 5193 set_abiversion (ibfd, abiversion (info->output_bfd)); 5194 5195 p = &htab->dot_syms; 5196 while ((eh = *p) != NULL) 5197 { 5198 *p = NULL; 5199 if (&eh->elf == htab->elf.hgot) 5200 ; 5201 else if (htab->elf.hgot == NULL 5202 && strcmp (eh->elf.root.root.string, ".TOC.") == 0) 5203 htab->elf.hgot = &eh->elf; 5204 else if (abiversion (ibfd) <= 1) 5205 { 5206 htab->need_func_desc_adj = 1; 5207 if (!add_symbol_adjust (eh, info)) 5208 return FALSE; 5209 } 5210 p = &eh->u.next_dot_sym; 5211 } 5212 return TRUE; 5213} 5214 5215/* Undo hash table changes when an --as-needed input file is determined 5216 not to be needed. */ 5217 5218static bfd_boolean 5219ppc64_elf_notice_as_needed (bfd *ibfd, 5220 struct bfd_link_info *info, 5221 enum notice_asneeded_action act) 5222{ 5223 if (act == notice_not_needed) 5224 { 5225 struct ppc_link_hash_table *htab = ppc_hash_table (info); 5226 5227 if (htab == NULL) 5228 return FALSE; 5229 5230 htab->dot_syms = NULL; 5231 } 5232 return _bfd_elf_notice_as_needed (ibfd, info, act); 5233} 5234 5235/* If --just-symbols against a final linked binary, then assume we need 5236 toc adjusting stubs when calling functions defined there. */ 5237 5238static void 5239ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info) 5240{ 5241 if ((sec->flags & SEC_CODE) != 0 5242 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0 5243 && is_ppc64_elf (sec->owner)) 5244 { 5245 if (abiversion (sec->owner) >= 2 5246 || bfd_get_section_by_name (sec->owner, ".opd") != NULL) 5247 sec->has_toc_reloc = 1; 5248 } 5249 _bfd_elf_link_just_syms (sec, info); 5250} 5251 5252static struct plt_entry ** 5253update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr, 5254 unsigned long r_symndx, bfd_vma r_addend, int tls_type) 5255{ 5256 struct got_entry **local_got_ents = elf_local_got_ents (abfd); 5257 struct plt_entry **local_plt; 5258 unsigned char *local_got_tls_masks; 5259 5260 if (local_got_ents == NULL) 5261 { 5262 bfd_size_type size = symtab_hdr->sh_info; 5263 5264 size *= (sizeof (*local_got_ents) 5265 + sizeof (*local_plt) 5266 + sizeof (*local_got_tls_masks)); 5267 local_got_ents = bfd_zalloc (abfd, size); 5268 if (local_got_ents == NULL) 5269 return NULL; 5270 elf_local_got_ents (abfd) = local_got_ents; 5271 } 5272 5273 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0) 5274 { 5275 struct got_entry *ent; 5276 5277 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next) 5278 if (ent->addend == r_addend 5279 && ent->owner == abfd 5280 && ent->tls_type == tls_type) 5281 break; 5282 if (ent == NULL) 5283 { 5284 bfd_size_type amt = sizeof (*ent); 5285 ent = bfd_alloc (abfd, amt); 5286 if (ent == NULL) 5287 return FALSE; 5288 ent->next = local_got_ents[r_symndx]; 5289 ent->addend = r_addend; 5290 ent->owner = abfd; 5291 ent->tls_type = tls_type; 5292 ent->is_indirect = FALSE; 5293 ent->got.refcount = 0; 5294 local_got_ents[r_symndx] = ent; 5295 } 5296 ent->got.refcount += 1; 5297 } 5298 5299 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info); 5300 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info); 5301 local_got_tls_masks[r_symndx] |= tls_type; 5302 5303 return local_plt + r_symndx; 5304} 5305 5306static bfd_boolean 5307update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend) 5308{ 5309 struct plt_entry *ent; 5310 5311 for (ent = *plist; ent != NULL; ent = ent->next) 5312 if (ent->addend == addend) 5313 break; 5314 if (ent == NULL) 5315 { 5316 bfd_size_type amt = sizeof (*ent); 5317 ent = bfd_alloc (abfd, amt); 5318 if (ent == NULL) 5319 return FALSE; 5320 ent->next = *plist; 5321 ent->addend = addend; 5322 ent->plt.refcount = 0; 5323 *plist = ent; 5324 } 5325 ent->plt.refcount += 1; 5326 return TRUE; 5327} 5328 5329static bfd_boolean 5330is_branch_reloc (enum elf_ppc64_reloc_type r_type) 5331{ 5332 return (r_type == R_PPC64_REL24 5333 || r_type == R_PPC64_REL14 5334 || r_type == R_PPC64_REL14_BRTAKEN 5335 || r_type == R_PPC64_REL14_BRNTAKEN 5336 || r_type == R_PPC64_ADDR24 5337 || r_type == R_PPC64_ADDR14 5338 || r_type == R_PPC64_ADDR14_BRTAKEN 5339 || r_type == R_PPC64_ADDR14_BRNTAKEN); 5340} 5341 5342/* Look through the relocs for a section during the first phase, and 5343 calculate needed space in the global offset table, procedure 5344 linkage table, and dynamic reloc sections. */ 5345 5346static bfd_boolean 5347ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 5348 asection *sec, const Elf_Internal_Rela *relocs) 5349{ 5350 struct ppc_link_hash_table *htab; 5351 Elf_Internal_Shdr *symtab_hdr; 5352 struct elf_link_hash_entry **sym_hashes; 5353 const Elf_Internal_Rela *rel; 5354 const Elf_Internal_Rela *rel_end; 5355 asection *sreloc; 5356 asection **opd_sym_map; 5357 struct elf_link_hash_entry *tga, *dottga; 5358 5359 if (bfd_link_relocatable (info)) 5360 return TRUE; 5361 5362 /* Don't do anything special with non-loaded, non-alloced sections. 5363 In particular, any relocs in such sections should not affect GOT 5364 and PLT reference counting (ie. we don't allow them to create GOT 5365 or PLT entries), there's no possibility or desire to optimize TLS 5366 relocs, and there's not much point in propagating relocs to shared 5367 libs that the dynamic linker won't relocate. */ 5368 if ((sec->flags & SEC_ALLOC) == 0) 5369 return TRUE; 5370 5371 BFD_ASSERT (is_ppc64_elf (abfd)); 5372 5373 htab = ppc_hash_table (info); 5374 if (htab == NULL) 5375 return FALSE; 5376 5377 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 5378 FALSE, FALSE, TRUE); 5379 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr", 5380 FALSE, FALSE, TRUE); 5381 symtab_hdr = &elf_symtab_hdr (abfd); 5382 sym_hashes = elf_sym_hashes (abfd); 5383 sreloc = NULL; 5384 opd_sym_map = NULL; 5385 if (ppc64_elf_section_data (sec) != NULL 5386 && ppc64_elf_section_data (sec)->sec_type == sec_opd) 5387 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec; 5388 5389 rel_end = relocs + sec->reloc_count; 5390 for (rel = relocs; rel < rel_end; rel++) 5391 { 5392 unsigned long r_symndx; 5393 struct elf_link_hash_entry *h; 5394 enum elf_ppc64_reloc_type r_type; 5395 int tls_type; 5396 struct _ppc64_elf_section_data *ppc64_sec; 5397 struct plt_entry **ifunc, **plt_list; 5398 5399 r_symndx = ELF64_R_SYM (rel->r_info); 5400 if (r_symndx < symtab_hdr->sh_info) 5401 h = NULL; 5402 else 5403 { 5404 struct ppc_link_hash_entry *eh; 5405 5406 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5407 h = elf_follow_link (h); 5408 eh = (struct ppc_link_hash_entry *) h; 5409 5410 /* PR15323, ref flags aren't set for references in the same 5411 object. */ 5412 h->root.non_ir_ref = 1; 5413 if (eh->is_func && eh->oh != NULL) 5414 eh->oh->elf.root.non_ir_ref = 1; 5415 5416 if (h == htab->elf.hgot) 5417 sec->has_toc_reloc = 1; 5418 } 5419 5420 tls_type = 0; 5421 ifunc = NULL; 5422 if (h != NULL) 5423 { 5424 if (h->type == STT_GNU_IFUNC) 5425 { 5426 h->needs_plt = 1; 5427 ifunc = &h->plt.plist; 5428 } 5429 } 5430 else 5431 { 5432 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache, 5433 abfd, r_symndx); 5434 if (isym == NULL) 5435 return FALSE; 5436 5437 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 5438 { 5439 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx, 5440 rel->r_addend, PLT_IFUNC); 5441 if (ifunc == NULL) 5442 return FALSE; 5443 } 5444 } 5445 5446 r_type = ELF64_R_TYPE (rel->r_info); 5447 switch (r_type) 5448 { 5449 case R_PPC64_TLSGD: 5450 case R_PPC64_TLSLD: 5451 /* These special tls relocs tie a call to __tls_get_addr with 5452 its parameter symbol. */ 5453 break; 5454 5455 case R_PPC64_GOT_TLSLD16: 5456 case R_PPC64_GOT_TLSLD16_LO: 5457 case R_PPC64_GOT_TLSLD16_HI: 5458 case R_PPC64_GOT_TLSLD16_HA: 5459 tls_type = TLS_TLS | TLS_LD; 5460 goto dogottls; 5461 5462 case R_PPC64_GOT_TLSGD16: 5463 case R_PPC64_GOT_TLSGD16_LO: 5464 case R_PPC64_GOT_TLSGD16_HI: 5465 case R_PPC64_GOT_TLSGD16_HA: 5466 tls_type = TLS_TLS | TLS_GD; 5467 goto dogottls; 5468 5469 case R_PPC64_GOT_TPREL16_DS: 5470 case R_PPC64_GOT_TPREL16_LO_DS: 5471 case R_PPC64_GOT_TPREL16_HI: 5472 case R_PPC64_GOT_TPREL16_HA: 5473 if (bfd_link_pic (info)) 5474 info->flags |= DF_STATIC_TLS; 5475 tls_type = TLS_TLS | TLS_TPREL; 5476 goto dogottls; 5477 5478 case R_PPC64_GOT_DTPREL16_DS: 5479 case R_PPC64_GOT_DTPREL16_LO_DS: 5480 case R_PPC64_GOT_DTPREL16_HI: 5481 case R_PPC64_GOT_DTPREL16_HA: 5482 tls_type = TLS_TLS | TLS_DTPREL; 5483 dogottls: 5484 sec->has_tls_reloc = 1; 5485 /* Fall through */ 5486 5487 case R_PPC64_GOT16: 5488 case R_PPC64_GOT16_DS: 5489 case R_PPC64_GOT16_HA: 5490 case R_PPC64_GOT16_HI: 5491 case R_PPC64_GOT16_LO: 5492 case R_PPC64_GOT16_LO_DS: 5493 /* This symbol requires a global offset table entry. */ 5494 sec->has_toc_reloc = 1; 5495 if (r_type == R_PPC64_GOT_TLSLD16 5496 || r_type == R_PPC64_GOT_TLSGD16 5497 || r_type == R_PPC64_GOT_TPREL16_DS 5498 || r_type == R_PPC64_GOT_DTPREL16_DS 5499 || r_type == R_PPC64_GOT16 5500 || r_type == R_PPC64_GOT16_DS) 5501 { 5502 htab->do_multi_toc = 1; 5503 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1; 5504 } 5505 5506 if (ppc64_elf_tdata (abfd)->got == NULL 5507 && !create_got_section (abfd, info)) 5508 return FALSE; 5509 5510 if (h != NULL) 5511 { 5512 struct ppc_link_hash_entry *eh; 5513 struct got_entry *ent; 5514 5515 eh = (struct ppc_link_hash_entry *) h; 5516 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next) 5517 if (ent->addend == rel->r_addend 5518 && ent->owner == abfd 5519 && ent->tls_type == tls_type) 5520 break; 5521 if (ent == NULL) 5522 { 5523 bfd_size_type amt = sizeof (*ent); 5524 ent = bfd_alloc (abfd, amt); 5525 if (ent == NULL) 5526 return FALSE; 5527 ent->next = eh->elf.got.glist; 5528 ent->addend = rel->r_addend; 5529 ent->owner = abfd; 5530 ent->tls_type = tls_type; 5531 ent->is_indirect = FALSE; 5532 ent->got.refcount = 0; 5533 eh->elf.got.glist = ent; 5534 } 5535 ent->got.refcount += 1; 5536 eh->tls_mask |= tls_type; 5537 } 5538 else 5539 /* This is a global offset table entry for a local symbol. */ 5540 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, 5541 rel->r_addend, tls_type)) 5542 return FALSE; 5543 5544 /* We may also need a plt entry if the symbol turns out to be 5545 an ifunc. */ 5546 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1) 5547 { 5548 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend)) 5549 return FALSE; 5550 } 5551 break; 5552 5553 case R_PPC64_PLT16_HA: 5554 case R_PPC64_PLT16_HI: 5555 case R_PPC64_PLT16_LO: 5556 case R_PPC64_PLT32: 5557 case R_PPC64_PLT64: 5558 /* This symbol requires a procedure linkage table entry. */ 5559 plt_list = ifunc; 5560 if (h != NULL) 5561 { 5562 h->needs_plt = 1; 5563 if (h->root.root.string[0] == '.' 5564 && h->root.root.string[1] != '\0') 5565 ((struct ppc_link_hash_entry *) h)->is_func = 1; 5566 plt_list = &h->plt.plist; 5567 } 5568 if (plt_list == NULL) 5569 { 5570 /* It does not make sense to have a procedure linkage 5571 table entry for a non-ifunc local symbol. */ 5572 info->callbacks->einfo 5573 /* xgettext:c-format */ 5574 (_("%P: %H: %s reloc against local symbol\n"), 5575 abfd, sec, rel->r_offset, 5576 ppc64_elf_howto_table[r_type]->name); 5577 bfd_set_error (bfd_error_bad_value); 5578 return FALSE; 5579 } 5580 if (!update_plt_info (abfd, plt_list, rel->r_addend)) 5581 return FALSE; 5582 break; 5583 5584 /* The following relocations don't need to propagate the 5585 relocation if linking a shared object since they are 5586 section relative. */ 5587 case R_PPC64_SECTOFF: 5588 case R_PPC64_SECTOFF_LO: 5589 case R_PPC64_SECTOFF_HI: 5590 case R_PPC64_SECTOFF_HA: 5591 case R_PPC64_SECTOFF_DS: 5592 case R_PPC64_SECTOFF_LO_DS: 5593 case R_PPC64_DTPREL16: 5594 case R_PPC64_DTPREL16_LO: 5595 case R_PPC64_DTPREL16_HI: 5596 case R_PPC64_DTPREL16_HA: 5597 case R_PPC64_DTPREL16_DS: 5598 case R_PPC64_DTPREL16_LO_DS: 5599 case R_PPC64_DTPREL16_HIGH: 5600 case R_PPC64_DTPREL16_HIGHA: 5601 case R_PPC64_DTPREL16_HIGHER: 5602 case R_PPC64_DTPREL16_HIGHERA: 5603 case R_PPC64_DTPREL16_HIGHEST: 5604 case R_PPC64_DTPREL16_HIGHESTA: 5605 break; 5606 5607 /* Nor do these. */ 5608 case R_PPC64_REL16: 5609 case R_PPC64_REL16_LO: 5610 case R_PPC64_REL16_HI: 5611 case R_PPC64_REL16_HA: 5612 case R_PPC64_REL16DX_HA: 5613 break; 5614 5615 /* Not supported as a dynamic relocation. */ 5616 case R_PPC64_ADDR64_LOCAL: 5617 if (bfd_link_pic (info)) 5618 { 5619 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 5620 ppc_howto_init (); 5621 /* xgettext:c-format */ 5622 info->callbacks->einfo (_("%P: %H: %s reloc unsupported " 5623 "in shared libraries and PIEs.\n"), 5624 abfd, sec, rel->r_offset, 5625 ppc64_elf_howto_table[r_type]->name); 5626 bfd_set_error (bfd_error_bad_value); 5627 return FALSE; 5628 } 5629 break; 5630 5631 case R_PPC64_TOC16: 5632 case R_PPC64_TOC16_DS: 5633 htab->do_multi_toc = 1; 5634 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1; 5635 /* Fall through. */ 5636 case R_PPC64_TOC16_LO: 5637 case R_PPC64_TOC16_HI: 5638 case R_PPC64_TOC16_HA: 5639 case R_PPC64_TOC16_LO_DS: 5640 sec->has_toc_reloc = 1; 5641 break; 5642 5643 /* Marker reloc. */ 5644 case R_PPC64_ENTRY: 5645 break; 5646 5647 /* This relocation describes the C++ object vtable hierarchy. 5648 Reconstruct it for later use during GC. */ 5649 case R_PPC64_GNU_VTINHERIT: 5650 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 5651 return FALSE; 5652 break; 5653 5654 /* This relocation describes which C++ vtable entries are actually 5655 used. Record for later use during GC. */ 5656 case R_PPC64_GNU_VTENTRY: 5657 BFD_ASSERT (h != NULL); 5658 if (h != NULL 5659 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 5660 return FALSE; 5661 break; 5662 5663 case R_PPC64_REL14: 5664 case R_PPC64_REL14_BRTAKEN: 5665 case R_PPC64_REL14_BRNTAKEN: 5666 { 5667 asection *dest = NULL; 5668 5669 /* Heuristic: If jumping outside our section, chances are 5670 we are going to need a stub. */ 5671 if (h != NULL) 5672 { 5673 /* If the sym is weak it may be overridden later, so 5674 don't assume we know where a weak sym lives. */ 5675 if (h->root.type == bfd_link_hash_defined) 5676 dest = h->root.u.def.section; 5677 } 5678 else 5679 { 5680 Elf_Internal_Sym *isym; 5681 5682 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 5683 abfd, r_symndx); 5684 if (isym == NULL) 5685 return FALSE; 5686 5687 dest = bfd_section_from_elf_index (abfd, isym->st_shndx); 5688 } 5689 5690 if (dest != sec) 5691 ppc64_elf_section_data (sec)->has_14bit_branch = 1; 5692 } 5693 /* Fall through. */ 5694 5695 case R_PPC64_REL24: 5696 plt_list = ifunc; 5697 if (h != NULL) 5698 { 5699 h->needs_plt = 1; 5700 if (h->root.root.string[0] == '.' 5701 && h->root.root.string[1] != '\0') 5702 ((struct ppc_link_hash_entry *) h)->is_func = 1; 5703 5704 if (h == tga || h == dottga) 5705 { 5706 sec->has_tls_reloc = 1; 5707 if (rel != relocs 5708 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD 5709 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD)) 5710 /* We have a new-style __tls_get_addr call with 5711 a marker reloc. */ 5712 ; 5713 else 5714 /* Mark this section as having an old-style call. */ 5715 sec->has_tls_get_addr_call = 1; 5716 } 5717 plt_list = &h->plt.plist; 5718 } 5719 5720 /* We may need a .plt entry if the function this reloc 5721 refers to is in a shared lib. */ 5722 if (plt_list 5723 && !update_plt_info (abfd, plt_list, rel->r_addend)) 5724 return FALSE; 5725 break; 5726 5727 case R_PPC64_ADDR14: 5728 case R_PPC64_ADDR14_BRNTAKEN: 5729 case R_PPC64_ADDR14_BRTAKEN: 5730 case R_PPC64_ADDR24: 5731 goto dodyn; 5732 5733 case R_PPC64_TPREL64: 5734 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL; 5735 if (bfd_link_pic (info)) 5736 info->flags |= DF_STATIC_TLS; 5737 goto dotlstoc; 5738 5739 case R_PPC64_DTPMOD64: 5740 if (rel + 1 < rel_end 5741 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64) 5742 && rel[1].r_offset == rel->r_offset + 8) 5743 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD; 5744 else 5745 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD; 5746 goto dotlstoc; 5747 5748 case R_PPC64_DTPREL64: 5749 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL; 5750 if (rel != relocs 5751 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64) 5752 && rel[-1].r_offset == rel->r_offset - 8) 5753 /* This is the second reloc of a dtpmod, dtprel pair. 5754 Don't mark with TLS_DTPREL. */ 5755 goto dodyn; 5756 5757 dotlstoc: 5758 sec->has_tls_reloc = 1; 5759 if (h != NULL) 5760 { 5761 struct ppc_link_hash_entry *eh; 5762 eh = (struct ppc_link_hash_entry *) h; 5763 eh->tls_mask |= tls_type; 5764 } 5765 else 5766 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, 5767 rel->r_addend, tls_type)) 5768 return FALSE; 5769 5770 ppc64_sec = ppc64_elf_section_data (sec); 5771 if (ppc64_sec->sec_type != sec_toc) 5772 { 5773 bfd_size_type amt; 5774 5775 /* One extra to simplify get_tls_mask. */ 5776 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned); 5777 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt); 5778 if (ppc64_sec->u.toc.symndx == NULL) 5779 return FALSE; 5780 amt = sec->size * sizeof (bfd_vma) / 8; 5781 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt); 5782 if (ppc64_sec->u.toc.add == NULL) 5783 return FALSE; 5784 BFD_ASSERT (ppc64_sec->sec_type == sec_normal); 5785 ppc64_sec->sec_type = sec_toc; 5786 } 5787 BFD_ASSERT (rel->r_offset % 8 == 0); 5788 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx; 5789 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend; 5790 5791 /* Mark the second slot of a GD or LD entry. 5792 -1 to indicate GD and -2 to indicate LD. */ 5793 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD)) 5794 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1; 5795 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD)) 5796 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2; 5797 goto dodyn; 5798 5799 case R_PPC64_TPREL16: 5800 case R_PPC64_TPREL16_LO: 5801 case R_PPC64_TPREL16_HI: 5802 case R_PPC64_TPREL16_HA: 5803 case R_PPC64_TPREL16_DS: 5804 case R_PPC64_TPREL16_LO_DS: 5805 case R_PPC64_TPREL16_HIGH: 5806 case R_PPC64_TPREL16_HIGHA: 5807 case R_PPC64_TPREL16_HIGHER: 5808 case R_PPC64_TPREL16_HIGHERA: 5809 case R_PPC64_TPREL16_HIGHEST: 5810 case R_PPC64_TPREL16_HIGHESTA: 5811 if (bfd_link_pic (info)) 5812 { 5813 info->flags |= DF_STATIC_TLS; 5814 goto dodyn; 5815 } 5816 break; 5817 5818 case R_PPC64_ADDR64: 5819 if (opd_sym_map != NULL 5820 && rel + 1 < rel_end 5821 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC) 5822 { 5823 if (h != NULL) 5824 ((struct ppc_link_hash_entry *) h)->is_func = 1; 5825 else 5826 { 5827 asection *s; 5828 Elf_Internal_Sym *isym; 5829 5830 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 5831 abfd, r_symndx); 5832 if (isym == NULL) 5833 return FALSE; 5834 5835 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 5836 if (s != NULL && s != sec) 5837 opd_sym_map[OPD_NDX (rel->r_offset)] = s; 5838 } 5839 } 5840 /* Fall through. */ 5841 5842 case R_PPC64_ADDR16: 5843 case R_PPC64_ADDR16_DS: 5844 case R_PPC64_ADDR16_HA: 5845 case R_PPC64_ADDR16_HI: 5846 case R_PPC64_ADDR16_HIGH: 5847 case R_PPC64_ADDR16_HIGHA: 5848 case R_PPC64_ADDR16_HIGHER: 5849 case R_PPC64_ADDR16_HIGHERA: 5850 case R_PPC64_ADDR16_HIGHEST: 5851 case R_PPC64_ADDR16_HIGHESTA: 5852 case R_PPC64_ADDR16_LO: 5853 case R_PPC64_ADDR16_LO_DS: 5854 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1 5855 && rel->r_addend == 0) 5856 { 5857 /* We may need a .plt entry if this reloc refers to a 5858 function in a shared lib. */ 5859 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend)) 5860 return FALSE; 5861 h->pointer_equality_needed = 1; 5862 } 5863 /* Fall through. */ 5864 5865 case R_PPC64_REL30: 5866 case R_PPC64_REL32: 5867 case R_PPC64_REL64: 5868 case R_PPC64_ADDR32: 5869 case R_PPC64_UADDR16: 5870 case R_PPC64_UADDR32: 5871 case R_PPC64_UADDR64: 5872 case R_PPC64_TOC: 5873 if (h != NULL && !bfd_link_pic (info)) 5874 /* We may need a copy reloc. */ 5875 h->non_got_ref = 1; 5876 5877 /* Don't propagate .opd relocs. */ 5878 if (NO_OPD_RELOCS && opd_sym_map != NULL) 5879 break; 5880 5881 /* If we are creating a shared library, and this is a reloc 5882 against a global symbol, or a non PC relative reloc 5883 against a local symbol, then we need to copy the reloc 5884 into the shared library. However, if we are linking with 5885 -Bsymbolic, we do not need to copy a reloc against a 5886 global symbol which is defined in an object we are 5887 including in the link (i.e., DEF_REGULAR is set). At 5888 this point we have not seen all the input files, so it is 5889 possible that DEF_REGULAR is not set now but will be set 5890 later (it is never cleared). In case of a weak definition, 5891 DEF_REGULAR may be cleared later by a strong definition in 5892 a shared library. We account for that possibility below by 5893 storing information in the dyn_relocs field of the hash 5894 table entry. A similar situation occurs when creating 5895 shared libraries and symbol visibility changes render the 5896 symbol local. 5897 5898 If on the other hand, we are creating an executable, we 5899 may need to keep relocations for symbols satisfied by a 5900 dynamic library if we manage to avoid copy relocs for the 5901 symbol. */ 5902 dodyn: 5903 if ((bfd_link_pic (info) 5904 && (must_be_dyn_reloc (info, r_type) 5905 || (h != NULL 5906 && (!SYMBOLIC_BIND (info, h) 5907 || h->root.type == bfd_link_hash_defweak 5908 || !h->def_regular)))) 5909 || (ELIMINATE_COPY_RELOCS 5910 && !bfd_link_pic (info) 5911 && h != NULL 5912 && (h->root.type == bfd_link_hash_defweak 5913 || !h->def_regular)) 5914 || (!bfd_link_pic (info) 5915 && ifunc != NULL)) 5916 { 5917 /* We must copy these reloc types into the output file. 5918 Create a reloc section in dynobj and make room for 5919 this reloc. */ 5920 if (sreloc == NULL) 5921 { 5922 sreloc = _bfd_elf_make_dynamic_reloc_section 5923 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE); 5924 5925 if (sreloc == NULL) 5926 return FALSE; 5927 } 5928 5929 /* If this is a global symbol, we count the number of 5930 relocations we need for this symbol. */ 5931 if (h != NULL) 5932 { 5933 struct elf_dyn_relocs *p; 5934 struct elf_dyn_relocs **head; 5935 5936 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs; 5937 p = *head; 5938 if (p == NULL || p->sec != sec) 5939 { 5940 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 5941 if (p == NULL) 5942 return FALSE; 5943 p->next = *head; 5944 *head = p; 5945 p->sec = sec; 5946 p->count = 0; 5947 p->pc_count = 0; 5948 } 5949 p->count += 1; 5950 if (!must_be_dyn_reloc (info, r_type)) 5951 p->pc_count += 1; 5952 } 5953 else 5954 { 5955 /* Track dynamic relocs needed for local syms too. 5956 We really need local syms available to do this 5957 easily. Oh well. */ 5958 struct ppc_dyn_relocs *p; 5959 struct ppc_dyn_relocs **head; 5960 bfd_boolean is_ifunc; 5961 asection *s; 5962 void *vpp; 5963 Elf_Internal_Sym *isym; 5964 5965 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 5966 abfd, r_symndx); 5967 if (isym == NULL) 5968 return FALSE; 5969 5970 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 5971 if (s == NULL) 5972 s = sec; 5973 5974 vpp = &elf_section_data (s)->local_dynrel; 5975 head = (struct ppc_dyn_relocs **) vpp; 5976 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC; 5977 p = *head; 5978 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc) 5979 p = p->next; 5980 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc) 5981 { 5982 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 5983 if (p == NULL) 5984 return FALSE; 5985 p->next = *head; 5986 *head = p; 5987 p->sec = sec; 5988 p->ifunc = is_ifunc; 5989 p->count = 0; 5990 } 5991 p->count += 1; 5992 } 5993 } 5994 break; 5995 5996 default: 5997 break; 5998 } 5999 } 6000 6001 return TRUE; 6002} 6003 6004/* Merge backend specific data from an object file to the output 6005 object file when linking. */ 6006 6007static bfd_boolean 6008ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 6009{ 6010 bfd *obfd = info->output_bfd; 6011 unsigned long iflags, oflags; 6012 6013 if ((ibfd->flags & BFD_LINKER_CREATED) != 0) 6014 return TRUE; 6015 6016 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd)) 6017 return TRUE; 6018 6019 if (!_bfd_generic_verify_endian_match (ibfd, info)) 6020 return FALSE; 6021 6022 iflags = elf_elfheader (ibfd)->e_flags; 6023 oflags = elf_elfheader (obfd)->e_flags; 6024 6025 if (iflags & ~EF_PPC64_ABI) 6026 { 6027 _bfd_error_handler 6028 /* xgettext:c-format */ 6029 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags); 6030 bfd_set_error (bfd_error_bad_value); 6031 return FALSE; 6032 } 6033 else if (iflags != oflags && iflags != 0) 6034 { 6035 _bfd_error_handler 6036 /* xgettext:c-format */ 6037 (_("%B: ABI version %ld is not compatible with ABI version %ld output"), 6038 ibfd, iflags, oflags); 6039 bfd_set_error (bfd_error_bad_value); 6040 return FALSE; 6041 } 6042 6043 _bfd_elf_ppc_merge_fp_attributes (ibfd, info); 6044 6045 /* Merge Tag_compatibility attributes and any common GNU ones. */ 6046 _bfd_elf_merge_object_attributes (ibfd, info); 6047 6048 return TRUE; 6049} 6050 6051static bfd_boolean 6052ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr) 6053{ 6054 /* Print normal ELF private data. */ 6055 _bfd_elf_print_private_bfd_data (abfd, ptr); 6056 6057 if (elf_elfheader (abfd)->e_flags != 0) 6058 { 6059 FILE *file = ptr; 6060 6061 fprintf (file, _("private flags = 0x%lx:"), 6062 elf_elfheader (abfd)->e_flags); 6063 6064 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0) 6065 fprintf (file, _(" [abiv%ld]"), 6066 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI); 6067 fputc ('\n', file); 6068 } 6069 6070 return TRUE; 6071} 6072 6073/* OFFSET in OPD_SEC specifies a function descriptor. Return the address 6074 of the code entry point, and its section, which must be in the same 6075 object as OPD_SEC. Returns (bfd_vma) -1 on error. */ 6076 6077static bfd_vma 6078opd_entry_value (asection *opd_sec, 6079 bfd_vma offset, 6080 asection **code_sec, 6081 bfd_vma *code_off, 6082 bfd_boolean in_code_sec) 6083{ 6084 bfd *opd_bfd = opd_sec->owner; 6085 Elf_Internal_Rela *relocs; 6086 Elf_Internal_Rela *lo, *hi, *look; 6087 bfd_vma val; 6088 6089 /* No relocs implies we are linking a --just-symbols object, or looking 6090 at a final linked executable with addr2line or somesuch. */ 6091 if (opd_sec->reloc_count == 0) 6092 { 6093 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents; 6094 6095 if (contents == NULL) 6096 { 6097 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents)) 6098 return (bfd_vma) -1; 6099 ppc64_elf_tdata (opd_bfd)->opd.contents = contents; 6100 } 6101 6102 /* PR 17512: file: 64b9dfbb. */ 6103 if (offset + 7 >= opd_sec->size || offset + 7 < offset) 6104 return (bfd_vma) -1; 6105 6106 val = bfd_get_64 (opd_bfd, contents + offset); 6107 if (code_sec != NULL) 6108 { 6109 asection *sec, *likely = NULL; 6110 6111 if (in_code_sec) 6112 { 6113 sec = *code_sec; 6114 if (sec->vma <= val 6115 && val < sec->vma + sec->size) 6116 likely = sec; 6117 else 6118 val = -1; 6119 } 6120 else 6121 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next) 6122 if (sec->vma <= val 6123 && (sec->flags & SEC_LOAD) != 0 6124 && (sec->flags & SEC_ALLOC) != 0) 6125 likely = sec; 6126 if (likely != NULL) 6127 { 6128 *code_sec = likely; 6129 if (code_off != NULL) 6130 *code_off = val - likely->vma; 6131 } 6132 } 6133 return val; 6134 } 6135 6136 BFD_ASSERT (is_ppc64_elf (opd_bfd)); 6137 6138 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs; 6139 if (relocs == NULL) 6140 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE); 6141 /* PR 17512: file: df8e1fd6. */ 6142 if (relocs == NULL) 6143 return (bfd_vma) -1; 6144 6145 /* Go find the opd reloc at the sym address. */ 6146 lo = relocs; 6147 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */ 6148 val = (bfd_vma) -1; 6149 while (lo < hi) 6150 { 6151 look = lo + (hi - lo) / 2; 6152 if (look->r_offset < offset) 6153 lo = look + 1; 6154 else if (look->r_offset > offset) 6155 hi = look; 6156 else 6157 { 6158 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd); 6159 6160 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64 6161 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC) 6162 { 6163 unsigned long symndx = ELF64_R_SYM (look->r_info); 6164 asection *sec = NULL; 6165 6166 if (symndx >= symtab_hdr->sh_info 6167 && elf_sym_hashes (opd_bfd) != NULL) 6168 { 6169 struct elf_link_hash_entry **sym_hashes; 6170 struct elf_link_hash_entry *rh; 6171 6172 sym_hashes = elf_sym_hashes (opd_bfd); 6173 rh = sym_hashes[symndx - symtab_hdr->sh_info]; 6174 if (rh != NULL) 6175 { 6176 rh = elf_follow_link (rh); 6177 if (rh->root.type != bfd_link_hash_defined 6178 && rh->root.type != bfd_link_hash_defweak) 6179 break; 6180 if (rh->root.u.def.section->owner == opd_bfd) 6181 { 6182 val = rh->root.u.def.value; 6183 sec = rh->root.u.def.section; 6184 } 6185 } 6186 } 6187 6188 if (sec == NULL) 6189 { 6190 Elf_Internal_Sym *sym; 6191 6192 if (symndx < symtab_hdr->sh_info) 6193 { 6194 sym = (Elf_Internal_Sym *) symtab_hdr->contents; 6195 if (sym == NULL) 6196 { 6197 size_t symcnt = symtab_hdr->sh_info; 6198 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 6199 symcnt, 0, 6200 NULL, NULL, NULL); 6201 if (sym == NULL) 6202 break; 6203 symtab_hdr->contents = (bfd_byte *) sym; 6204 } 6205 sym += symndx; 6206 } 6207 else 6208 { 6209 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 6210 1, symndx, 6211 NULL, NULL, NULL); 6212 if (sym == NULL) 6213 break; 6214 } 6215 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx); 6216 if (sec == NULL) 6217 break; 6218 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0); 6219 val = sym->st_value; 6220 } 6221 6222 val += look->r_addend; 6223 if (code_off != NULL) 6224 *code_off = val; 6225 if (code_sec != NULL) 6226 { 6227 if (in_code_sec && *code_sec != sec) 6228 return -1; 6229 else 6230 *code_sec = sec; 6231 } 6232 if (sec->output_section != NULL) 6233 val += sec->output_section->vma + sec->output_offset; 6234 } 6235 break; 6236 } 6237 } 6238 6239 return val; 6240} 6241 6242/* If the ELF symbol SYM might be a function in SEC, return the 6243 function size and set *CODE_OFF to the function's entry point, 6244 otherwise return zero. */ 6245 6246static bfd_size_type 6247ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec, 6248 bfd_vma *code_off) 6249{ 6250 bfd_size_type size; 6251 6252 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT 6253 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0) 6254 return 0; 6255 6256 size = 0; 6257 if (!(sym->flags & BSF_SYNTHETIC)) 6258 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size; 6259 6260 if (strcmp (sym->section->name, ".opd") == 0) 6261 { 6262 struct _opd_sec_data *opd = get_opd_info (sym->section); 6263 bfd_vma symval = sym->value; 6264 6265 if (opd != NULL 6266 && opd->adjust != NULL 6267 && elf_section_data (sym->section)->relocs != NULL) 6268 { 6269 /* opd_entry_value will use cached relocs that have been 6270 adjusted, but with raw symbols. That means both local 6271 and global symbols need adjusting. */ 6272 long adjust = opd->adjust[OPD_NDX (symval)]; 6273 if (adjust == -1) 6274 return 0; 6275 symval += adjust; 6276 } 6277 6278 if (opd_entry_value (sym->section, symval, 6279 &sec, code_off, TRUE) == (bfd_vma) -1) 6280 return 0; 6281 /* An old ABI binary with dot-syms has a size of 24 on the .opd 6282 symbol. This size has nothing to do with the code size of the 6283 function, which is what we're supposed to return, but the 6284 code size isn't available without looking up the dot-sym. 6285 However, doing that would be a waste of time particularly 6286 since elf_find_function will look at the dot-sym anyway. 6287 Now, elf_find_function will keep the largest size of any 6288 function sym found at the code address of interest, so return 6289 1 here to avoid it incorrectly caching a larger function size 6290 for a small function. This does mean we return the wrong 6291 size for a new-ABI function of size 24, but all that does is 6292 disable caching for such functions. */ 6293 if (size == 24) 6294 size = 1; 6295 } 6296 else 6297 { 6298 if (sym->section != sec) 6299 return 0; 6300 *code_off = sym->value; 6301 } 6302 if (size == 0) 6303 size = 1; 6304 return size; 6305} 6306 6307/* Return true if symbol is defined in a regular object file. */ 6308 6309static bfd_boolean 6310is_static_defined (struct elf_link_hash_entry *h) 6311{ 6312 return ((h->root.type == bfd_link_hash_defined 6313 || h->root.type == bfd_link_hash_defweak) 6314 && h->root.u.def.section != NULL 6315 && h->root.u.def.section->output_section != NULL); 6316} 6317 6318/* If FDH is a function descriptor symbol, return the associated code 6319 entry symbol if it is defined. Return NULL otherwise. */ 6320 6321static struct ppc_link_hash_entry * 6322defined_code_entry (struct ppc_link_hash_entry *fdh) 6323{ 6324 if (fdh->is_func_descriptor) 6325 { 6326 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh); 6327 if (fh->elf.root.type == bfd_link_hash_defined 6328 || fh->elf.root.type == bfd_link_hash_defweak) 6329 return fh; 6330 } 6331 return NULL; 6332} 6333 6334/* If FH is a function code entry symbol, return the associated 6335 function descriptor symbol if it is defined. Return NULL otherwise. */ 6336 6337static struct ppc_link_hash_entry * 6338defined_func_desc (struct ppc_link_hash_entry *fh) 6339{ 6340 if (fh->oh != NULL 6341 && fh->oh->is_func_descriptor) 6342 { 6343 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh); 6344 if (fdh->elf.root.type == bfd_link_hash_defined 6345 || fdh->elf.root.type == bfd_link_hash_defweak) 6346 return fdh; 6347 } 6348 return NULL; 6349} 6350 6351static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *); 6352 6353/* Garbage collect sections, after first dealing with dot-symbols. */ 6354 6355static bfd_boolean 6356ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info) 6357{ 6358 struct ppc_link_hash_table *htab = ppc_hash_table (info); 6359 6360 if (htab != NULL && htab->need_func_desc_adj) 6361 { 6362 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info); 6363 htab->need_func_desc_adj = 0; 6364 } 6365 return bfd_elf_gc_sections (abfd, info); 6366} 6367 6368/* Mark all our entry sym sections, both opd and code section. */ 6369 6370static void 6371ppc64_elf_gc_keep (struct bfd_link_info *info) 6372{ 6373 struct ppc_link_hash_table *htab = ppc_hash_table (info); 6374 struct bfd_sym_chain *sym; 6375 6376 if (htab == NULL) 6377 return; 6378 6379 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next) 6380 { 6381 struct ppc_link_hash_entry *eh, *fh; 6382 asection *sec; 6383 6384 eh = (struct ppc_link_hash_entry *) 6385 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE); 6386 if (eh == NULL) 6387 continue; 6388 if (eh->elf.root.type != bfd_link_hash_defined 6389 && eh->elf.root.type != bfd_link_hash_defweak) 6390 continue; 6391 6392 fh = defined_code_entry (eh); 6393 if (fh != NULL) 6394 { 6395 sec = fh->elf.root.u.def.section; 6396 sec->flags |= SEC_KEEP; 6397 } 6398 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 6399 && opd_entry_value (eh->elf.root.u.def.section, 6400 eh->elf.root.u.def.value, 6401 &sec, NULL, FALSE) != (bfd_vma) -1) 6402 sec->flags |= SEC_KEEP; 6403 6404 sec = eh->elf.root.u.def.section; 6405 sec->flags |= SEC_KEEP; 6406 } 6407} 6408 6409/* Mark sections containing dynamically referenced symbols. When 6410 building shared libraries, we must assume that any visible symbol is 6411 referenced. */ 6412 6413static bfd_boolean 6414ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf) 6415{ 6416 struct bfd_link_info *info = (struct bfd_link_info *) inf; 6417 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h; 6418 struct ppc_link_hash_entry *fdh; 6419 struct bfd_elf_dynamic_list *d = info->dynamic_list; 6420 6421 /* Dynamic linking info is on the func descriptor sym. */ 6422 fdh = defined_func_desc (eh); 6423 if (fdh != NULL) 6424 eh = fdh; 6425 6426 if ((eh->elf.root.type == bfd_link_hash_defined 6427 || eh->elf.root.type == bfd_link_hash_defweak) 6428 && (eh->elf.ref_dynamic 6429 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf)) 6430 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL 6431 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN 6432 && (!bfd_link_executable (info) 6433 || info->gc_keep_exported 6434 || info->export_dynamic 6435 || (eh->elf.dynamic 6436 && d != NULL 6437 && (*d->match) (&d->head, NULL, eh->elf.root.root.string))) 6438 && (eh->elf.versioned >= versioned 6439 || !bfd_hide_sym_by_version (info->version_info, 6440 eh->elf.root.root.string))))) 6441 { 6442 asection *code_sec; 6443 struct ppc_link_hash_entry *fh; 6444 6445 eh->elf.root.u.def.section->flags |= SEC_KEEP; 6446 6447 /* Function descriptor syms cause the associated 6448 function code sym section to be marked. */ 6449 fh = defined_code_entry (eh); 6450 if (fh != NULL) 6451 { 6452 code_sec = fh->elf.root.u.def.section; 6453 code_sec->flags |= SEC_KEEP; 6454 } 6455 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 6456 && opd_entry_value (eh->elf.root.u.def.section, 6457 eh->elf.root.u.def.value, 6458 &code_sec, NULL, FALSE) != (bfd_vma) -1) 6459 code_sec->flags |= SEC_KEEP; 6460 } 6461 6462 return TRUE; 6463} 6464 6465/* Return the section that should be marked against GC for a given 6466 relocation. */ 6467 6468static asection * 6469ppc64_elf_gc_mark_hook (asection *sec, 6470 struct bfd_link_info *info, 6471 Elf_Internal_Rela *rel, 6472 struct elf_link_hash_entry *h, 6473 Elf_Internal_Sym *sym) 6474{ 6475 asection *rsec; 6476 6477 /* Syms return NULL if we're marking .opd, so we avoid marking all 6478 function sections, as all functions are referenced in .opd. */ 6479 rsec = NULL; 6480 if (get_opd_info (sec) != NULL) 6481 return rsec; 6482 6483 if (h != NULL) 6484 { 6485 enum elf_ppc64_reloc_type r_type; 6486 struct ppc_link_hash_entry *eh, *fh, *fdh; 6487 6488 r_type = ELF64_R_TYPE (rel->r_info); 6489 switch (r_type) 6490 { 6491 case R_PPC64_GNU_VTINHERIT: 6492 case R_PPC64_GNU_VTENTRY: 6493 break; 6494 6495 default: 6496 switch (h->root.type) 6497 { 6498 case bfd_link_hash_defined: 6499 case bfd_link_hash_defweak: 6500 eh = (struct ppc_link_hash_entry *) h; 6501 fdh = defined_func_desc (eh); 6502 if (fdh != NULL) 6503 { 6504 /* -mcall-aixdesc code references the dot-symbol on 6505 a call reloc. Mark the function descriptor too 6506 against garbage collection. */ 6507 fdh->elf.mark = 1; 6508 if (fdh->elf.u.weakdef != NULL) 6509 fdh->elf.u.weakdef->mark = 1; 6510 eh = fdh; 6511 } 6512 6513 /* Function descriptor syms cause the associated 6514 function code sym section to be marked. */ 6515 fh = defined_code_entry (eh); 6516 if (fh != NULL) 6517 { 6518 /* They also mark their opd section. */ 6519 eh->elf.root.u.def.section->gc_mark = 1; 6520 6521 rsec = fh->elf.root.u.def.section; 6522 } 6523 else if (get_opd_info (eh->elf.root.u.def.section) != NULL 6524 && opd_entry_value (eh->elf.root.u.def.section, 6525 eh->elf.root.u.def.value, 6526 &rsec, NULL, FALSE) != (bfd_vma) -1) 6527 eh->elf.root.u.def.section->gc_mark = 1; 6528 else 6529 rsec = h->root.u.def.section; 6530 break; 6531 6532 case bfd_link_hash_common: 6533 rsec = h->root.u.c.p->section; 6534 break; 6535 6536 default: 6537 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 6538 } 6539 } 6540 } 6541 else 6542 { 6543 struct _opd_sec_data *opd; 6544 6545 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx); 6546 opd = get_opd_info (rsec); 6547 if (opd != NULL && opd->func_sec != NULL) 6548 { 6549 rsec->gc_mark = 1; 6550 6551 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)]; 6552 } 6553 } 6554 6555 return rsec; 6556} 6557 6558/* Update the .got, .plt. and dynamic reloc reference counts for the 6559 section being removed. */ 6560 6561static bfd_boolean 6562ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, 6563 asection *sec, const Elf_Internal_Rela *relocs) 6564{ 6565 struct ppc_link_hash_table *htab; 6566 Elf_Internal_Shdr *symtab_hdr; 6567 struct elf_link_hash_entry **sym_hashes; 6568 struct got_entry **local_got_ents; 6569 const Elf_Internal_Rela *rel, *relend; 6570 6571 if (bfd_link_relocatable (info)) 6572 return TRUE; 6573 6574 if ((sec->flags & SEC_ALLOC) == 0) 6575 return TRUE; 6576 6577 elf_section_data (sec)->local_dynrel = NULL; 6578 6579 htab = ppc_hash_table (info); 6580 if (htab == NULL) 6581 return FALSE; 6582 6583 symtab_hdr = &elf_symtab_hdr (abfd); 6584 sym_hashes = elf_sym_hashes (abfd); 6585 local_got_ents = elf_local_got_ents (abfd); 6586 6587 relend = relocs + sec->reloc_count; 6588 for (rel = relocs; rel < relend; rel++) 6589 { 6590 unsigned long r_symndx; 6591 enum elf_ppc64_reloc_type r_type; 6592 struct elf_link_hash_entry *h = NULL; 6593 struct plt_entry **plt_list; 6594 unsigned char tls_type = 0; 6595 6596 r_symndx = ELF64_R_SYM (rel->r_info); 6597 r_type = ELF64_R_TYPE (rel->r_info); 6598 if (r_symndx >= symtab_hdr->sh_info) 6599 { 6600 struct ppc_link_hash_entry *eh; 6601 struct elf_dyn_relocs **pp; 6602 struct elf_dyn_relocs *p; 6603 6604 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6605 h = elf_follow_link (h); 6606 eh = (struct ppc_link_hash_entry *) h; 6607 6608 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 6609 if (p->sec == sec) 6610 { 6611 /* Everything must go for SEC. */ 6612 *pp = p->next; 6613 break; 6614 } 6615 } 6616 6617 switch (r_type) 6618 { 6619 case R_PPC64_GOT_TLSLD16: 6620 case R_PPC64_GOT_TLSLD16_LO: 6621 case R_PPC64_GOT_TLSLD16_HI: 6622 case R_PPC64_GOT_TLSLD16_HA: 6623 tls_type = TLS_TLS | TLS_LD; 6624 goto dogot; 6625 6626 case R_PPC64_GOT_TLSGD16: 6627 case R_PPC64_GOT_TLSGD16_LO: 6628 case R_PPC64_GOT_TLSGD16_HI: 6629 case R_PPC64_GOT_TLSGD16_HA: 6630 tls_type = TLS_TLS | TLS_GD; 6631 goto dogot; 6632 6633 case R_PPC64_GOT_TPREL16_DS: 6634 case R_PPC64_GOT_TPREL16_LO_DS: 6635 case R_PPC64_GOT_TPREL16_HI: 6636 case R_PPC64_GOT_TPREL16_HA: 6637 tls_type = TLS_TLS | TLS_TPREL; 6638 goto dogot; 6639 6640 case R_PPC64_GOT_DTPREL16_DS: 6641 case R_PPC64_GOT_DTPREL16_LO_DS: 6642 case R_PPC64_GOT_DTPREL16_HI: 6643 case R_PPC64_GOT_DTPREL16_HA: 6644 tls_type = TLS_TLS | TLS_DTPREL; 6645 goto dogot; 6646 6647 case R_PPC64_GOT16: 6648 case R_PPC64_GOT16_DS: 6649 case R_PPC64_GOT16_HA: 6650 case R_PPC64_GOT16_HI: 6651 case R_PPC64_GOT16_LO: 6652 case R_PPC64_GOT16_LO_DS: 6653 dogot: 6654 { 6655 struct got_entry *ent; 6656 6657 if (h != NULL) 6658 ent = h->got.glist; 6659 else 6660 ent = local_got_ents[r_symndx]; 6661 6662 for (; ent != NULL; ent = ent->next) 6663 if (ent->addend == rel->r_addend 6664 && ent->owner == abfd 6665 && ent->tls_type == tls_type) 6666 break; 6667 if (ent == NULL) 6668 abort (); 6669 if (ent->got.refcount > 0) 6670 ent->got.refcount -= 1; 6671 } 6672 break; 6673 6674 case R_PPC64_PLT16_HA: 6675 case R_PPC64_PLT16_HI: 6676 case R_PPC64_PLT16_LO: 6677 case R_PPC64_PLT32: 6678 case R_PPC64_PLT64: 6679 case R_PPC64_REL14: 6680 case R_PPC64_REL14_BRNTAKEN: 6681 case R_PPC64_REL14_BRTAKEN: 6682 case R_PPC64_REL24: 6683 plt_list = NULL; 6684 if (h != NULL) 6685 plt_list = &h->plt.plist; 6686 else if (local_got_ents != NULL) 6687 { 6688 struct plt_entry **local_plt = (struct plt_entry **) 6689 (local_got_ents + symtab_hdr->sh_info); 6690 unsigned char *local_got_tls_masks = (unsigned char *) 6691 (local_plt + symtab_hdr->sh_info); 6692 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0) 6693 plt_list = local_plt + r_symndx; 6694 } 6695 if (plt_list) 6696 { 6697 struct plt_entry *ent; 6698 6699 for (ent = *plt_list; ent != NULL; ent = ent->next) 6700 if (ent->addend == rel->r_addend) 6701 break; 6702 if (ent != NULL && ent->plt.refcount > 0) 6703 ent->plt.refcount -= 1; 6704 } 6705 break; 6706 6707 default: 6708 break; 6709 } 6710 } 6711 return TRUE; 6712} 6713 6714/* The maximum size of .sfpr. */ 6715#define SFPR_MAX (218*4) 6716 6717struct sfpr_def_parms 6718{ 6719 const char name[12]; 6720 unsigned char lo, hi; 6721 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int); 6722 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int); 6723}; 6724 6725/* Auto-generate _save*, _rest* functions in .sfpr. 6726 If STUB_SEC is non-null, define alias symbols in STUB_SEC 6727 instead. */ 6728 6729static bfd_boolean 6730sfpr_define (struct bfd_link_info *info, 6731 const struct sfpr_def_parms *parm, 6732 asection *stub_sec) 6733{ 6734 struct ppc_link_hash_table *htab = ppc_hash_table (info); 6735 unsigned int i; 6736 size_t len = strlen (parm->name); 6737 bfd_boolean writing = FALSE; 6738 char sym[16]; 6739 6740 if (htab == NULL) 6741 return FALSE; 6742 6743 memcpy (sym, parm->name, len); 6744 sym[len + 2] = 0; 6745 6746 for (i = parm->lo; i <= parm->hi; i++) 6747 { 6748 struct ppc_link_hash_entry *h; 6749 6750 sym[len + 0] = i / 10 + '0'; 6751 sym[len + 1] = i % 10 + '0'; 6752 h = (struct ppc_link_hash_entry *) 6753 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE); 6754 if (stub_sec != NULL) 6755 { 6756 if (h != NULL 6757 && h->elf.root.type == bfd_link_hash_defined 6758 && h->elf.root.u.def.section == htab->sfpr) 6759 { 6760 struct elf_link_hash_entry *s; 6761 char buf[32]; 6762 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym); 6763 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE); 6764 if (s == NULL) 6765 return FALSE; 6766 if (s->root.type == bfd_link_hash_new 6767 || (s->root.type = bfd_link_hash_defined 6768 && s->root.u.def.section == stub_sec)) 6769 { 6770 s->root.type = bfd_link_hash_defined; 6771 s->root.u.def.section = stub_sec; 6772 s->root.u.def.value = (stub_sec->size 6773 + h->elf.root.u.def.value); 6774 s->ref_regular = 1; 6775 s->def_regular = 1; 6776 s->ref_regular_nonweak = 1; 6777 s->forced_local = 1; 6778 s->non_elf = 0; 6779 s->root.linker_def = 1; 6780 } 6781 } 6782 continue; 6783 } 6784 if (h != NULL) 6785 { 6786 h->save_res = 1; 6787 if (!h->elf.def_regular) 6788 { 6789 h->elf.root.type = bfd_link_hash_defined; 6790 h->elf.root.u.def.section = htab->sfpr; 6791 h->elf.root.u.def.value = htab->sfpr->size; 6792 h->elf.type = STT_FUNC; 6793 h->elf.def_regular = 1; 6794 h->elf.non_elf = 0; 6795 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE); 6796 writing = TRUE; 6797 if (htab->sfpr->contents == NULL) 6798 { 6799 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX); 6800 if (htab->sfpr->contents == NULL) 6801 return FALSE; 6802 } 6803 } 6804 } 6805 if (writing) 6806 { 6807 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size; 6808 if (i != parm->hi) 6809 p = (*parm->write_ent) (htab->elf.dynobj, p, i); 6810 else 6811 p = (*parm->write_tail) (htab->elf.dynobj, p, i); 6812 htab->sfpr->size = p - htab->sfpr->contents; 6813 } 6814 } 6815 6816 return TRUE; 6817} 6818 6819static bfd_byte * 6820savegpr0 (bfd *abfd, bfd_byte *p, int r) 6821{ 6822 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6823 return p + 4; 6824} 6825 6826static bfd_byte * 6827savegpr0_tail (bfd *abfd, bfd_byte *p, int r) 6828{ 6829 p = savegpr0 (abfd, p, r); 6830 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p); 6831 p = p + 4; 6832 bfd_put_32 (abfd, BLR, p); 6833 return p + 4; 6834} 6835 6836static bfd_byte * 6837restgpr0 (bfd *abfd, bfd_byte *p, int r) 6838{ 6839 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6840 return p + 4; 6841} 6842 6843static bfd_byte * 6844restgpr0_tail (bfd *abfd, bfd_byte *p, int r) 6845{ 6846 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p); 6847 p = p + 4; 6848 p = restgpr0 (abfd, p, r); 6849 bfd_put_32 (abfd, MTLR_R0, p); 6850 p = p + 4; 6851 if (r == 29) 6852 { 6853 p = restgpr0 (abfd, p, 30); 6854 p = restgpr0 (abfd, p, 31); 6855 } 6856 bfd_put_32 (abfd, BLR, p); 6857 return p + 4; 6858} 6859 6860static bfd_byte * 6861savegpr1 (bfd *abfd, bfd_byte *p, int r) 6862{ 6863 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6864 return p + 4; 6865} 6866 6867static bfd_byte * 6868savegpr1_tail (bfd *abfd, bfd_byte *p, int r) 6869{ 6870 p = savegpr1 (abfd, p, r); 6871 bfd_put_32 (abfd, BLR, p); 6872 return p + 4; 6873} 6874 6875static bfd_byte * 6876restgpr1 (bfd *abfd, bfd_byte *p, int r) 6877{ 6878 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6879 return p + 4; 6880} 6881 6882static bfd_byte * 6883restgpr1_tail (bfd *abfd, bfd_byte *p, int r) 6884{ 6885 p = restgpr1 (abfd, p, r); 6886 bfd_put_32 (abfd, BLR, p); 6887 return p + 4; 6888} 6889 6890static bfd_byte * 6891savefpr (bfd *abfd, bfd_byte *p, int r) 6892{ 6893 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6894 return p + 4; 6895} 6896 6897static bfd_byte * 6898savefpr0_tail (bfd *abfd, bfd_byte *p, int r) 6899{ 6900 p = savefpr (abfd, p, r); 6901 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p); 6902 p = p + 4; 6903 bfd_put_32 (abfd, BLR, p); 6904 return p + 4; 6905} 6906 6907static bfd_byte * 6908restfpr (bfd *abfd, bfd_byte *p, int r) 6909{ 6910 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p); 6911 return p + 4; 6912} 6913 6914static bfd_byte * 6915restfpr0_tail (bfd *abfd, bfd_byte *p, int r) 6916{ 6917 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p); 6918 p = p + 4; 6919 p = restfpr (abfd, p, r); 6920 bfd_put_32 (abfd, MTLR_R0, p); 6921 p = p + 4; 6922 if (r == 29) 6923 { 6924 p = restfpr (abfd, p, 30); 6925 p = restfpr (abfd, p, 31); 6926 } 6927 bfd_put_32 (abfd, BLR, p); 6928 return p + 4; 6929} 6930 6931static bfd_byte * 6932savefpr1_tail (bfd *abfd, bfd_byte *p, int r) 6933{ 6934 p = savefpr (abfd, p, r); 6935 bfd_put_32 (abfd, BLR, p); 6936 return p + 4; 6937} 6938 6939static bfd_byte * 6940restfpr1_tail (bfd *abfd, bfd_byte *p, int r) 6941{ 6942 p = restfpr (abfd, p, r); 6943 bfd_put_32 (abfd, BLR, p); 6944 return p + 4; 6945} 6946 6947static bfd_byte * 6948savevr (bfd *abfd, bfd_byte *p, int r) 6949{ 6950 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p); 6951 p = p + 4; 6952 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p); 6953 return p + 4; 6954} 6955 6956static bfd_byte * 6957savevr_tail (bfd *abfd, bfd_byte *p, int r) 6958{ 6959 p = savevr (abfd, p, r); 6960 bfd_put_32 (abfd, BLR, p); 6961 return p + 4; 6962} 6963 6964static bfd_byte * 6965restvr (bfd *abfd, bfd_byte *p, int r) 6966{ 6967 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p); 6968 p = p + 4; 6969 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p); 6970 return p + 4; 6971} 6972 6973static bfd_byte * 6974restvr_tail (bfd *abfd, bfd_byte *p, int r) 6975{ 6976 p = restvr (abfd, p, r); 6977 bfd_put_32 (abfd, BLR, p); 6978 return p + 4; 6979} 6980 6981/* Called via elf_link_hash_traverse to transfer dynamic linking 6982 information on function code symbol entries to their corresponding 6983 function descriptor symbol entries. */ 6984 6985static bfd_boolean 6986func_desc_adjust (struct elf_link_hash_entry *h, void *inf) 6987{ 6988 struct bfd_link_info *info; 6989 struct ppc_link_hash_table *htab; 6990 struct ppc_link_hash_entry *fh; 6991 struct ppc_link_hash_entry *fdh; 6992 bfd_boolean force_local; 6993 6994 fh = (struct ppc_link_hash_entry *) h; 6995 if (fh->elf.root.type == bfd_link_hash_indirect) 6996 return TRUE; 6997 6998 if (!fh->is_func) 6999 return TRUE; 7000 7001 if (fh->elf.root.root.string[0] != '.' 7002 || fh->elf.root.root.string[1] == '\0') 7003 return TRUE; 7004 7005 info = inf; 7006 htab = ppc_hash_table (info); 7007 if (htab == NULL) 7008 return FALSE; 7009 7010 /* Find the corresponding function descriptor symbol. */ 7011 fdh = lookup_fdh (fh, htab); 7012 7013 /* Resolve undefined references to dot-symbols as the value 7014 in the function descriptor, if we have one in a regular object. 7015 This is to satisfy cases like ".quad .foo". Calls to functions 7016 in dynamic objects are handled elsewhere. */ 7017 if ((fh->elf.root.type == bfd_link_hash_undefined 7018 || fh->elf.root.type == bfd_link_hash_undefweak) 7019 && (fdh->elf.root.type == bfd_link_hash_defined 7020 || fdh->elf.root.type == bfd_link_hash_defweak) 7021 && get_opd_info (fdh->elf.root.u.def.section) != NULL 7022 && opd_entry_value (fdh->elf.root.u.def.section, 7023 fdh->elf.root.u.def.value, 7024 &fh->elf.root.u.def.section, 7025 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1) 7026 { 7027 fh->elf.root.type = fdh->elf.root.type; 7028 fh->elf.forced_local = 1; 7029 fh->elf.def_regular = fdh->elf.def_regular; 7030 fh->elf.def_dynamic = fdh->elf.def_dynamic; 7031 } 7032 7033 if (!fh->elf.dynamic) 7034 { 7035 struct plt_entry *ent; 7036 7037 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next) 7038 if (ent->plt.refcount > 0) 7039 break; 7040 if (ent == NULL) 7041 return TRUE; 7042 } 7043 7044 /* Create a descriptor as undefined if necessary. */ 7045 if (fdh == NULL 7046 && !bfd_link_executable (info) 7047 && (fh->elf.root.type == bfd_link_hash_undefined 7048 || fh->elf.root.type == bfd_link_hash_undefweak)) 7049 { 7050 fdh = make_fdh (info, fh); 7051 if (fdh == NULL) 7052 return FALSE; 7053 } 7054 7055 /* We can't support overriding of symbols on a fake descriptor. */ 7056 if (fdh != NULL 7057 && fdh->fake 7058 && (fh->elf.root.type == bfd_link_hash_defined 7059 || fh->elf.root.type == bfd_link_hash_defweak)) 7060 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE); 7061 7062 /* Transfer dynamic linking information to the function descriptor. */ 7063 if (fdh != NULL) 7064 { 7065 fdh->elf.ref_regular |= fh->elf.ref_regular; 7066 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic; 7067 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak; 7068 fdh->elf.non_got_ref |= fh->elf.non_got_ref; 7069 fdh->elf.dynamic |= fh->elf.dynamic; 7070 fdh->elf.needs_plt |= (fh->elf.needs_plt 7071 || fh->elf.type == STT_FUNC 7072 || fh->elf.type == STT_GNU_IFUNC); 7073 move_plt_plist (fh, fdh); 7074 7075 if (!fdh->elf.forced_local 7076 && fh->elf.dynindx != -1) 7077 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf)) 7078 return FALSE; 7079 } 7080 7081 /* Now that the info is on the function descriptor, clear the 7082 function code sym info. Any function code syms for which we 7083 don't have a definition in a regular file, we force local. 7084 This prevents a shared library from exporting syms that have 7085 been imported from another library. Function code syms that 7086 are really in the library we must leave global to prevent the 7087 linker dragging in a definition from a static library. */ 7088 force_local = (!fh->elf.def_regular 7089 || fdh == NULL 7090 || !fdh->elf.def_regular 7091 || fdh->elf.forced_local); 7092 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local); 7093 7094 return TRUE; 7095} 7096 7097static const struct sfpr_def_parms save_res_funcs[] = 7098 { 7099 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail }, 7100 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail }, 7101 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail }, 7102 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail }, 7103 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail }, 7104 { "_savefpr_", 14, 31, savefpr, savefpr0_tail }, 7105 { "_restfpr_", 14, 29, restfpr, restfpr0_tail }, 7106 { "_restfpr_", 30, 31, restfpr, restfpr0_tail }, 7107 { "._savef", 14, 31, savefpr, savefpr1_tail }, 7108 { "._restf", 14, 31, restfpr, restfpr1_tail }, 7109 { "_savevr_", 20, 31, savevr, savevr_tail }, 7110 { "_restvr_", 20, 31, restvr, restvr_tail } 7111 }; 7112 7113/* Called near the start of bfd_elf_size_dynamic_sections. We use 7114 this hook to a) provide some gcc support functions, and b) transfer 7115 dynamic linking information gathered so far on function code symbol 7116 entries, to their corresponding function descriptor symbol entries. */ 7117 7118static bfd_boolean 7119ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED, 7120 struct bfd_link_info *info) 7121{ 7122 struct ppc_link_hash_table *htab; 7123 7124 htab = ppc_hash_table (info); 7125 if (htab == NULL) 7126 return FALSE; 7127 7128 /* Provide any missing _save* and _rest* functions. */ 7129 if (htab->sfpr != NULL) 7130 { 7131 unsigned int i; 7132 7133 htab->sfpr->size = 0; 7134 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++) 7135 if (!sfpr_define (info, &save_res_funcs[i], NULL)) 7136 return FALSE; 7137 if (htab->sfpr->size == 0) 7138 htab->sfpr->flags |= SEC_EXCLUDE; 7139 } 7140 7141 if (bfd_link_relocatable (info)) 7142 return TRUE; 7143 7144 if (htab->elf.hgot != NULL) 7145 { 7146 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE); 7147 /* Make .TOC. defined so as to prevent it being made dynamic. 7148 The wrong value here is fixed later in ppc64_elf_set_toc. */ 7149 if (!htab->elf.hgot->def_regular 7150 || htab->elf.hgot->root.type != bfd_link_hash_defined) 7151 { 7152 htab->elf.hgot->root.type = bfd_link_hash_defined; 7153 htab->elf.hgot->root.u.def.value = 0; 7154 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr; 7155 htab->elf.hgot->def_regular = 1; 7156 htab->elf.hgot->root.linker_def = 1; 7157 } 7158 htab->elf.hgot->type = STT_OBJECT; 7159 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1)) 7160 | STV_HIDDEN); 7161 } 7162 7163 if (htab->need_func_desc_adj) 7164 { 7165 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info); 7166 htab->need_func_desc_adj = 0; 7167 } 7168 7169 return TRUE; 7170} 7171 7172/* Return true if we have dynamic relocs against H that apply to 7173 read-only sections. */ 7174 7175static bfd_boolean 7176readonly_dynrelocs (struct elf_link_hash_entry *h) 7177{ 7178 struct ppc_link_hash_entry *eh; 7179 struct elf_dyn_relocs *p; 7180 7181 eh = (struct ppc_link_hash_entry *) h; 7182 for (p = eh->dyn_relocs; p != NULL; p = p->next) 7183 { 7184 asection *s = p->sec->output_section; 7185 7186 if (s != NULL && (s->flags & SEC_READONLY) != 0) 7187 return TRUE; 7188 } 7189 return FALSE; 7190} 7191 7192/* Return true if we have dynamic relocs against H or any of its weak 7193 aliases, that apply to read-only sections. */ 7194 7195static bfd_boolean 7196alias_readonly_dynrelocs (struct elf_link_hash_entry *h) 7197{ 7198 struct ppc_link_hash_entry *eh; 7199 7200 eh = (struct ppc_link_hash_entry *) h; 7201 do 7202 { 7203 if (readonly_dynrelocs (&eh->elf)) 7204 return TRUE; 7205 eh = eh->weakref; 7206 } while (eh != NULL && &eh->elf != h); 7207 7208 return FALSE; 7209} 7210 7211/* Return whether EH has pc-relative dynamic relocs. */ 7212 7213static bfd_boolean 7214pc_dynrelocs (struct ppc_link_hash_entry *eh) 7215{ 7216 struct elf_dyn_relocs *p; 7217 7218 for (p = eh->dyn_relocs; p != NULL; p = p->next) 7219 if (p->pc_count != 0) 7220 return TRUE; 7221 return FALSE; 7222} 7223 7224/* Return true if a global entry stub will be created for H. Valid 7225 for ELFv2 before plt entries have been allocated. */ 7226 7227static bfd_boolean 7228global_entry_stub (struct elf_link_hash_entry *h) 7229{ 7230 struct plt_entry *pent; 7231 7232 if (!h->pointer_equality_needed 7233 || h->def_regular) 7234 return FALSE; 7235 7236 for (pent = h->plt.plist; pent != NULL; pent = pent->next) 7237 if (pent->plt.refcount > 0 7238 && pent->addend == 0) 7239 return TRUE; 7240 7241 return FALSE; 7242} 7243 7244/* Adjust a symbol defined by a dynamic object and referenced by a 7245 regular object. The current definition is in some section of the 7246 dynamic object, but we're not including those sections. We have to 7247 change the definition to something the rest of the link can 7248 understand. */ 7249 7250static bfd_boolean 7251ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 7252 struct elf_link_hash_entry *h) 7253{ 7254 struct ppc_link_hash_table *htab; 7255 asection *s, *srel; 7256 7257 htab = ppc_hash_table (info); 7258 if (htab == NULL) 7259 return FALSE; 7260 7261 /* Deal with function syms. */ 7262 if (h->type == STT_FUNC 7263 || h->type == STT_GNU_IFUNC 7264 || h->needs_plt) 7265 { 7266 /* Clear procedure linkage table information for any symbol that 7267 won't need a .plt entry. */ 7268 struct plt_entry *ent; 7269 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 7270 if (ent->plt.refcount > 0) 7271 break; 7272 if (ent == NULL 7273 || (h->type != STT_GNU_IFUNC 7274 && (SYMBOL_CALLS_LOCAL (info, h) 7275 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 7276 && h->root.type == bfd_link_hash_undefweak))) 7277 || ((struct ppc_link_hash_entry *) h)->save_res) 7278 { 7279 h->plt.plist = NULL; 7280 h->needs_plt = 0; 7281 h->pointer_equality_needed = 0; 7282 } 7283 else if (abiversion (info->output_bfd) >= 2) 7284 { 7285 /* Taking a function's address in a read/write section 7286 doesn't require us to define the function symbol in the 7287 executable on a global entry stub. A dynamic reloc can 7288 be used instead. The reason we prefer a few more dynamic 7289 relocs is that calling via a global entry stub costs a 7290 few more instructions, and pointer_equality_needed causes 7291 extra work in ld.so when resolving these symbols. */ 7292 if (global_entry_stub (h) 7293 && !alias_readonly_dynrelocs (h)) 7294 { 7295 h->pointer_equality_needed = 0; 7296 /* After adjust_dynamic_symbol, non_got_ref set in 7297 the non-pic case means that dyn_relocs for this 7298 symbol should be discarded. */ 7299 h->non_got_ref = 0; 7300 } 7301 7302 /* If making a plt entry, then we don't need copy relocs. */ 7303 return TRUE; 7304 } 7305 } 7306 else 7307 h->plt.plist = NULL; 7308 7309 /* If this is a weak symbol, and there is a real definition, the 7310 processor independent code will have arranged for us to see the 7311 real definition first, and we can just use the same value. */ 7312 if (h->u.weakdef != NULL) 7313 { 7314 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 7315 || h->u.weakdef->root.type == bfd_link_hash_defweak); 7316 h->root.u.def.section = h->u.weakdef->root.u.def.section; 7317 h->root.u.def.value = h->u.weakdef->root.u.def.value; 7318 if (ELIMINATE_COPY_RELOCS) 7319 h->non_got_ref = h->u.weakdef->non_got_ref; 7320 return TRUE; 7321 } 7322 7323 /* If we are creating a shared library, we must presume that the 7324 only references to the symbol are via the global offset table. 7325 For such cases we need not do anything here; the relocations will 7326 be handled correctly by relocate_section. */ 7327 if (bfd_link_pic (info)) 7328 return TRUE; 7329 7330 /* If there are no references to this symbol that do not use the 7331 GOT, we don't need to generate a copy reloc. */ 7332 if (!h->non_got_ref) 7333 return TRUE; 7334 7335 /* Don't generate a copy reloc for symbols defined in the executable. */ 7336 if (!h->def_dynamic || !h->ref_regular || h->def_regular 7337 7338 /* If -z nocopyreloc was given, don't generate them either. */ 7339 || info->nocopyreloc 7340 7341 /* If we didn't find any dynamic relocs in read-only sections, then 7342 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 7343 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h)) 7344 7345 /* Protected variables do not work with .dynbss. The copy in 7346 .dynbss won't be used by the shared library with the protected 7347 definition for the variable. Text relocations are preferable 7348 to an incorrect program. */ 7349 || h->protected_def) 7350 { 7351 h->non_got_ref = 0; 7352 return TRUE; 7353 } 7354 7355 if (h->plt.plist != NULL) 7356 { 7357 /* We should never get here, but unfortunately there are versions 7358 of gcc out there that improperly (for this ABI) put initialized 7359 function pointers, vtable refs and suchlike in read-only 7360 sections. Allow them to proceed, but warn that this might 7361 break at runtime. */ 7362 info->callbacks->einfo 7363 (_("%P: copy reloc against `%T' requires lazy plt linking; " 7364 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"), 7365 h->root.root.string); 7366 } 7367 7368 /* This is a reference to a symbol defined by a dynamic object which 7369 is not a function. */ 7370 7371 /* We must allocate the symbol in our .dynbss section, which will 7372 become part of the .bss section of the executable. There will be 7373 an entry for this symbol in the .dynsym section. The dynamic 7374 object will contain position independent code, so all references 7375 from the dynamic object to this symbol will go through the global 7376 offset table. The dynamic linker will use the .dynsym entry to 7377 determine the address it must put in the global offset table, so 7378 both the dynamic object and the regular object will refer to the 7379 same memory location for the variable. */ 7380 7381 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker 7382 to copy the initial value out of the dynamic object and into the 7383 runtime process image. We need to remember the offset into the 7384 .rela.bss section we are going to use. */ 7385 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 7386 { 7387 s = htab->elf.sdynrelro; 7388 srel = htab->elf.sreldynrelro; 7389 } 7390 else 7391 { 7392 s = htab->elf.sdynbss; 7393 srel = htab->elf.srelbss; 7394 } 7395 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 7396 { 7397 srel->size += sizeof (Elf64_External_Rela); 7398 h->needs_copy = 1; 7399 } 7400 7401 return _bfd_elf_adjust_dynamic_copy (info, h, s); 7402} 7403 7404/* If given a function descriptor symbol, hide both the function code 7405 sym and the descriptor. */ 7406static void 7407ppc64_elf_hide_symbol (struct bfd_link_info *info, 7408 struct elf_link_hash_entry *h, 7409 bfd_boolean force_local) 7410{ 7411 struct ppc_link_hash_entry *eh; 7412 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 7413 7414 eh = (struct ppc_link_hash_entry *) h; 7415 if (eh->is_func_descriptor) 7416 { 7417 struct ppc_link_hash_entry *fh = eh->oh; 7418 7419 if (fh == NULL) 7420 { 7421 const char *p, *q; 7422 struct elf_link_hash_table *htab = elf_hash_table (info); 7423 char save; 7424 7425 /* We aren't supposed to use alloca in BFD because on 7426 systems which do not have alloca the version in libiberty 7427 calls xmalloc, which might cause the program to crash 7428 when it runs out of memory. This function doesn't have a 7429 return status, so there's no way to gracefully return an 7430 error. So cheat. We know that string[-1] can be safely 7431 accessed; It's either a string in an ELF string table, 7432 or allocated in an objalloc structure. */ 7433 7434 p = eh->elf.root.root.string - 1; 7435 save = *p; 7436 *(char *) p = '.'; 7437 fh = (struct ppc_link_hash_entry *) 7438 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE); 7439 *(char *) p = save; 7440 7441 /* Unfortunately, if it so happens that the string we were 7442 looking for was allocated immediately before this string, 7443 then we overwrote the string terminator. That's the only 7444 reason the lookup should fail. */ 7445 if (fh == NULL) 7446 { 7447 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string); 7448 while (q >= eh->elf.root.root.string && *q == *p) 7449 --q, --p; 7450 if (q < eh->elf.root.root.string && *p == '.') 7451 fh = (struct ppc_link_hash_entry *) 7452 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE); 7453 } 7454 if (fh != NULL) 7455 { 7456 eh->oh = fh; 7457 fh->oh = eh; 7458 } 7459 } 7460 if (fh != NULL) 7461 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local); 7462 } 7463} 7464 7465static bfd_boolean 7466get_sym_h (struct elf_link_hash_entry **hp, 7467 Elf_Internal_Sym **symp, 7468 asection **symsecp, 7469 unsigned char **tls_maskp, 7470 Elf_Internal_Sym **locsymsp, 7471 unsigned long r_symndx, 7472 bfd *ibfd) 7473{ 7474 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 7475 7476 if (r_symndx >= symtab_hdr->sh_info) 7477 { 7478 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 7479 struct elf_link_hash_entry *h; 7480 7481 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 7482 h = elf_follow_link (h); 7483 7484 if (hp != NULL) 7485 *hp = h; 7486 7487 if (symp != NULL) 7488 *symp = NULL; 7489 7490 if (symsecp != NULL) 7491 { 7492 asection *symsec = NULL; 7493 if (h->root.type == bfd_link_hash_defined 7494 || h->root.type == bfd_link_hash_defweak) 7495 symsec = h->root.u.def.section; 7496 *symsecp = symsec; 7497 } 7498 7499 if (tls_maskp != NULL) 7500 { 7501 struct ppc_link_hash_entry *eh; 7502 7503 eh = (struct ppc_link_hash_entry *) h; 7504 *tls_maskp = &eh->tls_mask; 7505 } 7506 } 7507 else 7508 { 7509 Elf_Internal_Sym *sym; 7510 Elf_Internal_Sym *locsyms = *locsymsp; 7511 7512 if (locsyms == NULL) 7513 { 7514 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 7515 if (locsyms == NULL) 7516 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 7517 symtab_hdr->sh_info, 7518 0, NULL, NULL, NULL); 7519 if (locsyms == NULL) 7520 return FALSE; 7521 *locsymsp = locsyms; 7522 } 7523 sym = locsyms + r_symndx; 7524 7525 if (hp != NULL) 7526 *hp = NULL; 7527 7528 if (symp != NULL) 7529 *symp = sym; 7530 7531 if (symsecp != NULL) 7532 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx); 7533 7534 if (tls_maskp != NULL) 7535 { 7536 struct got_entry **lgot_ents; 7537 unsigned char *tls_mask; 7538 7539 tls_mask = NULL; 7540 lgot_ents = elf_local_got_ents (ibfd); 7541 if (lgot_ents != NULL) 7542 { 7543 struct plt_entry **local_plt = (struct plt_entry **) 7544 (lgot_ents + symtab_hdr->sh_info); 7545 unsigned char *lgot_masks = (unsigned char *) 7546 (local_plt + symtab_hdr->sh_info); 7547 tls_mask = &lgot_masks[r_symndx]; 7548 } 7549 *tls_maskp = tls_mask; 7550 } 7551 } 7552 return TRUE; 7553} 7554 7555/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on 7556 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD 7557 type suitable for optimization, and 1 otherwise. */ 7558 7559static int 7560get_tls_mask (unsigned char **tls_maskp, 7561 unsigned long *toc_symndx, 7562 bfd_vma *toc_addend, 7563 Elf_Internal_Sym **locsymsp, 7564 const Elf_Internal_Rela *rel, 7565 bfd *ibfd) 7566{ 7567 unsigned long r_symndx; 7568 int next_r; 7569 struct elf_link_hash_entry *h; 7570 Elf_Internal_Sym *sym; 7571 asection *sec; 7572 bfd_vma off; 7573 7574 r_symndx = ELF64_R_SYM (rel->r_info); 7575 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd)) 7576 return 0; 7577 7578 if ((*tls_maskp != NULL && **tls_maskp != 0) 7579 || sec == NULL 7580 || ppc64_elf_section_data (sec) == NULL 7581 || ppc64_elf_section_data (sec)->sec_type != sec_toc) 7582 return 1; 7583 7584 /* Look inside a TOC section too. */ 7585 if (h != NULL) 7586 { 7587 BFD_ASSERT (h->root.type == bfd_link_hash_defined); 7588 off = h->root.u.def.value; 7589 } 7590 else 7591 off = sym->st_value; 7592 off += rel->r_addend; 7593 BFD_ASSERT (off % 8 == 0); 7594 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8]; 7595 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1]; 7596 if (toc_symndx != NULL) 7597 *toc_symndx = r_symndx; 7598 if (toc_addend != NULL) 7599 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8]; 7600 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd)) 7601 return 0; 7602 if ((h == NULL || is_static_defined (h)) 7603 && (next_r == -1 || next_r == -2)) 7604 return 1 - next_r; 7605 return 1; 7606} 7607 7608/* Find (or create) an entry in the tocsave hash table. */ 7609 7610static struct tocsave_entry * 7611tocsave_find (struct ppc_link_hash_table *htab, 7612 enum insert_option insert, 7613 Elf_Internal_Sym **local_syms, 7614 const Elf_Internal_Rela *irela, 7615 bfd *ibfd) 7616{ 7617 unsigned long r_indx; 7618 struct elf_link_hash_entry *h; 7619 Elf_Internal_Sym *sym; 7620 struct tocsave_entry ent, *p; 7621 hashval_t hash; 7622 struct tocsave_entry **slot; 7623 7624 r_indx = ELF64_R_SYM (irela->r_info); 7625 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd)) 7626 return NULL; 7627 if (ent.sec == NULL || ent.sec->output_section == NULL) 7628 { 7629 _bfd_error_handler 7630 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd); 7631 return NULL; 7632 } 7633 7634 if (h != NULL) 7635 ent.offset = h->root.u.def.value; 7636 else 7637 ent.offset = sym->st_value; 7638 ent.offset += irela->r_addend; 7639 7640 hash = tocsave_htab_hash (&ent); 7641 slot = ((struct tocsave_entry **) 7642 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert)); 7643 if (slot == NULL) 7644 return NULL; 7645 7646 if (*slot == NULL) 7647 { 7648 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p)); 7649 if (p == NULL) 7650 return NULL; 7651 *p = ent; 7652 *slot = p; 7653 } 7654 return *slot; 7655} 7656 7657/* Adjust all global syms defined in opd sections. In gcc generated 7658 code for the old ABI, these will already have been done. */ 7659 7660static bfd_boolean 7661adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 7662{ 7663 struct ppc_link_hash_entry *eh; 7664 asection *sym_sec; 7665 struct _opd_sec_data *opd; 7666 7667 if (h->root.type == bfd_link_hash_indirect) 7668 return TRUE; 7669 7670 if (h->root.type != bfd_link_hash_defined 7671 && h->root.type != bfd_link_hash_defweak) 7672 return TRUE; 7673 7674 eh = (struct ppc_link_hash_entry *) h; 7675 if (eh->adjust_done) 7676 return TRUE; 7677 7678 sym_sec = eh->elf.root.u.def.section; 7679 opd = get_opd_info (sym_sec); 7680 if (opd != NULL && opd->adjust != NULL) 7681 { 7682 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)]; 7683 if (adjust == -1) 7684 { 7685 /* This entry has been deleted. */ 7686 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section; 7687 if (dsec == NULL) 7688 { 7689 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next) 7690 if (discarded_section (dsec)) 7691 { 7692 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec; 7693 break; 7694 } 7695 } 7696 eh->elf.root.u.def.value = 0; 7697 eh->elf.root.u.def.section = dsec; 7698 } 7699 else 7700 eh->elf.root.u.def.value += adjust; 7701 eh->adjust_done = 1; 7702 } 7703 return TRUE; 7704} 7705 7706/* Handles decrementing dynamic reloc counts for the reloc specified by 7707 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM 7708 have already been determined. */ 7709 7710static bfd_boolean 7711dec_dynrel_count (bfd_vma r_info, 7712 asection *sec, 7713 struct bfd_link_info *info, 7714 Elf_Internal_Sym **local_syms, 7715 struct elf_link_hash_entry *h, 7716 Elf_Internal_Sym *sym) 7717{ 7718 enum elf_ppc64_reloc_type r_type; 7719 asection *sym_sec = NULL; 7720 7721 /* Can this reloc be dynamic? This switch, and later tests here 7722 should be kept in sync with the code in check_relocs. */ 7723 r_type = ELF64_R_TYPE (r_info); 7724 switch (r_type) 7725 { 7726 default: 7727 return TRUE; 7728 7729 case R_PPC64_TPREL16: 7730 case R_PPC64_TPREL16_LO: 7731 case R_PPC64_TPREL16_HI: 7732 case R_PPC64_TPREL16_HA: 7733 case R_PPC64_TPREL16_DS: 7734 case R_PPC64_TPREL16_LO_DS: 7735 case R_PPC64_TPREL16_HIGH: 7736 case R_PPC64_TPREL16_HIGHA: 7737 case R_PPC64_TPREL16_HIGHER: 7738 case R_PPC64_TPREL16_HIGHERA: 7739 case R_PPC64_TPREL16_HIGHEST: 7740 case R_PPC64_TPREL16_HIGHESTA: 7741 if (!bfd_link_pic (info)) 7742 return TRUE; 7743 7744 case R_PPC64_TPREL64: 7745 case R_PPC64_DTPMOD64: 7746 case R_PPC64_DTPREL64: 7747 case R_PPC64_ADDR64: 7748 case R_PPC64_REL30: 7749 case R_PPC64_REL32: 7750 case R_PPC64_REL64: 7751 case R_PPC64_ADDR14: 7752 case R_PPC64_ADDR14_BRNTAKEN: 7753 case R_PPC64_ADDR14_BRTAKEN: 7754 case R_PPC64_ADDR16: 7755 case R_PPC64_ADDR16_DS: 7756 case R_PPC64_ADDR16_HA: 7757 case R_PPC64_ADDR16_HI: 7758 case R_PPC64_ADDR16_HIGH: 7759 case R_PPC64_ADDR16_HIGHA: 7760 case R_PPC64_ADDR16_HIGHER: 7761 case R_PPC64_ADDR16_HIGHERA: 7762 case R_PPC64_ADDR16_HIGHEST: 7763 case R_PPC64_ADDR16_HIGHESTA: 7764 case R_PPC64_ADDR16_LO: 7765 case R_PPC64_ADDR16_LO_DS: 7766 case R_PPC64_ADDR24: 7767 case R_PPC64_ADDR32: 7768 case R_PPC64_UADDR16: 7769 case R_PPC64_UADDR32: 7770 case R_PPC64_UADDR64: 7771 case R_PPC64_TOC: 7772 break; 7773 } 7774 7775 if (local_syms != NULL) 7776 { 7777 unsigned long r_symndx; 7778 bfd *ibfd = sec->owner; 7779 7780 r_symndx = ELF64_R_SYM (r_info); 7781 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd)) 7782 return FALSE; 7783 } 7784 7785 if ((bfd_link_pic (info) 7786 && (must_be_dyn_reloc (info, r_type) 7787 || (h != NULL 7788 && (!SYMBOLIC_BIND (info, h) 7789 || h->root.type == bfd_link_hash_defweak 7790 || !h->def_regular)))) 7791 || (ELIMINATE_COPY_RELOCS 7792 && !bfd_link_pic (info) 7793 && h != NULL 7794 && (h->root.type == bfd_link_hash_defweak 7795 || !h->def_regular))) 7796 ; 7797 else 7798 return TRUE; 7799 7800 if (h != NULL) 7801 { 7802 struct elf_dyn_relocs *p; 7803 struct elf_dyn_relocs **pp; 7804 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs; 7805 7806 /* elf_gc_sweep may have already removed all dyn relocs associated 7807 with local syms for a given section. Also, symbol flags are 7808 changed by elf_gc_sweep_symbol, confusing the test above. Don't 7809 report a dynreloc miscount. */ 7810 if (*pp == NULL && info->gc_sections) 7811 return TRUE; 7812 7813 while ((p = *pp) != NULL) 7814 { 7815 if (p->sec == sec) 7816 { 7817 if (!must_be_dyn_reloc (info, r_type)) 7818 p->pc_count -= 1; 7819 p->count -= 1; 7820 if (p->count == 0) 7821 *pp = p->next; 7822 return TRUE; 7823 } 7824 pp = &p->next; 7825 } 7826 } 7827 else 7828 { 7829 struct ppc_dyn_relocs *p; 7830 struct ppc_dyn_relocs **pp; 7831 void *vpp; 7832 bfd_boolean is_ifunc; 7833 7834 if (local_syms == NULL) 7835 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx); 7836 if (sym_sec == NULL) 7837 sym_sec = sec; 7838 7839 vpp = &elf_section_data (sym_sec)->local_dynrel; 7840 pp = (struct ppc_dyn_relocs **) vpp; 7841 7842 if (*pp == NULL && info->gc_sections) 7843 return TRUE; 7844 7845 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC; 7846 while ((p = *pp) != NULL) 7847 { 7848 if (p->sec == sec && p->ifunc == is_ifunc) 7849 { 7850 p->count -= 1; 7851 if (p->count == 0) 7852 *pp = p->next; 7853 return TRUE; 7854 } 7855 pp = &p->next; 7856 } 7857 } 7858 7859 /* xgettext:c-format */ 7860 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"), 7861 sec->owner, sec); 7862 bfd_set_error (bfd_error_bad_value); 7863 return FALSE; 7864} 7865 7866/* Remove unused Official Procedure Descriptor entries. Currently we 7867 only remove those associated with functions in discarded link-once 7868 sections, or weakly defined functions that have been overridden. It 7869 would be possible to remove many more entries for statically linked 7870 applications. */ 7871 7872bfd_boolean 7873ppc64_elf_edit_opd (struct bfd_link_info *info) 7874{ 7875 bfd *ibfd; 7876 bfd_boolean some_edited = FALSE; 7877 asection *need_pad = NULL; 7878 struct ppc_link_hash_table *htab; 7879 7880 htab = ppc_hash_table (info); 7881 if (htab == NULL) 7882 return FALSE; 7883 7884 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 7885 { 7886 asection *sec; 7887 Elf_Internal_Rela *relstart, *rel, *relend; 7888 Elf_Internal_Shdr *symtab_hdr; 7889 Elf_Internal_Sym *local_syms; 7890 struct _opd_sec_data *opd; 7891 bfd_boolean need_edit, add_aux_fields, broken; 7892 bfd_size_type cnt_16b = 0; 7893 7894 if (!is_ppc64_elf (ibfd)) 7895 continue; 7896 7897 sec = bfd_get_section_by_name (ibfd, ".opd"); 7898 if (sec == NULL || sec->size == 0) 7899 continue; 7900 7901 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 7902 continue; 7903 7904 if (sec->output_section == bfd_abs_section_ptr) 7905 continue; 7906 7907 /* Look through the section relocs. */ 7908 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0) 7909 continue; 7910 7911 local_syms = NULL; 7912 symtab_hdr = &elf_symtab_hdr (ibfd); 7913 7914 /* Read the relocations. */ 7915 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 7916 info->keep_memory); 7917 if (relstart == NULL) 7918 return FALSE; 7919 7920 /* First run through the relocs to check they are sane, and to 7921 determine whether we need to edit this opd section. */ 7922 need_edit = FALSE; 7923 broken = FALSE; 7924 need_pad = sec; 7925 relend = relstart + sec->reloc_count; 7926 for (rel = relstart; rel < relend; ) 7927 { 7928 enum elf_ppc64_reloc_type r_type; 7929 unsigned long r_symndx; 7930 asection *sym_sec; 7931 struct elf_link_hash_entry *h; 7932 Elf_Internal_Sym *sym; 7933 bfd_vma offset; 7934 7935 /* .opd contains an array of 16 or 24 byte entries. We're 7936 only interested in the reloc pointing to a function entry 7937 point. */ 7938 offset = rel->r_offset; 7939 if (rel + 1 == relend 7940 || rel[1].r_offset != offset + 8) 7941 { 7942 /* If someone messes with .opd alignment then after a 7943 "ld -r" we might have padding in the middle of .opd. 7944 Also, there's nothing to prevent someone putting 7945 something silly in .opd with the assembler. No .opd 7946 optimization for them! */ 7947 broken_opd: 7948 _bfd_error_handler 7949 (_("%B: .opd is not a regular array of opd entries"), ibfd); 7950 broken = TRUE; 7951 break; 7952 } 7953 7954 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64 7955 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC) 7956 { 7957 _bfd_error_handler 7958 /* xgettext:c-format */ 7959 (_("%B: unexpected reloc type %u in .opd section"), 7960 ibfd, r_type); 7961 broken = TRUE; 7962 break; 7963 } 7964 7965 r_symndx = ELF64_R_SYM (rel->r_info); 7966 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 7967 r_symndx, ibfd)) 7968 goto error_ret; 7969 7970 if (sym_sec == NULL || sym_sec->owner == NULL) 7971 { 7972 const char *sym_name; 7973 if (h != NULL) 7974 sym_name = h->root.root.string; 7975 else 7976 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym, 7977 sym_sec); 7978 7979 _bfd_error_handler 7980 /* xgettext:c-format */ 7981 (_("%B: undefined sym `%s' in .opd section"), 7982 ibfd, sym_name); 7983 broken = TRUE; 7984 break; 7985 } 7986 7987 /* opd entries are always for functions defined in the 7988 current input bfd. If the symbol isn't defined in the 7989 input bfd, then we won't be using the function in this 7990 bfd; It must be defined in a linkonce section in another 7991 bfd, or is weak. It's also possible that we are 7992 discarding the function due to a linker script /DISCARD/, 7993 which we test for via the output_section. */ 7994 if (sym_sec->owner != ibfd 7995 || sym_sec->output_section == bfd_abs_section_ptr) 7996 need_edit = TRUE; 7997 7998 rel += 2; 7999 if (rel + 1 == relend 8000 || (rel + 2 < relend 8001 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)) 8002 ++rel; 8003 8004 if (rel == relend) 8005 { 8006 if (sec->size == offset + 24) 8007 { 8008 need_pad = NULL; 8009 break; 8010 } 8011 if (sec->size == offset + 16) 8012 { 8013 cnt_16b++; 8014 break; 8015 } 8016 goto broken_opd; 8017 } 8018 else if (rel + 1 < relend 8019 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64 8020 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC) 8021 { 8022 if (rel[0].r_offset == offset + 16) 8023 cnt_16b++; 8024 else if (rel[0].r_offset != offset + 24) 8025 goto broken_opd; 8026 } 8027 else 8028 goto broken_opd; 8029 } 8030 8031 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0; 8032 8033 if (!broken && (need_edit || add_aux_fields)) 8034 { 8035 Elf_Internal_Rela *write_rel; 8036 Elf_Internal_Shdr *rel_hdr; 8037 bfd_byte *rptr, *wptr; 8038 bfd_byte *new_contents; 8039 bfd_size_type amt; 8040 8041 new_contents = NULL; 8042 amt = OPD_NDX (sec->size) * sizeof (long); 8043 opd = &ppc64_elf_section_data (sec)->u.opd; 8044 opd->adjust = bfd_zalloc (sec->owner, amt); 8045 if (opd->adjust == NULL) 8046 return FALSE; 8047 ppc64_elf_section_data (sec)->sec_type = sec_opd; 8048 8049 /* This seems a waste of time as input .opd sections are all 8050 zeros as generated by gcc, but I suppose there's no reason 8051 this will always be so. We might start putting something in 8052 the third word of .opd entries. */ 8053 if ((sec->flags & SEC_IN_MEMORY) == 0) 8054 { 8055 bfd_byte *loc; 8056 if (!bfd_malloc_and_get_section (ibfd, sec, &loc)) 8057 { 8058 if (loc != NULL) 8059 free (loc); 8060 error_ret: 8061 if (local_syms != NULL 8062 && symtab_hdr->contents != (unsigned char *) local_syms) 8063 free (local_syms); 8064 if (elf_section_data (sec)->relocs != relstart) 8065 free (relstart); 8066 return FALSE; 8067 } 8068 sec->contents = loc; 8069 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS); 8070 } 8071 8072 elf_section_data (sec)->relocs = relstart; 8073 8074 new_contents = sec->contents; 8075 if (add_aux_fields) 8076 { 8077 new_contents = bfd_malloc (sec->size + cnt_16b * 8); 8078 if (new_contents == NULL) 8079 return FALSE; 8080 need_pad = NULL; 8081 } 8082 wptr = new_contents; 8083 rptr = sec->contents; 8084 write_rel = relstart; 8085 for (rel = relstart; rel < relend; ) 8086 { 8087 unsigned long r_symndx; 8088 asection *sym_sec; 8089 struct elf_link_hash_entry *h; 8090 struct ppc_link_hash_entry *fdh = NULL; 8091 Elf_Internal_Sym *sym; 8092 long opd_ent_size; 8093 Elf_Internal_Rela *next_rel; 8094 bfd_boolean skip; 8095 8096 r_symndx = ELF64_R_SYM (rel->r_info); 8097 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 8098 r_symndx, ibfd)) 8099 goto error_ret; 8100 8101 next_rel = rel + 2; 8102 if (next_rel + 1 == relend 8103 || (next_rel + 2 < relend 8104 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC)) 8105 ++next_rel; 8106 8107 /* See if the .opd entry is full 24 byte or 8108 16 byte (with fd_aux entry overlapped with next 8109 fd_func). */ 8110 opd_ent_size = 24; 8111 if (next_rel == relend) 8112 { 8113 if (sec->size == rel->r_offset + 16) 8114 opd_ent_size = 16; 8115 } 8116 else if (next_rel->r_offset == rel->r_offset + 16) 8117 opd_ent_size = 16; 8118 8119 if (h != NULL 8120 && h->root.root.string[0] == '.') 8121 { 8122 fdh = ((struct ppc_link_hash_entry *) h)->oh; 8123 if (fdh != NULL) 8124 { 8125 fdh = ppc_follow_link (fdh); 8126 if (fdh->elf.root.type != bfd_link_hash_defined 8127 && fdh->elf.root.type != bfd_link_hash_defweak) 8128 fdh = NULL; 8129 } 8130 } 8131 8132 skip = (sym_sec->owner != ibfd 8133 || sym_sec->output_section == bfd_abs_section_ptr); 8134 if (skip) 8135 { 8136 if (fdh != NULL && sym_sec->owner == ibfd) 8137 { 8138 /* Arrange for the function descriptor sym 8139 to be dropped. */ 8140 fdh->elf.root.u.def.value = 0; 8141 fdh->elf.root.u.def.section = sym_sec; 8142 } 8143 opd->adjust[OPD_NDX (rel->r_offset)] = -1; 8144 8145 if (NO_OPD_RELOCS || bfd_link_relocatable (info)) 8146 rel = next_rel; 8147 else 8148 while (1) 8149 { 8150 if (!dec_dynrel_count (rel->r_info, sec, info, 8151 NULL, h, sym)) 8152 goto error_ret; 8153 8154 if (++rel == next_rel) 8155 break; 8156 8157 r_symndx = ELF64_R_SYM (rel->r_info); 8158 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 8159 r_symndx, ibfd)) 8160 goto error_ret; 8161 } 8162 } 8163 else 8164 { 8165 /* We'll be keeping this opd entry. */ 8166 long adjust; 8167 8168 if (fdh != NULL) 8169 { 8170 /* Redefine the function descriptor symbol to 8171 this location in the opd section. It is 8172 necessary to update the value here rather 8173 than using an array of adjustments as we do 8174 for local symbols, because various places 8175 in the generic ELF code use the value 8176 stored in u.def.value. */ 8177 fdh->elf.root.u.def.value = wptr - new_contents; 8178 fdh->adjust_done = 1; 8179 } 8180 8181 /* Local syms are a bit tricky. We could 8182 tweak them as they can be cached, but 8183 we'd need to look through the local syms 8184 for the function descriptor sym which we 8185 don't have at the moment. So keep an 8186 array of adjustments. */ 8187 adjust = (wptr - new_contents) - (rptr - sec->contents); 8188 opd->adjust[OPD_NDX (rel->r_offset)] = adjust; 8189 8190 if (wptr != rptr) 8191 memcpy (wptr, rptr, opd_ent_size); 8192 wptr += opd_ent_size; 8193 if (add_aux_fields && opd_ent_size == 16) 8194 { 8195 memset (wptr, '\0', 8); 8196 wptr += 8; 8197 } 8198 8199 /* We need to adjust any reloc offsets to point to the 8200 new opd entries. */ 8201 for ( ; rel != next_rel; ++rel) 8202 { 8203 rel->r_offset += adjust; 8204 if (write_rel != rel) 8205 memcpy (write_rel, rel, sizeof (*rel)); 8206 ++write_rel; 8207 } 8208 } 8209 8210 rptr += opd_ent_size; 8211 } 8212 8213 sec->size = wptr - new_contents; 8214 sec->reloc_count = write_rel - relstart; 8215 if (add_aux_fields) 8216 { 8217 free (sec->contents); 8218 sec->contents = new_contents; 8219 } 8220 8221 /* Fudge the header size too, as this is used later in 8222 elf_bfd_final_link if we are emitting relocs. */ 8223 rel_hdr = _bfd_elf_single_rel_hdr (sec); 8224 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize; 8225 some_edited = TRUE; 8226 } 8227 else if (elf_section_data (sec)->relocs != relstart) 8228 free (relstart); 8229 8230 if (local_syms != NULL 8231 && symtab_hdr->contents != (unsigned char *) local_syms) 8232 { 8233 if (!info->keep_memory) 8234 free (local_syms); 8235 else 8236 symtab_hdr->contents = (unsigned char *) local_syms; 8237 } 8238 } 8239 8240 if (some_edited) 8241 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL); 8242 8243 /* If we are doing a final link and the last .opd entry is just 16 byte 8244 long, add a 8 byte padding after it. */ 8245 if (need_pad != NULL && !bfd_link_relocatable (info)) 8246 { 8247 bfd_byte *p; 8248 8249 if ((need_pad->flags & SEC_IN_MEMORY) == 0) 8250 { 8251 BFD_ASSERT (need_pad->size > 0); 8252 8253 p = bfd_malloc (need_pad->size + 8); 8254 if (p == NULL) 8255 return FALSE; 8256 8257 if (! bfd_get_section_contents (need_pad->owner, need_pad, 8258 p, 0, need_pad->size)) 8259 return FALSE; 8260 8261 need_pad->contents = p; 8262 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS); 8263 } 8264 else 8265 { 8266 p = bfd_realloc (need_pad->contents, need_pad->size + 8); 8267 if (p == NULL) 8268 return FALSE; 8269 8270 need_pad->contents = p; 8271 } 8272 8273 memset (need_pad->contents + need_pad->size, 0, 8); 8274 need_pad->size += 8; 8275 } 8276 8277 return TRUE; 8278} 8279 8280/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */ 8281 8282asection * 8283ppc64_elf_tls_setup (struct bfd_link_info *info) 8284{ 8285 struct ppc_link_hash_table *htab; 8286 8287 htab = ppc_hash_table (info); 8288 if (htab == NULL) 8289 return NULL; 8290 8291 if (abiversion (info->output_bfd) == 1) 8292 htab->opd_abi = 1; 8293 8294 if (htab->params->no_multi_toc) 8295 htab->do_multi_toc = 0; 8296 else if (!htab->do_multi_toc) 8297 htab->params->no_multi_toc = 1; 8298 8299 htab->tls_get_addr = ((struct ppc_link_hash_entry *) 8300 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr", 8301 FALSE, FALSE, TRUE)); 8302 /* Move dynamic linking info to the function descriptor sym. */ 8303 if (htab->tls_get_addr != NULL) 8304 func_desc_adjust (&htab->tls_get_addr->elf, info); 8305 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *) 8306 elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 8307 FALSE, FALSE, TRUE)); 8308 if (htab->params->tls_get_addr_opt) 8309 { 8310 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd; 8311 8312 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt", 8313 FALSE, FALSE, TRUE); 8314 if (opt != NULL) 8315 func_desc_adjust (opt, info); 8316 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt", 8317 FALSE, FALSE, TRUE); 8318 if (opt_fd != NULL 8319 && (opt_fd->root.type == bfd_link_hash_defined 8320 || opt_fd->root.type == bfd_link_hash_defweak)) 8321 { 8322 /* If glibc supports an optimized __tls_get_addr call stub, 8323 signalled by the presence of __tls_get_addr_opt, and we'll 8324 be calling __tls_get_addr via a plt call stub, then 8325 make __tls_get_addr point to __tls_get_addr_opt. */ 8326 tga_fd = &htab->tls_get_addr_fd->elf; 8327 if (htab->elf.dynamic_sections_created 8328 && tga_fd != NULL 8329 && (tga_fd->type == STT_FUNC 8330 || tga_fd->needs_plt) 8331 && !(SYMBOL_CALLS_LOCAL (info, tga_fd) 8332 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT 8333 && tga_fd->root.type == bfd_link_hash_undefweak))) 8334 { 8335 struct plt_entry *ent; 8336 8337 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next) 8338 if (ent->plt.refcount > 0) 8339 break; 8340 if (ent != NULL) 8341 { 8342 tga_fd->root.type = bfd_link_hash_indirect; 8343 tga_fd->root.u.i.link = &opt_fd->root; 8344 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd); 8345 opt_fd->forced_local = 0; 8346 if (opt_fd->dynindx != -1) 8347 { 8348 /* Use __tls_get_addr_opt in dynamic relocations. */ 8349 opt_fd->dynindx = -1; 8350 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 8351 opt_fd->dynstr_index); 8352 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd)) 8353 return NULL; 8354 } 8355 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd; 8356 tga = &htab->tls_get_addr->elf; 8357 if (opt != NULL && tga != NULL) 8358 { 8359 tga->root.type = bfd_link_hash_indirect; 8360 tga->root.u.i.link = &opt->root; 8361 ppc64_elf_copy_indirect_symbol (info, opt, tga); 8362 opt->forced_local = 0; 8363 _bfd_elf_link_hash_hide_symbol (info, opt, 8364 tga->forced_local); 8365 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt; 8366 } 8367 htab->tls_get_addr_fd->oh = htab->tls_get_addr; 8368 htab->tls_get_addr_fd->is_func_descriptor = 1; 8369 if (htab->tls_get_addr != NULL) 8370 { 8371 htab->tls_get_addr->oh = htab->tls_get_addr_fd; 8372 htab->tls_get_addr->is_func = 1; 8373 } 8374 } 8375 } 8376 } 8377 else if (htab->params->tls_get_addr_opt < 0) 8378 htab->params->tls_get_addr_opt = 0; 8379 } 8380 return _bfd_elf_tls_setup (info->output_bfd, info); 8381} 8382 8383/* Return TRUE iff REL is a branch reloc with a global symbol matching 8384 HASH1 or HASH2. */ 8385 8386static bfd_boolean 8387branch_reloc_hash_match (const bfd *ibfd, 8388 const Elf_Internal_Rela *rel, 8389 const struct ppc_link_hash_entry *hash1, 8390 const struct ppc_link_hash_entry *hash2) 8391{ 8392 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 8393 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info); 8394 unsigned int r_symndx = ELF64_R_SYM (rel->r_info); 8395 8396 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type)) 8397 { 8398 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 8399 struct elf_link_hash_entry *h; 8400 8401 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 8402 h = elf_follow_link (h); 8403 if (h == &hash1->elf || h == &hash2->elf) 8404 return TRUE; 8405 } 8406 return FALSE; 8407} 8408 8409/* Run through all the TLS relocs looking for optimization 8410 opportunities. The linker has been hacked (see ppc64elf.em) to do 8411 a preliminary section layout so that we know the TLS segment 8412 offsets. We can't optimize earlier because some optimizations need 8413 to know the tp offset, and we need to optimize before allocating 8414 dynamic relocations. */ 8415 8416bfd_boolean 8417ppc64_elf_tls_optimize (struct bfd_link_info *info) 8418{ 8419 bfd *ibfd; 8420 asection *sec; 8421 struct ppc_link_hash_table *htab; 8422 unsigned char *toc_ref; 8423 int pass; 8424 8425 if (!bfd_link_executable (info)) 8426 return TRUE; 8427 8428 htab = ppc_hash_table (info); 8429 if (htab == NULL) 8430 return FALSE; 8431 8432 /* Make two passes over the relocs. On the first pass, mark toc 8433 entries involved with tls relocs, and check that tls relocs 8434 involved in setting up a tls_get_addr call are indeed followed by 8435 such a call. If they are not, we can't do any tls optimization. 8436 On the second pass twiddle tls_mask flags to notify 8437 relocate_section that optimization can be done, and adjust got 8438 and plt refcounts. */ 8439 toc_ref = NULL; 8440 for (pass = 0; pass < 2; ++pass) 8441 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 8442 { 8443 Elf_Internal_Sym *locsyms = NULL; 8444 asection *toc = bfd_get_section_by_name (ibfd, ".toc"); 8445 8446 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 8447 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section)) 8448 { 8449 Elf_Internal_Rela *relstart, *rel, *relend; 8450 bfd_boolean found_tls_get_addr_arg = 0; 8451 8452 /* Read the relocations. */ 8453 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 8454 info->keep_memory); 8455 if (relstart == NULL) 8456 { 8457 free (toc_ref); 8458 return FALSE; 8459 } 8460 8461 relend = relstart + sec->reloc_count; 8462 for (rel = relstart; rel < relend; rel++) 8463 { 8464 enum elf_ppc64_reloc_type r_type; 8465 unsigned long r_symndx; 8466 struct elf_link_hash_entry *h; 8467 Elf_Internal_Sym *sym; 8468 asection *sym_sec; 8469 unsigned char *tls_mask; 8470 unsigned char tls_set, tls_clear, tls_type = 0; 8471 bfd_vma value; 8472 bfd_boolean ok_tprel, is_local; 8473 long toc_ref_index = 0; 8474 int expecting_tls_get_addr = 0; 8475 bfd_boolean ret = FALSE; 8476 8477 r_symndx = ELF64_R_SYM (rel->r_info); 8478 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms, 8479 r_symndx, ibfd)) 8480 { 8481 err_free_rel: 8482 if (elf_section_data (sec)->relocs != relstart) 8483 free (relstart); 8484 if (toc_ref != NULL) 8485 free (toc_ref); 8486 if (locsyms != NULL 8487 && (elf_symtab_hdr (ibfd).contents 8488 != (unsigned char *) locsyms)) 8489 free (locsyms); 8490 return ret; 8491 } 8492 8493 if (h != NULL) 8494 { 8495 if (h->root.type == bfd_link_hash_defined 8496 || h->root.type == bfd_link_hash_defweak) 8497 value = h->root.u.def.value; 8498 else if (h->root.type == bfd_link_hash_undefweak) 8499 value = 0; 8500 else 8501 { 8502 found_tls_get_addr_arg = 0; 8503 continue; 8504 } 8505 } 8506 else 8507 /* Symbols referenced by TLS relocs must be of type 8508 STT_TLS. So no need for .opd local sym adjust. */ 8509 value = sym->st_value; 8510 8511 ok_tprel = FALSE; 8512 is_local = FALSE; 8513 if (h == NULL 8514 || !h->def_dynamic) 8515 { 8516 is_local = TRUE; 8517 if (h != NULL 8518 && h->root.type == bfd_link_hash_undefweak) 8519 ok_tprel = TRUE; 8520 else if (sym_sec != NULL 8521 && sym_sec->output_section != NULL) 8522 { 8523 value += sym_sec->output_offset; 8524 value += sym_sec->output_section->vma; 8525 value -= htab->elf.tls_sec->vma; 8526 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31) 8527 < (bfd_vma) 1 << 32); 8528 } 8529 } 8530 8531 r_type = ELF64_R_TYPE (rel->r_info); 8532 /* If this section has old-style __tls_get_addr calls 8533 without marker relocs, then check that each 8534 __tls_get_addr call reloc is preceded by a reloc 8535 that conceivably belongs to the __tls_get_addr arg 8536 setup insn. If we don't find matching arg setup 8537 relocs, don't do any tls optimization. */ 8538 if (pass == 0 8539 && sec->has_tls_get_addr_call 8540 && h != NULL 8541 && (h == &htab->tls_get_addr->elf 8542 || h == &htab->tls_get_addr_fd->elf) 8543 && !found_tls_get_addr_arg 8544 && is_branch_reloc (r_type)) 8545 { 8546 info->callbacks->minfo (_("%H __tls_get_addr lost arg, " 8547 "TLS optimization disabled\n"), 8548 ibfd, sec, rel->r_offset); 8549 ret = TRUE; 8550 goto err_free_rel; 8551 } 8552 8553 found_tls_get_addr_arg = 0; 8554 switch (r_type) 8555 { 8556 case R_PPC64_GOT_TLSLD16: 8557 case R_PPC64_GOT_TLSLD16_LO: 8558 expecting_tls_get_addr = 1; 8559 found_tls_get_addr_arg = 1; 8560 /* Fall through. */ 8561 8562 case R_PPC64_GOT_TLSLD16_HI: 8563 case R_PPC64_GOT_TLSLD16_HA: 8564 /* These relocs should never be against a symbol 8565 defined in a shared lib. Leave them alone if 8566 that turns out to be the case. */ 8567 if (!is_local) 8568 continue; 8569 8570 /* LD -> LE */ 8571 tls_set = 0; 8572 tls_clear = TLS_LD; 8573 tls_type = TLS_TLS | TLS_LD; 8574 break; 8575 8576 case R_PPC64_GOT_TLSGD16: 8577 case R_PPC64_GOT_TLSGD16_LO: 8578 expecting_tls_get_addr = 1; 8579 found_tls_get_addr_arg = 1; 8580 /* Fall through. */ 8581 8582 case R_PPC64_GOT_TLSGD16_HI: 8583 case R_PPC64_GOT_TLSGD16_HA: 8584 if (ok_tprel) 8585 /* GD -> LE */ 8586 tls_set = 0; 8587 else 8588 /* GD -> IE */ 8589 tls_set = TLS_TLS | TLS_TPRELGD; 8590 tls_clear = TLS_GD; 8591 tls_type = TLS_TLS | TLS_GD; 8592 break; 8593 8594 case R_PPC64_GOT_TPREL16_DS: 8595 case R_PPC64_GOT_TPREL16_LO_DS: 8596 case R_PPC64_GOT_TPREL16_HI: 8597 case R_PPC64_GOT_TPREL16_HA: 8598 if (ok_tprel) 8599 { 8600 /* IE -> LE */ 8601 tls_set = 0; 8602 tls_clear = TLS_TPREL; 8603 tls_type = TLS_TLS | TLS_TPREL; 8604 break; 8605 } 8606 continue; 8607 8608 case R_PPC64_TLSGD: 8609 case R_PPC64_TLSLD: 8610 found_tls_get_addr_arg = 1; 8611 /* Fall through. */ 8612 8613 case R_PPC64_TLS: 8614 case R_PPC64_TOC16: 8615 case R_PPC64_TOC16_LO: 8616 if (sym_sec == NULL || sym_sec != toc) 8617 continue; 8618 8619 /* Mark this toc entry as referenced by a TLS 8620 code sequence. We can do that now in the 8621 case of R_PPC64_TLS, and after checking for 8622 tls_get_addr for the TOC16 relocs. */ 8623 if (toc_ref == NULL) 8624 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8); 8625 if (toc_ref == NULL) 8626 goto err_free_rel; 8627 8628 if (h != NULL) 8629 value = h->root.u.def.value; 8630 else 8631 value = sym->st_value; 8632 value += rel->r_addend; 8633 if (value % 8 != 0) 8634 continue; 8635 BFD_ASSERT (value < toc->size 8636 && toc->output_offset % 8 == 0); 8637 toc_ref_index = (value + toc->output_offset) / 8; 8638 if (r_type == R_PPC64_TLS 8639 || r_type == R_PPC64_TLSGD 8640 || r_type == R_PPC64_TLSLD) 8641 { 8642 toc_ref[toc_ref_index] = 1; 8643 continue; 8644 } 8645 8646 if (pass != 0 && toc_ref[toc_ref_index] == 0) 8647 continue; 8648 8649 tls_set = 0; 8650 tls_clear = 0; 8651 expecting_tls_get_addr = 2; 8652 break; 8653 8654 case R_PPC64_TPREL64: 8655 if (pass == 0 8656 || sec != toc 8657 || toc_ref == NULL 8658 || !toc_ref[(rel->r_offset + toc->output_offset) / 8]) 8659 continue; 8660 if (ok_tprel) 8661 { 8662 /* IE -> LE */ 8663 tls_set = TLS_EXPLICIT; 8664 tls_clear = TLS_TPREL; 8665 break; 8666 } 8667 continue; 8668 8669 case R_PPC64_DTPMOD64: 8670 if (pass == 0 8671 || sec != toc 8672 || toc_ref == NULL 8673 || !toc_ref[(rel->r_offset + toc->output_offset) / 8]) 8674 continue; 8675 if (rel + 1 < relend 8676 && (rel[1].r_info 8677 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)) 8678 && rel[1].r_offset == rel->r_offset + 8) 8679 { 8680 if (ok_tprel) 8681 /* GD -> LE */ 8682 tls_set = TLS_EXPLICIT | TLS_GD; 8683 else 8684 /* GD -> IE */ 8685 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD; 8686 tls_clear = TLS_GD; 8687 } 8688 else 8689 { 8690 if (!is_local) 8691 continue; 8692 8693 /* LD -> LE */ 8694 tls_set = TLS_EXPLICIT; 8695 tls_clear = TLS_LD; 8696 } 8697 break; 8698 8699 default: 8700 continue; 8701 } 8702 8703 if (pass == 0) 8704 { 8705 if (!expecting_tls_get_addr 8706 || !sec->has_tls_get_addr_call) 8707 continue; 8708 8709 if (rel + 1 < relend 8710 && branch_reloc_hash_match (ibfd, rel + 1, 8711 htab->tls_get_addr, 8712 htab->tls_get_addr_fd)) 8713 { 8714 if (expecting_tls_get_addr == 2) 8715 { 8716 /* Check for toc tls entries. */ 8717 unsigned char *toc_tls; 8718 int retval; 8719 8720 retval = get_tls_mask (&toc_tls, NULL, NULL, 8721 &locsyms, 8722 rel, ibfd); 8723 if (retval == 0) 8724 goto err_free_rel; 8725 if (toc_tls != NULL) 8726 { 8727 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0) 8728 found_tls_get_addr_arg = 1; 8729 if (retval > 1) 8730 toc_ref[toc_ref_index] = 1; 8731 } 8732 } 8733 continue; 8734 } 8735 8736 if (expecting_tls_get_addr != 1) 8737 continue; 8738 8739 /* Uh oh, we didn't find the expected call. We 8740 could just mark this symbol to exclude it 8741 from tls optimization but it's safer to skip 8742 the entire optimization. */ 8743 /* xgettext:c-format */ 8744 info->callbacks->minfo (_("%H arg lost __tls_get_addr, " 8745 "TLS optimization disabled\n"), 8746 ibfd, sec, rel->r_offset); 8747 ret = TRUE; 8748 goto err_free_rel; 8749 } 8750 8751 if (expecting_tls_get_addr && htab->tls_get_addr != NULL) 8752 { 8753 struct plt_entry *ent; 8754 for (ent = htab->tls_get_addr->elf.plt.plist; 8755 ent != NULL; 8756 ent = ent->next) 8757 if (ent->addend == 0) 8758 { 8759 if (ent->plt.refcount > 0) 8760 { 8761 ent->plt.refcount -= 1; 8762 expecting_tls_get_addr = 0; 8763 } 8764 break; 8765 } 8766 } 8767 8768 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL) 8769 { 8770 struct plt_entry *ent; 8771 for (ent = htab->tls_get_addr_fd->elf.plt.plist; 8772 ent != NULL; 8773 ent = ent->next) 8774 if (ent->addend == 0) 8775 { 8776 if (ent->plt.refcount > 0) 8777 ent->plt.refcount -= 1; 8778 break; 8779 } 8780 } 8781 8782 if (tls_clear == 0) 8783 continue; 8784 8785 if ((tls_set & TLS_EXPLICIT) == 0) 8786 { 8787 struct got_entry *ent; 8788 8789 /* Adjust got entry for this reloc. */ 8790 if (h != NULL) 8791 ent = h->got.glist; 8792 else 8793 ent = elf_local_got_ents (ibfd)[r_symndx]; 8794 8795 for (; ent != NULL; ent = ent->next) 8796 if (ent->addend == rel->r_addend 8797 && ent->owner == ibfd 8798 && ent->tls_type == tls_type) 8799 break; 8800 if (ent == NULL) 8801 abort (); 8802 8803 if (tls_set == 0) 8804 { 8805 /* We managed to get rid of a got entry. */ 8806 if (ent->got.refcount > 0) 8807 ent->got.refcount -= 1; 8808 } 8809 } 8810 else 8811 { 8812 /* If we got rid of a DTPMOD/DTPREL reloc pair then 8813 we'll lose one or two dyn relocs. */ 8814 if (!dec_dynrel_count (rel->r_info, sec, info, 8815 NULL, h, sym)) 8816 return FALSE; 8817 8818 if (tls_set == (TLS_EXPLICIT | TLS_GD)) 8819 { 8820 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info, 8821 NULL, h, sym)) 8822 return FALSE; 8823 } 8824 } 8825 8826 *tls_mask |= tls_set; 8827 *tls_mask &= ~tls_clear; 8828 } 8829 8830 if (elf_section_data (sec)->relocs != relstart) 8831 free (relstart); 8832 } 8833 8834 if (locsyms != NULL 8835 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms)) 8836 { 8837 if (!info->keep_memory) 8838 free (locsyms); 8839 else 8840 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms; 8841 } 8842 } 8843 8844 if (toc_ref != NULL) 8845 free (toc_ref); 8846 return TRUE; 8847} 8848 8849/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust 8850 the values of any global symbols in a toc section that has been 8851 edited. Globals in toc sections should be a rarity, so this function 8852 sets a flag if any are found in toc sections other than the one just 8853 edited, so that futher hash table traversals can be avoided. */ 8854 8855struct adjust_toc_info 8856{ 8857 asection *toc; 8858 unsigned long *skip; 8859 bfd_boolean global_toc_syms; 8860}; 8861 8862enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 }; 8863 8864static bfd_boolean 8865adjust_toc_syms (struct elf_link_hash_entry *h, void *inf) 8866{ 8867 struct ppc_link_hash_entry *eh; 8868 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf; 8869 unsigned long i; 8870 8871 if (h->root.type != bfd_link_hash_defined 8872 && h->root.type != bfd_link_hash_defweak) 8873 return TRUE; 8874 8875 eh = (struct ppc_link_hash_entry *) h; 8876 if (eh->adjust_done) 8877 return TRUE; 8878 8879 if (eh->elf.root.u.def.section == toc_inf->toc) 8880 { 8881 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize) 8882 i = toc_inf->toc->rawsize >> 3; 8883 else 8884 i = eh->elf.root.u.def.value >> 3; 8885 8886 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0) 8887 { 8888 _bfd_error_handler 8889 (_("%s defined on removed toc entry"), eh->elf.root.root.string); 8890 do 8891 ++i; 8892 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0); 8893 eh->elf.root.u.def.value = (bfd_vma) i << 3; 8894 } 8895 8896 eh->elf.root.u.def.value -= toc_inf->skip[i]; 8897 eh->adjust_done = 1; 8898 } 8899 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0) 8900 toc_inf->global_toc_syms = TRUE; 8901 8902 return TRUE; 8903} 8904 8905/* Return TRUE iff INSN with a relocation of R_TYPE is one we expect 8906 on a _LO variety toc/got reloc. */ 8907 8908static bfd_boolean 8909ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type) 8910{ 8911 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */ 8912 || (insn & (0x3f << 26)) == 14u << 26 /* addi */ 8913 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */ 8914 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */ 8915 || (insn & (0x3f << 26)) == 36u << 26 /* stw */ 8916 || (insn & (0x3f << 26)) == 38u << 26 /* stb */ 8917 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */ 8918 || (insn & (0x3f << 26)) == 42u << 26 /* lha */ 8919 || (insn & (0x3f << 26)) == 44u << 26 /* sth */ 8920 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */ 8921 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */ 8922 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */ 8923 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */ 8924 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */ 8925 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */ 8926 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */ 8927 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */ 8928 /* Exclude lfqu by testing reloc. If relocs are ever 8929 defined for the reduced D field in psq_lu then those 8930 will need testing too. */ 8931 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO) 8932 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */ 8933 && (insn & 1) == 0) 8934 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */ 8935 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */ 8936 /* Exclude stfqu. psq_stu as above for psq_lu. */ 8937 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO) 8938 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */ 8939 && (insn & 1) == 0)); 8940} 8941 8942/* Examine all relocs referencing .toc sections in order to remove 8943 unused .toc entries. */ 8944 8945bfd_boolean 8946ppc64_elf_edit_toc (struct bfd_link_info *info) 8947{ 8948 bfd *ibfd; 8949 struct adjust_toc_info toc_inf; 8950 struct ppc_link_hash_table *htab = ppc_hash_table (info); 8951 8952 htab->do_toc_opt = 1; 8953 toc_inf.global_toc_syms = TRUE; 8954 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 8955 { 8956 asection *toc, *sec; 8957 Elf_Internal_Shdr *symtab_hdr; 8958 Elf_Internal_Sym *local_syms; 8959 Elf_Internal_Rela *relstart, *rel, *toc_relocs; 8960 unsigned long *skip, *drop; 8961 unsigned char *used; 8962 unsigned char *keep, last, some_unused; 8963 8964 if (!is_ppc64_elf (ibfd)) 8965 continue; 8966 8967 toc = bfd_get_section_by_name (ibfd, ".toc"); 8968 if (toc == NULL 8969 || toc->size == 0 8970 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS 8971 || discarded_section (toc)) 8972 continue; 8973 8974 toc_relocs = NULL; 8975 local_syms = NULL; 8976 symtab_hdr = &elf_symtab_hdr (ibfd); 8977 8978 /* Look at sections dropped from the final link. */ 8979 skip = NULL; 8980 relstart = NULL; 8981 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 8982 { 8983 if (sec->reloc_count == 0 8984 || !discarded_section (sec) 8985 || get_opd_info (sec) 8986 || (sec->flags & SEC_ALLOC) == 0 8987 || (sec->flags & SEC_DEBUGGING) != 0) 8988 continue; 8989 8990 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE); 8991 if (relstart == NULL) 8992 goto error_ret; 8993 8994 /* Run through the relocs to see which toc entries might be 8995 unused. */ 8996 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 8997 { 8998 enum elf_ppc64_reloc_type r_type; 8999 unsigned long r_symndx; 9000 asection *sym_sec; 9001 struct elf_link_hash_entry *h; 9002 Elf_Internal_Sym *sym; 9003 bfd_vma val; 9004 9005 r_type = ELF64_R_TYPE (rel->r_info); 9006 switch (r_type) 9007 { 9008 default: 9009 continue; 9010 9011 case R_PPC64_TOC16: 9012 case R_PPC64_TOC16_LO: 9013 case R_PPC64_TOC16_HI: 9014 case R_PPC64_TOC16_HA: 9015 case R_PPC64_TOC16_DS: 9016 case R_PPC64_TOC16_LO_DS: 9017 break; 9018 } 9019 9020 r_symndx = ELF64_R_SYM (rel->r_info); 9021 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 9022 r_symndx, ibfd)) 9023 goto error_ret; 9024 9025 if (sym_sec != toc) 9026 continue; 9027 9028 if (h != NULL) 9029 val = h->root.u.def.value; 9030 else 9031 val = sym->st_value; 9032 val += rel->r_addend; 9033 9034 if (val >= toc->size) 9035 continue; 9036 9037 /* Anything in the toc ought to be aligned to 8 bytes. 9038 If not, don't mark as unused. */ 9039 if (val & 7) 9040 continue; 9041 9042 if (skip == NULL) 9043 { 9044 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8); 9045 if (skip == NULL) 9046 goto error_ret; 9047 } 9048 9049 skip[val >> 3] = ref_from_discarded; 9050 } 9051 9052 if (elf_section_data (sec)->relocs != relstart) 9053 free (relstart); 9054 } 9055 9056 /* For largetoc loads of address constants, we can convert 9057 . addis rx,2,addr@got@ha 9058 . ld ry,addr@got@l(rx) 9059 to 9060 . addis rx,2,addr@toc@ha 9061 . addi ry,rx,addr@toc@l 9062 when addr is within 2G of the toc pointer. This then means 9063 that the word storing "addr" in the toc is no longer needed. */ 9064 9065 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc 9066 && toc->output_section->rawsize < (bfd_vma) 1 << 31 9067 && toc->reloc_count != 0) 9068 { 9069 /* Read toc relocs. */ 9070 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL, 9071 info->keep_memory); 9072 if (toc_relocs == NULL) 9073 goto error_ret; 9074 9075 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel) 9076 { 9077 enum elf_ppc64_reloc_type r_type; 9078 unsigned long r_symndx; 9079 asection *sym_sec; 9080 struct elf_link_hash_entry *h; 9081 Elf_Internal_Sym *sym; 9082 bfd_vma val, addr; 9083 9084 r_type = ELF64_R_TYPE (rel->r_info); 9085 if (r_type != R_PPC64_ADDR64) 9086 continue; 9087 9088 r_symndx = ELF64_R_SYM (rel->r_info); 9089 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 9090 r_symndx, ibfd)) 9091 goto error_ret; 9092 9093 if (sym_sec == NULL 9094 || sym_sec->output_section == NULL 9095 || discarded_section (sym_sec)) 9096 continue; 9097 9098 if (!SYMBOL_REFERENCES_LOCAL (info, h)) 9099 continue; 9100 9101 if (h != NULL) 9102 { 9103 if (h->type == STT_GNU_IFUNC) 9104 continue; 9105 val = h->root.u.def.value; 9106 } 9107 else 9108 { 9109 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 9110 continue; 9111 val = sym->st_value; 9112 } 9113 val += rel->r_addend; 9114 val += sym_sec->output_section->vma + sym_sec->output_offset; 9115 9116 /* We don't yet know the exact toc pointer value, but we 9117 know it will be somewhere in the toc section. Don't 9118 optimize if the difference from any possible toc 9119 pointer is outside [ff..f80008000, 7fff7fff]. */ 9120 addr = toc->output_section->vma + TOC_BASE_OFF; 9121 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32) 9122 continue; 9123 9124 addr = toc->output_section->vma + toc->output_section->rawsize; 9125 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32) 9126 continue; 9127 9128 if (skip == NULL) 9129 { 9130 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8); 9131 if (skip == NULL) 9132 goto error_ret; 9133 } 9134 9135 skip[rel->r_offset >> 3] 9136 |= can_optimize | ((rel - toc_relocs) << 2); 9137 } 9138 } 9139 9140 if (skip == NULL) 9141 continue; 9142 9143 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8); 9144 if (used == NULL) 9145 { 9146 error_ret: 9147 if (local_syms != NULL 9148 && symtab_hdr->contents != (unsigned char *) local_syms) 9149 free (local_syms); 9150 if (sec != NULL 9151 && relstart != NULL 9152 && elf_section_data (sec)->relocs != relstart) 9153 free (relstart); 9154 if (toc_relocs != NULL 9155 && elf_section_data (toc)->relocs != toc_relocs) 9156 free (toc_relocs); 9157 if (skip != NULL) 9158 free (skip); 9159 return FALSE; 9160 } 9161 9162 /* Now check all kept sections that might reference the toc. 9163 Check the toc itself last. */ 9164 for (sec = (ibfd->sections == toc && toc->next ? toc->next 9165 : ibfd->sections); 9166 sec != NULL; 9167 sec = (sec == toc ? NULL 9168 : sec->next == NULL ? toc 9169 : sec->next == toc && toc->next ? toc->next 9170 : sec->next)) 9171 { 9172 int repeat; 9173 9174 if (sec->reloc_count == 0 9175 || discarded_section (sec) 9176 || get_opd_info (sec) 9177 || (sec->flags & SEC_ALLOC) == 0 9178 || (sec->flags & SEC_DEBUGGING) != 0) 9179 continue; 9180 9181 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 9182 info->keep_memory); 9183 if (relstart == NULL) 9184 { 9185 free (used); 9186 goto error_ret; 9187 } 9188 9189 /* Mark toc entries referenced as used. */ 9190 do 9191 { 9192 repeat = 0; 9193 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 9194 { 9195 enum elf_ppc64_reloc_type r_type; 9196 unsigned long r_symndx; 9197 asection *sym_sec; 9198 struct elf_link_hash_entry *h; 9199 Elf_Internal_Sym *sym; 9200 bfd_vma val; 9201 enum {no_check, check_lo, check_ha} insn_check; 9202 9203 r_type = ELF64_R_TYPE (rel->r_info); 9204 switch (r_type) 9205 { 9206 default: 9207 insn_check = no_check; 9208 break; 9209 9210 case R_PPC64_GOT_TLSLD16_HA: 9211 case R_PPC64_GOT_TLSGD16_HA: 9212 case R_PPC64_GOT_TPREL16_HA: 9213 case R_PPC64_GOT_DTPREL16_HA: 9214 case R_PPC64_GOT16_HA: 9215 case R_PPC64_TOC16_HA: 9216 insn_check = check_ha; 9217 break; 9218 9219 case R_PPC64_GOT_TLSLD16_LO: 9220 case R_PPC64_GOT_TLSGD16_LO: 9221 case R_PPC64_GOT_TPREL16_LO_DS: 9222 case R_PPC64_GOT_DTPREL16_LO_DS: 9223 case R_PPC64_GOT16_LO: 9224 case R_PPC64_GOT16_LO_DS: 9225 case R_PPC64_TOC16_LO: 9226 case R_PPC64_TOC16_LO_DS: 9227 insn_check = check_lo; 9228 break; 9229 } 9230 9231 if (insn_check != no_check) 9232 { 9233 bfd_vma off = rel->r_offset & ~3; 9234 unsigned char buf[4]; 9235 unsigned int insn; 9236 9237 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4)) 9238 { 9239 free (used); 9240 goto error_ret; 9241 } 9242 insn = bfd_get_32 (ibfd, buf); 9243 if (insn_check == check_lo 9244 ? !ok_lo_toc_insn (insn, r_type) 9245 : ((insn & ((0x3f << 26) | 0x1f << 16)) 9246 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */)) 9247 { 9248 char str[12]; 9249 9250 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1; 9251 sprintf (str, "%#08x", insn); 9252 info->callbacks->einfo 9253 /* xgettext:c-format */ 9254 (_("%P: %H: toc optimization is not supported for" 9255 " %s instruction.\n"), 9256 ibfd, sec, rel->r_offset & ~3, str); 9257 } 9258 } 9259 9260 switch (r_type) 9261 { 9262 case R_PPC64_TOC16: 9263 case R_PPC64_TOC16_LO: 9264 case R_PPC64_TOC16_HI: 9265 case R_PPC64_TOC16_HA: 9266 case R_PPC64_TOC16_DS: 9267 case R_PPC64_TOC16_LO_DS: 9268 /* In case we're taking addresses of toc entries. */ 9269 case R_PPC64_ADDR64: 9270 break; 9271 9272 default: 9273 continue; 9274 } 9275 9276 r_symndx = ELF64_R_SYM (rel->r_info); 9277 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 9278 r_symndx, ibfd)) 9279 { 9280 free (used); 9281 goto error_ret; 9282 } 9283 9284 if (sym_sec != toc) 9285 continue; 9286 9287 if (h != NULL) 9288 val = h->root.u.def.value; 9289 else 9290 val = sym->st_value; 9291 val += rel->r_addend; 9292 9293 if (val >= toc->size) 9294 continue; 9295 9296 if ((skip[val >> 3] & can_optimize) != 0) 9297 { 9298 bfd_vma off; 9299 unsigned char opc; 9300 9301 switch (r_type) 9302 { 9303 case R_PPC64_TOC16_HA: 9304 break; 9305 9306 case R_PPC64_TOC16_LO_DS: 9307 off = rel->r_offset; 9308 off += (bfd_big_endian (ibfd) ? -2 : 3); 9309 if (!bfd_get_section_contents (ibfd, sec, &opc, 9310 off, 1)) 9311 { 9312 free (used); 9313 goto error_ret; 9314 } 9315 if ((opc & (0x3f << 2)) == (58u << 2)) 9316 break; 9317 /* Fall through. */ 9318 9319 default: 9320 /* Wrong sort of reloc, or not a ld. We may 9321 as well clear ref_from_discarded too. */ 9322 skip[val >> 3] = 0; 9323 } 9324 } 9325 9326 if (sec != toc) 9327 used[val >> 3] = 1; 9328 /* For the toc section, we only mark as used if this 9329 entry itself isn't unused. */ 9330 else if ((used[rel->r_offset >> 3] 9331 || !(skip[rel->r_offset >> 3] & ref_from_discarded)) 9332 && !used[val >> 3]) 9333 { 9334 /* Do all the relocs again, to catch reference 9335 chains. */ 9336 repeat = 1; 9337 used[val >> 3] = 1; 9338 } 9339 } 9340 } 9341 while (repeat); 9342 9343 if (elf_section_data (sec)->relocs != relstart) 9344 free (relstart); 9345 } 9346 9347 /* Merge the used and skip arrays. Assume that TOC 9348 doublewords not appearing as either used or unused belong 9349 to to an entry more than one doubleword in size. */ 9350 for (drop = skip, keep = used, last = 0, some_unused = 0; 9351 drop < skip + (toc->size + 7) / 8; 9352 ++drop, ++keep) 9353 { 9354 if (*keep) 9355 { 9356 *drop &= ~ref_from_discarded; 9357 if ((*drop & can_optimize) != 0) 9358 some_unused = 1; 9359 last = 0; 9360 } 9361 else if ((*drop & ref_from_discarded) != 0) 9362 { 9363 some_unused = 1; 9364 last = ref_from_discarded; 9365 } 9366 else 9367 *drop = last; 9368 } 9369 9370 free (used); 9371 9372 if (some_unused) 9373 { 9374 bfd_byte *contents, *src; 9375 unsigned long off; 9376 Elf_Internal_Sym *sym; 9377 bfd_boolean local_toc_syms = FALSE; 9378 9379 /* Shuffle the toc contents, and at the same time convert the 9380 skip array from booleans into offsets. */ 9381 if (!bfd_malloc_and_get_section (ibfd, toc, &contents)) 9382 goto error_ret; 9383 9384 elf_section_data (toc)->this_hdr.contents = contents; 9385 9386 for (src = contents, off = 0, drop = skip; 9387 src < contents + toc->size; 9388 src += 8, ++drop) 9389 { 9390 if ((*drop & (can_optimize | ref_from_discarded)) != 0) 9391 off += 8; 9392 else if (off != 0) 9393 { 9394 *drop = off; 9395 memcpy (src - off, src, 8); 9396 } 9397 } 9398 *drop = off; 9399 toc->rawsize = toc->size; 9400 toc->size = src - contents - off; 9401 9402 /* Adjust addends for relocs against the toc section sym, 9403 and optimize any accesses we can. */ 9404 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 9405 { 9406 if (sec->reloc_count == 0 9407 || discarded_section (sec)) 9408 continue; 9409 9410 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 9411 info->keep_memory); 9412 if (relstart == NULL) 9413 goto error_ret; 9414 9415 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel) 9416 { 9417 enum elf_ppc64_reloc_type r_type; 9418 unsigned long r_symndx; 9419 asection *sym_sec; 9420 struct elf_link_hash_entry *h; 9421 bfd_vma val; 9422 9423 r_type = ELF64_R_TYPE (rel->r_info); 9424 switch (r_type) 9425 { 9426 default: 9427 continue; 9428 9429 case R_PPC64_TOC16: 9430 case R_PPC64_TOC16_LO: 9431 case R_PPC64_TOC16_HI: 9432 case R_PPC64_TOC16_HA: 9433 case R_PPC64_TOC16_DS: 9434 case R_PPC64_TOC16_LO_DS: 9435 case R_PPC64_ADDR64: 9436 break; 9437 } 9438 9439 r_symndx = ELF64_R_SYM (rel->r_info); 9440 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 9441 r_symndx, ibfd)) 9442 goto error_ret; 9443 9444 if (sym_sec != toc) 9445 continue; 9446 9447 if (h != NULL) 9448 val = h->root.u.def.value; 9449 else 9450 { 9451 val = sym->st_value; 9452 if (val != 0) 9453 local_toc_syms = TRUE; 9454 } 9455 9456 val += rel->r_addend; 9457 9458 if (val > toc->rawsize) 9459 val = toc->rawsize; 9460 else if ((skip[val >> 3] & ref_from_discarded) != 0) 9461 continue; 9462 else if ((skip[val >> 3] & can_optimize) != 0) 9463 { 9464 Elf_Internal_Rela *tocrel 9465 = toc_relocs + (skip[val >> 3] >> 2); 9466 unsigned long tsym = ELF64_R_SYM (tocrel->r_info); 9467 9468 switch (r_type) 9469 { 9470 case R_PPC64_TOC16_HA: 9471 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA); 9472 break; 9473 9474 case R_PPC64_TOC16_LO_DS: 9475 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT); 9476 break; 9477 9478 default: 9479 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 9480 ppc_howto_init (); 9481 info->callbacks->einfo 9482 /* xgettext:c-format */ 9483 (_("%P: %H: %s references " 9484 "optimized away TOC entry\n"), 9485 ibfd, sec, rel->r_offset, 9486 ppc64_elf_howto_table[r_type]->name); 9487 bfd_set_error (bfd_error_bad_value); 9488 goto error_ret; 9489 } 9490 rel->r_addend = tocrel->r_addend; 9491 elf_section_data (sec)->relocs = relstart; 9492 continue; 9493 } 9494 9495 if (h != NULL || sym->st_value != 0) 9496 continue; 9497 9498 rel->r_addend -= skip[val >> 3]; 9499 elf_section_data (sec)->relocs = relstart; 9500 } 9501 9502 if (elf_section_data (sec)->relocs != relstart) 9503 free (relstart); 9504 } 9505 9506 /* We shouldn't have local or global symbols defined in the TOC, 9507 but handle them anyway. */ 9508 if (local_syms != NULL) 9509 for (sym = local_syms; 9510 sym < local_syms + symtab_hdr->sh_info; 9511 ++sym) 9512 if (sym->st_value != 0 9513 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc) 9514 { 9515 unsigned long i; 9516 9517 if (sym->st_value > toc->rawsize) 9518 i = toc->rawsize >> 3; 9519 else 9520 i = sym->st_value >> 3; 9521 9522 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0) 9523 { 9524 if (local_toc_syms) 9525 _bfd_error_handler 9526 (_("%s defined on removed toc entry"), 9527 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL)); 9528 do 9529 ++i; 9530 while ((skip[i] & (ref_from_discarded | can_optimize))); 9531 sym->st_value = (bfd_vma) i << 3; 9532 } 9533 9534 sym->st_value -= skip[i]; 9535 symtab_hdr->contents = (unsigned char *) local_syms; 9536 } 9537 9538 /* Adjust any global syms defined in this toc input section. */ 9539 if (toc_inf.global_toc_syms) 9540 { 9541 toc_inf.toc = toc; 9542 toc_inf.skip = skip; 9543 toc_inf.global_toc_syms = FALSE; 9544 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms, 9545 &toc_inf); 9546 } 9547 9548 if (toc->reloc_count != 0) 9549 { 9550 Elf_Internal_Shdr *rel_hdr; 9551 Elf_Internal_Rela *wrel; 9552 bfd_size_type sz; 9553 9554 /* Remove unused toc relocs, and adjust those we keep. */ 9555 if (toc_relocs == NULL) 9556 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL, 9557 info->keep_memory); 9558 if (toc_relocs == NULL) 9559 goto error_ret; 9560 9561 wrel = toc_relocs; 9562 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel) 9563 if ((skip[rel->r_offset >> 3] 9564 & (ref_from_discarded | can_optimize)) == 0) 9565 { 9566 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3]; 9567 wrel->r_info = rel->r_info; 9568 wrel->r_addend = rel->r_addend; 9569 ++wrel; 9570 } 9571 else if (!dec_dynrel_count (rel->r_info, toc, info, 9572 &local_syms, NULL, NULL)) 9573 goto error_ret; 9574 9575 elf_section_data (toc)->relocs = toc_relocs; 9576 toc->reloc_count = wrel - toc_relocs; 9577 rel_hdr = _bfd_elf_single_rel_hdr (toc); 9578 sz = rel_hdr->sh_entsize; 9579 rel_hdr->sh_size = toc->reloc_count * sz; 9580 } 9581 } 9582 else if (toc_relocs != NULL 9583 && elf_section_data (toc)->relocs != toc_relocs) 9584 free (toc_relocs); 9585 9586 if (local_syms != NULL 9587 && symtab_hdr->contents != (unsigned char *) local_syms) 9588 { 9589 if (!info->keep_memory) 9590 free (local_syms); 9591 else 9592 symtab_hdr->contents = (unsigned char *) local_syms; 9593 } 9594 free (skip); 9595 } 9596 9597 return TRUE; 9598} 9599 9600/* Return true iff input section I references the TOC using 9601 instructions limited to +/-32k offsets. */ 9602 9603bfd_boolean 9604ppc64_elf_has_small_toc_reloc (asection *i) 9605{ 9606 return (is_ppc64_elf (i->owner) 9607 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc); 9608} 9609 9610/* Allocate space for one GOT entry. */ 9611 9612static void 9613allocate_got (struct elf_link_hash_entry *h, 9614 struct bfd_link_info *info, 9615 struct got_entry *gent) 9616{ 9617 struct ppc_link_hash_table *htab = ppc_hash_table (info); 9618 bfd_boolean dyn; 9619 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h; 9620 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD) 9621 ? 16 : 8); 9622 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD 9623 ? 2 : 1) * sizeof (Elf64_External_Rela); 9624 asection *got = ppc64_elf_tdata (gent->owner)->got; 9625 9626 gent->got.offset = got->size; 9627 got->size += entsize; 9628 9629 dyn = htab->elf.dynamic_sections_created; 9630 if (h->type == STT_GNU_IFUNC) 9631 { 9632 htab->elf.irelplt->size += rentsize; 9633 htab->got_reli_size += rentsize; 9634 } 9635 else if ((bfd_link_pic (info) 9636 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)) 9637 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 9638 || h->root.type != bfd_link_hash_undefweak)) 9639 { 9640 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot; 9641 relgot->size += rentsize; 9642 } 9643} 9644 9645/* This function merges got entries in the same toc group. */ 9646 9647static void 9648merge_got_entries (struct got_entry **pent) 9649{ 9650 struct got_entry *ent, *ent2; 9651 9652 for (ent = *pent; ent != NULL; ent = ent->next) 9653 if (!ent->is_indirect) 9654 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next) 9655 if (!ent2->is_indirect 9656 && ent2->addend == ent->addend 9657 && ent2->tls_type == ent->tls_type 9658 && elf_gp (ent2->owner) == elf_gp (ent->owner)) 9659 { 9660 ent2->is_indirect = TRUE; 9661 ent2->got.ent = ent; 9662 } 9663} 9664 9665/* Allocate space in .plt, .got and associated reloc sections for 9666 dynamic relocs. */ 9667 9668static bfd_boolean 9669allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 9670{ 9671 struct bfd_link_info *info; 9672 struct ppc_link_hash_table *htab; 9673 asection *s; 9674 struct ppc_link_hash_entry *eh; 9675 struct got_entry **pgent, *gent; 9676 9677 if (h->root.type == bfd_link_hash_indirect) 9678 return TRUE; 9679 9680 info = (struct bfd_link_info *) inf; 9681 htab = ppc_hash_table (info); 9682 if (htab == NULL) 9683 return FALSE; 9684 9685 eh = (struct ppc_link_hash_entry *) h; 9686 /* Run through the TLS GD got entries first if we're changing them 9687 to TPREL. */ 9688 if ((eh->tls_mask & TLS_TPRELGD) != 0) 9689 for (gent = h->got.glist; gent != NULL; gent = gent->next) 9690 if (gent->got.refcount > 0 9691 && (gent->tls_type & TLS_GD) != 0) 9692 { 9693 /* This was a GD entry that has been converted to TPREL. If 9694 there happens to be a TPREL entry we can use that one. */ 9695 struct got_entry *ent; 9696 for (ent = h->got.glist; ent != NULL; ent = ent->next) 9697 if (ent->got.refcount > 0 9698 && (ent->tls_type & TLS_TPREL) != 0 9699 && ent->addend == gent->addend 9700 && ent->owner == gent->owner) 9701 { 9702 gent->got.refcount = 0; 9703 break; 9704 } 9705 9706 /* If not, then we'll be using our own TPREL entry. */ 9707 if (gent->got.refcount != 0) 9708 gent->tls_type = TLS_TLS | TLS_TPREL; 9709 } 9710 9711 /* Remove any list entry that won't generate a word in the GOT before 9712 we call merge_got_entries. Otherwise we risk merging to empty 9713 entries. */ 9714 pgent = &h->got.glist; 9715 while ((gent = *pgent) != NULL) 9716 if (gent->got.refcount > 0) 9717 { 9718 if ((gent->tls_type & TLS_LD) != 0 9719 && !h->def_dynamic) 9720 { 9721 ppc64_tlsld_got (gent->owner)->got.refcount += 1; 9722 *pgent = gent->next; 9723 } 9724 else 9725 pgent = &gent->next; 9726 } 9727 else 9728 *pgent = gent->next; 9729 9730 if (!htab->do_multi_toc) 9731 merge_got_entries (&h->got.glist); 9732 9733 for (gent = h->got.glist; gent != NULL; gent = gent->next) 9734 if (!gent->is_indirect) 9735 { 9736 /* Make sure this symbol is output as a dynamic symbol. 9737 Undefined weak syms won't yet be marked as dynamic, 9738 nor will all TLS symbols. */ 9739 if (h->dynindx == -1 9740 && !h->forced_local 9741 && h->type != STT_GNU_IFUNC 9742 && htab->elf.dynamic_sections_created) 9743 { 9744 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 9745 return FALSE; 9746 } 9747 9748 if (!is_ppc64_elf (gent->owner)) 9749 abort (); 9750 9751 allocate_got (h, info, gent); 9752 } 9753 9754 if (!htab->elf.dynamic_sections_created 9755 && h->type != STT_GNU_IFUNC) 9756 eh->dyn_relocs = NULL; 9757 9758 if (eh->dyn_relocs != NULL) 9759 { 9760 struct elf_dyn_relocs *p, **pp; 9761 9762 /* In the shared -Bsymbolic case, discard space allocated for 9763 dynamic pc-relative relocs against symbols which turn out to 9764 be defined in regular objects. For the normal shared case, 9765 discard space for relocs that have become local due to symbol 9766 visibility changes. */ 9767 9768 if (bfd_link_pic (info)) 9769 { 9770 /* Relocs that use pc_count are those that appear on a call 9771 insn, or certain REL relocs (see must_be_dyn_reloc) that 9772 can be generated via assembly. We want calls to 9773 protected symbols to resolve directly to the function 9774 rather than going via the plt. If people want function 9775 pointer comparisons to work as expected then they should 9776 avoid writing weird assembly. */ 9777 if (SYMBOL_CALLS_LOCAL (info, h)) 9778 { 9779 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 9780 { 9781 p->count -= p->pc_count; 9782 p->pc_count = 0; 9783 if (p->count == 0) 9784 *pp = p->next; 9785 else 9786 pp = &p->next; 9787 } 9788 } 9789 9790 /* Also discard relocs on undefined weak syms with 9791 non-default visibility. */ 9792 if (eh->dyn_relocs != NULL 9793 && h->root.type == bfd_link_hash_undefweak) 9794 { 9795 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 9796 eh->dyn_relocs = NULL; 9797 9798 /* Make sure this symbol is output as a dynamic symbol. 9799 Undefined weak syms won't yet be marked as dynamic. */ 9800 else if (h->dynindx == -1 9801 && !h->forced_local) 9802 { 9803 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 9804 return FALSE; 9805 } 9806 } 9807 } 9808 else if (h->type == STT_GNU_IFUNC) 9809 { 9810 /* A plt entry is always created when making direct calls to 9811 an ifunc, even when building a static executable, but 9812 that doesn't cover all cases. We may have only an ifunc 9813 initialised function pointer for a given ifunc symbol. 9814 9815 For ELFv2, dynamic relocations are not required when 9816 generating a global entry PLT stub. */ 9817 if (abiversion (info->output_bfd) >= 2) 9818 { 9819 if (global_entry_stub (h)) 9820 eh->dyn_relocs = NULL; 9821 } 9822 9823 /* For ELFv1 we have function descriptors. Descriptors need 9824 to be treated like PLT entries and thus have dynamic 9825 relocations. One exception is when the function 9826 descriptor is copied into .dynbss (which should only 9827 happen with ancient versions of gcc). */ 9828 else if (h->needs_copy) 9829 eh->dyn_relocs = NULL; 9830 } 9831 else if (ELIMINATE_COPY_RELOCS) 9832 { 9833 /* For the non-pic case, discard space for relocs against 9834 symbols which turn out to need copy relocs or are not 9835 dynamic. */ 9836 9837 /* First make sure this symbol is output as a dynamic symbol. 9838 Undefined weak syms won't yet be marked as dynamic. */ 9839 if (h->root.type == bfd_link_hash_undefweak 9840 && !h->non_got_ref 9841 && !h->def_regular 9842 && h->dynindx == -1 9843 && !h->forced_local 9844 && !bfd_elf_link_record_dynamic_symbol (info, h)) 9845 return FALSE; 9846 9847 if (h->non_got_ref 9848 || h->def_regular 9849 || h->dynindx == -1) 9850 eh->dyn_relocs = NULL; 9851 } 9852 9853 /* Finally, allocate space. */ 9854 for (p = eh->dyn_relocs; p != NULL; p = p->next) 9855 { 9856 asection *sreloc = elf_section_data (p->sec)->sreloc; 9857 if (eh->elf.type == STT_GNU_IFUNC) 9858 sreloc = htab->elf.irelplt; 9859 sreloc->size += p->count * sizeof (Elf64_External_Rela); 9860 } 9861 } 9862 9863 if ((htab->elf.dynamic_sections_created 9864 && h->dynindx != -1 9865 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 9866 || h->type == STT_GNU_IFUNC) 9867 { 9868 struct plt_entry *pent; 9869 bfd_boolean doneone = FALSE; 9870 for (pent = h->plt.plist; pent != NULL; pent = pent->next) 9871 if (pent->plt.refcount > 0) 9872 { 9873 if (!htab->elf.dynamic_sections_created 9874 || h->dynindx == -1) 9875 { 9876 s = htab->elf.iplt; 9877 pent->plt.offset = s->size; 9878 s->size += PLT_ENTRY_SIZE (htab); 9879 s = htab->elf.irelplt; 9880 } 9881 else 9882 { 9883 /* If this is the first .plt entry, make room for the special 9884 first entry. */ 9885 s = htab->elf.splt; 9886 if (s->size == 0) 9887 s->size += PLT_INITIAL_ENTRY_SIZE (htab); 9888 9889 pent->plt.offset = s->size; 9890 9891 /* Make room for this entry. */ 9892 s->size += PLT_ENTRY_SIZE (htab); 9893 9894 /* Make room for the .glink code. */ 9895 s = htab->glink; 9896 if (s->size == 0) 9897 s->size += GLINK_CALL_STUB_SIZE; 9898 if (htab->opd_abi) 9899 { 9900 /* We need bigger stubs past index 32767. */ 9901 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4) 9902 s->size += 4; 9903 s->size += 2*4; 9904 } 9905 else 9906 s->size += 4; 9907 9908 /* We also need to make an entry in the .rela.plt section. */ 9909 s = htab->elf.srelplt; 9910 } 9911 s->size += sizeof (Elf64_External_Rela); 9912 doneone = TRUE; 9913 } 9914 else 9915 pent->plt.offset = (bfd_vma) -1; 9916 if (!doneone) 9917 { 9918 h->plt.plist = NULL; 9919 h->needs_plt = 0; 9920 } 9921 } 9922 else 9923 { 9924 h->plt.plist = NULL; 9925 h->needs_plt = 0; 9926 } 9927 9928 return TRUE; 9929} 9930 9931/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections 9932 to set up space for global entry stubs. These are put in glink, 9933 after the branch table. */ 9934 9935static bfd_boolean 9936size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf) 9937{ 9938 struct bfd_link_info *info; 9939 struct ppc_link_hash_table *htab; 9940 struct plt_entry *pent; 9941 asection *s; 9942 9943 if (h->root.type == bfd_link_hash_indirect) 9944 return TRUE; 9945 9946 if (!h->pointer_equality_needed) 9947 return TRUE; 9948 9949 if (h->def_regular) 9950 return TRUE; 9951 9952 info = inf; 9953 htab = ppc_hash_table (info); 9954 if (htab == NULL) 9955 return FALSE; 9956 9957 s = htab->glink; 9958 for (pent = h->plt.plist; pent != NULL; pent = pent->next) 9959 if (pent->plt.offset != (bfd_vma) -1 9960 && pent->addend == 0) 9961 { 9962 /* For ELFv2, if this symbol is not defined in a regular file 9963 and we are not generating a shared library or pie, then we 9964 need to define the symbol in the executable on a call stub. 9965 This is to avoid text relocations. */ 9966 s->size = (s->size + 15) & -16; 9967 h->root.type = bfd_link_hash_defined; 9968 h->root.u.def.section = s; 9969 h->root.u.def.value = s->size; 9970 s->size += 16; 9971 break; 9972 } 9973 return TRUE; 9974} 9975 9976/* Set DF_TEXTREL if we find any dynamic relocs that apply to 9977 read-only sections. */ 9978 9979static bfd_boolean 9980maybe_set_textrel (struct elf_link_hash_entry *h, void *info) 9981{ 9982 if (h->root.type == bfd_link_hash_indirect) 9983 return TRUE; 9984 9985 if (readonly_dynrelocs (h)) 9986 { 9987 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL; 9988 9989 /* Not an error, just cut short the traversal. */ 9990 return FALSE; 9991 } 9992 return TRUE; 9993} 9994 9995/* Set the sizes of the dynamic sections. */ 9996 9997static bfd_boolean 9998ppc64_elf_size_dynamic_sections (bfd *output_bfd, 9999 struct bfd_link_info *info) 10000{ 10001 struct ppc_link_hash_table *htab; 10002 bfd *dynobj; 10003 asection *s; 10004 bfd_boolean relocs; 10005 bfd *ibfd; 10006 struct got_entry *first_tlsld; 10007 10008 htab = ppc_hash_table (info); 10009 if (htab == NULL) 10010 return FALSE; 10011 10012 dynobj = htab->elf.dynobj; 10013 if (dynobj == NULL) 10014 abort (); 10015 10016 if (htab->elf.dynamic_sections_created) 10017 { 10018 /* Set the contents of the .interp section to the interpreter. */ 10019 if (bfd_link_executable (info) && !info->nointerp) 10020 { 10021 s = bfd_get_linker_section (dynobj, ".interp"); 10022 if (s == NULL) 10023 abort (); 10024 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 10025 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 10026 } 10027 } 10028 10029 /* Set up .got offsets for local syms, and space for local dynamic 10030 relocs. */ 10031 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 10032 { 10033 struct got_entry **lgot_ents; 10034 struct got_entry **end_lgot_ents; 10035 struct plt_entry **local_plt; 10036 struct plt_entry **end_local_plt; 10037 unsigned char *lgot_masks; 10038 bfd_size_type locsymcount; 10039 Elf_Internal_Shdr *symtab_hdr; 10040 10041 if (!is_ppc64_elf (ibfd)) 10042 continue; 10043 10044 for (s = ibfd->sections; s != NULL; s = s->next) 10045 { 10046 struct ppc_dyn_relocs *p; 10047 10048 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 10049 { 10050 if (!bfd_is_abs_section (p->sec) 10051 && bfd_is_abs_section (p->sec->output_section)) 10052 { 10053 /* Input section has been discarded, either because 10054 it is a copy of a linkonce section or due to 10055 linker script /DISCARD/, so we'll be discarding 10056 the relocs too. */ 10057 } 10058 else if (p->count != 0) 10059 { 10060 asection *srel = elf_section_data (p->sec)->sreloc; 10061 if (p->ifunc) 10062 srel = htab->elf.irelplt; 10063 srel->size += p->count * sizeof (Elf64_External_Rela); 10064 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 10065 info->flags |= DF_TEXTREL; 10066 } 10067 } 10068 } 10069 10070 lgot_ents = elf_local_got_ents (ibfd); 10071 if (!lgot_ents) 10072 continue; 10073 10074 symtab_hdr = &elf_symtab_hdr (ibfd); 10075 locsymcount = symtab_hdr->sh_info; 10076 end_lgot_ents = lgot_ents + locsymcount; 10077 local_plt = (struct plt_entry **) end_lgot_ents; 10078 end_local_plt = local_plt + locsymcount; 10079 lgot_masks = (unsigned char *) end_local_plt; 10080 s = ppc64_elf_tdata (ibfd)->got; 10081 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks) 10082 { 10083 struct got_entry **pent, *ent; 10084 10085 pent = lgot_ents; 10086 while ((ent = *pent) != NULL) 10087 if (ent->got.refcount > 0) 10088 { 10089 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0) 10090 { 10091 ppc64_tlsld_got (ibfd)->got.refcount += 1; 10092 *pent = ent->next; 10093 } 10094 else 10095 { 10096 unsigned int ent_size = 8; 10097 unsigned int rel_size = sizeof (Elf64_External_Rela); 10098 10099 ent->got.offset = s->size; 10100 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0) 10101 { 10102 ent_size *= 2; 10103 rel_size *= 2; 10104 } 10105 s->size += ent_size; 10106 if ((*lgot_masks & PLT_IFUNC) != 0) 10107 { 10108 htab->elf.irelplt->size += rel_size; 10109 htab->got_reli_size += rel_size; 10110 } 10111 else if (bfd_link_pic (info)) 10112 { 10113 asection *srel = ppc64_elf_tdata (ibfd)->relgot; 10114 srel->size += rel_size; 10115 } 10116 pent = &ent->next; 10117 } 10118 } 10119 else 10120 *pent = ent->next; 10121 } 10122 10123 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */ 10124 for (; local_plt < end_local_plt; ++local_plt) 10125 { 10126 struct plt_entry *ent; 10127 10128 for (ent = *local_plt; ent != NULL; ent = ent->next) 10129 if (ent->plt.refcount > 0) 10130 { 10131 s = htab->elf.iplt; 10132 ent->plt.offset = s->size; 10133 s->size += PLT_ENTRY_SIZE (htab); 10134 10135 htab->elf.irelplt->size += sizeof (Elf64_External_Rela); 10136 } 10137 else 10138 ent->plt.offset = (bfd_vma) -1; 10139 } 10140 } 10141 10142 /* Allocate global sym .plt and .got entries, and space for global 10143 sym dynamic relocs. */ 10144 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 10145 /* Stash the end of glink branch table. */ 10146 if (htab->glink != NULL) 10147 htab->glink->rawsize = htab->glink->size; 10148 10149 if (!htab->opd_abi && !bfd_link_pic (info)) 10150 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info); 10151 10152 first_tlsld = NULL; 10153 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 10154 { 10155 struct got_entry *ent; 10156 10157 if (!is_ppc64_elf (ibfd)) 10158 continue; 10159 10160 ent = ppc64_tlsld_got (ibfd); 10161 if (ent->got.refcount > 0) 10162 { 10163 if (!htab->do_multi_toc && first_tlsld != NULL) 10164 { 10165 ent->is_indirect = TRUE; 10166 ent->got.ent = first_tlsld; 10167 } 10168 else 10169 { 10170 if (first_tlsld == NULL) 10171 first_tlsld = ent; 10172 s = ppc64_elf_tdata (ibfd)->got; 10173 ent->got.offset = s->size; 10174 ent->owner = ibfd; 10175 s->size += 16; 10176 if (bfd_link_pic (info)) 10177 { 10178 asection *srel = ppc64_elf_tdata (ibfd)->relgot; 10179 srel->size += sizeof (Elf64_External_Rela); 10180 } 10181 } 10182 } 10183 else 10184 ent->got.offset = (bfd_vma) -1; 10185 } 10186 10187 /* We now have determined the sizes of the various dynamic sections. 10188 Allocate memory for them. */ 10189 relocs = FALSE; 10190 for (s = dynobj->sections; s != NULL; s = s->next) 10191 { 10192 if ((s->flags & SEC_LINKER_CREATED) == 0) 10193 continue; 10194 10195 if (s == htab->brlt || s == htab->relbrlt) 10196 /* These haven't been allocated yet; don't strip. */ 10197 continue; 10198 else if (s == htab->elf.sgot 10199 || s == htab->elf.splt 10200 || s == htab->elf.iplt 10201 || s == htab->glink 10202 || s == htab->elf.sdynbss 10203 || s == htab->elf.sdynrelro) 10204 { 10205 /* Strip this section if we don't need it; see the 10206 comment below. */ 10207 } 10208 else if (s == htab->glink_eh_frame) 10209 { 10210 if (!bfd_is_abs_section (s->output_section)) 10211 /* Not sized yet. */ 10212 continue; 10213 } 10214 else if (CONST_STRNEQ (s->name, ".rela")) 10215 { 10216 if (s->size != 0) 10217 { 10218 if (s != htab->elf.srelplt) 10219 relocs = TRUE; 10220 10221 /* We use the reloc_count field as a counter if we need 10222 to copy relocs into the output file. */ 10223 s->reloc_count = 0; 10224 } 10225 } 10226 else 10227 { 10228 /* It's not one of our sections, so don't allocate space. */ 10229 continue; 10230 } 10231 10232 if (s->size == 0) 10233 { 10234 /* If we don't need this section, strip it from the 10235 output file. This is mostly to handle .rela.bss and 10236 .rela.plt. We must create both sections in 10237 create_dynamic_sections, because they must be created 10238 before the linker maps input sections to output 10239 sections. The linker does that before 10240 adjust_dynamic_symbol is called, and it is that 10241 function which decides whether anything needs to go 10242 into these sections. */ 10243 s->flags |= SEC_EXCLUDE; 10244 continue; 10245 } 10246 10247 if ((s->flags & SEC_HAS_CONTENTS) == 0) 10248 continue; 10249 10250 /* Allocate memory for the section contents. We use bfd_zalloc 10251 here in case unused entries are not reclaimed before the 10252 section's contents are written out. This should not happen, 10253 but this way if it does we get a R_PPC64_NONE reloc in .rela 10254 sections instead of garbage. 10255 We also rely on the section contents being zero when writing 10256 the GOT and .dynrelro. */ 10257 s->contents = bfd_zalloc (dynobj, s->size); 10258 if (s->contents == NULL) 10259 return FALSE; 10260 } 10261 10262 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 10263 { 10264 if (!is_ppc64_elf (ibfd)) 10265 continue; 10266 10267 s = ppc64_elf_tdata (ibfd)->got; 10268 if (s != NULL && s != htab->elf.sgot) 10269 { 10270 if (s->size == 0) 10271 s->flags |= SEC_EXCLUDE; 10272 else 10273 { 10274 s->contents = bfd_zalloc (ibfd, s->size); 10275 if (s->contents == NULL) 10276 return FALSE; 10277 } 10278 } 10279 s = ppc64_elf_tdata (ibfd)->relgot; 10280 if (s != NULL) 10281 { 10282 if (s->size == 0) 10283 s->flags |= SEC_EXCLUDE; 10284 else 10285 { 10286 s->contents = bfd_zalloc (ibfd, s->size); 10287 if (s->contents == NULL) 10288 return FALSE; 10289 relocs = TRUE; 10290 s->reloc_count = 0; 10291 } 10292 } 10293 } 10294 10295 if (htab->elf.dynamic_sections_created) 10296 { 10297 bfd_boolean tls_opt; 10298 10299 /* Add some entries to the .dynamic section. We fill in the 10300 values later, in ppc64_elf_finish_dynamic_sections, but we 10301 must add the entries now so that we get the correct size for 10302 the .dynamic section. The DT_DEBUG entry is filled in by the 10303 dynamic linker and used by the debugger. */ 10304#define add_dynamic_entry(TAG, VAL) \ 10305 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 10306 10307 if (bfd_link_executable (info)) 10308 { 10309 if (!add_dynamic_entry (DT_DEBUG, 0)) 10310 return FALSE; 10311 } 10312 10313 if (htab->elf.splt != NULL && htab->elf.splt->size != 0) 10314 { 10315 if (!add_dynamic_entry (DT_PLTGOT, 0) 10316 || !add_dynamic_entry (DT_PLTRELSZ, 0) 10317 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 10318 || !add_dynamic_entry (DT_JMPREL, 0) 10319 || !add_dynamic_entry (DT_PPC64_GLINK, 0)) 10320 return FALSE; 10321 } 10322 10323 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1) 10324 { 10325 if (!add_dynamic_entry (DT_PPC64_OPD, 0) 10326 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0)) 10327 return FALSE; 10328 } 10329 10330 tls_opt = (htab->params->tls_get_addr_opt 10331 && htab->tls_get_addr_fd != NULL 10332 && htab->tls_get_addr_fd->elf.plt.plist != NULL); 10333 if (tls_opt || !htab->opd_abi) 10334 { 10335 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0)) 10336 return FALSE; 10337 } 10338 10339 if (relocs) 10340 { 10341 if (!add_dynamic_entry (DT_RELA, 0) 10342 || !add_dynamic_entry (DT_RELASZ, 0) 10343 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 10344 return FALSE; 10345 10346 /* If any dynamic relocs apply to a read-only section, 10347 then we need a DT_TEXTREL entry. */ 10348 if ((info->flags & DF_TEXTREL) == 0) 10349 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info); 10350 10351 if ((info->flags & DF_TEXTREL) != 0) 10352 { 10353 if (!add_dynamic_entry (DT_TEXTREL, 0)) 10354 return FALSE; 10355 } 10356 } 10357 } 10358#undef add_dynamic_entry 10359 10360 return TRUE; 10361} 10362 10363/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 10364 10365static bfd_boolean 10366ppc64_elf_hash_symbol (struct elf_link_hash_entry *h) 10367{ 10368 if (h->plt.plist != NULL 10369 && !h->def_regular 10370 && !h->pointer_equality_needed) 10371 return FALSE; 10372 10373 return _bfd_elf_hash_symbol (h); 10374} 10375 10376/* Determine the type of stub needed, if any, for a call. */ 10377 10378static inline enum ppc_stub_type 10379ppc_type_of_stub (asection *input_sec, 10380 const Elf_Internal_Rela *rel, 10381 struct ppc_link_hash_entry **hash, 10382 struct plt_entry **plt_ent, 10383 bfd_vma destination, 10384 unsigned long local_off) 10385{ 10386 struct ppc_link_hash_entry *h = *hash; 10387 bfd_vma location; 10388 bfd_vma branch_offset; 10389 bfd_vma max_branch_offset; 10390 enum elf_ppc64_reloc_type r_type; 10391 10392 if (h != NULL) 10393 { 10394 struct plt_entry *ent; 10395 struct ppc_link_hash_entry *fdh = h; 10396 if (h->oh != NULL 10397 && h->oh->is_func_descriptor) 10398 { 10399 fdh = ppc_follow_link (h->oh); 10400 *hash = fdh; 10401 } 10402 10403 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next) 10404 if (ent->addend == rel->r_addend 10405 && ent->plt.offset != (bfd_vma) -1) 10406 { 10407 *plt_ent = ent; 10408 return ppc_stub_plt_call; 10409 } 10410 10411 /* Here, we know we don't have a plt entry. If we don't have a 10412 either a defined function descriptor or a defined entry symbol 10413 in a regular object file, then it is pointless trying to make 10414 any other type of stub. */ 10415 if (!is_static_defined (&fdh->elf) 10416 && !is_static_defined (&h->elf)) 10417 return ppc_stub_none; 10418 } 10419 else if (elf_local_got_ents (input_sec->owner) != NULL) 10420 { 10421 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner); 10422 struct plt_entry **local_plt = (struct plt_entry **) 10423 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info; 10424 unsigned long r_symndx = ELF64_R_SYM (rel->r_info); 10425 10426 if (local_plt[r_symndx] != NULL) 10427 { 10428 struct plt_entry *ent; 10429 10430 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next) 10431 if (ent->addend == rel->r_addend 10432 && ent->plt.offset != (bfd_vma) -1) 10433 { 10434 *plt_ent = ent; 10435 return ppc_stub_plt_call; 10436 } 10437 } 10438 } 10439 10440 /* Determine where the call point is. */ 10441 location = (input_sec->output_offset 10442 + input_sec->output_section->vma 10443 + rel->r_offset); 10444 10445 branch_offset = destination - location; 10446 r_type = ELF64_R_TYPE (rel->r_info); 10447 10448 /* Determine if a long branch stub is needed. */ 10449 max_branch_offset = 1 << 25; 10450 if (r_type != R_PPC64_REL24) 10451 max_branch_offset = 1 << 15; 10452 10453 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off) 10454 /* We need a stub. Figure out whether a long_branch or plt_branch 10455 is needed later. */ 10456 return ppc_stub_long_branch; 10457 10458 return ppc_stub_none; 10459} 10460 10461/* With power7 weakly ordered memory model, it is possible for ld.so 10462 to update a plt entry in one thread and have another thread see a 10463 stale zero toc entry. To avoid this we need some sort of acquire 10464 barrier in the call stub. One solution is to make the load of the 10465 toc word seem to appear to depend on the load of the function entry 10466 word. Another solution is to test for r2 being zero, and branch to 10467 the appropriate glink entry if so. 10468 10469 . fake dep barrier compare 10470 . ld 12,xxx(2) ld 12,xxx(2) 10471 . mtctr 12 mtctr 12 10472 . xor 11,12,12 ld 2,xxx+8(2) 10473 . add 2,2,11 cmpldi 2,0 10474 . ld 2,xxx+8(2) bnectr+ 10475 . bctr b <glink_entry> 10476 10477 The solution involving the compare turns out to be faster, so 10478 that's what we use unless the branch won't reach. */ 10479 10480#define ALWAYS_USE_FAKE_DEP 0 10481#define ALWAYS_EMIT_R2SAVE 0 10482 10483#define PPC_LO(v) ((v) & 0xffff) 10484#define PPC_HI(v) (((v) >> 16) & 0xffff) 10485#define PPC_HA(v) PPC_HI ((v) + 0x8000) 10486 10487static inline unsigned int 10488plt_stub_size (struct ppc_link_hash_table *htab, 10489 struct ppc_stub_hash_entry *stub_entry, 10490 bfd_vma off) 10491{ 10492 unsigned size = 12; 10493 10494 if (ALWAYS_EMIT_R2SAVE 10495 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10496 size += 4; 10497 if (PPC_HA (off) != 0) 10498 size += 4; 10499 if (htab->opd_abi) 10500 { 10501 size += 4; 10502 if (htab->params->plt_static_chain) 10503 size += 4; 10504 if (htab->params->plt_thread_safe 10505 && htab->elf.dynamic_sections_created 10506 && stub_entry->h != NULL 10507 && stub_entry->h->elf.dynindx != -1) 10508 size += 8; 10509 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off)) 10510 size += 4; 10511 } 10512 if (stub_entry->h != NULL 10513 && (stub_entry->h == htab->tls_get_addr_fd 10514 || stub_entry->h == htab->tls_get_addr) 10515 && htab->params->tls_get_addr_opt) 10516 size += 13 * 4; 10517 return size; 10518} 10519 10520/* If this stub would cross fewer 2**plt_stub_align boundaries if we align, 10521 then return the padding needed to do so. */ 10522static inline unsigned int 10523plt_stub_pad (struct ppc_link_hash_table *htab, 10524 struct ppc_stub_hash_entry *stub_entry, 10525 bfd_vma plt_off) 10526{ 10527 int stub_align = 1 << htab->params->plt_stub_align; 10528 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off); 10529 bfd_vma stub_off = stub_entry->group->stub_sec->size; 10530 10531 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align) 10532 > ((stub_size - 1) & -stub_align)) 10533 return stub_align - (stub_off & (stub_align - 1)); 10534 return 0; 10535} 10536 10537/* Build a .plt call stub. */ 10538 10539static inline bfd_byte * 10540build_plt_stub (struct ppc_link_hash_table *htab, 10541 struct ppc_stub_hash_entry *stub_entry, 10542 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r) 10543{ 10544 bfd *obfd = htab->params->stub_bfd; 10545 bfd_boolean plt_load_toc = htab->opd_abi; 10546 bfd_boolean plt_static_chain = htab->params->plt_static_chain; 10547 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe 10548 && htab->elf.dynamic_sections_created 10549 && stub_entry->h != NULL 10550 && stub_entry->h->elf.dynindx != -1); 10551 bfd_boolean use_fake_dep = plt_thread_safe; 10552 bfd_vma cmp_branch_off = 0; 10553 10554 if (!ALWAYS_USE_FAKE_DEP 10555 && plt_load_toc 10556 && plt_thread_safe 10557 && !((stub_entry->h == htab->tls_get_addr_fd 10558 || stub_entry->h == htab->tls_get_addr) 10559 && htab->params->tls_get_addr_opt)) 10560 { 10561 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1; 10562 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab)) 10563 / PLT_ENTRY_SIZE (htab)); 10564 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8; 10565 bfd_vma to, from; 10566 10567 if (pltindex > 32768) 10568 glinkoff += (pltindex - 32768) * 4; 10569 to = (glinkoff 10570 + htab->glink->output_offset 10571 + htab->glink->output_section->vma); 10572 from = (p - stub_entry->group->stub_sec->contents 10573 + 4 * (ALWAYS_EMIT_R2SAVE 10574 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10575 + 4 * (PPC_HA (offset) != 0) 10576 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain) 10577 != PPC_HA (offset)) 10578 + 4 * (plt_static_chain != 0) 10579 + 20 10580 + stub_entry->group->stub_sec->output_offset 10581 + stub_entry->group->stub_sec->output_section->vma); 10582 cmp_branch_off = to - from; 10583 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26); 10584 } 10585 10586 if (PPC_HA (offset) != 0) 10587 { 10588 if (r != NULL) 10589 { 10590 if (ALWAYS_EMIT_R2SAVE 10591 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10592 r[0].r_offset += 4; 10593 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA); 10594 r[1].r_offset = r[0].r_offset + 4; 10595 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 10596 r[1].r_addend = r[0].r_addend; 10597 if (plt_load_toc) 10598 { 10599 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset)) 10600 { 10601 r[2].r_offset = r[1].r_offset + 4; 10602 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO); 10603 r[2].r_addend = r[0].r_addend; 10604 } 10605 else 10606 { 10607 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep; 10608 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 10609 r[2].r_addend = r[0].r_addend + 8; 10610 if (plt_static_chain) 10611 { 10612 r[3].r_offset = r[2].r_offset + 4; 10613 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 10614 r[3].r_addend = r[0].r_addend + 16; 10615 } 10616 } 10617 } 10618 } 10619 if (ALWAYS_EMIT_R2SAVE 10620 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10621 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4; 10622 if (plt_load_toc) 10623 { 10624 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4; 10625 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4; 10626 } 10627 else 10628 { 10629 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4; 10630 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4; 10631 } 10632 if (plt_load_toc 10633 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset)) 10634 { 10635 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4; 10636 offset = 0; 10637 } 10638 bfd_put_32 (obfd, MTCTR_R12, p), p += 4; 10639 if (plt_load_toc) 10640 { 10641 if (use_fake_dep) 10642 { 10643 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4; 10644 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4; 10645 } 10646 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4; 10647 if (plt_static_chain) 10648 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4; 10649 } 10650 } 10651 else 10652 { 10653 if (r != NULL) 10654 { 10655 if (ALWAYS_EMIT_R2SAVE 10656 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10657 r[0].r_offset += 4; 10658 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 10659 if (plt_load_toc) 10660 { 10661 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset)) 10662 { 10663 r[1].r_offset = r[0].r_offset + 4; 10664 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16); 10665 r[1].r_addend = r[0].r_addend; 10666 } 10667 else 10668 { 10669 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep; 10670 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 10671 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain; 10672 if (plt_static_chain) 10673 { 10674 r[2].r_offset = r[1].r_offset + 4; 10675 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 10676 r[2].r_addend = r[0].r_addend + 8; 10677 } 10678 } 10679 } 10680 } 10681 if (ALWAYS_EMIT_R2SAVE 10682 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 10683 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4; 10684 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4; 10685 if (plt_load_toc 10686 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset)) 10687 { 10688 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4; 10689 offset = 0; 10690 } 10691 bfd_put_32 (obfd, MTCTR_R12, p), p += 4; 10692 if (plt_load_toc) 10693 { 10694 if (use_fake_dep) 10695 { 10696 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4; 10697 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4; 10698 } 10699 if (plt_static_chain) 10700 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4; 10701 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4; 10702 } 10703 } 10704 if (plt_load_toc && plt_thread_safe && !use_fake_dep) 10705 { 10706 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4; 10707 bfd_put_32 (obfd, BNECTR_P4, p), p += 4; 10708 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4; 10709 } 10710 else 10711 bfd_put_32 (obfd, BCTR, p), p += 4; 10712 return p; 10713} 10714 10715/* Build a special .plt call stub for __tls_get_addr. */ 10716 10717#define LD_R11_0R3 0xe9630000 10718#define LD_R12_0R3 0xe9830000 10719#define MR_R0_R3 0x7c601b78 10720#define CMPDI_R11_0 0x2c2b0000 10721#define ADD_R3_R12_R13 0x7c6c6a14 10722#define BEQLR 0x4d820020 10723#define MR_R3_R0 0x7c030378 10724#define STD_R11_0R1 0xf9610000 10725#define BCTRL 0x4e800421 10726#define LD_R11_0R1 0xe9610000 10727#define MTLR_R11 0x7d6803a6 10728 10729static inline bfd_byte * 10730build_tls_get_addr_stub (struct ppc_link_hash_table *htab, 10731 struct ppc_stub_hash_entry *stub_entry, 10732 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r) 10733{ 10734 bfd *obfd = htab->params->stub_bfd; 10735 10736 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4; 10737 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4; 10738 bfd_put_32 (obfd, MR_R0_R3, p), p += 4; 10739 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4; 10740 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4; 10741 bfd_put_32 (obfd, BEQLR, p), p += 4; 10742 bfd_put_32 (obfd, MR_R3_R0, p), p += 4; 10743 bfd_put_32 (obfd, MFLR_R11, p), p += 4; 10744 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4; 10745 10746 if (r != NULL) 10747 r[0].r_offset += 9 * 4; 10748 p = build_plt_stub (htab, stub_entry, p, offset, r); 10749 bfd_put_32 (obfd, BCTRL, p - 4); 10750 10751 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4; 10752 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4; 10753 bfd_put_32 (obfd, MTLR_R11, p), p += 4; 10754 bfd_put_32 (obfd, BLR, p), p += 4; 10755 10756 return p; 10757} 10758 10759static Elf_Internal_Rela * 10760get_relocs (asection *sec, int count) 10761{ 10762 Elf_Internal_Rela *relocs; 10763 struct bfd_elf_section_data *elfsec_data; 10764 10765 elfsec_data = elf_section_data (sec); 10766 relocs = elfsec_data->relocs; 10767 if (relocs == NULL) 10768 { 10769 bfd_size_type relsize; 10770 relsize = sec->reloc_count * sizeof (*relocs); 10771 relocs = bfd_alloc (sec->owner, relsize); 10772 if (relocs == NULL) 10773 return NULL; 10774 elfsec_data->relocs = relocs; 10775 elfsec_data->rela.hdr = bfd_zalloc (sec->owner, 10776 sizeof (Elf_Internal_Shdr)); 10777 if (elfsec_data->rela.hdr == NULL) 10778 return NULL; 10779 elfsec_data->rela.hdr->sh_size = (sec->reloc_count 10780 * sizeof (Elf64_External_Rela)); 10781 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela); 10782 sec->reloc_count = 0; 10783 } 10784 relocs += sec->reloc_count; 10785 sec->reloc_count += count; 10786 return relocs; 10787} 10788 10789static bfd_vma 10790get_r2off (struct bfd_link_info *info, 10791 struct ppc_stub_hash_entry *stub_entry) 10792{ 10793 struct ppc_link_hash_table *htab = ppc_hash_table (info); 10794 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off; 10795 10796 if (r2off == 0) 10797 { 10798 /* Support linking -R objects. Get the toc pointer from the 10799 opd entry. */ 10800 char buf[8]; 10801 if (!htab->opd_abi) 10802 return r2off; 10803 asection *opd = stub_entry->h->elf.root.u.def.section; 10804 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value; 10805 10806 if (strcmp (opd->name, ".opd") != 0 10807 || opd->reloc_count != 0) 10808 { 10809 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"), 10810 stub_entry->h->elf.root.root.string); 10811 bfd_set_error (bfd_error_bad_value); 10812 return (bfd_vma) -1; 10813 } 10814 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8)) 10815 return (bfd_vma) -1; 10816 r2off = bfd_get_64 (opd->owner, buf); 10817 r2off -= elf_gp (info->output_bfd); 10818 } 10819 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off; 10820 return r2off; 10821} 10822 10823static bfd_boolean 10824ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 10825{ 10826 struct ppc_stub_hash_entry *stub_entry; 10827 struct ppc_branch_hash_entry *br_entry; 10828 struct bfd_link_info *info; 10829 struct ppc_link_hash_table *htab; 10830 bfd_byte *loc; 10831 bfd_byte *p; 10832 bfd_vma dest, off; 10833 int size; 10834 Elf_Internal_Rela *r; 10835 asection *plt; 10836 10837 /* Massage our args to the form they really have. */ 10838 stub_entry = (struct ppc_stub_hash_entry *) gen_entry; 10839 info = in_arg; 10840 10841 htab = ppc_hash_table (info); 10842 if (htab == NULL) 10843 return FALSE; 10844 10845 /* Make a note of the offset within the stubs for this entry. */ 10846 stub_entry->stub_offset = stub_entry->group->stub_sec->size; 10847 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset; 10848 10849 htab->stub_count[stub_entry->stub_type - 1] += 1; 10850 switch (stub_entry->stub_type) 10851 { 10852 case ppc_stub_long_branch: 10853 case ppc_stub_long_branch_r2off: 10854 /* Branches are relative. This is where we are going to. */ 10855 dest = (stub_entry->target_value 10856 + stub_entry->target_section->output_offset 10857 + stub_entry->target_section->output_section->vma); 10858 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other); 10859 off = dest; 10860 10861 /* And this is where we are coming from. */ 10862 off -= (stub_entry->stub_offset 10863 + stub_entry->group->stub_sec->output_offset 10864 + stub_entry->group->stub_sec->output_section->vma); 10865 10866 size = 4; 10867 if (stub_entry->stub_type == ppc_stub_long_branch_r2off) 10868 { 10869 bfd_vma r2off = get_r2off (info, stub_entry); 10870 10871 if (r2off == (bfd_vma) -1) 10872 { 10873 htab->stub_error = TRUE; 10874 return FALSE; 10875 } 10876 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc); 10877 loc += 4; 10878 size = 8; 10879 if (PPC_HA (r2off) != 0) 10880 { 10881 bfd_put_32 (htab->params->stub_bfd, 10882 ADDIS_R2_R2 | PPC_HA (r2off), loc); 10883 loc += 4; 10884 size += 4; 10885 } 10886 if (PPC_LO (r2off) != 0) 10887 { 10888 bfd_put_32 (htab->params->stub_bfd, 10889 ADDI_R2_R2 | PPC_LO (r2off), loc); 10890 loc += 4; 10891 size += 4; 10892 } 10893 off -= size - 4; 10894 } 10895 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc); 10896 10897 if (off + (1 << 25) >= (bfd_vma) (1 << 26)) 10898 { 10899 info->callbacks->einfo 10900 (_("%P: long branch stub `%s' offset overflow\n"), 10901 stub_entry->root.string); 10902 htab->stub_error = TRUE; 10903 return FALSE; 10904 } 10905 10906 if (info->emitrelocations) 10907 { 10908 r = get_relocs (stub_entry->group->stub_sec, 1); 10909 if (r == NULL) 10910 return FALSE; 10911 r->r_offset = loc - stub_entry->group->stub_sec->contents; 10912 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24); 10913 r->r_addend = dest; 10914 if (stub_entry->h != NULL) 10915 { 10916 struct elf_link_hash_entry **hashes; 10917 unsigned long symndx; 10918 struct ppc_link_hash_entry *h; 10919 10920 hashes = elf_sym_hashes (htab->params->stub_bfd); 10921 if (hashes == NULL) 10922 { 10923 bfd_size_type hsize; 10924 10925 hsize = (htab->stub_globals + 1) * sizeof (*hashes); 10926 hashes = bfd_zalloc (htab->params->stub_bfd, hsize); 10927 if (hashes == NULL) 10928 return FALSE; 10929 elf_sym_hashes (htab->params->stub_bfd) = hashes; 10930 htab->stub_globals = 1; 10931 } 10932 symndx = htab->stub_globals++; 10933 h = stub_entry->h; 10934 hashes[symndx] = &h->elf; 10935 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24); 10936 if (h->oh != NULL && h->oh->is_func) 10937 h = ppc_follow_link (h->oh); 10938 if (h->elf.root.u.def.section != stub_entry->target_section) 10939 /* H is an opd symbol. The addend must be zero. */ 10940 r->r_addend = 0; 10941 else 10942 { 10943 off = (h->elf.root.u.def.value 10944 + h->elf.root.u.def.section->output_offset 10945 + h->elf.root.u.def.section->output_section->vma); 10946 r->r_addend -= off; 10947 } 10948 } 10949 } 10950 break; 10951 10952 case ppc_stub_plt_branch: 10953 case ppc_stub_plt_branch_r2off: 10954 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table, 10955 stub_entry->root.string + 9, 10956 FALSE, FALSE); 10957 if (br_entry == NULL) 10958 { 10959 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"), 10960 stub_entry->root.string); 10961 htab->stub_error = TRUE; 10962 return FALSE; 10963 } 10964 10965 dest = (stub_entry->target_value 10966 + stub_entry->target_section->output_offset 10967 + stub_entry->target_section->output_section->vma); 10968 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off) 10969 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other); 10970 10971 bfd_put_64 (htab->brlt->owner, dest, 10972 htab->brlt->contents + br_entry->offset); 10973 10974 if (br_entry->iter == htab->stub_iteration) 10975 { 10976 br_entry->iter = 0; 10977 10978 if (htab->relbrlt != NULL) 10979 { 10980 /* Create a reloc for the branch lookup table entry. */ 10981 Elf_Internal_Rela rela; 10982 bfd_byte *rl; 10983 10984 rela.r_offset = (br_entry->offset 10985 + htab->brlt->output_offset 10986 + htab->brlt->output_section->vma); 10987 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 10988 rela.r_addend = dest; 10989 10990 rl = htab->relbrlt->contents; 10991 rl += (htab->relbrlt->reloc_count++ 10992 * sizeof (Elf64_External_Rela)); 10993 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl); 10994 } 10995 else if (info->emitrelocations) 10996 { 10997 r = get_relocs (htab->brlt, 1); 10998 if (r == NULL) 10999 return FALSE; 11000 /* brlt, being SEC_LINKER_CREATED does not go through the 11001 normal reloc processing. Symbols and offsets are not 11002 translated from input file to output file form, so 11003 set up the offset per the output file. */ 11004 r->r_offset = (br_entry->offset 11005 + htab->brlt->output_offset 11006 + htab->brlt->output_section->vma); 11007 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 11008 r->r_addend = dest; 11009 } 11010 } 11011 11012 dest = (br_entry->offset 11013 + htab->brlt->output_offset 11014 + htab->brlt->output_section->vma); 11015 11016 off = (dest 11017 - elf_gp (htab->brlt->output_section->owner) 11018 - htab->sec_info[stub_entry->group->link_sec->id].toc_off); 11019 11020 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0) 11021 { 11022 info->callbacks->einfo 11023 (_("%P: linkage table error against `%T'\n"), 11024 stub_entry->root.string); 11025 bfd_set_error (bfd_error_bad_value); 11026 htab->stub_error = TRUE; 11027 return FALSE; 11028 } 11029 11030 if (info->emitrelocations) 11031 { 11032 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0)); 11033 if (r == NULL) 11034 return FALSE; 11035 r[0].r_offset = loc - stub_entry->group->stub_sec->contents; 11036 if (bfd_big_endian (info->output_bfd)) 11037 r[0].r_offset += 2; 11038 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off) 11039 r[0].r_offset += 4; 11040 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS); 11041 r[0].r_addend = dest; 11042 if (PPC_HA (off) != 0) 11043 { 11044 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA); 11045 r[1].r_offset = r[0].r_offset + 4; 11046 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS); 11047 r[1].r_addend = r[0].r_addend; 11048 } 11049 } 11050 11051 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off) 11052 { 11053 if (PPC_HA (off) != 0) 11054 { 11055 size = 16; 11056 bfd_put_32 (htab->params->stub_bfd, 11057 ADDIS_R12_R2 | PPC_HA (off), loc); 11058 loc += 4; 11059 bfd_put_32 (htab->params->stub_bfd, 11060 LD_R12_0R12 | PPC_LO (off), loc); 11061 } 11062 else 11063 { 11064 size = 12; 11065 bfd_put_32 (htab->params->stub_bfd, 11066 LD_R12_0R2 | PPC_LO (off), loc); 11067 } 11068 } 11069 else 11070 { 11071 bfd_vma r2off = get_r2off (info, stub_entry); 11072 11073 if (r2off == (bfd_vma) -1) 11074 { 11075 htab->stub_error = TRUE; 11076 return FALSE; 11077 } 11078 11079 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc); 11080 loc += 4; 11081 size = 16; 11082 if (PPC_HA (off) != 0) 11083 { 11084 size += 4; 11085 bfd_put_32 (htab->params->stub_bfd, 11086 ADDIS_R12_R2 | PPC_HA (off), loc); 11087 loc += 4; 11088 bfd_put_32 (htab->params->stub_bfd, 11089 LD_R12_0R12 | PPC_LO (off), loc); 11090 } 11091 else 11092 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc); 11093 11094 if (PPC_HA (r2off) != 0) 11095 { 11096 size += 4; 11097 loc += 4; 11098 bfd_put_32 (htab->params->stub_bfd, 11099 ADDIS_R2_R2 | PPC_HA (r2off), loc); 11100 } 11101 if (PPC_LO (r2off) != 0) 11102 { 11103 size += 4; 11104 loc += 4; 11105 bfd_put_32 (htab->params->stub_bfd, 11106 ADDI_R2_R2 | PPC_LO (r2off), loc); 11107 } 11108 } 11109 loc += 4; 11110 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc); 11111 loc += 4; 11112 bfd_put_32 (htab->params->stub_bfd, BCTR, loc); 11113 break; 11114 11115 case ppc_stub_plt_call: 11116 case ppc_stub_plt_call_r2save: 11117 if (stub_entry->h != NULL 11118 && stub_entry->h->is_func_descriptor 11119 && stub_entry->h->oh != NULL) 11120 { 11121 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh); 11122 11123 /* If the old-ABI "dot-symbol" is undefined make it weak so 11124 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */ 11125 if (fh->elf.root.type == bfd_link_hash_undefined 11126 && (stub_entry->h->elf.root.type == bfd_link_hash_defined 11127 || stub_entry->h->elf.root.type == bfd_link_hash_defweak)) 11128 fh->elf.root.type = bfd_link_hash_undefweak; 11129 } 11130 11131 /* Now build the stub. */ 11132 dest = stub_entry->plt_ent->plt.offset & ~1; 11133 if (dest >= (bfd_vma) -2) 11134 abort (); 11135 11136 plt = htab->elf.splt; 11137 if (!htab->elf.dynamic_sections_created 11138 || stub_entry->h == NULL 11139 || stub_entry->h->elf.dynindx == -1) 11140 plt = htab->elf.iplt; 11141 11142 dest += plt->output_offset + plt->output_section->vma; 11143 11144 if (stub_entry->h == NULL 11145 && (stub_entry->plt_ent->plt.offset & 1) == 0) 11146 { 11147 Elf_Internal_Rela rela; 11148 bfd_byte *rl; 11149 11150 rela.r_offset = dest; 11151 if (htab->opd_abi) 11152 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL); 11153 else 11154 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE); 11155 rela.r_addend = (stub_entry->target_value 11156 + stub_entry->target_section->output_offset 11157 + stub_entry->target_section->output_section->vma); 11158 11159 rl = (htab->elf.irelplt->contents 11160 + (htab->elf.irelplt->reloc_count++ 11161 * sizeof (Elf64_External_Rela))); 11162 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl); 11163 stub_entry->plt_ent->plt.offset |= 1; 11164 } 11165 11166 off = (dest 11167 - elf_gp (plt->output_section->owner) 11168 - htab->sec_info[stub_entry->group->link_sec->id].toc_off); 11169 11170 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0) 11171 { 11172 info->callbacks->einfo 11173 /* xgettext:c-format */ 11174 (_("%P: linkage table error against `%T'\n"), 11175 stub_entry->h != NULL 11176 ? stub_entry->h->elf.root.root.string 11177 : "<local sym>"); 11178 bfd_set_error (bfd_error_bad_value); 11179 htab->stub_error = TRUE; 11180 return FALSE; 11181 } 11182 11183 if (htab->params->plt_stub_align != 0) 11184 { 11185 unsigned pad = plt_stub_pad (htab, stub_entry, off); 11186 11187 stub_entry->group->stub_sec->size += pad; 11188 stub_entry->stub_offset = stub_entry->group->stub_sec->size; 11189 loc += pad; 11190 } 11191 11192 r = NULL; 11193 if (info->emitrelocations) 11194 { 11195 r = get_relocs (stub_entry->group->stub_sec, 11196 ((PPC_HA (off) != 0) 11197 + (htab->opd_abi 11198 ? 2 + (htab->params->plt_static_chain 11199 && PPC_HA (off + 16) == PPC_HA (off)) 11200 : 1))); 11201 if (r == NULL) 11202 return FALSE; 11203 r[0].r_offset = loc - stub_entry->group->stub_sec->contents; 11204 if (bfd_big_endian (info->output_bfd)) 11205 r[0].r_offset += 2; 11206 r[0].r_addend = dest; 11207 } 11208 if (stub_entry->h != NULL 11209 && (stub_entry->h == htab->tls_get_addr_fd 11210 || stub_entry->h == htab->tls_get_addr) 11211 && htab->params->tls_get_addr_opt) 11212 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r); 11213 else 11214 p = build_plt_stub (htab, stub_entry, loc, off, r); 11215 size = p - loc; 11216 break; 11217 11218 case ppc_stub_save_res: 11219 return TRUE; 11220 11221 default: 11222 BFD_FAIL (); 11223 return FALSE; 11224 } 11225 11226 stub_entry->group->stub_sec->size += size; 11227 11228 if (htab->params->emit_stub_syms) 11229 { 11230 struct elf_link_hash_entry *h; 11231 size_t len1, len2; 11232 char *name; 11233 const char *const stub_str[] = { "long_branch", 11234 "long_branch_r2off", 11235 "plt_branch", 11236 "plt_branch_r2off", 11237 "plt_call", 11238 "plt_call" }; 11239 11240 len1 = strlen (stub_str[stub_entry->stub_type - 1]); 11241 len2 = strlen (stub_entry->root.string); 11242 name = bfd_malloc (len1 + len2 + 2); 11243 if (name == NULL) 11244 return FALSE; 11245 memcpy (name, stub_entry->root.string, 9); 11246 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1); 11247 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1); 11248 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); 11249 if (h == NULL) 11250 return FALSE; 11251 if (h->root.type == bfd_link_hash_new) 11252 { 11253 h->root.type = bfd_link_hash_defined; 11254 h->root.u.def.section = stub_entry->group->stub_sec; 11255 h->root.u.def.value = stub_entry->stub_offset; 11256 h->ref_regular = 1; 11257 h->def_regular = 1; 11258 h->ref_regular_nonweak = 1; 11259 h->forced_local = 1; 11260 h->non_elf = 0; 11261 h->root.linker_def = 1; 11262 } 11263 } 11264 11265 return TRUE; 11266} 11267 11268/* As above, but don't actually build the stub. Just bump offset so 11269 we know stub section sizes, and select plt_branch stubs where 11270 long_branch stubs won't do. */ 11271 11272static bfd_boolean 11273ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 11274{ 11275 struct ppc_stub_hash_entry *stub_entry; 11276 struct bfd_link_info *info; 11277 struct ppc_link_hash_table *htab; 11278 bfd_vma off; 11279 int size; 11280 11281 /* Massage our args to the form they really have. */ 11282 stub_entry = (struct ppc_stub_hash_entry *) gen_entry; 11283 info = in_arg; 11284 11285 htab = ppc_hash_table (info); 11286 if (htab == NULL) 11287 return FALSE; 11288 11289 if (stub_entry->h != NULL 11290 && stub_entry->h->save_res 11291 && stub_entry->h->elf.root.type == bfd_link_hash_defined 11292 && stub_entry->h->elf.root.u.def.section == htab->sfpr) 11293 { 11294 /* Don't make stubs to out-of-line register save/restore 11295 functions. Instead, emit copies of the functions. */ 11296 stub_entry->group->needs_save_res = 1; 11297 stub_entry->stub_type = ppc_stub_save_res; 11298 return TRUE; 11299 } 11300 11301 if (stub_entry->stub_type == ppc_stub_plt_call 11302 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 11303 { 11304 asection *plt; 11305 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1; 11306 if (off >= (bfd_vma) -2) 11307 abort (); 11308 plt = htab->elf.splt; 11309 if (!htab->elf.dynamic_sections_created 11310 || stub_entry->h == NULL 11311 || stub_entry->h->elf.dynindx == -1) 11312 plt = htab->elf.iplt; 11313 off += (plt->output_offset 11314 + plt->output_section->vma 11315 - elf_gp (plt->output_section->owner) 11316 - htab->sec_info[stub_entry->group->link_sec->id].toc_off); 11317 11318 size = plt_stub_size (htab, stub_entry, off); 11319 if (htab->params->plt_stub_align) 11320 size += plt_stub_pad (htab, stub_entry, off); 11321 if (info->emitrelocations) 11322 { 11323 stub_entry->group->stub_sec->reloc_count 11324 += ((PPC_HA (off) != 0) 11325 + (htab->opd_abi 11326 ? 2 + (htab->params->plt_static_chain 11327 && PPC_HA (off + 16) == PPC_HA (off)) 11328 : 1)); 11329 stub_entry->group->stub_sec->flags |= SEC_RELOC; 11330 } 11331 } 11332 else 11333 { 11334 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off 11335 variants. */ 11336 bfd_vma r2off = 0; 11337 bfd_vma local_off = 0; 11338 11339 off = (stub_entry->target_value 11340 + stub_entry->target_section->output_offset 11341 + stub_entry->target_section->output_section->vma); 11342 off -= (stub_entry->group->stub_sec->size 11343 + stub_entry->group->stub_sec->output_offset 11344 + stub_entry->group->stub_sec->output_section->vma); 11345 11346 /* Reset the stub type from the plt variant in case we now 11347 can reach with a shorter stub. */ 11348 if (stub_entry->stub_type >= ppc_stub_plt_branch) 11349 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch; 11350 11351 size = 4; 11352 if (stub_entry->stub_type == ppc_stub_long_branch_r2off) 11353 { 11354 r2off = get_r2off (info, stub_entry); 11355 if (r2off == (bfd_vma) -1) 11356 { 11357 htab->stub_error = TRUE; 11358 return FALSE; 11359 } 11360 size = 8; 11361 if (PPC_HA (r2off) != 0) 11362 size += 4; 11363 if (PPC_LO (r2off) != 0) 11364 size += 4; 11365 off -= size - 4; 11366 } 11367 11368 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other); 11369 11370 /* If the branch offset if too big, use a ppc_stub_plt_branch. 11371 Do the same for -R objects without function descriptors. */ 11372 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off 11373 || (stub_entry->stub_type == ppc_stub_long_branch_r2off 11374 && r2off == 0 11375 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)) 11376 { 11377 struct ppc_branch_hash_entry *br_entry; 11378 11379 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table, 11380 stub_entry->root.string + 9, 11381 TRUE, FALSE); 11382 if (br_entry == NULL) 11383 { 11384 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"), 11385 stub_entry->root.string); 11386 htab->stub_error = TRUE; 11387 return FALSE; 11388 } 11389 11390 if (br_entry->iter != htab->stub_iteration) 11391 { 11392 br_entry->iter = htab->stub_iteration; 11393 br_entry->offset = htab->brlt->size; 11394 htab->brlt->size += 8; 11395 11396 if (htab->relbrlt != NULL) 11397 htab->relbrlt->size += sizeof (Elf64_External_Rela); 11398 else if (info->emitrelocations) 11399 { 11400 htab->brlt->reloc_count += 1; 11401 htab->brlt->flags |= SEC_RELOC; 11402 } 11403 } 11404 11405 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch; 11406 off = (br_entry->offset 11407 + htab->brlt->output_offset 11408 + htab->brlt->output_section->vma 11409 - elf_gp (htab->brlt->output_section->owner) 11410 - htab->sec_info[stub_entry->group->link_sec->id].toc_off); 11411 11412 if (info->emitrelocations) 11413 { 11414 stub_entry->group->stub_sec->reloc_count 11415 += 1 + (PPC_HA (off) != 0); 11416 stub_entry->group->stub_sec->flags |= SEC_RELOC; 11417 } 11418 11419 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off) 11420 { 11421 size = 12; 11422 if (PPC_HA (off) != 0) 11423 size = 16; 11424 } 11425 else 11426 { 11427 size = 16; 11428 if (PPC_HA (off) != 0) 11429 size += 4; 11430 11431 if (PPC_HA (r2off) != 0) 11432 size += 4; 11433 if (PPC_LO (r2off) != 0) 11434 size += 4; 11435 } 11436 } 11437 else if (info->emitrelocations) 11438 { 11439 stub_entry->group->stub_sec->reloc_count += 1; 11440 stub_entry->group->stub_sec->flags |= SEC_RELOC; 11441 } 11442 } 11443 11444 stub_entry->group->stub_sec->size += size; 11445 return TRUE; 11446} 11447 11448/* Set up various things so that we can make a list of input sections 11449 for each output section included in the link. Returns -1 on error, 11450 0 when no stubs will be needed, and 1 on success. */ 11451 11452int 11453ppc64_elf_setup_section_lists (struct bfd_link_info *info) 11454{ 11455 unsigned int id; 11456 bfd_size_type amt; 11457 struct ppc_link_hash_table *htab = ppc_hash_table (info); 11458 11459 if (htab == NULL) 11460 return -1; 11461 11462 htab->sec_info_arr_size = bfd_get_next_section_id (); 11463 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size); 11464 htab->sec_info = bfd_zmalloc (amt); 11465 if (htab->sec_info == NULL) 11466 return -1; 11467 11468 /* Set toc_off for com, und, abs and ind sections. */ 11469 for (id = 0; id < 3; id++) 11470 htab->sec_info[id].toc_off = TOC_BASE_OFF; 11471 11472 return 1; 11473} 11474 11475/* Set up for first pass at multitoc partitioning. */ 11476 11477void 11478ppc64_elf_start_multitoc_partition (struct bfd_link_info *info) 11479{ 11480 struct ppc_link_hash_table *htab = ppc_hash_table (info); 11481 11482 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd); 11483 htab->toc_bfd = NULL; 11484 htab->toc_first_sec = NULL; 11485} 11486 11487/* The linker repeatedly calls this function for each TOC input section 11488 and linker generated GOT section. Group input bfds such that the toc 11489 within a group is less than 64k in size. */ 11490 11491bfd_boolean 11492ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec) 11493{ 11494 struct ppc_link_hash_table *htab = ppc_hash_table (info); 11495 bfd_vma addr, off, limit; 11496 11497 if (htab == NULL) 11498 return FALSE; 11499 11500 if (!htab->second_toc_pass) 11501 { 11502 /* Keep track of the first .toc or .got section for this input bfd. */ 11503 bfd_boolean new_bfd = htab->toc_bfd != isec->owner; 11504 11505 if (new_bfd) 11506 { 11507 htab->toc_bfd = isec->owner; 11508 htab->toc_first_sec = isec; 11509 } 11510 11511 addr = isec->output_offset + isec->output_section->vma; 11512 off = addr - htab->toc_curr; 11513 limit = 0x80008000; 11514 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc) 11515 limit = 0x10000; 11516 if (off + isec->size > limit) 11517 { 11518 addr = (htab->toc_first_sec->output_offset 11519 + htab->toc_first_sec->output_section->vma); 11520 htab->toc_curr = addr; 11521 htab->toc_curr &= -TOC_BASE_ALIGN; 11522 } 11523 11524 /* toc_curr is the base address of this toc group. Set elf_gp 11525 for the input section to be the offset relative to the 11526 output toc base plus 0x8000. Making the input elf_gp an 11527 offset allows us to move the toc as a whole without 11528 recalculating input elf_gp. */ 11529 off = htab->toc_curr - elf_gp (isec->output_section->owner); 11530 off += TOC_BASE_OFF; 11531 11532 /* Die if someone uses a linker script that doesn't keep input 11533 file .toc and .got together. */ 11534 if (new_bfd 11535 && elf_gp (isec->owner) != 0 11536 && elf_gp (isec->owner) != off) 11537 return FALSE; 11538 11539 elf_gp (isec->owner) = off; 11540 return TRUE; 11541 } 11542 11543 /* During the second pass toc_first_sec points to the start of 11544 a toc group, and toc_curr is used to track the old elf_gp. 11545 We use toc_bfd to ensure we only look at each bfd once. */ 11546 if (htab->toc_bfd == isec->owner) 11547 return TRUE; 11548 htab->toc_bfd = isec->owner; 11549 11550 if (htab->toc_first_sec == NULL 11551 || htab->toc_curr != elf_gp (isec->owner)) 11552 { 11553 htab->toc_curr = elf_gp (isec->owner); 11554 htab->toc_first_sec = isec; 11555 } 11556 addr = (htab->toc_first_sec->output_offset 11557 + htab->toc_first_sec->output_section->vma); 11558 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF; 11559 elf_gp (isec->owner) = off; 11560 11561 return TRUE; 11562} 11563 11564/* Called via elf_link_hash_traverse to merge GOT entries for global 11565 symbol H. */ 11566 11567static bfd_boolean 11568merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED) 11569{ 11570 if (h->root.type == bfd_link_hash_indirect) 11571 return TRUE; 11572 11573 merge_got_entries (&h->got.glist); 11574 11575 return TRUE; 11576} 11577 11578/* Called via elf_link_hash_traverse to allocate GOT entries for global 11579 symbol H. */ 11580 11581static bfd_boolean 11582reallocate_got (struct elf_link_hash_entry *h, void *inf) 11583{ 11584 struct got_entry *gent; 11585 11586 if (h->root.type == bfd_link_hash_indirect) 11587 return TRUE; 11588 11589 for (gent = h->got.glist; gent != NULL; gent = gent->next) 11590 if (!gent->is_indirect) 11591 allocate_got (h, (struct bfd_link_info *) inf, gent); 11592 return TRUE; 11593} 11594 11595/* Called on the first multitoc pass after the last call to 11596 ppc64_elf_next_toc_section. This function removes duplicate GOT 11597 entries. */ 11598 11599bfd_boolean 11600ppc64_elf_layout_multitoc (struct bfd_link_info *info) 11601{ 11602 struct ppc_link_hash_table *htab = ppc_hash_table (info); 11603 struct bfd *ibfd, *ibfd2; 11604 bfd_boolean done_something; 11605 11606 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd); 11607 11608 if (!htab->do_multi_toc) 11609 return FALSE; 11610 11611 /* Merge global sym got entries within a toc group. */ 11612 elf_link_hash_traverse (&htab->elf, merge_global_got, info); 11613 11614 /* And tlsld_got. */ 11615 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 11616 { 11617 struct got_entry *ent, *ent2; 11618 11619 if (!is_ppc64_elf (ibfd)) 11620 continue; 11621 11622 ent = ppc64_tlsld_got (ibfd); 11623 if (!ent->is_indirect 11624 && ent->got.offset != (bfd_vma) -1) 11625 { 11626 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next) 11627 { 11628 if (!is_ppc64_elf (ibfd2)) 11629 continue; 11630 11631 ent2 = ppc64_tlsld_got (ibfd2); 11632 if (!ent2->is_indirect 11633 && ent2->got.offset != (bfd_vma) -1 11634 && elf_gp (ibfd2) == elf_gp (ibfd)) 11635 { 11636 ent2->is_indirect = TRUE; 11637 ent2->got.ent = ent; 11638 } 11639 } 11640 } 11641 } 11642 11643 /* Zap sizes of got sections. */ 11644 htab->elf.irelplt->rawsize = htab->elf.irelplt->size; 11645 htab->elf.irelplt->size -= htab->got_reli_size; 11646 htab->got_reli_size = 0; 11647 11648 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 11649 { 11650 asection *got, *relgot; 11651 11652 if (!is_ppc64_elf (ibfd)) 11653 continue; 11654 11655 got = ppc64_elf_tdata (ibfd)->got; 11656 if (got != NULL) 11657 { 11658 got->rawsize = got->size; 11659 got->size = 0; 11660 relgot = ppc64_elf_tdata (ibfd)->relgot; 11661 relgot->rawsize = relgot->size; 11662 relgot->size = 0; 11663 } 11664 } 11665 11666 /* Now reallocate the got, local syms first. We don't need to 11667 allocate section contents again since we never increase size. */ 11668 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 11669 { 11670 struct got_entry **lgot_ents; 11671 struct got_entry **end_lgot_ents; 11672 struct plt_entry **local_plt; 11673 struct plt_entry **end_local_plt; 11674 unsigned char *lgot_masks; 11675 bfd_size_type locsymcount; 11676 Elf_Internal_Shdr *symtab_hdr; 11677 asection *s; 11678 11679 if (!is_ppc64_elf (ibfd)) 11680 continue; 11681 11682 lgot_ents = elf_local_got_ents (ibfd); 11683 if (!lgot_ents) 11684 continue; 11685 11686 symtab_hdr = &elf_symtab_hdr (ibfd); 11687 locsymcount = symtab_hdr->sh_info; 11688 end_lgot_ents = lgot_ents + locsymcount; 11689 local_plt = (struct plt_entry **) end_lgot_ents; 11690 end_local_plt = local_plt + locsymcount; 11691 lgot_masks = (unsigned char *) end_local_plt; 11692 s = ppc64_elf_tdata (ibfd)->got; 11693 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks) 11694 { 11695 struct got_entry *ent; 11696 11697 for (ent = *lgot_ents; ent != NULL; ent = ent->next) 11698 { 11699 unsigned int ent_size = 8; 11700 unsigned int rel_size = sizeof (Elf64_External_Rela); 11701 11702 ent->got.offset = s->size; 11703 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0) 11704 { 11705 ent_size *= 2; 11706 rel_size *= 2; 11707 } 11708 s->size += ent_size; 11709 if ((*lgot_masks & PLT_IFUNC) != 0) 11710 { 11711 htab->elf.irelplt->size += rel_size; 11712 htab->got_reli_size += rel_size; 11713 } 11714 else if (bfd_link_pic (info)) 11715 { 11716 asection *srel = ppc64_elf_tdata (ibfd)->relgot; 11717 srel->size += rel_size; 11718 } 11719 } 11720 } 11721 } 11722 11723 elf_link_hash_traverse (&htab->elf, reallocate_got, info); 11724 11725 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 11726 { 11727 struct got_entry *ent; 11728 11729 if (!is_ppc64_elf (ibfd)) 11730 continue; 11731 11732 ent = ppc64_tlsld_got (ibfd); 11733 if (!ent->is_indirect 11734 && ent->got.offset != (bfd_vma) -1) 11735 { 11736 asection *s = ppc64_elf_tdata (ibfd)->got; 11737 ent->got.offset = s->size; 11738 s->size += 16; 11739 if (bfd_link_pic (info)) 11740 { 11741 asection *srel = ppc64_elf_tdata (ibfd)->relgot; 11742 srel->size += sizeof (Elf64_External_Rela); 11743 } 11744 } 11745 } 11746 11747 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size; 11748 if (!done_something) 11749 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 11750 { 11751 asection *got; 11752 11753 if (!is_ppc64_elf (ibfd)) 11754 continue; 11755 11756 got = ppc64_elf_tdata (ibfd)->got; 11757 if (got != NULL) 11758 { 11759 done_something = got->rawsize != got->size; 11760 if (done_something) 11761 break; 11762 } 11763 } 11764 11765 if (done_something) 11766 (*htab->params->layout_sections_again) (); 11767 11768 /* Set up for second pass over toc sections to recalculate elf_gp 11769 on input sections. */ 11770 htab->toc_bfd = NULL; 11771 htab->toc_first_sec = NULL; 11772 htab->second_toc_pass = TRUE; 11773 return done_something; 11774} 11775 11776/* Called after second pass of multitoc partitioning. */ 11777 11778void 11779ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info) 11780{ 11781 struct ppc_link_hash_table *htab = ppc_hash_table (info); 11782 11783 /* After the second pass, toc_curr tracks the TOC offset used 11784 for code sections below in ppc64_elf_next_input_section. */ 11785 htab->toc_curr = TOC_BASE_OFF; 11786} 11787 11788/* No toc references were found in ISEC. If the code in ISEC makes no 11789 calls, then there's no need to use toc adjusting stubs when branching 11790 into ISEC. Actually, indirect calls from ISEC are OK as they will 11791 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub 11792 needed, and 2 if a cyclical call-graph was found but no other reason 11793 for a stub was detected. If called from the top level, a return of 11794 2 means the same as a return of 0. */ 11795 11796static int 11797toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec) 11798{ 11799 int ret; 11800 11801 /* Mark this section as checked. */ 11802 isec->call_check_done = 1; 11803 11804 /* We know none of our code bearing sections will need toc stubs. */ 11805 if ((isec->flags & SEC_LINKER_CREATED) != 0) 11806 return 0; 11807 11808 if (isec->size == 0) 11809 return 0; 11810 11811 if (isec->output_section == NULL) 11812 return 0; 11813 11814 ret = 0; 11815 if (isec->reloc_count != 0) 11816 { 11817 Elf_Internal_Rela *relstart, *rel; 11818 Elf_Internal_Sym *local_syms; 11819 struct ppc_link_hash_table *htab; 11820 11821 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL, 11822 info->keep_memory); 11823 if (relstart == NULL) 11824 return -1; 11825 11826 /* Look for branches to outside of this section. */ 11827 local_syms = NULL; 11828 htab = ppc_hash_table (info); 11829 if (htab == NULL) 11830 return -1; 11831 11832 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel) 11833 { 11834 enum elf_ppc64_reloc_type r_type; 11835 unsigned long r_symndx; 11836 struct elf_link_hash_entry *h; 11837 struct ppc_link_hash_entry *eh; 11838 Elf_Internal_Sym *sym; 11839 asection *sym_sec; 11840 struct _opd_sec_data *opd; 11841 bfd_vma sym_value; 11842 bfd_vma dest; 11843 11844 r_type = ELF64_R_TYPE (rel->r_info); 11845 if (r_type != R_PPC64_REL24 11846 && r_type != R_PPC64_REL14 11847 && r_type != R_PPC64_REL14_BRTAKEN 11848 && r_type != R_PPC64_REL14_BRNTAKEN) 11849 continue; 11850 11851 r_symndx = ELF64_R_SYM (rel->r_info); 11852 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx, 11853 isec->owner)) 11854 { 11855 ret = -1; 11856 break; 11857 } 11858 11859 /* Calls to dynamic lib functions go through a plt call stub 11860 that uses r2. */ 11861 eh = (struct ppc_link_hash_entry *) h; 11862 if (eh != NULL 11863 && (eh->elf.plt.plist != NULL 11864 || (eh->oh != NULL 11865 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL))) 11866 { 11867 ret = 1; 11868 break; 11869 } 11870 11871 if (sym_sec == NULL) 11872 /* Ignore other undefined symbols. */ 11873 continue; 11874 11875 /* Assume branches to other sections not included in the 11876 link need stubs too, to cover -R and absolute syms. */ 11877 if (sym_sec->output_section == NULL) 11878 { 11879 ret = 1; 11880 break; 11881 } 11882 11883 if (h == NULL) 11884 sym_value = sym->st_value; 11885 else 11886 { 11887 if (h->root.type != bfd_link_hash_defined 11888 && h->root.type != bfd_link_hash_defweak) 11889 abort (); 11890 sym_value = h->root.u.def.value; 11891 } 11892 sym_value += rel->r_addend; 11893 11894 /* If this branch reloc uses an opd sym, find the code section. */ 11895 opd = get_opd_info (sym_sec); 11896 if (opd != NULL) 11897 { 11898 if (h == NULL && opd->adjust != NULL) 11899 { 11900 long adjust; 11901 11902 adjust = opd->adjust[OPD_NDX (sym_value)]; 11903 if (adjust == -1) 11904 /* Assume deleted functions won't ever be called. */ 11905 continue; 11906 sym_value += adjust; 11907 } 11908 11909 dest = opd_entry_value (sym_sec, sym_value, 11910 &sym_sec, NULL, FALSE); 11911 if (dest == (bfd_vma) -1) 11912 continue; 11913 } 11914 else 11915 dest = (sym_value 11916 + sym_sec->output_offset 11917 + sym_sec->output_section->vma); 11918 11919 /* Ignore branch to self. */ 11920 if (sym_sec == isec) 11921 continue; 11922 11923 /* If the called function uses the toc, we need a stub. */ 11924 if (sym_sec->has_toc_reloc 11925 || sym_sec->makes_toc_func_call) 11926 { 11927 ret = 1; 11928 break; 11929 } 11930 11931 /* Assume any branch that needs a long branch stub might in fact 11932 need a plt_branch stub. A plt_branch stub uses r2. */ 11933 else if (dest - (isec->output_offset 11934 + isec->output_section->vma 11935 + rel->r_offset) + (1 << 25) 11936 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h 11937 ? h->other 11938 : sym->st_other)) 11939 { 11940 ret = 1; 11941 break; 11942 } 11943 11944 /* If calling back to a section in the process of being 11945 tested, we can't say for sure that no toc adjusting stubs 11946 are needed, so don't return zero. */ 11947 else if (sym_sec->call_check_in_progress) 11948 ret = 2; 11949 11950 /* Branches to another section that itself doesn't have any TOC 11951 references are OK. Recursively call ourselves to check. */ 11952 else if (!sym_sec->call_check_done) 11953 { 11954 int recur; 11955 11956 /* Mark current section as indeterminate, so that other 11957 sections that call back to current won't be marked as 11958 known. */ 11959 isec->call_check_in_progress = 1; 11960 recur = toc_adjusting_stub_needed (info, sym_sec); 11961 isec->call_check_in_progress = 0; 11962 11963 if (recur != 0) 11964 { 11965 ret = recur; 11966 if (recur != 2) 11967 break; 11968 } 11969 } 11970 } 11971 11972 if (local_syms != NULL 11973 && (elf_symtab_hdr (isec->owner).contents 11974 != (unsigned char *) local_syms)) 11975 free (local_syms); 11976 if (elf_section_data (isec)->relocs != relstart) 11977 free (relstart); 11978 } 11979 11980 if ((ret & 1) == 0 11981 && isec->map_head.s != NULL 11982 && (strcmp (isec->output_section->name, ".init") == 0 11983 || strcmp (isec->output_section->name, ".fini") == 0)) 11984 { 11985 if (isec->map_head.s->has_toc_reloc 11986 || isec->map_head.s->makes_toc_func_call) 11987 ret = 1; 11988 else if (!isec->map_head.s->call_check_done) 11989 { 11990 int recur; 11991 isec->call_check_in_progress = 1; 11992 recur = toc_adjusting_stub_needed (info, isec->map_head.s); 11993 isec->call_check_in_progress = 0; 11994 if (recur != 0) 11995 ret = recur; 11996 } 11997 } 11998 11999 if (ret == 1) 12000 isec->makes_toc_func_call = 1; 12001 12002 return ret; 12003} 12004 12005/* The linker repeatedly calls this function for each input section, 12006 in the order that input sections are linked into output sections. 12007 Build lists of input sections to determine groupings between which 12008 we may insert linker stubs. */ 12009 12010bfd_boolean 12011ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec) 12012{ 12013 struct ppc_link_hash_table *htab = ppc_hash_table (info); 12014 12015 if (htab == NULL) 12016 return FALSE; 12017 12018 if ((isec->output_section->flags & SEC_CODE) != 0 12019 && isec->output_section->id < htab->sec_info_arr_size) 12020 { 12021 /* This happens to make the list in reverse order, 12022 which is what we want. */ 12023 htab->sec_info[isec->id].u.list 12024 = htab->sec_info[isec->output_section->id].u.list; 12025 htab->sec_info[isec->output_section->id].u.list = isec; 12026 } 12027 12028 if (htab->multi_toc_needed) 12029 { 12030 /* Analyse sections that aren't already flagged as needing a 12031 valid toc pointer. Exclude .fixup for the linux kernel. 12032 .fixup contains branches, but only back to the function that 12033 hit an exception. */ 12034 if (!(isec->has_toc_reloc 12035 || (isec->flags & SEC_CODE) == 0 12036 || strcmp (isec->name, ".fixup") == 0 12037 || isec->call_check_done)) 12038 { 12039 if (toc_adjusting_stub_needed (info, isec) < 0) 12040 return FALSE; 12041 } 12042 /* Make all sections use the TOC assigned for this object file. 12043 This will be wrong for pasted sections; We fix that in 12044 check_pasted_section(). */ 12045 if (elf_gp (isec->owner) != 0) 12046 htab->toc_curr = elf_gp (isec->owner); 12047 } 12048 12049 htab->sec_info[isec->id].toc_off = htab->toc_curr; 12050 return TRUE; 12051} 12052 12053/* Check that all .init and .fini sections use the same toc, if they 12054 have toc relocs. */ 12055 12056static bfd_boolean 12057check_pasted_section (struct bfd_link_info *info, const char *name) 12058{ 12059 asection *o = bfd_get_section_by_name (info->output_bfd, name); 12060 12061 if (o != NULL) 12062 { 12063 struct ppc_link_hash_table *htab = ppc_hash_table (info); 12064 bfd_vma toc_off = 0; 12065 asection *i; 12066 12067 for (i = o->map_head.s; i != NULL; i = i->map_head.s) 12068 if (i->has_toc_reloc) 12069 { 12070 if (toc_off == 0) 12071 toc_off = htab->sec_info[i->id].toc_off; 12072 else if (toc_off != htab->sec_info[i->id].toc_off) 12073 return FALSE; 12074 } 12075 12076 if (toc_off == 0) 12077 for (i = o->map_head.s; i != NULL; i = i->map_head.s) 12078 if (i->makes_toc_func_call) 12079 { 12080 toc_off = htab->sec_info[i->id].toc_off; 12081 break; 12082 } 12083 12084 /* Make sure the whole pasted function uses the same toc offset. */ 12085 if (toc_off != 0) 12086 for (i = o->map_head.s; i != NULL; i = i->map_head.s) 12087 htab->sec_info[i->id].toc_off = toc_off; 12088 } 12089 return TRUE; 12090} 12091 12092bfd_boolean 12093ppc64_elf_check_init_fini (struct bfd_link_info *info) 12094{ 12095 return (check_pasted_section (info, ".init") 12096 & check_pasted_section (info, ".fini")); 12097} 12098 12099/* See whether we can group stub sections together. Grouping stub 12100 sections may result in fewer stubs. More importantly, we need to 12101 put all .init* and .fini* stubs at the beginning of the .init or 12102 .fini output sections respectively, because glibc splits the 12103 _init and _fini functions into multiple parts. Putting a stub in 12104 the middle of a function is not a good idea. */ 12105 12106static bfd_boolean 12107group_sections (struct bfd_link_info *info, 12108 bfd_size_type stub_group_size, 12109 bfd_boolean stubs_always_before_branch) 12110{ 12111 struct ppc_link_hash_table *htab; 12112 asection *osec; 12113 bfd_boolean suppress_size_errors; 12114 12115 htab = ppc_hash_table (info); 12116 if (htab == NULL) 12117 return FALSE; 12118 12119 suppress_size_errors = FALSE; 12120 if (stub_group_size == 1) 12121 { 12122 /* Default values. */ 12123 if (stubs_always_before_branch) 12124 stub_group_size = 0x1e00000; 12125 else 12126 stub_group_size = 0x1c00000; 12127 suppress_size_errors = TRUE; 12128 } 12129 12130 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next) 12131 { 12132 asection *tail; 12133 12134 if (osec->id >= htab->sec_info_arr_size) 12135 continue; 12136 12137 tail = htab->sec_info[osec->id].u.list; 12138 while (tail != NULL) 12139 { 12140 asection *curr; 12141 asection *prev; 12142 bfd_size_type total; 12143 bfd_boolean big_sec; 12144 bfd_vma curr_toc; 12145 struct map_stub *group; 12146 bfd_size_type group_size; 12147 12148 curr = tail; 12149 total = tail->size; 12150 group_size = (ppc64_elf_section_data (tail) != NULL 12151 && ppc64_elf_section_data (tail)->has_14bit_branch 12152 ? stub_group_size >> 10 : stub_group_size); 12153 12154 big_sec = total > group_size; 12155 if (big_sec && !suppress_size_errors) 12156 /* xgettext:c-format */ 12157 _bfd_error_handler (_("%B section %A exceeds stub group size"), 12158 tail->owner, tail); 12159 curr_toc = htab->sec_info[tail->id].toc_off; 12160 12161 while ((prev = htab->sec_info[curr->id].u.list) != NULL 12162 && ((total += curr->output_offset - prev->output_offset) 12163 < (ppc64_elf_section_data (prev) != NULL 12164 && ppc64_elf_section_data (prev)->has_14bit_branch 12165 ? (group_size = stub_group_size >> 10) : group_size)) 12166 && htab->sec_info[prev->id].toc_off == curr_toc) 12167 curr = prev; 12168 12169 /* OK, the size from the start of CURR to the end is less 12170 than group_size and thus can be handled by one stub 12171 section. (or the tail section is itself larger than 12172 group_size, in which case we may be toast.) We should 12173 really be keeping track of the total size of stubs added 12174 here, as stubs contribute to the final output section 12175 size. That's a little tricky, and this way will only 12176 break if stubs added make the total size more than 2^25, 12177 ie. for the default stub_group_size, if stubs total more 12178 than 2097152 bytes, or nearly 75000 plt call stubs. */ 12179 group = bfd_alloc (curr->owner, sizeof (*group)); 12180 if (group == NULL) 12181 return FALSE; 12182 group->link_sec = curr; 12183 group->stub_sec = NULL; 12184 group->needs_save_res = 0; 12185 group->next = htab->group; 12186 htab->group = group; 12187 do 12188 { 12189 prev = htab->sec_info[tail->id].u.list; 12190 /* Set up this stub group. */ 12191 htab->sec_info[tail->id].u.group = group; 12192 } 12193 while (tail != curr && (tail = prev) != NULL); 12194 12195 /* But wait, there's more! Input sections up to group_size 12196 bytes before the stub section can be handled by it too. 12197 Don't do this if we have a really large section after the 12198 stubs, as adding more stubs increases the chance that 12199 branches may not reach into the stub section. */ 12200 if (!stubs_always_before_branch && !big_sec) 12201 { 12202 total = 0; 12203 while (prev != NULL 12204 && ((total += tail->output_offset - prev->output_offset) 12205 < (ppc64_elf_section_data (prev) != NULL 12206 && ppc64_elf_section_data (prev)->has_14bit_branch 12207 ? (group_size = stub_group_size >> 10) : group_size)) 12208 && htab->sec_info[prev->id].toc_off == curr_toc) 12209 { 12210 tail = prev; 12211 prev = htab->sec_info[tail->id].u.list; 12212 htab->sec_info[tail->id].u.group = group; 12213 } 12214 } 12215 tail = prev; 12216 } 12217 } 12218 return TRUE; 12219} 12220 12221static const unsigned char glink_eh_frame_cie[] = 12222{ 12223 0, 0, 0, 16, /* length. */ 12224 0, 0, 0, 0, /* id. */ 12225 1, /* CIE version. */ 12226 'z', 'R', 0, /* Augmentation string. */ 12227 4, /* Code alignment. */ 12228 0x78, /* Data alignment. */ 12229 65, /* RA reg. */ 12230 1, /* Augmentation size. */ 12231 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */ 12232 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */ 12233 0, 0, 0, 0 12234}; 12235 12236/* Stripping output sections is normally done before dynamic section 12237 symbols have been allocated. This function is called later, and 12238 handles cases like htab->brlt which is mapped to its own output 12239 section. */ 12240 12241static void 12242maybe_strip_output (struct bfd_link_info *info, asection *isec) 12243{ 12244 if (isec->size == 0 12245 && isec->output_section->size == 0 12246 && !(isec->output_section->flags & SEC_KEEP) 12247 && !bfd_section_removed_from_list (info->output_bfd, 12248 isec->output_section) 12249 && elf_section_data (isec->output_section)->dynindx == 0) 12250 { 12251 isec->output_section->flags |= SEC_EXCLUDE; 12252 bfd_section_list_remove (info->output_bfd, isec->output_section); 12253 info->output_bfd->section_count--; 12254 } 12255} 12256 12257/* Determine and set the size of the stub section for a final link. 12258 12259 The basic idea here is to examine all the relocations looking for 12260 PC-relative calls to a target that is unreachable with a "bl" 12261 instruction. */ 12262 12263bfd_boolean 12264ppc64_elf_size_stubs (struct bfd_link_info *info) 12265{ 12266 bfd_size_type stub_group_size; 12267 bfd_boolean stubs_always_before_branch; 12268 struct ppc_link_hash_table *htab = ppc_hash_table (info); 12269 12270 if (htab == NULL) 12271 return FALSE; 12272 12273 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info)) 12274 htab->params->plt_thread_safe = 1; 12275 if (!htab->opd_abi) 12276 htab->params->plt_thread_safe = 0; 12277 else if (htab->params->plt_thread_safe == -1) 12278 { 12279 static const char *const thread_starter[] = 12280 { 12281 "pthread_create", 12282 /* libstdc++ */ 12283 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE", 12284 /* librt */ 12285 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio", 12286 "mq_notify", "create_timer", 12287 /* libanl */ 12288 "getaddrinfo_a", 12289 /* libgomp */ 12290 "GOMP_parallel", 12291 "GOMP_parallel_start", 12292 "GOMP_parallel_loop_static", 12293 "GOMP_parallel_loop_static_start", 12294 "GOMP_parallel_loop_dynamic", 12295 "GOMP_parallel_loop_dynamic_start", 12296 "GOMP_parallel_loop_guided", 12297 "GOMP_parallel_loop_guided_start", 12298 "GOMP_parallel_loop_runtime", 12299 "GOMP_parallel_loop_runtime_start", 12300 "GOMP_parallel_sections", 12301 "GOMP_parallel_sections_start", 12302 /* libgo */ 12303 "__go_go", 12304 }; 12305 unsigned i; 12306 12307 for (i = 0; i < ARRAY_SIZE (thread_starter); i++) 12308 { 12309 struct elf_link_hash_entry *h; 12310 h = elf_link_hash_lookup (&htab->elf, thread_starter[i], 12311 FALSE, FALSE, TRUE); 12312 htab->params->plt_thread_safe = h != NULL && h->ref_regular; 12313 if (htab->params->plt_thread_safe) 12314 break; 12315 } 12316 } 12317 stubs_always_before_branch = htab->params->group_size < 0; 12318 if (htab->params->group_size < 0) 12319 stub_group_size = -htab->params->group_size; 12320 else 12321 stub_group_size = htab->params->group_size; 12322 12323 if (!group_sections (info, stub_group_size, stubs_always_before_branch)) 12324 return FALSE; 12325 12326#define STUB_SHRINK_ITER 20 12327 /* Loop until no stubs added. After iteration 20 of this loop we may 12328 exit on a stub section shrinking. This is to break out of a 12329 pathological case where adding stubs on one iteration decreases 12330 section gaps (perhaps due to alignment), which then requires 12331 fewer or smaller stubs on the next iteration. */ 12332 12333 while (1) 12334 { 12335 bfd *input_bfd; 12336 unsigned int bfd_indx; 12337 struct map_stub *group; 12338 asection *stub_sec; 12339 12340 htab->stub_iteration += 1; 12341 12342 for (input_bfd = info->input_bfds, bfd_indx = 0; 12343 input_bfd != NULL; 12344 input_bfd = input_bfd->link.next, bfd_indx++) 12345 { 12346 Elf_Internal_Shdr *symtab_hdr; 12347 asection *section; 12348 Elf_Internal_Sym *local_syms = NULL; 12349 12350 if (!is_ppc64_elf (input_bfd)) 12351 continue; 12352 12353 /* We'll need the symbol table in a second. */ 12354 symtab_hdr = &elf_symtab_hdr (input_bfd); 12355 if (symtab_hdr->sh_info == 0) 12356 continue; 12357 12358 /* Walk over each section attached to the input bfd. */ 12359 for (section = input_bfd->sections; 12360 section != NULL; 12361 section = section->next) 12362 { 12363 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 12364 12365 /* If there aren't any relocs, then there's nothing more 12366 to do. */ 12367 if ((section->flags & SEC_RELOC) == 0 12368 || (section->flags & SEC_ALLOC) == 0 12369 || (section->flags & SEC_LOAD) == 0 12370 || (section->flags & SEC_CODE) == 0 12371 || section->reloc_count == 0) 12372 continue; 12373 12374 /* If this section is a link-once section that will be 12375 discarded, then don't create any stubs. */ 12376 if (section->output_section == NULL 12377 || section->output_section->owner != info->output_bfd) 12378 continue; 12379 12380 /* Get the relocs. */ 12381 internal_relocs 12382 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL, 12383 info->keep_memory); 12384 if (internal_relocs == NULL) 12385 goto error_ret_free_local; 12386 12387 /* Now examine each relocation. */ 12388 irela = internal_relocs; 12389 irelaend = irela + section->reloc_count; 12390 for (; irela < irelaend; irela++) 12391 { 12392 enum elf_ppc64_reloc_type r_type; 12393 unsigned int r_indx; 12394 enum ppc_stub_type stub_type; 12395 struct ppc_stub_hash_entry *stub_entry; 12396 asection *sym_sec, *code_sec; 12397 bfd_vma sym_value, code_value; 12398 bfd_vma destination; 12399 unsigned long local_off; 12400 bfd_boolean ok_dest; 12401 struct ppc_link_hash_entry *hash; 12402 struct ppc_link_hash_entry *fdh; 12403 struct elf_link_hash_entry *h; 12404 Elf_Internal_Sym *sym; 12405 char *stub_name; 12406 const asection *id_sec; 12407 struct _opd_sec_data *opd; 12408 struct plt_entry *plt_ent; 12409 12410 r_type = ELF64_R_TYPE (irela->r_info); 12411 r_indx = ELF64_R_SYM (irela->r_info); 12412 12413 if (r_type >= R_PPC64_max) 12414 { 12415 bfd_set_error (bfd_error_bad_value); 12416 goto error_ret_free_internal; 12417 } 12418 12419 /* Only look for stubs on branch instructions. */ 12420 if (r_type != R_PPC64_REL24 12421 && r_type != R_PPC64_REL14 12422 && r_type != R_PPC64_REL14_BRTAKEN 12423 && r_type != R_PPC64_REL14_BRNTAKEN) 12424 continue; 12425 12426 /* Now determine the call target, its name, value, 12427 section. */ 12428 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, 12429 r_indx, input_bfd)) 12430 goto error_ret_free_internal; 12431 hash = (struct ppc_link_hash_entry *) h; 12432 12433 ok_dest = FALSE; 12434 fdh = NULL; 12435 sym_value = 0; 12436 if (hash == NULL) 12437 { 12438 sym_value = sym->st_value; 12439 if (sym_sec != NULL 12440 && sym_sec->output_section != NULL) 12441 ok_dest = TRUE; 12442 } 12443 else if (hash->elf.root.type == bfd_link_hash_defined 12444 || hash->elf.root.type == bfd_link_hash_defweak) 12445 { 12446 sym_value = hash->elf.root.u.def.value; 12447 if (sym_sec->output_section != NULL) 12448 ok_dest = TRUE; 12449 } 12450 else if (hash->elf.root.type == bfd_link_hash_undefweak 12451 || hash->elf.root.type == bfd_link_hash_undefined) 12452 { 12453 /* Recognise an old ABI func code entry sym, and 12454 use the func descriptor sym instead if it is 12455 defined. */ 12456 if (hash->elf.root.root.string[0] == '.' 12457 && hash->oh != NULL) 12458 { 12459 fdh = ppc_follow_link (hash->oh); 12460 if (fdh->elf.root.type == bfd_link_hash_defined 12461 || fdh->elf.root.type == bfd_link_hash_defweak) 12462 { 12463 sym_sec = fdh->elf.root.u.def.section; 12464 sym_value = fdh->elf.root.u.def.value; 12465 if (sym_sec->output_section != NULL) 12466 ok_dest = TRUE; 12467 } 12468 else 12469 fdh = NULL; 12470 } 12471 } 12472 else 12473 { 12474 bfd_set_error (bfd_error_bad_value); 12475 goto error_ret_free_internal; 12476 } 12477 12478 destination = 0; 12479 local_off = 0; 12480 if (ok_dest) 12481 { 12482 sym_value += irela->r_addend; 12483 destination = (sym_value 12484 + sym_sec->output_offset 12485 + sym_sec->output_section->vma); 12486 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash 12487 ? hash->elf.other 12488 : sym->st_other); 12489 } 12490 12491 code_sec = sym_sec; 12492 code_value = sym_value; 12493 opd = get_opd_info (sym_sec); 12494 if (opd != NULL) 12495 { 12496 bfd_vma dest; 12497 12498 if (hash == NULL && opd->adjust != NULL) 12499 { 12500 long adjust = opd->adjust[OPD_NDX (sym_value)]; 12501 if (adjust == -1) 12502 continue; 12503 code_value += adjust; 12504 sym_value += adjust; 12505 } 12506 dest = opd_entry_value (sym_sec, sym_value, 12507 &code_sec, &code_value, FALSE); 12508 if (dest != (bfd_vma) -1) 12509 { 12510 destination = dest; 12511 if (fdh != NULL) 12512 { 12513 /* Fixup old ABI sym to point at code 12514 entry. */ 12515 hash->elf.root.type = bfd_link_hash_defweak; 12516 hash->elf.root.u.def.section = code_sec; 12517 hash->elf.root.u.def.value = code_value; 12518 } 12519 } 12520 } 12521 12522 /* Determine what (if any) linker stub is needed. */ 12523 plt_ent = NULL; 12524 stub_type = ppc_type_of_stub (section, irela, &hash, 12525 &plt_ent, destination, 12526 local_off); 12527 12528 if (stub_type != ppc_stub_plt_call) 12529 { 12530 /* Check whether we need a TOC adjusting stub. 12531 Since the linker pastes together pieces from 12532 different object files when creating the 12533 _init and _fini functions, it may be that a 12534 call to what looks like a local sym is in 12535 fact a call needing a TOC adjustment. */ 12536 if (code_sec != NULL 12537 && code_sec->output_section != NULL 12538 && (htab->sec_info[code_sec->id].toc_off 12539 != htab->sec_info[section->id].toc_off) 12540 && (code_sec->has_toc_reloc 12541 || code_sec->makes_toc_func_call)) 12542 stub_type = ppc_stub_long_branch_r2off; 12543 } 12544 12545 if (stub_type == ppc_stub_none) 12546 continue; 12547 12548 /* __tls_get_addr calls might be eliminated. */ 12549 if (stub_type != ppc_stub_plt_call 12550 && hash != NULL 12551 && (hash == htab->tls_get_addr 12552 || hash == htab->tls_get_addr_fd) 12553 && section->has_tls_reloc 12554 && irela != internal_relocs) 12555 { 12556 /* Get tls info. */ 12557 unsigned char *tls_mask; 12558 12559 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms, 12560 irela - 1, input_bfd)) 12561 goto error_ret_free_internal; 12562 if (*tls_mask != 0) 12563 continue; 12564 } 12565 12566 if (stub_type == ppc_stub_plt_call 12567 && irela + 1 < irelaend 12568 && irela[1].r_offset == irela->r_offset + 4 12569 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE) 12570 { 12571 if (!tocsave_find (htab, INSERT, 12572 &local_syms, irela + 1, input_bfd)) 12573 goto error_ret_free_internal; 12574 } 12575 else if (stub_type == ppc_stub_plt_call) 12576 stub_type = ppc_stub_plt_call_r2save; 12577 12578 /* Support for grouping stub sections. */ 12579 id_sec = htab->sec_info[section->id].u.group->link_sec; 12580 12581 /* Get the name of this stub. */ 12582 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela); 12583 if (!stub_name) 12584 goto error_ret_free_internal; 12585 12586 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, 12587 stub_name, FALSE, FALSE); 12588 if (stub_entry != NULL) 12589 { 12590 /* The proper stub has already been created. */ 12591 free (stub_name); 12592 if (stub_type == ppc_stub_plt_call_r2save) 12593 stub_entry->stub_type = stub_type; 12594 continue; 12595 } 12596 12597 stub_entry = ppc_add_stub (stub_name, section, info); 12598 if (stub_entry == NULL) 12599 { 12600 free (stub_name); 12601 error_ret_free_internal: 12602 if (elf_section_data (section)->relocs == NULL) 12603 free (internal_relocs); 12604 error_ret_free_local: 12605 if (local_syms != NULL 12606 && (symtab_hdr->contents 12607 != (unsigned char *) local_syms)) 12608 free (local_syms); 12609 return FALSE; 12610 } 12611 12612 stub_entry->stub_type = stub_type; 12613 if (stub_type != ppc_stub_plt_call 12614 && stub_type != ppc_stub_plt_call_r2save) 12615 { 12616 stub_entry->target_value = code_value; 12617 stub_entry->target_section = code_sec; 12618 } 12619 else 12620 { 12621 stub_entry->target_value = sym_value; 12622 stub_entry->target_section = sym_sec; 12623 } 12624 stub_entry->h = hash; 12625 stub_entry->plt_ent = plt_ent; 12626 stub_entry->other = hash ? hash->elf.other : sym->st_other; 12627 12628 if (stub_entry->h != NULL) 12629 htab->stub_globals += 1; 12630 } 12631 12632 /* We're done with the internal relocs, free them. */ 12633 if (elf_section_data (section)->relocs != internal_relocs) 12634 free (internal_relocs); 12635 } 12636 12637 if (local_syms != NULL 12638 && symtab_hdr->contents != (unsigned char *) local_syms) 12639 { 12640 if (!info->keep_memory) 12641 free (local_syms); 12642 else 12643 symtab_hdr->contents = (unsigned char *) local_syms; 12644 } 12645 } 12646 12647 /* We may have added some stubs. Find out the new size of the 12648 stub sections. */ 12649 for (stub_sec = htab->params->stub_bfd->sections; 12650 stub_sec != NULL; 12651 stub_sec = stub_sec->next) 12652 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 12653 { 12654 if (htab->stub_iteration <= STUB_SHRINK_ITER 12655 || stub_sec->rawsize < stub_sec->size) 12656 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */ 12657 stub_sec->rawsize = stub_sec->size; 12658 stub_sec->size = 0; 12659 stub_sec->reloc_count = 0; 12660 stub_sec->flags &= ~SEC_RELOC; 12661 } 12662 12663 htab->brlt->size = 0; 12664 htab->brlt->reloc_count = 0; 12665 htab->brlt->flags &= ~SEC_RELOC; 12666 if (htab->relbrlt != NULL) 12667 htab->relbrlt->size = 0; 12668 12669 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info); 12670 12671 for (group = htab->group; group != NULL; group = group->next) 12672 if (group->needs_save_res) 12673 group->stub_sec->size += htab->sfpr->size; 12674 12675 if (info->emitrelocations 12676 && htab->glink != NULL && htab->glink->size != 0) 12677 { 12678 htab->glink->reloc_count = 1; 12679 htab->glink->flags |= SEC_RELOC; 12680 } 12681 12682 if (htab->glink_eh_frame != NULL 12683 && !bfd_is_abs_section (htab->glink_eh_frame->output_section) 12684 && htab->glink_eh_frame->output_section->size != 0) 12685 { 12686 size_t size = 0, align; 12687 12688 for (stub_sec = htab->params->stub_bfd->sections; 12689 stub_sec != NULL; 12690 stub_sec = stub_sec->next) 12691 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 12692 size += 24; 12693 if (htab->glink != NULL && htab->glink->size != 0) 12694 size += 24; 12695 if (size != 0) 12696 size += sizeof (glink_eh_frame_cie); 12697 align = 1; 12698 align <<= htab->glink_eh_frame->output_section->alignment_power; 12699 align -= 1; 12700 size = (size + align) & ~align; 12701 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size; 12702 htab->glink_eh_frame->size = size; 12703 } 12704 12705 if (htab->params->plt_stub_align != 0) 12706 for (stub_sec = htab->params->stub_bfd->sections; 12707 stub_sec != NULL; 12708 stub_sec = stub_sec->next) 12709 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 12710 stub_sec->size = ((stub_sec->size 12711 + (1 << htab->params->plt_stub_align) - 1) 12712 & -(1 << htab->params->plt_stub_align)); 12713 12714 for (stub_sec = htab->params->stub_bfd->sections; 12715 stub_sec != NULL; 12716 stub_sec = stub_sec->next) 12717 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0 12718 && stub_sec->rawsize != stub_sec->size 12719 && (htab->stub_iteration <= STUB_SHRINK_ITER 12720 || stub_sec->rawsize < stub_sec->size)) 12721 break; 12722 12723 if (stub_sec == NULL 12724 && (htab->glink_eh_frame == NULL 12725 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size)) 12726 break; 12727 12728 /* Ask the linker to do its stuff. */ 12729 (*htab->params->layout_sections_again) (); 12730 } 12731 12732 if (htab->glink_eh_frame != NULL 12733 && htab->glink_eh_frame->size != 0) 12734 { 12735 bfd_vma val; 12736 bfd_byte *p, *last_fde; 12737 size_t last_fde_len, size, align, pad; 12738 asection *stub_sec; 12739 12740 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size); 12741 if (p == NULL) 12742 return FALSE; 12743 htab->glink_eh_frame->contents = p; 12744 last_fde = p; 12745 12746 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie)); 12747 /* CIE length (rewrite in case little-endian). */ 12748 last_fde_len = sizeof (glink_eh_frame_cie) - 4; 12749 bfd_put_32 (htab->elf.dynobj, last_fde_len, p); 12750 p += sizeof (glink_eh_frame_cie); 12751 12752 for (stub_sec = htab->params->stub_bfd->sections; 12753 stub_sec != NULL; 12754 stub_sec = stub_sec->next) 12755 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 12756 { 12757 last_fde = p; 12758 last_fde_len = 20; 12759 /* FDE length. */ 12760 bfd_put_32 (htab->elf.dynobj, 20, p); 12761 p += 4; 12762 /* CIE pointer. */ 12763 val = p - htab->glink_eh_frame->contents; 12764 bfd_put_32 (htab->elf.dynobj, val, p); 12765 p += 4; 12766 /* Offset to stub section, written later. */ 12767 p += 4; 12768 /* stub section size. */ 12769 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p); 12770 p += 4; 12771 /* Augmentation. */ 12772 p += 1; 12773 /* Pad. */ 12774 p += 7; 12775 } 12776 if (htab->glink != NULL && htab->glink->size != 0) 12777 { 12778 last_fde = p; 12779 last_fde_len = 20; 12780 /* FDE length. */ 12781 bfd_put_32 (htab->elf.dynobj, 20, p); 12782 p += 4; 12783 /* CIE pointer. */ 12784 val = p - htab->glink_eh_frame->contents; 12785 bfd_put_32 (htab->elf.dynobj, val, p); 12786 p += 4; 12787 /* Offset to .glink, written later. */ 12788 p += 4; 12789 /* .glink size. */ 12790 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p); 12791 p += 4; 12792 /* Augmentation. */ 12793 p += 1; 12794 12795 *p++ = DW_CFA_advance_loc + 1; 12796 *p++ = DW_CFA_register; 12797 *p++ = 65; 12798 *p++ = htab->opd_abi ? 12 : 0; 12799 *p++ = DW_CFA_advance_loc + 4; 12800 *p++ = DW_CFA_restore_extended; 12801 *p++ = 65; 12802 } 12803 /* Subsume any padding into the last FDE if user .eh_frame 12804 sections are aligned more than glink_eh_frame. Otherwise any 12805 zero padding will be seen as a terminator. */ 12806 size = p - htab->glink_eh_frame->contents; 12807 align = 1; 12808 align <<= htab->glink_eh_frame->output_section->alignment_power; 12809 align -= 1; 12810 pad = ((size + align) & ~align) - size; 12811 htab->glink_eh_frame->size = size + pad; 12812 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde); 12813 } 12814 12815 maybe_strip_output (info, htab->brlt); 12816 if (htab->glink_eh_frame != NULL) 12817 maybe_strip_output (info, htab->glink_eh_frame); 12818 12819 return TRUE; 12820} 12821 12822/* Called after we have determined section placement. If sections 12823 move, we'll be called again. Provide a value for TOCstart. */ 12824 12825bfd_vma 12826ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd) 12827{ 12828 asection *s; 12829 bfd_vma TOCstart, adjust; 12830 12831 if (info != NULL) 12832 { 12833 struct elf_link_hash_entry *h; 12834 struct elf_link_hash_table *htab = elf_hash_table (info); 12835 12836 if (is_elf_hash_table (htab) 12837 && htab->hgot != NULL) 12838 h = htab->hgot; 12839 else 12840 { 12841 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE); 12842 if (is_elf_hash_table (htab)) 12843 htab->hgot = h; 12844 } 12845 if (h != NULL 12846 && h->root.type == bfd_link_hash_defined 12847 && !h->root.linker_def 12848 && (!is_elf_hash_table (htab) 12849 || h->def_regular)) 12850 { 12851 TOCstart = (h->root.u.def.value - TOC_BASE_OFF 12852 + h->root.u.def.section->output_offset 12853 + h->root.u.def.section->output_section->vma); 12854 _bfd_set_gp_value (obfd, TOCstart); 12855 return TOCstart; 12856 } 12857 } 12858 12859 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that 12860 order. The TOC starts where the first of these sections starts. */ 12861 s = bfd_get_section_by_name (obfd, ".got"); 12862 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0) 12863 s = bfd_get_section_by_name (obfd, ".toc"); 12864 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0) 12865 s = bfd_get_section_by_name (obfd, ".tocbss"); 12866 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0) 12867 s = bfd_get_section_by_name (obfd, ".plt"); 12868 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0) 12869 { 12870 /* This may happen for 12871 o references to TOC base (SYM@toc / TOC[tc0]) without a 12872 .toc directive 12873 o bad linker script 12874 o --gc-sections and empty TOC sections 12875 12876 FIXME: Warn user? */ 12877 12878 /* Look for a likely section. We probably won't even be 12879 using TOCstart. */ 12880 for (s = obfd->sections; s != NULL; s = s->next) 12881 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY 12882 | SEC_EXCLUDE)) 12883 == (SEC_ALLOC | SEC_SMALL_DATA)) 12884 break; 12885 if (s == NULL) 12886 for (s = obfd->sections; s != NULL; s = s->next) 12887 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE)) 12888 == (SEC_ALLOC | SEC_SMALL_DATA)) 12889 break; 12890 if (s == NULL) 12891 for (s = obfd->sections; s != NULL; s = s->next) 12892 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE)) 12893 == SEC_ALLOC) 12894 break; 12895 if (s == NULL) 12896 for (s = obfd->sections; s != NULL; s = s->next) 12897 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC) 12898 break; 12899 } 12900 12901 TOCstart = 0; 12902 if (s != NULL) 12903 TOCstart = s->output_section->vma + s->output_offset; 12904 12905 /* Force alignment. */ 12906 adjust = TOCstart & (TOC_BASE_ALIGN - 1); 12907 TOCstart -= adjust; 12908 _bfd_set_gp_value (obfd, TOCstart); 12909 12910 if (info != NULL && s != NULL) 12911 { 12912 struct ppc_link_hash_table *htab = ppc_hash_table (info); 12913 12914 if (htab != NULL) 12915 { 12916 if (htab->elf.hgot != NULL) 12917 { 12918 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust; 12919 htab->elf.hgot->root.u.def.section = s; 12920 } 12921 } 12922 else 12923 { 12924 struct bfd_link_hash_entry *bh = NULL; 12925 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL, 12926 s, TOC_BASE_OFF - adjust, 12927 NULL, FALSE, FALSE, &bh); 12928 } 12929 } 12930 return TOCstart; 12931} 12932 12933/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to 12934 write out any global entry stubs. */ 12935 12936static bfd_boolean 12937build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf) 12938{ 12939 struct bfd_link_info *info; 12940 struct ppc_link_hash_table *htab; 12941 struct plt_entry *pent; 12942 asection *s; 12943 12944 if (h->root.type == bfd_link_hash_indirect) 12945 return TRUE; 12946 12947 if (!h->pointer_equality_needed) 12948 return TRUE; 12949 12950 if (h->def_regular) 12951 return TRUE; 12952 12953 info = inf; 12954 htab = ppc_hash_table (info); 12955 if (htab == NULL) 12956 return FALSE; 12957 12958 s = htab->glink; 12959 for (pent = h->plt.plist; pent != NULL; pent = pent->next) 12960 if (pent->plt.offset != (bfd_vma) -1 12961 && pent->addend == 0) 12962 { 12963 bfd_byte *p; 12964 asection *plt; 12965 bfd_vma off; 12966 12967 p = s->contents + h->root.u.def.value; 12968 plt = htab->elf.splt; 12969 if (!htab->elf.dynamic_sections_created 12970 || h->dynindx == -1) 12971 plt = htab->elf.iplt; 12972 off = pent->plt.offset + plt->output_offset + plt->output_section->vma; 12973 off -= h->root.u.def.value + s->output_offset + s->output_section->vma; 12974 12975 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0) 12976 { 12977 info->callbacks->einfo 12978 (_("%P: linkage table error against `%T'\n"), 12979 h->root.root.string); 12980 bfd_set_error (bfd_error_bad_value); 12981 htab->stub_error = TRUE; 12982 } 12983 12984 htab->stub_count[ppc_stub_global_entry - 1] += 1; 12985 if (htab->params->emit_stub_syms) 12986 { 12987 size_t len = strlen (h->root.root.string); 12988 char *name = bfd_malloc (sizeof "12345678.global_entry." + len); 12989 12990 if (name == NULL) 12991 return FALSE; 12992 12993 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string); 12994 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); 12995 if (h == NULL) 12996 return FALSE; 12997 if (h->root.type == bfd_link_hash_new) 12998 { 12999 h->root.type = bfd_link_hash_defined; 13000 h->root.u.def.section = s; 13001 h->root.u.def.value = p - s->contents; 13002 h->ref_regular = 1; 13003 h->def_regular = 1; 13004 h->ref_regular_nonweak = 1; 13005 h->forced_local = 1; 13006 h->non_elf = 0; 13007 h->root.linker_def = 1; 13008 } 13009 } 13010 13011 if (PPC_HA (off) != 0) 13012 { 13013 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p); 13014 p += 4; 13015 } 13016 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p); 13017 p += 4; 13018 bfd_put_32 (s->owner, MTCTR_R12, p); 13019 p += 4; 13020 bfd_put_32 (s->owner, BCTR, p); 13021 break; 13022 } 13023 return TRUE; 13024} 13025 13026/* Build all the stubs associated with the current output file. 13027 The stubs are kept in a hash table attached to the main linker 13028 hash table. This function is called via gldelf64ppc_finish. */ 13029 13030bfd_boolean 13031ppc64_elf_build_stubs (struct bfd_link_info *info, 13032 char **stats) 13033{ 13034 struct ppc_link_hash_table *htab = ppc_hash_table (info); 13035 struct map_stub *group; 13036 asection *stub_sec; 13037 bfd_byte *p; 13038 int stub_sec_count = 0; 13039 13040 if (htab == NULL) 13041 return FALSE; 13042 13043 /* Allocate memory to hold the linker stubs. */ 13044 for (stub_sec = htab->params->stub_bfd->sections; 13045 stub_sec != NULL; 13046 stub_sec = stub_sec->next) 13047 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0 13048 && stub_sec->size != 0) 13049 { 13050 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size); 13051 if (stub_sec->contents == NULL) 13052 return FALSE; 13053 stub_sec->size = 0; 13054 } 13055 13056 if (htab->glink != NULL && htab->glink->size != 0) 13057 { 13058 unsigned int indx; 13059 bfd_vma plt0; 13060 13061 /* Build the .glink plt call stub. */ 13062 if (htab->params->emit_stub_syms) 13063 { 13064 struct elf_link_hash_entry *h; 13065 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve", 13066 TRUE, FALSE, FALSE); 13067 if (h == NULL) 13068 return FALSE; 13069 if (h->root.type == bfd_link_hash_new) 13070 { 13071 h->root.type = bfd_link_hash_defined; 13072 h->root.u.def.section = htab->glink; 13073 h->root.u.def.value = 8; 13074 h->ref_regular = 1; 13075 h->def_regular = 1; 13076 h->ref_regular_nonweak = 1; 13077 h->forced_local = 1; 13078 h->non_elf = 0; 13079 h->root.linker_def = 1; 13080 } 13081 } 13082 plt0 = (htab->elf.splt->output_section->vma 13083 + htab->elf.splt->output_offset 13084 - 16); 13085 if (info->emitrelocations) 13086 { 13087 Elf_Internal_Rela *r = get_relocs (htab->glink, 1); 13088 if (r == NULL) 13089 return FALSE; 13090 r->r_offset = (htab->glink->output_offset 13091 + htab->glink->output_section->vma); 13092 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64); 13093 r->r_addend = plt0; 13094 } 13095 p = htab->glink->contents; 13096 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset; 13097 bfd_put_64 (htab->glink->owner, plt0, p); 13098 p += 8; 13099 if (htab->opd_abi) 13100 { 13101 bfd_put_32 (htab->glink->owner, MFLR_R12, p); 13102 p += 4; 13103 bfd_put_32 (htab->glink->owner, BCL_20_31, p); 13104 p += 4; 13105 bfd_put_32 (htab->glink->owner, MFLR_R11, p); 13106 p += 4; 13107 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p); 13108 p += 4; 13109 bfd_put_32 (htab->glink->owner, MTLR_R12, p); 13110 p += 4; 13111 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p); 13112 p += 4; 13113 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p); 13114 p += 4; 13115 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p); 13116 p += 4; 13117 bfd_put_32 (htab->glink->owner, MTCTR_R12, p); 13118 p += 4; 13119 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p); 13120 p += 4; 13121 } 13122 else 13123 { 13124 bfd_put_32 (htab->glink->owner, MFLR_R0, p); 13125 p += 4; 13126 bfd_put_32 (htab->glink->owner, BCL_20_31, p); 13127 p += 4; 13128 bfd_put_32 (htab->glink->owner, MFLR_R11, p); 13129 p += 4; 13130 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p); 13131 p += 4; 13132 bfd_put_32 (htab->glink->owner, MTLR_R0, p); 13133 p += 4; 13134 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p); 13135 p += 4; 13136 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p); 13137 p += 4; 13138 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p); 13139 p += 4; 13140 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p); 13141 p += 4; 13142 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p); 13143 p += 4; 13144 bfd_put_32 (htab->glink->owner, MTCTR_R12, p); 13145 p += 4; 13146 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p); 13147 p += 4; 13148 } 13149 bfd_put_32 (htab->glink->owner, BCTR, p); 13150 p += 4; 13151 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE) 13152 { 13153 bfd_put_32 (htab->glink->owner, NOP, p); 13154 p += 4; 13155 } 13156 13157 /* Build the .glink lazy link call stubs. */ 13158 indx = 0; 13159 while (p < htab->glink->contents + htab->glink->rawsize) 13160 { 13161 if (htab->opd_abi) 13162 { 13163 if (indx < 0x8000) 13164 { 13165 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p); 13166 p += 4; 13167 } 13168 else 13169 { 13170 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p); 13171 p += 4; 13172 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), 13173 p); 13174 p += 4; 13175 } 13176 } 13177 bfd_put_32 (htab->glink->owner, 13178 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p); 13179 indx++; 13180 p += 4; 13181 } 13182 13183 /* Build .glink global entry stubs. */ 13184 if (htab->glink->size > htab->glink->rawsize) 13185 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info); 13186 } 13187 13188 if (htab->brlt != NULL && htab->brlt->size != 0) 13189 { 13190 htab->brlt->contents = bfd_zalloc (htab->brlt->owner, 13191 htab->brlt->size); 13192 if (htab->brlt->contents == NULL) 13193 return FALSE; 13194 } 13195 if (htab->relbrlt != NULL && htab->relbrlt->size != 0) 13196 { 13197 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner, 13198 htab->relbrlt->size); 13199 if (htab->relbrlt->contents == NULL) 13200 return FALSE; 13201 } 13202 13203 /* Build the stubs as directed by the stub hash table. */ 13204 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info); 13205 13206 for (group = htab->group; group != NULL; group = group->next) 13207 if (group->needs_save_res) 13208 { 13209 stub_sec = group->stub_sec; 13210 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents, 13211 htab->sfpr->size); 13212 if (htab->params->emit_stub_syms) 13213 { 13214 unsigned int i; 13215 13216 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++) 13217 if (!sfpr_define (info, &save_res_funcs[i], stub_sec)) 13218 return FALSE; 13219 } 13220 stub_sec->size += htab->sfpr->size; 13221 } 13222 13223 if (htab->relbrlt != NULL) 13224 htab->relbrlt->reloc_count = 0; 13225 13226 if (htab->params->plt_stub_align != 0) 13227 for (stub_sec = htab->params->stub_bfd->sections; 13228 stub_sec != NULL; 13229 stub_sec = stub_sec->next) 13230 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 13231 stub_sec->size = ((stub_sec->size 13232 + (1 << htab->params->plt_stub_align) - 1) 13233 & -(1 << htab->params->plt_stub_align)); 13234 13235 for (stub_sec = htab->params->stub_bfd->sections; 13236 stub_sec != NULL; 13237 stub_sec = stub_sec->next) 13238 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 13239 { 13240 stub_sec_count += 1; 13241 if (stub_sec->rawsize != stub_sec->size 13242 && (htab->stub_iteration <= STUB_SHRINK_ITER 13243 || stub_sec->rawsize < stub_sec->size)) 13244 break; 13245 } 13246 13247 /* Note that the glink_eh_frame check here is not only testing that 13248 the generated size matched the calculated size but also that 13249 bfd_elf_discard_info didn't make any changes to the section. */ 13250 if (stub_sec != NULL 13251 || (htab->glink_eh_frame != NULL 13252 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size)) 13253 { 13254 htab->stub_error = TRUE; 13255 info->callbacks->einfo (_("%P: stubs don't match calculated size\n")); 13256 } 13257 13258 if (htab->stub_error) 13259 return FALSE; 13260 13261 if (stats != NULL) 13262 { 13263 *stats = bfd_malloc (500); 13264 if (*stats == NULL) 13265 return FALSE; 13266 13267 sprintf (*stats, _("linker stubs in %u group%s\n" 13268 " branch %lu\n" 13269 " toc adjust %lu\n" 13270 " long branch %lu\n" 13271 " long toc adj %lu\n" 13272 " plt call %lu\n" 13273 " plt call toc %lu\n" 13274 " global entry %lu"), 13275 stub_sec_count, 13276 stub_sec_count == 1 ? "" : "s", 13277 htab->stub_count[ppc_stub_long_branch - 1], 13278 htab->stub_count[ppc_stub_long_branch_r2off - 1], 13279 htab->stub_count[ppc_stub_plt_branch - 1], 13280 htab->stub_count[ppc_stub_plt_branch_r2off - 1], 13281 htab->stub_count[ppc_stub_plt_call - 1], 13282 htab->stub_count[ppc_stub_plt_call_r2save - 1], 13283 htab->stub_count[ppc_stub_global_entry - 1]); 13284 } 13285 return TRUE; 13286} 13287 13288/* What to do when ld finds relocations against symbols defined in 13289 discarded sections. */ 13290 13291static unsigned int 13292ppc64_elf_action_discarded (asection *sec) 13293{ 13294 if (strcmp (".opd", sec->name) == 0) 13295 return 0; 13296 13297 if (strcmp (".toc", sec->name) == 0) 13298 return 0; 13299 13300 if (strcmp (".toc1", sec->name) == 0) 13301 return 0; 13302 13303 return _bfd_elf_default_action_discarded (sec); 13304} 13305 13306/* The RELOCATE_SECTION function is called by the ELF backend linker 13307 to handle the relocations for a section. 13308 13309 The relocs are always passed as Rela structures; if the section 13310 actually uses Rel structures, the r_addend field will always be 13311 zero. 13312 13313 This function is responsible for adjust the section contents as 13314 necessary, and (if using Rela relocs and generating a 13315 relocatable output file) adjusting the reloc addend as 13316 necessary. 13317 13318 This function does not have to worry about setting the reloc 13319 address or the reloc symbol index. 13320 13321 LOCAL_SYMS is a pointer to the swapped in local symbols. 13322 13323 LOCAL_SECTIONS is an array giving the section in the input file 13324 corresponding to the st_shndx field of each local symbol. 13325 13326 The global hash table entry for the global symbols can be found 13327 via elf_sym_hashes (input_bfd). 13328 13329 When generating relocatable output, this function must handle 13330 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 13331 going to be the section symbol corresponding to the output 13332 section, which means that the addend must be adjusted 13333 accordingly. */ 13334 13335static bfd_boolean 13336ppc64_elf_relocate_section (bfd *output_bfd, 13337 struct bfd_link_info *info, 13338 bfd *input_bfd, 13339 asection *input_section, 13340 bfd_byte *contents, 13341 Elf_Internal_Rela *relocs, 13342 Elf_Internal_Sym *local_syms, 13343 asection **local_sections) 13344{ 13345 struct ppc_link_hash_table *htab; 13346 Elf_Internal_Shdr *symtab_hdr; 13347 struct elf_link_hash_entry **sym_hashes; 13348 Elf_Internal_Rela *rel; 13349 Elf_Internal_Rela *wrel; 13350 Elf_Internal_Rela *relend; 13351 Elf_Internal_Rela outrel; 13352 bfd_byte *loc; 13353 struct got_entry **local_got_ents; 13354 bfd_vma TOCstart; 13355 bfd_boolean ret = TRUE; 13356 bfd_boolean is_opd; 13357 /* Assume 'at' branch hints. */ 13358 bfd_boolean is_isa_v2 = TRUE; 13359 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0); 13360 13361 /* Initialize howto table if needed. */ 13362 if (!ppc64_elf_howto_table[R_PPC64_ADDR32]) 13363 ppc_howto_init (); 13364 13365 htab = ppc_hash_table (info); 13366 if (htab == NULL) 13367 return FALSE; 13368 13369 /* Don't relocate stub sections. */ 13370 if (input_section->owner == htab->params->stub_bfd) 13371 return TRUE; 13372 13373 BFD_ASSERT (is_ppc64_elf (input_bfd)); 13374 13375 local_got_ents = elf_local_got_ents (input_bfd); 13376 TOCstart = elf_gp (output_bfd); 13377 symtab_hdr = &elf_symtab_hdr (input_bfd); 13378 sym_hashes = elf_sym_hashes (input_bfd); 13379 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd; 13380 13381 rel = wrel = relocs; 13382 relend = relocs + input_section->reloc_count; 13383 for (; rel < relend; wrel++, rel++) 13384 { 13385 enum elf_ppc64_reloc_type r_type; 13386 bfd_vma addend; 13387 bfd_reloc_status_type r; 13388 Elf_Internal_Sym *sym; 13389 asection *sec; 13390 struct elf_link_hash_entry *h_elf; 13391 struct ppc_link_hash_entry *h; 13392 struct ppc_link_hash_entry *fdh; 13393 const char *sym_name; 13394 unsigned long r_symndx, toc_symndx; 13395 bfd_vma toc_addend; 13396 unsigned char tls_mask, tls_gd, tls_type; 13397 unsigned char sym_type; 13398 bfd_vma relocation; 13399 bfd_boolean unresolved_reloc; 13400 bfd_boolean warned; 13401 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest; 13402 unsigned int insn; 13403 unsigned int mask; 13404 struct ppc_stub_hash_entry *stub_entry; 13405 bfd_vma max_br_offset; 13406 bfd_vma from; 13407 Elf_Internal_Rela orig_rel; 13408 reloc_howto_type *howto; 13409 struct reloc_howto_struct alt_howto; 13410 13411 again: 13412 orig_rel = *rel; 13413 13414 r_type = ELF64_R_TYPE (rel->r_info); 13415 r_symndx = ELF64_R_SYM (rel->r_info); 13416 13417 /* For old style R_PPC64_TOC relocs with a zero symbol, use the 13418 symbol of the previous ADDR64 reloc. The symbol gives us the 13419 proper TOC base to use. */ 13420 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC) 13421 && wrel != relocs 13422 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64 13423 && is_opd) 13424 r_symndx = ELF64_R_SYM (wrel[-1].r_info); 13425 13426 sym = NULL; 13427 sec = NULL; 13428 h_elf = NULL; 13429 sym_name = NULL; 13430 unresolved_reloc = FALSE; 13431 warned = FALSE; 13432 13433 if (r_symndx < symtab_hdr->sh_info) 13434 { 13435 /* It's a local symbol. */ 13436 struct _opd_sec_data *opd; 13437 13438 sym = local_syms + r_symndx; 13439 sec = local_sections[r_symndx]; 13440 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); 13441 sym_type = ELF64_ST_TYPE (sym->st_info); 13442 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 13443 opd = get_opd_info (sec); 13444 if (opd != NULL && opd->adjust != NULL) 13445 { 13446 long adjust = opd->adjust[OPD_NDX (sym->st_value 13447 + rel->r_addend)]; 13448 if (adjust == -1) 13449 relocation = 0; 13450 else 13451 { 13452 /* If this is a relocation against the opd section sym 13453 and we have edited .opd, adjust the reloc addend so 13454 that ld -r and ld --emit-relocs output is correct. 13455 If it is a reloc against some other .opd symbol, 13456 then the symbol value will be adjusted later. */ 13457 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 13458 rel->r_addend += adjust; 13459 else 13460 relocation += adjust; 13461 } 13462 } 13463 } 13464 else 13465 { 13466 bfd_boolean ignored; 13467 13468 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 13469 r_symndx, symtab_hdr, sym_hashes, 13470 h_elf, sec, relocation, 13471 unresolved_reloc, warned, ignored); 13472 sym_name = h_elf->root.root.string; 13473 sym_type = h_elf->type; 13474 if (sec != NULL 13475 && sec->owner == output_bfd 13476 && strcmp (sec->name, ".opd") == 0) 13477 { 13478 /* This is a symbol defined in a linker script. All 13479 such are defined in output sections, even those 13480 defined by simple assignment from a symbol defined in 13481 an input section. Transfer the symbol to an 13482 appropriate input .opd section, so that a branch to 13483 this symbol will be mapped to the location specified 13484 by the opd entry. */ 13485 struct bfd_link_order *lo; 13486 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next) 13487 if (lo->type == bfd_indirect_link_order) 13488 { 13489 asection *isec = lo->u.indirect.section; 13490 if (h_elf->root.u.def.value >= isec->output_offset 13491 && h_elf->root.u.def.value < (isec->output_offset 13492 + isec->size)) 13493 { 13494 h_elf->root.u.def.value -= isec->output_offset; 13495 h_elf->root.u.def.section = isec; 13496 sec = isec; 13497 break; 13498 } 13499 } 13500 } 13501 } 13502 h = (struct ppc_link_hash_entry *) h_elf; 13503 13504 if (sec != NULL && discarded_section (sec)) 13505 { 13506 _bfd_clear_contents (ppc64_elf_howto_table[r_type], 13507 input_bfd, input_section, 13508 contents + rel->r_offset); 13509 wrel->r_offset = rel->r_offset; 13510 wrel->r_info = 0; 13511 wrel->r_addend = 0; 13512 13513 /* For ld -r, remove relocations in debug sections against 13514 sections defined in discarded sections. Not done for 13515 non-debug to preserve relocs in .eh_frame which the 13516 eh_frame editing code expects to be present. */ 13517 if (bfd_link_relocatable (info) 13518 && (input_section->flags & SEC_DEBUGGING)) 13519 wrel--; 13520 13521 continue; 13522 } 13523 13524 if (bfd_link_relocatable (info)) 13525 goto copy_reloc; 13526 13527 if (h != NULL && &h->elf == htab->elf.hgot) 13528 { 13529 relocation = TOCstart + htab->sec_info[input_section->id].toc_off; 13530 sec = bfd_abs_section_ptr; 13531 unresolved_reloc = FALSE; 13532 } 13533 13534 /* TLS optimizations. Replace instruction sequences and relocs 13535 based on information we collected in tls_optimize. We edit 13536 RELOCS so that --emit-relocs will output something sensible 13537 for the final instruction stream. */ 13538 tls_mask = 0; 13539 tls_gd = 0; 13540 toc_symndx = 0; 13541 if (h != NULL) 13542 tls_mask = h->tls_mask; 13543 else if (local_got_ents != NULL) 13544 { 13545 struct plt_entry **local_plt = (struct plt_entry **) 13546 (local_got_ents + symtab_hdr->sh_info); 13547 unsigned char *lgot_masks = (unsigned char *) 13548 (local_plt + symtab_hdr->sh_info); 13549 tls_mask = lgot_masks[r_symndx]; 13550 } 13551 if (tls_mask == 0 13552 && (r_type == R_PPC64_TLS 13553 || r_type == R_PPC64_TLSGD 13554 || r_type == R_PPC64_TLSLD)) 13555 { 13556 /* Check for toc tls entries. */ 13557 unsigned char *toc_tls; 13558 13559 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend, 13560 &local_syms, rel, input_bfd)) 13561 return FALSE; 13562 13563 if (toc_tls) 13564 tls_mask = *toc_tls; 13565 } 13566 13567 /* Check that tls relocs are used with tls syms, and non-tls 13568 relocs are used with non-tls syms. */ 13569 if (r_symndx != STN_UNDEF 13570 && r_type != R_PPC64_NONE 13571 && (h == NULL 13572 || h->elf.root.type == bfd_link_hash_defined 13573 || h->elf.root.type == bfd_link_hash_defweak) 13574 && (IS_PPC64_TLS_RELOC (r_type) 13575 != (sym_type == STT_TLS 13576 || (sym_type == STT_SECTION 13577 && (sec->flags & SEC_THREAD_LOCAL) != 0)))) 13578 { 13579 if (tls_mask != 0 13580 && (r_type == R_PPC64_TLS 13581 || r_type == R_PPC64_TLSGD 13582 || r_type == R_PPC64_TLSLD)) 13583 /* R_PPC64_TLS is OK against a symbol in the TOC. */ 13584 ; 13585 else 13586 info->callbacks->einfo 13587 (!IS_PPC64_TLS_RELOC (r_type) 13588 /* xgettext:c-format */ 13589 ? _("%P: %H: %s used with TLS symbol `%T'\n") 13590 /* xgettext:c-format */ 13591 : _("%P: %H: %s used with non-TLS symbol `%T'\n"), 13592 input_bfd, input_section, rel->r_offset, 13593 ppc64_elf_howto_table[r_type]->name, 13594 sym_name); 13595 } 13596 13597 /* Ensure reloc mapping code below stays sane. */ 13598 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1 13599 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1 13600 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3) 13601 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3) 13602 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3) 13603 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3) 13604 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3) 13605 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3) 13606 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3) 13607 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3)) 13608 abort (); 13609 13610 switch (r_type) 13611 { 13612 default: 13613 break; 13614 13615 case R_PPC64_LO_DS_OPT: 13616 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset); 13617 if ((insn & (0x3f << 26)) != 58u << 26) 13618 abort (); 13619 insn += (14u << 26) - (58u << 26); 13620 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset); 13621 r_type = R_PPC64_TOC16_LO; 13622 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13623 break; 13624 13625 case R_PPC64_TOC16: 13626 case R_PPC64_TOC16_LO: 13627 case R_PPC64_TOC16_DS: 13628 case R_PPC64_TOC16_LO_DS: 13629 { 13630 /* Check for toc tls entries. */ 13631 unsigned char *toc_tls; 13632 int retval; 13633 13634 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend, 13635 &local_syms, rel, input_bfd); 13636 if (retval == 0) 13637 return FALSE; 13638 13639 if (toc_tls) 13640 { 13641 tls_mask = *toc_tls; 13642 if (r_type == R_PPC64_TOC16_DS 13643 || r_type == R_PPC64_TOC16_LO_DS) 13644 { 13645 if (tls_mask != 0 13646 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0) 13647 goto toctprel; 13648 } 13649 else 13650 { 13651 /* If we found a GD reloc pair, then we might be 13652 doing a GD->IE transition. */ 13653 if (retval == 2) 13654 { 13655 tls_gd = TLS_TPRELGD; 13656 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 13657 goto tls_ldgd_opt; 13658 } 13659 else if (retval == 3) 13660 { 13661 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 13662 goto tls_ldgd_opt; 13663 } 13664 } 13665 } 13666 } 13667 break; 13668 13669 case R_PPC64_GOT_TPREL16_HI: 13670 case R_PPC64_GOT_TPREL16_HA: 13671 if (tls_mask != 0 13672 && (tls_mask & TLS_TPREL) == 0) 13673 { 13674 rel->r_offset -= d_offset; 13675 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset); 13676 r_type = R_PPC64_NONE; 13677 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13678 } 13679 break; 13680 13681 case R_PPC64_GOT_TPREL16_DS: 13682 case R_PPC64_GOT_TPREL16_LO_DS: 13683 if (tls_mask != 0 13684 && (tls_mask & TLS_TPREL) == 0) 13685 { 13686 toctprel: 13687 insn = bfd_get_32 (input_bfd, 13688 contents + rel->r_offset - d_offset); 13689 insn &= 31 << 21; 13690 insn |= 0x3c0d0000; /* addis 0,13,0 */ 13691 bfd_put_32 (input_bfd, insn, 13692 contents + rel->r_offset - d_offset); 13693 r_type = R_PPC64_TPREL16_HA; 13694 if (toc_symndx != 0) 13695 { 13696 rel->r_info = ELF64_R_INFO (toc_symndx, r_type); 13697 rel->r_addend = toc_addend; 13698 /* We changed the symbol. Start over in order to 13699 get h, sym, sec etc. right. */ 13700 goto again; 13701 } 13702 else 13703 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13704 } 13705 break; 13706 13707 case R_PPC64_TLS: 13708 if (tls_mask != 0 13709 && (tls_mask & TLS_TPREL) == 0) 13710 { 13711 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 13712 insn = _bfd_elf_ppc_at_tls_transform (insn, 13); 13713 if (insn == 0) 13714 abort (); 13715 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 13716 /* Was PPC64_TLS which sits on insn boundary, now 13717 PPC64_TPREL16_LO which is at low-order half-word. */ 13718 rel->r_offset += d_offset; 13719 r_type = R_PPC64_TPREL16_LO; 13720 if (toc_symndx != 0) 13721 { 13722 rel->r_info = ELF64_R_INFO (toc_symndx, r_type); 13723 rel->r_addend = toc_addend; 13724 /* We changed the symbol. Start over in order to 13725 get h, sym, sec etc. right. */ 13726 goto again; 13727 } 13728 else 13729 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13730 } 13731 break; 13732 13733 case R_PPC64_GOT_TLSGD16_HI: 13734 case R_PPC64_GOT_TLSGD16_HA: 13735 tls_gd = TLS_TPRELGD; 13736 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 13737 goto tls_gdld_hi; 13738 break; 13739 13740 case R_PPC64_GOT_TLSLD16_HI: 13741 case R_PPC64_GOT_TLSLD16_HA: 13742 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 13743 { 13744 tls_gdld_hi: 13745 if ((tls_mask & tls_gd) != 0) 13746 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3) 13747 + R_PPC64_GOT_TPREL16_DS); 13748 else 13749 { 13750 rel->r_offset -= d_offset; 13751 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset); 13752 r_type = R_PPC64_NONE; 13753 } 13754 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13755 } 13756 break; 13757 13758 case R_PPC64_GOT_TLSGD16: 13759 case R_PPC64_GOT_TLSGD16_LO: 13760 tls_gd = TLS_TPRELGD; 13761 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 13762 goto tls_ldgd_opt; 13763 break; 13764 13765 case R_PPC64_GOT_TLSLD16: 13766 case R_PPC64_GOT_TLSLD16_LO: 13767 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 13768 { 13769 unsigned int insn1, insn2, insn3; 13770 bfd_vma offset; 13771 13772 tls_ldgd_opt: 13773 offset = (bfd_vma) -1; 13774 /* If not using the newer R_PPC64_TLSGD/LD to mark 13775 __tls_get_addr calls, we must trust that the call 13776 stays with its arg setup insns, ie. that the next 13777 reloc is the __tls_get_addr call associated with 13778 the current reloc. Edit both insns. */ 13779 if (input_section->has_tls_get_addr_call 13780 && rel + 1 < relend 13781 && branch_reloc_hash_match (input_bfd, rel + 1, 13782 htab->tls_get_addr, 13783 htab->tls_get_addr_fd)) 13784 offset = rel[1].r_offset; 13785 /* We read the low GOT_TLS (or TOC16) insn because we 13786 need to keep the destination reg. It may be 13787 something other than the usual r3, and moved to r3 13788 before the call by intervening code. */ 13789 insn1 = bfd_get_32 (input_bfd, 13790 contents + rel->r_offset - d_offset); 13791 if ((tls_mask & tls_gd) != 0) 13792 { 13793 /* IE */ 13794 insn1 &= (0x1f << 21) | (0x1f << 16); 13795 insn1 |= 58 << 26; /* ld */ 13796 insn2 = 0x7c636a14; /* add 3,3,13 */ 13797 if (offset != (bfd_vma) -1) 13798 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE); 13799 if ((tls_mask & TLS_EXPLICIT) == 0) 13800 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3) 13801 + R_PPC64_GOT_TPREL16_DS); 13802 else 13803 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16; 13804 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13805 } 13806 else 13807 { 13808 /* LE */ 13809 insn1 &= 0x1f << 21; 13810 insn1 |= 0x3c0d0000; /* addis r,13,0 */ 13811 insn2 = 0x38630000; /* addi 3,3,0 */ 13812 if (tls_gd == 0) 13813 { 13814 /* Was an LD reloc. */ 13815 if (toc_symndx) 13816 sec = local_sections[toc_symndx]; 13817 for (r_symndx = 0; 13818 r_symndx < symtab_hdr->sh_info; 13819 r_symndx++) 13820 if (local_sections[r_symndx] == sec) 13821 break; 13822 if (r_symndx >= symtab_hdr->sh_info) 13823 r_symndx = STN_UNDEF; 13824 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 13825 if (r_symndx != STN_UNDEF) 13826 rel->r_addend -= (local_syms[r_symndx].st_value 13827 + sec->output_offset 13828 + sec->output_section->vma); 13829 } 13830 else if (toc_symndx != 0) 13831 { 13832 r_symndx = toc_symndx; 13833 rel->r_addend = toc_addend; 13834 } 13835 r_type = R_PPC64_TPREL16_HA; 13836 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13837 if (offset != (bfd_vma) -1) 13838 { 13839 rel[1].r_info = ELF64_R_INFO (r_symndx, 13840 R_PPC64_TPREL16_LO); 13841 rel[1].r_offset = offset + d_offset; 13842 rel[1].r_addend = rel->r_addend; 13843 } 13844 } 13845 bfd_put_32 (input_bfd, insn1, 13846 contents + rel->r_offset - d_offset); 13847 if (offset != (bfd_vma) -1) 13848 { 13849 insn3 = bfd_get_32 (input_bfd, 13850 contents + offset + 4); 13851 if (insn3 == NOP 13852 || insn3 == CROR_151515 || insn3 == CROR_313131) 13853 { 13854 rel[1].r_offset += 4; 13855 bfd_put_32 (input_bfd, insn2, contents + offset + 4); 13856 insn2 = NOP; 13857 } 13858 bfd_put_32 (input_bfd, insn2, contents + offset); 13859 } 13860 if ((tls_mask & tls_gd) == 0 13861 && (tls_gd == 0 || toc_symndx != 0)) 13862 { 13863 /* We changed the symbol. Start over in order 13864 to get h, sym, sec etc. right. */ 13865 goto again; 13866 } 13867 } 13868 break; 13869 13870 case R_PPC64_TLSGD: 13871 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 13872 { 13873 unsigned int insn2, insn3; 13874 bfd_vma offset = rel->r_offset; 13875 13876 if ((tls_mask & TLS_TPRELGD) != 0) 13877 { 13878 /* IE */ 13879 r_type = R_PPC64_NONE; 13880 insn2 = 0x7c636a14; /* add 3,3,13 */ 13881 } 13882 else 13883 { 13884 /* LE */ 13885 if (toc_symndx != 0) 13886 { 13887 r_symndx = toc_symndx; 13888 rel->r_addend = toc_addend; 13889 } 13890 r_type = R_PPC64_TPREL16_LO; 13891 rel->r_offset = offset + d_offset; 13892 insn2 = 0x38630000; /* addi 3,3,0 */ 13893 } 13894 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13895 /* Zap the reloc on the _tls_get_addr call too. */ 13896 BFD_ASSERT (offset == rel[1].r_offset); 13897 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE); 13898 insn3 = bfd_get_32 (input_bfd, 13899 contents + offset + 4); 13900 if (insn3 == NOP 13901 || insn3 == CROR_151515 || insn3 == CROR_313131) 13902 { 13903 rel->r_offset += 4; 13904 bfd_put_32 (input_bfd, insn2, contents + offset + 4); 13905 insn2 = NOP; 13906 } 13907 bfd_put_32 (input_bfd, insn2, contents + offset); 13908 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0) 13909 goto again; 13910 } 13911 break; 13912 13913 case R_PPC64_TLSLD: 13914 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 13915 { 13916 unsigned int insn2, insn3; 13917 bfd_vma offset = rel->r_offset; 13918 13919 if (toc_symndx) 13920 sec = local_sections[toc_symndx]; 13921 for (r_symndx = 0; 13922 r_symndx < symtab_hdr->sh_info; 13923 r_symndx++) 13924 if (local_sections[r_symndx] == sec) 13925 break; 13926 if (r_symndx >= symtab_hdr->sh_info) 13927 r_symndx = STN_UNDEF; 13928 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 13929 if (r_symndx != STN_UNDEF) 13930 rel->r_addend -= (local_syms[r_symndx].st_value 13931 + sec->output_offset 13932 + sec->output_section->vma); 13933 13934 r_type = R_PPC64_TPREL16_LO; 13935 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13936 rel->r_offset = offset + d_offset; 13937 /* Zap the reloc on the _tls_get_addr call too. */ 13938 BFD_ASSERT (offset == rel[1].r_offset); 13939 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE); 13940 insn2 = 0x38630000; /* addi 3,3,0 */ 13941 insn3 = bfd_get_32 (input_bfd, 13942 contents + offset + 4); 13943 if (insn3 == NOP 13944 || insn3 == CROR_151515 || insn3 == CROR_313131) 13945 { 13946 rel->r_offset += 4; 13947 bfd_put_32 (input_bfd, insn2, contents + offset + 4); 13948 insn2 = NOP; 13949 } 13950 bfd_put_32 (input_bfd, insn2, contents + offset); 13951 goto again; 13952 } 13953 break; 13954 13955 case R_PPC64_DTPMOD64: 13956 if (rel + 1 < relend 13957 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64) 13958 && rel[1].r_offset == rel->r_offset + 8) 13959 { 13960 if ((tls_mask & TLS_GD) == 0) 13961 { 13962 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE); 13963 if ((tls_mask & TLS_TPRELGD) != 0) 13964 r_type = R_PPC64_TPREL64; 13965 else 13966 { 13967 bfd_put_64 (output_bfd, 1, contents + rel->r_offset); 13968 r_type = R_PPC64_NONE; 13969 } 13970 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13971 } 13972 } 13973 else 13974 { 13975 if ((tls_mask & TLS_LD) == 0) 13976 { 13977 bfd_put_64 (output_bfd, 1, contents + rel->r_offset); 13978 r_type = R_PPC64_NONE; 13979 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13980 } 13981 } 13982 break; 13983 13984 case R_PPC64_TPREL64: 13985 if ((tls_mask & TLS_TPREL) == 0) 13986 { 13987 r_type = R_PPC64_NONE; 13988 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 13989 } 13990 break; 13991 13992 case R_PPC64_ENTRY: 13993 relocation = TOCstart + htab->sec_info[input_section->id].toc_off; 13994 if (!bfd_link_pic (info) 13995 && !info->traditional_format 13996 && relocation + 0x80008000 <= 0xffffffff) 13997 { 13998 unsigned int insn1, insn2; 13999 14000 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset); 14001 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 14002 if ((insn1 & ~0xfffc) == LD_R2_0R12 14003 && insn2 == ADD_R2_R2_R12) 14004 { 14005 bfd_put_32 (input_bfd, 14006 LIS_R2 + PPC_HA (relocation), 14007 contents + rel->r_offset); 14008 bfd_put_32 (input_bfd, 14009 ADDI_R2_R2 + PPC_LO (relocation), 14010 contents + rel->r_offset + 4); 14011 } 14012 } 14013 else 14014 { 14015 relocation -= (rel->r_offset 14016 + input_section->output_offset 14017 + input_section->output_section->vma); 14018 if (relocation + 0x80008000 <= 0xffffffff) 14019 { 14020 unsigned int insn1, insn2; 14021 14022 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset); 14023 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 14024 if ((insn1 & ~0xfffc) == LD_R2_0R12 14025 && insn2 == ADD_R2_R2_R12) 14026 { 14027 bfd_put_32 (input_bfd, 14028 ADDIS_R2_R12 + PPC_HA (relocation), 14029 contents + rel->r_offset); 14030 bfd_put_32 (input_bfd, 14031 ADDI_R2_R2 + PPC_LO (relocation), 14032 contents + rel->r_offset + 4); 14033 } 14034 } 14035 } 14036 break; 14037 14038 case R_PPC64_REL16_HA: 14039 /* If we are generating a non-PIC executable, edit 14040 . 0: addis 2,12,.TOC.-0b@ha 14041 . addi 2,2,.TOC.-0b@l 14042 used by ELFv2 global entry points to set up r2, to 14043 . lis 2,.TOC.@ha 14044 . addi 2,2,.TOC.@l 14045 if .TOC. is in range. */ 14046 if (!bfd_link_pic (info) 14047 && !info->traditional_format 14048 && !htab->opd_abi 14049 && rel->r_addend == d_offset 14050 && h != NULL && &h->elf == htab->elf.hgot 14051 && rel + 1 < relend 14052 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO) 14053 && rel[1].r_offset == rel->r_offset + 4 14054 && rel[1].r_addend == rel->r_addend + 4 14055 && relocation + 0x80008000 <= 0xffffffff) 14056 { 14057 unsigned int insn1, insn2; 14058 bfd_vma offset = rel->r_offset - d_offset; 14059 insn1 = bfd_get_32 (input_bfd, contents + offset); 14060 insn2 = bfd_get_32 (input_bfd, contents + offset + 4); 14061 if ((insn1 & 0xffff0000) == ADDIS_R2_R12 14062 && (insn2 & 0xffff0000) == ADDI_R2_R2) 14063 { 14064 r_type = R_PPC64_ADDR16_HA; 14065 rel->r_info = ELF64_R_INFO (r_symndx, r_type); 14066 rel->r_addend -= d_offset; 14067 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO); 14068 rel[1].r_addend -= d_offset + 4; 14069 bfd_put_32 (input_bfd, LIS_R2, contents + offset); 14070 } 14071 } 14072 break; 14073 } 14074 14075 /* Handle other relocations that tweak non-addend part of insn. */ 14076 insn = 0; 14077 max_br_offset = 1 << 25; 14078 addend = rel->r_addend; 14079 reloc_dest = DEST_NORMAL; 14080 switch (r_type) 14081 { 14082 default: 14083 break; 14084 14085 case R_PPC64_TOCSAVE: 14086 if (relocation + addend == (rel->r_offset 14087 + input_section->output_offset 14088 + input_section->output_section->vma) 14089 && tocsave_find (htab, NO_INSERT, 14090 &local_syms, rel, input_bfd)) 14091 { 14092 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 14093 if (insn == NOP 14094 || insn == CROR_151515 || insn == CROR_313131) 14095 bfd_put_32 (input_bfd, 14096 STD_R2_0R1 + STK_TOC (htab), 14097 contents + rel->r_offset); 14098 } 14099 break; 14100 14101 /* Branch taken prediction relocations. */ 14102 case R_PPC64_ADDR14_BRTAKEN: 14103 case R_PPC64_REL14_BRTAKEN: 14104 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */ 14105 /* Fall through. */ 14106 14107 /* Branch not taken prediction relocations. */ 14108 case R_PPC64_ADDR14_BRNTAKEN: 14109 case R_PPC64_REL14_BRNTAKEN: 14110 insn |= bfd_get_32 (input_bfd, 14111 contents + rel->r_offset) & ~(0x01 << 21); 14112 /* Fall through. */ 14113 14114 case R_PPC64_REL14: 14115 max_br_offset = 1 << 15; 14116 /* Fall through. */ 14117 14118 case R_PPC64_REL24: 14119 /* Calls to functions with a different TOC, such as calls to 14120 shared objects, need to alter the TOC pointer. This is 14121 done using a linkage stub. A REL24 branching to these 14122 linkage stubs needs to be followed by a nop, as the nop 14123 will be replaced with an instruction to restore the TOC 14124 base pointer. */ 14125 fdh = h; 14126 if (h != NULL 14127 && h->oh != NULL 14128 && h->oh->is_func_descriptor) 14129 fdh = ppc_follow_link (h->oh); 14130 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel, 14131 htab); 14132 if (stub_entry != NULL 14133 && (stub_entry->stub_type == ppc_stub_plt_call 14134 || stub_entry->stub_type == ppc_stub_plt_call_r2save 14135 || stub_entry->stub_type == ppc_stub_plt_branch_r2off 14136 || stub_entry->stub_type == ppc_stub_long_branch_r2off)) 14137 { 14138 bfd_boolean can_plt_call = FALSE; 14139 14140 /* All of these stubs will modify r2, so there must be a 14141 branch and link followed by a nop. The nop is 14142 replaced by an insn to restore r2. */ 14143 if (rel->r_offset + 8 <= input_section->size) 14144 { 14145 unsigned long br; 14146 14147 br = bfd_get_32 (input_bfd, 14148 contents + rel->r_offset); 14149 if ((br & 1) != 0) 14150 { 14151 unsigned long nop; 14152 14153 nop = bfd_get_32 (input_bfd, 14154 contents + rel->r_offset + 4); 14155 if (nop == NOP 14156 || nop == CROR_151515 || nop == CROR_313131) 14157 { 14158 if (h != NULL 14159 && (h == htab->tls_get_addr_fd 14160 || h == htab->tls_get_addr) 14161 && htab->params->tls_get_addr_opt) 14162 { 14163 /* Special stub used, leave nop alone. */ 14164 } 14165 else 14166 bfd_put_32 (input_bfd, 14167 LD_R2_0R1 + STK_TOC (htab), 14168 contents + rel->r_offset + 4); 14169 can_plt_call = TRUE; 14170 } 14171 } 14172 } 14173 14174 if (!can_plt_call && h != NULL) 14175 { 14176 const char *name = h->elf.root.root.string; 14177 14178 if (*name == '.') 14179 ++name; 14180 14181 if (strncmp (name, "__libc_start_main", 17) == 0 14182 && (name[17] == 0 || name[17] == '@')) 14183 { 14184 /* Allow crt1 branch to go via a toc adjusting 14185 stub. Other calls that never return could do 14186 the same, if we could detect such. */ 14187 can_plt_call = TRUE; 14188 } 14189 } 14190 14191 if (!can_plt_call) 14192 { 14193 /* g++ as of 20130507 emits self-calls without a 14194 following nop. This is arguably wrong since we 14195 have conflicting information. On the one hand a 14196 global symbol and on the other a local call 14197 sequence, but don't error for this special case. 14198 It isn't possible to cheaply verify we have 14199 exactly such a call. Allow all calls to the same 14200 section. */ 14201 asection *code_sec = sec; 14202 14203 if (get_opd_info (sec) != NULL) 14204 { 14205 bfd_vma off = (relocation + addend 14206 - sec->output_section->vma 14207 - sec->output_offset); 14208 14209 opd_entry_value (sec, off, &code_sec, NULL, FALSE); 14210 } 14211 if (code_sec == input_section) 14212 can_plt_call = TRUE; 14213 } 14214 14215 if (!can_plt_call) 14216 { 14217 if (stub_entry->stub_type == ppc_stub_plt_call 14218 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 14219 info->callbacks->einfo 14220 /* xgettext:c-format */ 14221 (_("%P: %H: call to `%T' lacks nop, can't restore toc; " 14222 "recompile with -fPIC\n"), 14223 input_bfd, input_section, rel->r_offset, sym_name); 14224 else 14225 info->callbacks->einfo 14226 /* xgettext:c-format */ 14227 (_("%P: %H: call to `%T' lacks nop, can't restore toc; " 14228 "(-mcmodel=small toc adjust stub)\n"), 14229 input_bfd, input_section, rel->r_offset, sym_name); 14230 14231 bfd_set_error (bfd_error_bad_value); 14232 ret = FALSE; 14233 } 14234 14235 if (can_plt_call 14236 && (stub_entry->stub_type == ppc_stub_plt_call 14237 || stub_entry->stub_type == ppc_stub_plt_call_r2save)) 14238 unresolved_reloc = FALSE; 14239 } 14240 14241 if ((stub_entry == NULL 14242 || stub_entry->stub_type == ppc_stub_long_branch 14243 || stub_entry->stub_type == ppc_stub_plt_branch) 14244 && get_opd_info (sec) != NULL) 14245 { 14246 /* The branch destination is the value of the opd entry. */ 14247 bfd_vma off = (relocation + addend 14248 - sec->output_section->vma 14249 - sec->output_offset); 14250 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE); 14251 if (dest != (bfd_vma) -1) 14252 { 14253 relocation = dest; 14254 addend = 0; 14255 reloc_dest = DEST_OPD; 14256 } 14257 } 14258 14259 /* If the branch is out of reach we ought to have a long 14260 branch stub. */ 14261 from = (rel->r_offset 14262 + input_section->output_offset 14263 + input_section->output_section->vma); 14264 14265 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh 14266 ? fdh->elf.other 14267 : sym->st_other); 14268 14269 if (stub_entry != NULL 14270 && (stub_entry->stub_type == ppc_stub_long_branch 14271 || stub_entry->stub_type == ppc_stub_plt_branch) 14272 && (r_type == R_PPC64_ADDR14_BRTAKEN 14273 || r_type == R_PPC64_ADDR14_BRNTAKEN 14274 || (relocation + addend - from + max_br_offset 14275 < 2 * max_br_offset))) 14276 /* Don't use the stub if this branch is in range. */ 14277 stub_entry = NULL; 14278 14279 if (stub_entry != NULL) 14280 { 14281 /* Munge up the value and addend so that we call the stub 14282 rather than the procedure directly. */ 14283 asection *stub_sec = stub_entry->group->stub_sec; 14284 14285 if (stub_entry->stub_type == ppc_stub_save_res) 14286 relocation += (stub_sec->output_offset 14287 + stub_sec->output_section->vma 14288 + stub_sec->size - htab->sfpr->size 14289 - htab->sfpr->output_offset 14290 - htab->sfpr->output_section->vma); 14291 else 14292 relocation = (stub_entry->stub_offset 14293 + stub_sec->output_offset 14294 + stub_sec->output_section->vma); 14295 addend = 0; 14296 reloc_dest = DEST_STUB; 14297 14298 if ((stub_entry->stub_type == ppc_stub_plt_call 14299 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 14300 && (ALWAYS_EMIT_R2SAVE 14301 || stub_entry->stub_type == ppc_stub_plt_call_r2save) 14302 && rel + 1 < relend 14303 && rel[1].r_offset == rel->r_offset + 4 14304 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE) 14305 relocation += 4; 14306 } 14307 14308 if (insn != 0) 14309 { 14310 if (is_isa_v2) 14311 { 14312 /* Set 'a' bit. This is 0b00010 in BO field for branch 14313 on CR(BI) insns (BO == 001at or 011at), and 0b01000 14314 for branch on CTR insns (BO == 1a00t or 1a01t). */ 14315 if ((insn & (0x14 << 21)) == (0x04 << 21)) 14316 insn |= 0x02 << 21; 14317 else if ((insn & (0x14 << 21)) == (0x10 << 21)) 14318 insn |= 0x08 << 21; 14319 else 14320 break; 14321 } 14322 else 14323 { 14324 /* Invert 'y' bit if not the default. */ 14325 if ((bfd_signed_vma) (relocation + addend - from) < 0) 14326 insn ^= 0x01 << 21; 14327 } 14328 14329 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 14330 } 14331 14332 /* NOP out calls to undefined weak functions. 14333 We can thus call a weak function without first 14334 checking whether the function is defined. */ 14335 else if (h != NULL 14336 && h->elf.root.type == bfd_link_hash_undefweak 14337 && h->elf.dynindx == -1 14338 && r_type == R_PPC64_REL24 14339 && relocation == 0 14340 && addend == 0) 14341 { 14342 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset); 14343 goto copy_reloc; 14344 } 14345 break; 14346 } 14347 14348 /* Set `addend'. */ 14349 tls_type = 0; 14350 switch (r_type) 14351 { 14352 default: 14353 info->callbacks->einfo 14354 /* xgettext:c-format */ 14355 (_("%P: %B: unknown relocation type %d for `%T'\n"), 14356 input_bfd, (int) r_type, sym_name); 14357 14358 bfd_set_error (bfd_error_bad_value); 14359 ret = FALSE; 14360 goto copy_reloc; 14361 14362 case R_PPC64_NONE: 14363 case R_PPC64_TLS: 14364 case R_PPC64_TLSGD: 14365 case R_PPC64_TLSLD: 14366 case R_PPC64_TOCSAVE: 14367 case R_PPC64_GNU_VTINHERIT: 14368 case R_PPC64_GNU_VTENTRY: 14369 case R_PPC64_ENTRY: 14370 goto copy_reloc; 14371 14372 /* GOT16 relocations. Like an ADDR16 using the symbol's 14373 address in the GOT as relocation value instead of the 14374 symbol's value itself. Also, create a GOT entry for the 14375 symbol and put the symbol value there. */ 14376 case R_PPC64_GOT_TLSGD16: 14377 case R_PPC64_GOT_TLSGD16_LO: 14378 case R_PPC64_GOT_TLSGD16_HI: 14379 case R_PPC64_GOT_TLSGD16_HA: 14380 tls_type = TLS_TLS | TLS_GD; 14381 goto dogot; 14382 14383 case R_PPC64_GOT_TLSLD16: 14384 case R_PPC64_GOT_TLSLD16_LO: 14385 case R_PPC64_GOT_TLSLD16_HI: 14386 case R_PPC64_GOT_TLSLD16_HA: 14387 tls_type = TLS_TLS | TLS_LD; 14388 goto dogot; 14389 14390 case R_PPC64_GOT_TPREL16_DS: 14391 case R_PPC64_GOT_TPREL16_LO_DS: 14392 case R_PPC64_GOT_TPREL16_HI: 14393 case R_PPC64_GOT_TPREL16_HA: 14394 tls_type = TLS_TLS | TLS_TPREL; 14395 goto dogot; 14396 14397 case R_PPC64_GOT_DTPREL16_DS: 14398 case R_PPC64_GOT_DTPREL16_LO_DS: 14399 case R_PPC64_GOT_DTPREL16_HI: 14400 case R_PPC64_GOT_DTPREL16_HA: 14401 tls_type = TLS_TLS | TLS_DTPREL; 14402 goto dogot; 14403 14404 case R_PPC64_GOT16: 14405 case R_PPC64_GOT16_LO: 14406 case R_PPC64_GOT16_HI: 14407 case R_PPC64_GOT16_HA: 14408 case R_PPC64_GOT16_DS: 14409 case R_PPC64_GOT16_LO_DS: 14410 dogot: 14411 { 14412 /* Relocation is to the entry for this symbol in the global 14413 offset table. */ 14414 asection *got; 14415 bfd_vma *offp; 14416 bfd_vma off; 14417 unsigned long indx = 0; 14418 struct got_entry *ent; 14419 14420 if (tls_type == (TLS_TLS | TLS_LD) 14421 && (h == NULL 14422 || !h->elf.def_dynamic)) 14423 ent = ppc64_tlsld_got (input_bfd); 14424 else 14425 { 14426 14427 if (h != NULL) 14428 { 14429 bfd_boolean dyn = htab->elf.dynamic_sections_created; 14430 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), 14431 &h->elf) 14432 || (bfd_link_pic (info) 14433 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))) 14434 /* This is actually a static link, or it is a 14435 -Bsymbolic link and the symbol is defined 14436 locally, or the symbol was forced to be local 14437 because of a version file. */ 14438 ; 14439 else 14440 { 14441 BFD_ASSERT (h->elf.dynindx != -1); 14442 indx = h->elf.dynindx; 14443 unresolved_reloc = FALSE; 14444 } 14445 ent = h->elf.got.glist; 14446 } 14447 else 14448 { 14449 if (local_got_ents == NULL) 14450 abort (); 14451 ent = local_got_ents[r_symndx]; 14452 } 14453 14454 for (; ent != NULL; ent = ent->next) 14455 if (ent->addend == orig_rel.r_addend 14456 && ent->owner == input_bfd 14457 && ent->tls_type == tls_type) 14458 break; 14459 } 14460 14461 if (ent == NULL) 14462 abort (); 14463 if (ent->is_indirect) 14464 ent = ent->got.ent; 14465 offp = &ent->got.offset; 14466 got = ppc64_elf_tdata (ent->owner)->got; 14467 if (got == NULL) 14468 abort (); 14469 14470 /* The offset must always be a multiple of 8. We use the 14471 least significant bit to record whether we have already 14472 processed this entry. */ 14473 off = *offp; 14474 if ((off & 1) != 0) 14475 off &= ~1; 14476 else 14477 { 14478 /* Generate relocs for the dynamic linker, except in 14479 the case of TLSLD where we'll use one entry per 14480 module. */ 14481 asection *relgot; 14482 bfd_boolean ifunc; 14483 14484 *offp = off | 1; 14485 relgot = NULL; 14486 ifunc = (h != NULL 14487 ? h->elf.type == STT_GNU_IFUNC 14488 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC); 14489 if (ifunc) 14490 relgot = htab->elf.irelplt; 14491 else if ((bfd_link_pic (info) || indx != 0) 14492 && (h == NULL 14493 || (tls_type == (TLS_TLS | TLS_LD) 14494 && !h->elf.def_dynamic) 14495 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT 14496 || h->elf.root.type != bfd_link_hash_undefweak)) 14497 relgot = ppc64_elf_tdata (ent->owner)->relgot; 14498 if (relgot != NULL) 14499 { 14500 outrel.r_offset = (got->output_section->vma 14501 + got->output_offset 14502 + off); 14503 outrel.r_addend = addend; 14504 if (tls_type & (TLS_LD | TLS_GD)) 14505 { 14506 outrel.r_addend = 0; 14507 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64); 14508 if (tls_type == (TLS_TLS | TLS_GD)) 14509 { 14510 loc = relgot->contents; 14511 loc += (relgot->reloc_count++ 14512 * sizeof (Elf64_External_Rela)); 14513 bfd_elf64_swap_reloca_out (output_bfd, 14514 &outrel, loc); 14515 outrel.r_offset += 8; 14516 outrel.r_addend = addend; 14517 outrel.r_info 14518 = ELF64_R_INFO (indx, R_PPC64_DTPREL64); 14519 } 14520 } 14521 else if (tls_type == (TLS_TLS | TLS_DTPREL)) 14522 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64); 14523 else if (tls_type == (TLS_TLS | TLS_TPREL)) 14524 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64); 14525 else if (indx != 0) 14526 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT); 14527 else 14528 { 14529 if (ifunc) 14530 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE); 14531 else 14532 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 14533 14534 /* Write the .got section contents for the sake 14535 of prelink. */ 14536 loc = got->contents + off; 14537 bfd_put_64 (output_bfd, outrel.r_addend + relocation, 14538 loc); 14539 } 14540 14541 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD)) 14542 { 14543 outrel.r_addend += relocation; 14544 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL)) 14545 { 14546 if (htab->elf.tls_sec == NULL) 14547 outrel.r_addend = 0; 14548 else 14549 outrel.r_addend -= htab->elf.tls_sec->vma; 14550 } 14551 } 14552 loc = relgot->contents; 14553 loc += (relgot->reloc_count++ 14554 * sizeof (Elf64_External_Rela)); 14555 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 14556 } 14557 14558 /* Init the .got section contents here if we're not 14559 emitting a reloc. */ 14560 else 14561 { 14562 relocation += addend; 14563 if (tls_type == (TLS_TLS | TLS_LD)) 14564 relocation = 1; 14565 else if (tls_type != 0) 14566 { 14567 if (htab->elf.tls_sec == NULL) 14568 relocation = 0; 14569 else 14570 { 14571 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET; 14572 if (tls_type == (TLS_TLS | TLS_TPREL)) 14573 relocation += DTP_OFFSET - TP_OFFSET; 14574 } 14575 14576 if (tls_type == (TLS_TLS | TLS_GD)) 14577 { 14578 bfd_put_64 (output_bfd, relocation, 14579 got->contents + off + 8); 14580 relocation = 1; 14581 } 14582 } 14583 14584 bfd_put_64 (output_bfd, relocation, 14585 got->contents + off); 14586 } 14587 } 14588 14589 if (off >= (bfd_vma) -2) 14590 abort (); 14591 14592 relocation = got->output_section->vma + got->output_offset + off; 14593 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off); 14594 } 14595 break; 14596 14597 case R_PPC64_PLT16_HA: 14598 case R_PPC64_PLT16_HI: 14599 case R_PPC64_PLT16_LO: 14600 case R_PPC64_PLT32: 14601 case R_PPC64_PLT64: 14602 /* Relocation is to the entry for this symbol in the 14603 procedure linkage table. */ 14604 { 14605 struct plt_entry **plt_list = NULL; 14606 if (h != NULL) 14607 plt_list = &h->elf.plt.plist; 14608 else if (local_got_ents != NULL) 14609 { 14610 struct plt_entry **local_plt = (struct plt_entry **) 14611 (local_got_ents + symtab_hdr->sh_info); 14612 unsigned char *local_got_tls_masks = (unsigned char *) 14613 (local_plt + symtab_hdr->sh_info); 14614 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0) 14615 plt_list = local_plt + r_symndx; 14616 } 14617 if (plt_list) 14618 { 14619 struct plt_entry *ent; 14620 14621 for (ent = *plt_list; ent != NULL; ent = ent->next) 14622 if (ent->plt.offset != (bfd_vma) -1 14623 && ent->addend == orig_rel.r_addend) 14624 { 14625 asection *plt; 14626 14627 plt = htab->elf.splt; 14628 if (!htab->elf.dynamic_sections_created 14629 || h == NULL 14630 || h->elf.dynindx == -1) 14631 plt = htab->elf.iplt; 14632 relocation = (plt->output_section->vma 14633 + plt->output_offset 14634 + ent->plt.offset); 14635 addend = 0; 14636 unresolved_reloc = FALSE; 14637 break; 14638 } 14639 } 14640 } 14641 break; 14642 14643 case R_PPC64_TOC: 14644 /* Relocation value is TOC base. */ 14645 relocation = TOCstart; 14646 if (r_symndx == STN_UNDEF) 14647 relocation += htab->sec_info[input_section->id].toc_off; 14648 else if (unresolved_reloc) 14649 ; 14650 else if (sec != NULL && sec->id < htab->sec_info_arr_size) 14651 relocation += htab->sec_info[sec->id].toc_off; 14652 else 14653 unresolved_reloc = TRUE; 14654 goto dodyn; 14655 14656 /* TOC16 relocs. We want the offset relative to the TOC base, 14657 which is the address of the start of the TOC plus 0x8000. 14658 The TOC consists of sections .got, .toc, .tocbss, and .plt, 14659 in this order. */ 14660 case R_PPC64_TOC16: 14661 case R_PPC64_TOC16_LO: 14662 case R_PPC64_TOC16_HI: 14663 case R_PPC64_TOC16_DS: 14664 case R_PPC64_TOC16_LO_DS: 14665 case R_PPC64_TOC16_HA: 14666 addend -= TOCstart + htab->sec_info[input_section->id].toc_off; 14667 break; 14668 14669 /* Relocate against the beginning of the section. */ 14670 case R_PPC64_SECTOFF: 14671 case R_PPC64_SECTOFF_LO: 14672 case R_PPC64_SECTOFF_HI: 14673 case R_PPC64_SECTOFF_DS: 14674 case R_PPC64_SECTOFF_LO_DS: 14675 case R_PPC64_SECTOFF_HA: 14676 if (sec != NULL) 14677 addend -= sec->output_section->vma; 14678 break; 14679 14680 case R_PPC64_REL16: 14681 case R_PPC64_REL16_LO: 14682 case R_PPC64_REL16_HI: 14683 case R_PPC64_REL16_HA: 14684 case R_PPC64_REL16DX_HA: 14685 break; 14686 14687 case R_PPC64_REL14: 14688 case R_PPC64_REL14_BRNTAKEN: 14689 case R_PPC64_REL14_BRTAKEN: 14690 case R_PPC64_REL24: 14691 break; 14692 14693 case R_PPC64_TPREL16: 14694 case R_PPC64_TPREL16_LO: 14695 case R_PPC64_TPREL16_HI: 14696 case R_PPC64_TPREL16_HA: 14697 case R_PPC64_TPREL16_DS: 14698 case R_PPC64_TPREL16_LO_DS: 14699 case R_PPC64_TPREL16_HIGH: 14700 case R_PPC64_TPREL16_HIGHA: 14701 case R_PPC64_TPREL16_HIGHER: 14702 case R_PPC64_TPREL16_HIGHERA: 14703 case R_PPC64_TPREL16_HIGHEST: 14704 case R_PPC64_TPREL16_HIGHESTA: 14705 if (h != NULL 14706 && h->elf.root.type == bfd_link_hash_undefweak 14707 && h->elf.dynindx == -1) 14708 { 14709 /* Make this relocation against an undefined weak symbol 14710 resolve to zero. This is really just a tweak, since 14711 code using weak externs ought to check that they are 14712 defined before using them. */ 14713 bfd_byte *p = contents + rel->r_offset - d_offset; 14714 14715 insn = bfd_get_32 (input_bfd, p); 14716 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13); 14717 if (insn != 0) 14718 bfd_put_32 (input_bfd, insn, p); 14719 break; 14720 } 14721 if (htab->elf.tls_sec != NULL) 14722 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 14723 if (bfd_link_pic (info)) 14724 /* The TPREL16 relocs shouldn't really be used in shared 14725 libs as they will result in DT_TEXTREL being set, but 14726 support them anyway. */ 14727 goto dodyn; 14728 break; 14729 14730 case R_PPC64_DTPREL16: 14731 case R_PPC64_DTPREL16_LO: 14732 case R_PPC64_DTPREL16_HI: 14733 case R_PPC64_DTPREL16_HA: 14734 case R_PPC64_DTPREL16_DS: 14735 case R_PPC64_DTPREL16_LO_DS: 14736 case R_PPC64_DTPREL16_HIGH: 14737 case R_PPC64_DTPREL16_HIGHA: 14738 case R_PPC64_DTPREL16_HIGHER: 14739 case R_PPC64_DTPREL16_HIGHERA: 14740 case R_PPC64_DTPREL16_HIGHEST: 14741 case R_PPC64_DTPREL16_HIGHESTA: 14742 if (htab->elf.tls_sec != NULL) 14743 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 14744 break; 14745 14746 case R_PPC64_ADDR64_LOCAL: 14747 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL 14748 ? h->elf.other 14749 : sym->st_other); 14750 break; 14751 14752 case R_PPC64_DTPMOD64: 14753 relocation = 1; 14754 addend = 0; 14755 goto dodyn; 14756 14757 case R_PPC64_TPREL64: 14758 if (htab->elf.tls_sec != NULL) 14759 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 14760 goto dodyn; 14761 14762 case R_PPC64_DTPREL64: 14763 if (htab->elf.tls_sec != NULL) 14764 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 14765 /* Fall through. */ 14766 14767 /* Relocations that may need to be propagated if this is a 14768 dynamic object. */ 14769 case R_PPC64_REL30: 14770 case R_PPC64_REL32: 14771 case R_PPC64_REL64: 14772 case R_PPC64_ADDR14: 14773 case R_PPC64_ADDR14_BRNTAKEN: 14774 case R_PPC64_ADDR14_BRTAKEN: 14775 case R_PPC64_ADDR16: 14776 case R_PPC64_ADDR16_DS: 14777 case R_PPC64_ADDR16_HA: 14778 case R_PPC64_ADDR16_HI: 14779 case R_PPC64_ADDR16_HIGH: 14780 case R_PPC64_ADDR16_HIGHA: 14781 case R_PPC64_ADDR16_HIGHER: 14782 case R_PPC64_ADDR16_HIGHERA: 14783 case R_PPC64_ADDR16_HIGHEST: 14784 case R_PPC64_ADDR16_HIGHESTA: 14785 case R_PPC64_ADDR16_LO: 14786 case R_PPC64_ADDR16_LO_DS: 14787 case R_PPC64_ADDR24: 14788 case R_PPC64_ADDR32: 14789 case R_PPC64_ADDR64: 14790 case R_PPC64_UADDR16: 14791 case R_PPC64_UADDR32: 14792 case R_PPC64_UADDR64: 14793 dodyn: 14794 if ((input_section->flags & SEC_ALLOC) == 0) 14795 break; 14796 14797 if (NO_OPD_RELOCS && is_opd) 14798 break; 14799 14800 if (bfd_link_pic (info) 14801 ? ((h == NULL 14802 || h->dyn_relocs != NULL) 14803 && ((h != NULL && pc_dynrelocs (h)) 14804 || must_be_dyn_reloc (info, r_type))) 14805 : (h != NULL 14806 ? h->dyn_relocs != NULL 14807 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)) 14808 { 14809 bfd_boolean skip, relocate; 14810 asection *sreloc; 14811 bfd_vma out_off; 14812 14813 /* When generating a dynamic object, these relocations 14814 are copied into the output file to be resolved at run 14815 time. */ 14816 14817 skip = FALSE; 14818 relocate = FALSE; 14819 14820 out_off = _bfd_elf_section_offset (output_bfd, info, 14821 input_section, rel->r_offset); 14822 if (out_off == (bfd_vma) -1) 14823 skip = TRUE; 14824 else if (out_off == (bfd_vma) -2) 14825 skip = TRUE, relocate = TRUE; 14826 out_off += (input_section->output_section->vma 14827 + input_section->output_offset); 14828 outrel.r_offset = out_off; 14829 outrel.r_addend = rel->r_addend; 14830 14831 /* Optimize unaligned reloc use. */ 14832 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0) 14833 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0)) 14834 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64; 14835 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0) 14836 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0)) 14837 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32; 14838 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0) 14839 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0)) 14840 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16; 14841 14842 if (skip) 14843 memset (&outrel, 0, sizeof outrel); 14844 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf) 14845 && !is_opd 14846 && r_type != R_PPC64_TOC) 14847 { 14848 BFD_ASSERT (h->elf.dynindx != -1); 14849 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type); 14850 } 14851 else 14852 { 14853 /* This symbol is local, or marked to become local, 14854 or this is an opd section reloc which must point 14855 at a local function. */ 14856 outrel.r_addend += relocation; 14857 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC) 14858 { 14859 if (is_opd && h != NULL) 14860 { 14861 /* Lie about opd entries. This case occurs 14862 when building shared libraries and we 14863 reference a function in another shared 14864 lib. The same thing happens for a weak 14865 definition in an application that's 14866 overridden by a strong definition in a 14867 shared lib. (I believe this is a generic 14868 bug in binutils handling of weak syms.) 14869 In these cases we won't use the opd 14870 entry in this lib. */ 14871 unresolved_reloc = FALSE; 14872 } 14873 if (!is_opd 14874 && r_type == R_PPC64_ADDR64 14875 && (h != NULL 14876 ? h->elf.type == STT_GNU_IFUNC 14877 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)) 14878 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE); 14879 else 14880 { 14881 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE); 14882 14883 /* We need to relocate .opd contents for ld.so. 14884 Prelink also wants simple and consistent rules 14885 for relocs. This make all RELATIVE relocs have 14886 *r_offset equal to r_addend. */ 14887 relocate = TRUE; 14888 } 14889 } 14890 else 14891 { 14892 long indx = 0; 14893 14894 if (h != NULL 14895 ? h->elf.type == STT_GNU_IFUNC 14896 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 14897 { 14898 info->callbacks->einfo 14899 /* xgettext:c-format */ 14900 (_("%P: %H: %s for indirect " 14901 "function `%T' unsupported\n"), 14902 input_bfd, input_section, rel->r_offset, 14903 ppc64_elf_howto_table[r_type]->name, 14904 sym_name); 14905 ret = FALSE; 14906 } 14907 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec)) 14908 ; 14909 else if (sec == NULL || sec->owner == NULL) 14910 { 14911 bfd_set_error (bfd_error_bad_value); 14912 return FALSE; 14913 } 14914 else 14915 { 14916 asection *osec; 14917 14918 osec = sec->output_section; 14919 indx = elf_section_data (osec)->dynindx; 14920 14921 if (indx == 0) 14922 { 14923 if ((osec->flags & SEC_READONLY) == 0 14924 && htab->elf.data_index_section != NULL) 14925 osec = htab->elf.data_index_section; 14926 else 14927 osec = htab->elf.text_index_section; 14928 indx = elf_section_data (osec)->dynindx; 14929 } 14930 BFD_ASSERT (indx != 0); 14931 14932 /* We are turning this relocation into one 14933 against a section symbol, so subtract out 14934 the output section's address but not the 14935 offset of the input section in the output 14936 section. */ 14937 outrel.r_addend -= osec->vma; 14938 } 14939 14940 outrel.r_info = ELF64_R_INFO (indx, r_type); 14941 } 14942 } 14943 14944 sreloc = elf_section_data (input_section)->sreloc; 14945 if (h != NULL 14946 ? h->elf.type == STT_GNU_IFUNC 14947 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 14948 sreloc = htab->elf.irelplt; 14949 if (sreloc == NULL) 14950 abort (); 14951 14952 if (sreloc->reloc_count * sizeof (Elf64_External_Rela) 14953 >= sreloc->size) 14954 abort (); 14955 loc = sreloc->contents; 14956 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 14957 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 14958 14959 /* If this reloc is against an external symbol, it will 14960 be computed at runtime, so there's no need to do 14961 anything now. However, for the sake of prelink ensure 14962 that the section contents are a known value. */ 14963 if (! relocate) 14964 { 14965 unresolved_reloc = FALSE; 14966 /* The value chosen here is quite arbitrary as ld.so 14967 ignores section contents except for the special 14968 case of .opd where the contents might be accessed 14969 before relocation. Choose zero, as that won't 14970 cause reloc overflow. */ 14971 relocation = 0; 14972 addend = 0; 14973 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs 14974 to improve backward compatibility with older 14975 versions of ld. */ 14976 if (r_type == R_PPC64_ADDR64) 14977 addend = outrel.r_addend; 14978 /* Adjust pc_relative relocs to have zero in *r_offset. */ 14979 else if (ppc64_elf_howto_table[r_type]->pc_relative) 14980 addend = (input_section->output_section->vma 14981 + input_section->output_offset 14982 + rel->r_offset); 14983 } 14984 } 14985 break; 14986 14987 case R_PPC64_COPY: 14988 case R_PPC64_GLOB_DAT: 14989 case R_PPC64_JMP_SLOT: 14990 case R_PPC64_JMP_IREL: 14991 case R_PPC64_RELATIVE: 14992 /* We shouldn't ever see these dynamic relocs in relocatable 14993 files. */ 14994 /* Fall through. */ 14995 14996 case R_PPC64_PLTGOT16: 14997 case R_PPC64_PLTGOT16_DS: 14998 case R_PPC64_PLTGOT16_HA: 14999 case R_PPC64_PLTGOT16_HI: 15000 case R_PPC64_PLTGOT16_LO: 15001 case R_PPC64_PLTGOT16_LO_DS: 15002 case R_PPC64_PLTREL32: 15003 case R_PPC64_PLTREL64: 15004 /* These ones haven't been implemented yet. */ 15005 15006 info->callbacks->einfo 15007 /* xgettext:c-format */ 15008 (_("%P: %B: %s is not supported for `%T'\n"), 15009 input_bfd, 15010 ppc64_elf_howto_table[r_type]->name, sym_name); 15011 15012 bfd_set_error (bfd_error_invalid_operation); 15013 ret = FALSE; 15014 goto copy_reloc; 15015 } 15016 15017 /* Multi-instruction sequences that access the TOC can be 15018 optimized, eg. addis ra,r2,0; addi rb,ra,x; 15019 to nop; addi rb,r2,x; */ 15020 switch (r_type) 15021 { 15022 default: 15023 break; 15024 15025 case R_PPC64_GOT_TLSLD16_HI: 15026 case R_PPC64_GOT_TLSGD16_HI: 15027 case R_PPC64_GOT_TPREL16_HI: 15028 case R_PPC64_GOT_DTPREL16_HI: 15029 case R_PPC64_GOT16_HI: 15030 case R_PPC64_TOC16_HI: 15031 /* These relocs would only be useful if building up an 15032 offset to later add to r2, perhaps in an indexed 15033 addressing mode instruction. Don't try to optimize. 15034 Unfortunately, the possibility of someone building up an 15035 offset like this or even with the HA relocs, means that 15036 we need to check the high insn when optimizing the low 15037 insn. */ 15038 break; 15039 15040 case R_PPC64_GOT_TLSLD16_HA: 15041 case R_PPC64_GOT_TLSGD16_HA: 15042 case R_PPC64_GOT_TPREL16_HA: 15043 case R_PPC64_GOT_DTPREL16_HA: 15044 case R_PPC64_GOT16_HA: 15045 case R_PPC64_TOC16_HA: 15046 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000 15047 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn) 15048 { 15049 bfd_byte *p = contents + (rel->r_offset & ~3); 15050 bfd_put_32 (input_bfd, NOP, p); 15051 } 15052 break; 15053 15054 case R_PPC64_GOT_TLSLD16_LO: 15055 case R_PPC64_GOT_TLSGD16_LO: 15056 case R_PPC64_GOT_TPREL16_LO_DS: 15057 case R_PPC64_GOT_DTPREL16_LO_DS: 15058 case R_PPC64_GOT16_LO: 15059 case R_PPC64_GOT16_LO_DS: 15060 case R_PPC64_TOC16_LO: 15061 case R_PPC64_TOC16_LO_DS: 15062 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000 15063 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn) 15064 { 15065 bfd_byte *p = contents + (rel->r_offset & ~3); 15066 insn = bfd_get_32 (input_bfd, p); 15067 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */) 15068 { 15069 /* Transform addic to addi when we change reg. */ 15070 insn &= ~((0x3f << 26) | (0x1f << 16)); 15071 insn |= (14u << 26) | (2 << 16); 15072 } 15073 else 15074 { 15075 insn &= ~(0x1f << 16); 15076 insn |= 2 << 16; 15077 } 15078 bfd_put_32 (input_bfd, insn, p); 15079 } 15080 break; 15081 } 15082 15083 /* Do any further special processing. */ 15084 howto = ppc64_elf_howto_table[(int) r_type]; 15085 switch (r_type) 15086 { 15087 default: 15088 break; 15089 15090 case R_PPC64_REL16_HA: 15091 case R_PPC64_REL16DX_HA: 15092 case R_PPC64_ADDR16_HA: 15093 case R_PPC64_ADDR16_HIGHA: 15094 case R_PPC64_ADDR16_HIGHERA: 15095 case R_PPC64_ADDR16_HIGHESTA: 15096 case R_PPC64_TOC16_HA: 15097 case R_PPC64_SECTOFF_HA: 15098 case R_PPC64_TPREL16_HA: 15099 case R_PPC64_TPREL16_HIGHA: 15100 case R_PPC64_TPREL16_HIGHERA: 15101 case R_PPC64_TPREL16_HIGHESTA: 15102 case R_PPC64_DTPREL16_HA: 15103 case R_PPC64_DTPREL16_HIGHA: 15104 case R_PPC64_DTPREL16_HIGHERA: 15105 case R_PPC64_DTPREL16_HIGHESTA: 15106 /* It's just possible that this symbol is a weak symbol 15107 that's not actually defined anywhere. In that case, 15108 'sec' would be NULL, and we should leave the symbol 15109 alone (it will be set to zero elsewhere in the link). */ 15110 if (sec == NULL) 15111 break; 15112 /* Fall through. */ 15113 15114 case R_PPC64_GOT16_HA: 15115 case R_PPC64_PLTGOT16_HA: 15116 case R_PPC64_PLT16_HA: 15117 case R_PPC64_GOT_TLSGD16_HA: 15118 case R_PPC64_GOT_TLSLD16_HA: 15119 case R_PPC64_GOT_TPREL16_HA: 15120 case R_PPC64_GOT_DTPREL16_HA: 15121 /* Add 0x10000 if sign bit in 0:15 is set. 15122 Bits 0:15 are not used. */ 15123 addend += 0x8000; 15124 break; 15125 15126 case R_PPC64_ADDR16_DS: 15127 case R_PPC64_ADDR16_LO_DS: 15128 case R_PPC64_GOT16_DS: 15129 case R_PPC64_GOT16_LO_DS: 15130 case R_PPC64_PLT16_LO_DS: 15131 case R_PPC64_SECTOFF_DS: 15132 case R_PPC64_SECTOFF_LO_DS: 15133 case R_PPC64_TOC16_DS: 15134 case R_PPC64_TOC16_LO_DS: 15135 case R_PPC64_PLTGOT16_DS: 15136 case R_PPC64_PLTGOT16_LO_DS: 15137 case R_PPC64_GOT_TPREL16_DS: 15138 case R_PPC64_GOT_TPREL16_LO_DS: 15139 case R_PPC64_GOT_DTPREL16_DS: 15140 case R_PPC64_GOT_DTPREL16_LO_DS: 15141 case R_PPC64_TPREL16_DS: 15142 case R_PPC64_TPREL16_LO_DS: 15143 case R_PPC64_DTPREL16_DS: 15144 case R_PPC64_DTPREL16_LO_DS: 15145 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3)); 15146 mask = 3; 15147 /* If this reloc is against an lq, lxv, or stxv insn, then 15148 the value must be a multiple of 16. This is somewhat of 15149 a hack, but the "correct" way to do this by defining _DQ 15150 forms of all the _DS relocs bloats all reloc switches in 15151 this file. It doesn't make much sense to use these 15152 relocs in data, so testing the insn should be safe. */ 15153 if ((insn & (0x3f << 26)) == (56u << 26) 15154 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1)) 15155 mask = 15; 15156 relocation += addend; 15157 addend = insn & (mask ^ 3); 15158 if ((relocation & mask) != 0) 15159 { 15160 relocation ^= relocation & mask; 15161 info->callbacks->einfo 15162 /* xgettext:c-format */ 15163 (_("%P: %H: error: %s not a multiple of %u\n"), 15164 input_bfd, input_section, rel->r_offset, 15165 howto->name, 15166 mask + 1); 15167 bfd_set_error (bfd_error_bad_value); 15168 ret = FALSE; 15169 goto copy_reloc; 15170 } 15171 break; 15172 } 15173 15174 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 15175 because such sections are not SEC_ALLOC and thus ld.so will 15176 not process them. */ 15177 if (unresolved_reloc 15178 && !((input_section->flags & SEC_DEBUGGING) != 0 15179 && h->elf.def_dynamic) 15180 && _bfd_elf_section_offset (output_bfd, info, input_section, 15181 rel->r_offset) != (bfd_vma) -1) 15182 { 15183 info->callbacks->einfo 15184 /* xgettext:c-format */ 15185 (_("%P: %H: unresolvable %s against `%T'\n"), 15186 input_bfd, input_section, rel->r_offset, 15187 howto->name, 15188 h->elf.root.root.string); 15189 ret = FALSE; 15190 } 15191 15192 /* 16-bit fields in insns mostly have signed values, but a 15193 few insns have 16-bit unsigned values. Really, we should 15194 have different reloc types. */ 15195 if (howto->complain_on_overflow != complain_overflow_dont 15196 && howto->dst_mask == 0xffff 15197 && (input_section->flags & SEC_CODE) != 0) 15198 { 15199 enum complain_overflow complain = complain_overflow_signed; 15200 15201 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3)); 15202 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */) 15203 complain = complain_overflow_bitfield; 15204 else if (howto->rightshift == 0 15205 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */ 15206 || (insn & (0x3f << 26)) == 24u << 26 /* ori */ 15207 || (insn & (0x3f << 26)) == 26u << 26 /* xori */) 15208 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */ 15209 || (insn & (0x3f << 26)) == 25u << 26 /* oris */ 15210 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */)) 15211 complain = complain_overflow_unsigned; 15212 if (howto->complain_on_overflow != complain) 15213 { 15214 alt_howto = *howto; 15215 alt_howto.complain_on_overflow = complain; 15216 howto = &alt_howto; 15217 } 15218 } 15219 15220 if (r_type == R_PPC64_REL16DX_HA) 15221 { 15222 /* Split field reloc isn't handled by _bfd_final_link_relocate. */ 15223 if (rel->r_offset + 4 > input_section->size) 15224 r = bfd_reloc_outofrange; 15225 else 15226 { 15227 bfd_signed_vma field; 15228 15229 relocation += addend; 15230 relocation -= (rel->r_offset 15231 + input_section->output_offset 15232 + input_section->output_section->vma); 15233 field = (bfd_signed_vma) relocation >> 16; 15234 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 15235 insn &= ~0x1fffc1; 15236 insn |= (field & 0xffc1) | ((field & 0x3e) << 15); 15237 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 15238 r = bfd_reloc_ok; 15239 if (relocation + 0x80000000 > 0xffffffff) 15240 r = bfd_reloc_overflow; 15241 } 15242 } 15243 else 15244 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, 15245 rel->r_offset, relocation, addend); 15246 15247 if (r != bfd_reloc_ok) 15248 { 15249 char *more_info = NULL; 15250 const char *reloc_name = howto->name; 15251 15252 if (reloc_dest != DEST_NORMAL) 15253 { 15254 more_info = bfd_malloc (strlen (reloc_name) + 8); 15255 if (more_info != NULL) 15256 { 15257 strcpy (more_info, reloc_name); 15258 strcat (more_info, (reloc_dest == DEST_OPD 15259 ? " (OPD)" : " (stub)")); 15260 reloc_name = more_info; 15261 } 15262 } 15263 15264 if (r == bfd_reloc_overflow) 15265 { 15266 /* On code like "if (foo) foo();" don't report overflow 15267 on a branch to zero when foo is undefined. */ 15268 if (!warned 15269 && (reloc_dest == DEST_STUB 15270 || !(h != NULL 15271 && (h->elf.root.type == bfd_link_hash_undefweak 15272 || h->elf.root.type == bfd_link_hash_undefined) 15273 && is_branch_reloc (r_type)))) 15274 info->callbacks->reloc_overflow (info, &h->elf.root, 15275 sym_name, reloc_name, 15276 orig_rel.r_addend, 15277 input_bfd, input_section, 15278 rel->r_offset); 15279 } 15280 else 15281 { 15282 info->callbacks->einfo 15283 /* xgettext:c-format */ 15284 (_("%P: %H: %s against `%T': error %d\n"), 15285 input_bfd, input_section, rel->r_offset, 15286 reloc_name, sym_name, (int) r); 15287 ret = FALSE; 15288 } 15289 if (more_info != NULL) 15290 free (more_info); 15291 } 15292 copy_reloc: 15293 if (wrel != rel) 15294 *wrel = *rel; 15295 } 15296 15297 if (wrel != rel) 15298 { 15299 Elf_Internal_Shdr *rel_hdr; 15300 size_t deleted = rel - wrel; 15301 15302 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); 15303 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 15304 if (rel_hdr->sh_size == 0) 15305 { 15306 /* It is too late to remove an empty reloc section. Leave 15307 one NONE reloc. 15308 ??? What is wrong with an empty section??? */ 15309 rel_hdr->sh_size = rel_hdr->sh_entsize; 15310 deleted -= 1; 15311 } 15312 rel_hdr = _bfd_elf_single_rel_hdr (input_section); 15313 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 15314 input_section->reloc_count -= deleted; 15315 } 15316 15317 /* If we're emitting relocations, then shortly after this function 15318 returns, reloc offsets and addends for this section will be 15319 adjusted. Worse, reloc symbol indices will be for the output 15320 file rather than the input. Save a copy of the relocs for 15321 opd_entry_value. */ 15322 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info))) 15323 { 15324 bfd_size_type amt; 15325 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela); 15326 rel = bfd_alloc (input_bfd, amt); 15327 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL); 15328 ppc64_elf_tdata (input_bfd)->opd.relocs = rel; 15329 if (rel == NULL) 15330 return FALSE; 15331 memcpy (rel, relocs, amt); 15332 } 15333 return ret; 15334} 15335 15336/* Adjust the value of any local symbols in opd sections. */ 15337 15338static int 15339ppc64_elf_output_symbol_hook (struct bfd_link_info *info, 15340 const char *name ATTRIBUTE_UNUSED, 15341 Elf_Internal_Sym *elfsym, 15342 asection *input_sec, 15343 struct elf_link_hash_entry *h) 15344{ 15345 struct _opd_sec_data *opd; 15346 long adjust; 15347 bfd_vma value; 15348 15349 if (h != NULL) 15350 return 1; 15351 15352 opd = get_opd_info (input_sec); 15353 if (opd == NULL || opd->adjust == NULL) 15354 return 1; 15355 15356 value = elfsym->st_value - input_sec->output_offset; 15357 if (!bfd_link_relocatable (info)) 15358 value -= input_sec->output_section->vma; 15359 15360 adjust = opd->adjust[OPD_NDX (value)]; 15361 if (adjust == -1) 15362 return 2; 15363 15364 elfsym->st_value += adjust; 15365 return 1; 15366} 15367 15368/* Finish up dynamic symbol handling. We set the contents of various 15369 dynamic sections here. */ 15370 15371static bfd_boolean 15372ppc64_elf_finish_dynamic_symbol (bfd *output_bfd, 15373 struct bfd_link_info *info, 15374 struct elf_link_hash_entry *h, 15375 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED) 15376{ 15377 struct ppc_link_hash_table *htab; 15378 struct plt_entry *ent; 15379 Elf_Internal_Rela rela; 15380 bfd_byte *loc; 15381 15382 htab = ppc_hash_table (info); 15383 if (htab == NULL) 15384 return FALSE; 15385 15386 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 15387 if (ent->plt.offset != (bfd_vma) -1) 15388 { 15389 /* This symbol has an entry in the procedure linkage 15390 table. Set it up. */ 15391 if (!htab->elf.dynamic_sections_created 15392 || h->dynindx == -1) 15393 { 15394 BFD_ASSERT (h->type == STT_GNU_IFUNC 15395 && h->def_regular 15396 && (h->root.type == bfd_link_hash_defined 15397 || h->root.type == bfd_link_hash_defweak)); 15398 rela.r_offset = (htab->elf.iplt->output_section->vma 15399 + htab->elf.iplt->output_offset 15400 + ent->plt.offset); 15401 if (htab->opd_abi) 15402 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL); 15403 else 15404 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE); 15405 rela.r_addend = (h->root.u.def.value 15406 + h->root.u.def.section->output_offset 15407 + h->root.u.def.section->output_section->vma 15408 + ent->addend); 15409 loc = (htab->elf.irelplt->contents 15410 + (htab->elf.irelplt->reloc_count++ 15411 * sizeof (Elf64_External_Rela))); 15412 } 15413 else 15414 { 15415 rela.r_offset = (htab->elf.splt->output_section->vma 15416 + htab->elf.splt->output_offset 15417 + ent->plt.offset); 15418 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT); 15419 rela.r_addend = ent->addend; 15420 loc = (htab->elf.srelplt->contents 15421 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab)) 15422 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela))); 15423 } 15424 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 15425 15426 if (!htab->opd_abi) 15427 { 15428 if (!h->def_regular) 15429 { 15430 /* Mark the symbol as undefined, rather than as 15431 defined in glink. Leave the value if there were 15432 any relocations where pointer equality matters 15433 (this is a clue for the dynamic linker, to make 15434 function pointer comparisons work between an 15435 application and shared library), otherwise set it 15436 to zero. */ 15437 sym->st_shndx = SHN_UNDEF; 15438 if (!h->pointer_equality_needed) 15439 sym->st_value = 0; 15440 else if (!h->ref_regular_nonweak) 15441 { 15442 /* This breaks function pointer comparisons, but 15443 that is better than breaking tests for a NULL 15444 function pointer. */ 15445 sym->st_value = 0; 15446 } 15447 } 15448 } 15449 } 15450 15451 if (h->needs_copy) 15452 { 15453 /* This symbol needs a copy reloc. Set it up. */ 15454 asection *srel; 15455 15456 if (h->dynindx == -1 15457 || (h->root.type != bfd_link_hash_defined 15458 && h->root.type != bfd_link_hash_defweak) 15459 || htab->elf.srelbss == NULL 15460 || htab->elf.sreldynrelro == NULL) 15461 abort (); 15462 15463 rela.r_offset = (h->root.u.def.value 15464 + h->root.u.def.section->output_section->vma 15465 + h->root.u.def.section->output_offset); 15466 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY); 15467 rela.r_addend = 0; 15468 if (h->root.u.def.section == htab->elf.sdynrelro) 15469 srel = htab->elf.sreldynrelro; 15470 else 15471 srel = htab->elf.srelbss; 15472 loc = srel->contents; 15473 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela); 15474 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 15475 } 15476 15477 return TRUE; 15478} 15479 15480/* Used to decide how to sort relocs in an optimal manner for the 15481 dynamic linker, before writing them out. */ 15482 15483static enum elf_reloc_type_class 15484ppc64_elf_reloc_type_class (const struct bfd_link_info *info, 15485 const asection *rel_sec, 15486 const Elf_Internal_Rela *rela) 15487{ 15488 enum elf_ppc64_reloc_type r_type; 15489 struct ppc_link_hash_table *htab = ppc_hash_table (info); 15490 15491 if (rel_sec == htab->elf.irelplt) 15492 return reloc_class_ifunc; 15493 15494 r_type = ELF64_R_TYPE (rela->r_info); 15495 switch (r_type) 15496 { 15497 case R_PPC64_RELATIVE: 15498 return reloc_class_relative; 15499 case R_PPC64_JMP_SLOT: 15500 return reloc_class_plt; 15501 case R_PPC64_COPY: 15502 return reloc_class_copy; 15503 default: 15504 return reloc_class_normal; 15505 } 15506} 15507 15508/* Finish up the dynamic sections. */ 15509 15510static bfd_boolean 15511ppc64_elf_finish_dynamic_sections (bfd *output_bfd, 15512 struct bfd_link_info *info) 15513{ 15514 struct ppc_link_hash_table *htab; 15515 bfd *dynobj; 15516 asection *sdyn; 15517 15518 htab = ppc_hash_table (info); 15519 if (htab == NULL) 15520 return FALSE; 15521 15522 dynobj = htab->elf.dynobj; 15523 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 15524 15525 if (htab->elf.dynamic_sections_created) 15526 { 15527 Elf64_External_Dyn *dyncon, *dynconend; 15528 15529 if (sdyn == NULL || htab->elf.sgot == NULL) 15530 abort (); 15531 15532 dyncon = (Elf64_External_Dyn *) sdyn->contents; 15533 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 15534 for (; dyncon < dynconend; dyncon++) 15535 { 15536 Elf_Internal_Dyn dyn; 15537 asection *s; 15538 15539 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 15540 15541 switch (dyn.d_tag) 15542 { 15543 default: 15544 continue; 15545 15546 case DT_PPC64_GLINK: 15547 s = htab->glink; 15548 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 15549 /* We stupidly defined DT_PPC64_GLINK to be the start 15550 of glink rather than the first entry point, which is 15551 what ld.so needs, and now have a bigger stub to 15552 support automatic multiple TOCs. */ 15553 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4; 15554 break; 15555 15556 case DT_PPC64_OPD: 15557 s = bfd_get_section_by_name (output_bfd, ".opd"); 15558 if (s == NULL) 15559 continue; 15560 dyn.d_un.d_ptr = s->vma; 15561 break; 15562 15563 case DT_PPC64_OPT: 15564 if (htab->do_multi_toc && htab->multi_toc_needed) 15565 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC; 15566 break; 15567 15568 case DT_PPC64_OPDSZ: 15569 s = bfd_get_section_by_name (output_bfd, ".opd"); 15570 if (s == NULL) 15571 continue; 15572 dyn.d_un.d_val = s->size; 15573 break; 15574 15575 case DT_PLTGOT: 15576 s = htab->elf.splt; 15577 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 15578 break; 15579 15580 case DT_JMPREL: 15581 s = htab->elf.srelplt; 15582 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 15583 break; 15584 15585 case DT_PLTRELSZ: 15586 dyn.d_un.d_val = htab->elf.srelplt->size; 15587 break; 15588 } 15589 15590 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 15591 } 15592 } 15593 15594 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0 15595 && htab->elf.sgot->output_section != bfd_abs_section_ptr) 15596 { 15597 /* Fill in the first entry in the global offset table. 15598 We use it to hold the link-time TOCbase. */ 15599 bfd_put_64 (output_bfd, 15600 elf_gp (output_bfd) + TOC_BASE_OFF, 15601 htab->elf.sgot->contents); 15602 15603 /* Set .got entry size. */ 15604 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8; 15605 } 15606 15607 if (htab->elf.splt != NULL && htab->elf.splt->size != 0 15608 && htab->elf.splt->output_section != bfd_abs_section_ptr) 15609 { 15610 /* Set .plt entry size. */ 15611 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize 15612 = PLT_ENTRY_SIZE (htab); 15613 } 15614 15615 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for 15616 brlt ourselves if emitrelocations. */ 15617 if (htab->brlt != NULL 15618 && htab->brlt->reloc_count != 0 15619 && !_bfd_elf_link_output_relocs (output_bfd, 15620 htab->brlt, 15621 elf_section_data (htab->brlt)->rela.hdr, 15622 elf_section_data (htab->brlt)->relocs, 15623 NULL)) 15624 return FALSE; 15625 15626 if (htab->glink != NULL 15627 && htab->glink->reloc_count != 0 15628 && !_bfd_elf_link_output_relocs (output_bfd, 15629 htab->glink, 15630 elf_section_data (htab->glink)->rela.hdr, 15631 elf_section_data (htab->glink)->relocs, 15632 NULL)) 15633 return FALSE; 15634 15635 if (htab->glink_eh_frame != NULL 15636 && htab->glink_eh_frame->size != 0) 15637 { 15638 bfd_vma val; 15639 bfd_byte *p; 15640 asection *stub_sec; 15641 15642 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie); 15643 for (stub_sec = htab->params->stub_bfd->sections; 15644 stub_sec != NULL; 15645 stub_sec = stub_sec->next) 15646 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0) 15647 { 15648 /* FDE length. */ 15649 p += 4; 15650 /* CIE pointer. */ 15651 p += 4; 15652 /* Offset to stub section. */ 15653 val = (stub_sec->output_section->vma 15654 + stub_sec->output_offset); 15655 val -= (htab->glink_eh_frame->output_section->vma 15656 + htab->glink_eh_frame->output_offset 15657 + (p - htab->glink_eh_frame->contents)); 15658 if (val + 0x80000000 > 0xffffffff) 15659 { 15660 info->callbacks->einfo 15661 (_("%P: %s offset too large for .eh_frame sdata4 encoding"), 15662 stub_sec->name); 15663 return FALSE; 15664 } 15665 bfd_put_32 (dynobj, val, p); 15666 p += 4; 15667 /* stub section size. */ 15668 p += 4; 15669 /* Augmentation. */ 15670 p += 1; 15671 /* Pad. */ 15672 p += 7; 15673 } 15674 if (htab->glink != NULL && htab->glink->size != 0) 15675 { 15676 /* FDE length. */ 15677 p += 4; 15678 /* CIE pointer. */ 15679 p += 4; 15680 /* Offset to .glink. */ 15681 val = (htab->glink->output_section->vma 15682 + htab->glink->output_offset 15683 + 8); 15684 val -= (htab->glink_eh_frame->output_section->vma 15685 + htab->glink_eh_frame->output_offset 15686 + (p - htab->glink_eh_frame->contents)); 15687 if (val + 0x80000000 > 0xffffffff) 15688 { 15689 info->callbacks->einfo 15690 (_("%P: %s offset too large for .eh_frame sdata4 encoding"), 15691 htab->glink->name); 15692 return FALSE; 15693 } 15694 bfd_put_32 (dynobj, val, p); 15695 p += 4; 15696 /* .glink size. */ 15697 p += 4; 15698 /* Augmentation. */ 15699 p += 1; 15700 /* Ops. */ 15701 p += 7; 15702 } 15703 15704 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME 15705 && !_bfd_elf_write_section_eh_frame (output_bfd, info, 15706 htab->glink_eh_frame, 15707 htab->glink_eh_frame->contents)) 15708 return FALSE; 15709 } 15710 15711 /* We need to handle writing out multiple GOT sections ourselves, 15712 since we didn't add them to DYNOBJ. We know dynobj is the first 15713 bfd. */ 15714 while ((dynobj = dynobj->link.next) != NULL) 15715 { 15716 asection *s; 15717 15718 if (!is_ppc64_elf (dynobj)) 15719 continue; 15720 15721 s = ppc64_elf_tdata (dynobj)->got; 15722 if (s != NULL 15723 && s->size != 0 15724 && s->output_section != bfd_abs_section_ptr 15725 && !bfd_set_section_contents (output_bfd, s->output_section, 15726 s->contents, s->output_offset, 15727 s->size)) 15728 return FALSE; 15729 s = ppc64_elf_tdata (dynobj)->relgot; 15730 if (s != NULL 15731 && s->size != 0 15732 && s->output_section != bfd_abs_section_ptr 15733 && !bfd_set_section_contents (output_bfd, s->output_section, 15734 s->contents, s->output_offset, 15735 s->size)) 15736 return FALSE; 15737 } 15738 15739 return TRUE; 15740} 15741 15742#include "elf64-target.h" 15743 15744/* FreeBSD support */ 15745 15746#undef TARGET_LITTLE_SYM 15747#undef TARGET_LITTLE_NAME 15748 15749#undef TARGET_BIG_SYM 15750#define TARGET_BIG_SYM powerpc_elf64_fbsd_vec 15751#undef TARGET_BIG_NAME 15752#define TARGET_BIG_NAME "elf64-powerpc-freebsd" 15753 15754#undef ELF_OSABI 15755#define ELF_OSABI ELFOSABI_FREEBSD 15756 15757#undef elf64_bed 15758#define elf64_bed elf64_powerpc_fbsd_bed 15759 15760#include "elf64-target.h" 15761 15762