bfd/elf64-ppc.c

   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
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, 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 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 125
 126 /* The name of the dynamic interpreter.  This is put in the .interp
 127    section.  */
 128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 129
 130 /* The size in bytes of an entry in the procedure linkage table.  */
 131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 132
 133 /* The initial size of the plt reserved for the dynamic linker.  */
 134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 135
 136 /* Offsets to some stack save slots.  */
 137 #define STK_LR 16
 138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 139 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 140    CR save slot.  Used only by optimised __tls_get_addr call stub,
 141    relying on __tls_get_addr_opt not saving CR..  */
 142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 143
 144 /* TOC base pointers offset from start of TOC.  */
 145 #define TOC_BASE_OFF    0x8000
 146 /* TOC base alignment.  */
 147 #define TOC_BASE_ALIGN  256
 148
 149 /* Offset of tp and dtp pointers from start of TLS block.  */
 150 #define TP_OFFSET       0x7000
 151 #define DTP_OFFSET      0x8000
 152
 153 /* .plt call stub instructions.  The normal stub is like this, but
 154    sometimes the .plt entry crosses a 64k boundary and we need to
 155    insert an addi to adjust r11.  */
 156 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 157 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 158 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 159 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 160 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 161 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 162 #define BCTR            0x4e800420      /* bctr                      */
 163
 164 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 165 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 166 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 167
 168 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 169 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 170 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 171 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 172 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 173 #define BNECTR          0x4ca20420      /* bnectr+               */
 174 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 175
 176 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 177 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 178 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 179
 180 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 181 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 182 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 183
 184 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 185 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 186 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 187 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 188 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 189
 190 /* glink call stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_CALL_STUB_SIZE (16*4)
 192                                         /* 0:                           */
 193                                         /*  .quad plt0-1f               */
 194                                         /* __glink:                     */
 195 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 196 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 197                                         /* 1:                           */
 198 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 199                                         /*  ld %2,(0b-1b)(%11)          */
 200 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 201 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 202                                         /*  ld %12,0(%11)               */
 203                                         /*  ld %2,8(%11)                */
 204                                         /*  mtctr %12                   */
 205                                         /*  ld %11,16(%11)              */
 206                                         /*  bctr                        */
 207 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 208 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 209 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 210 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 211 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 212
 213 /* Pad with this.  */
 214 #define NOP             0x60000000
 215
 216 /* Some other nops.  */
 217 #define CROR_151515     0x4def7b82
 218 #define CROR_313131     0x4ffffb82
 219
 220 /* .glink entries for the first 32k functions are two instructions.  */
 221 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 222 #define B_DOT           0x48000000      /* b     .              */
 223
 224 /* After that, we need two instructions to load the index, followed by
 225    a branch.  */
 226 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 227 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 228
 229 /* Instructions used by the save and restore reg functions.  */
 230 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 231 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 232 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 233 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 234 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 235 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 236 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 237 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 238 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 239 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 240 #define BLR             0x4e800020      /* blr                  */
 241
 242 /* Since .opd is an array of descriptors and each entry will end up
 243    with identical R_PPC64_RELATIVE relocs, there is really no need to
 244    propagate .opd relocs;  The dynamic linker should be taught to
 245    relocate .opd without reloc entries.  */
 246 #ifndef NO_OPD_RELOCS
 247 #define NO_OPD_RELOCS 0
 248 #endif
 249
 250 #ifndef ARRAY_SIZE
 251 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 252 #endif
 253
 254 static inline int
 255 abiversion (bfd *abfd)
 256 {
 257   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 258 }
 259
 260 static inline void
 261 set_abiversion (bfd *abfd, int ver)
 262 {
 263   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 264   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 265 }
 266 \f
 267 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 268
 269 /* Relocation HOWTO's.  */
 270 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 271
 272 static reloc_howto_type ppc64_elf_howto_raw[] = {
 273   /* This reloc does nothing.  */
 274   HOWTO (R_PPC64_NONE,          /* type */
 275          0,                     /* rightshift */
 276          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          0,                     /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_dont, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_NONE",        /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0,                     /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* A standard 32 bit relocation.  */
 289   HOWTO (R_PPC64_ADDR32,        /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          32,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_bitfield, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_PPC64_ADDR32",      /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0xffffffff,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   /* An absolute 26 bit branch; the lower two bits must be zero.
 304      FIXME: we don't check that, we just clear them.  */
 305   HOWTO (R_PPC64_ADDR24,        /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          26,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR24",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0x03fffffc,            /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A standard 16 bit relocation.  */
 320   HOWTO (R_PPC64_ADDR16,        /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_bitfield, /* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16",      /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* A 16 bit relocation without overflow.  */
 335   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 336          0,                     /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_dont,/* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_LO",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address.  */
 350   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 351          16,                    /* rightshift */
 352          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          FALSE,                 /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC64_ADDR16_HI",   /* name */
 359          FALSE,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xffff,                /* dst_mask */
 362          FALSE),                /* pcrel_offset */
 363
 364   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 365      bits, treated as a signed number, is negative.  */
 366   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 367          16,                    /* rightshift */
 368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          ppc64_elf_ha_reloc,    /* special_function */
 374          "R_PPC64_ADDR16_HA",   /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 16 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC64_ADDR14,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          16,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_signed, /* complain_on_overflow */
 389          ppc64_elf_branch_reloc, /* special_function */
 390          "R_PPC64_ADDR14",      /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x0000fffc,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* An absolute 16 bit branch, for which bit 10 should be set to
 397      indicate that the branch is expected to be taken.  The lower two
 398      bits must be zero.  */
 399   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 400          0,                     /* rightshift */
 401          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          FALSE,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          ppc64_elf_brtaken_reloc, /* special_function */
 407          "R_PPC64_ADDR14_BRTAKEN",/* name */
 408          FALSE,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0x0000fffc,            /* dst_mask */
 411          FALSE),                /* pcrel_offset */
 412
 413   /* An absolute 16 bit branch, for which bit 10 should be set to
 414      indicate that the branch is not expected to be taken.  The lower
 415      two bits must be zero.  */
 416   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          16,                    /* bitsize */
 420          FALSE,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_brtaken_reloc, /* special_function */
 424          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x0000fffc,            /* dst_mask */
 428          FALSE),                /* pcrel_offset */
 429
 430   /* A relative 26 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL24,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          26,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL24",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x03fffffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch; the lower two bits must be zero.  */
 446   HOWTO (R_PPC64_REL14,         /* type */
 447          0,                     /* rightshift */
 448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          16,                    /* bitsize */
 450          TRUE,                  /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          ppc64_elf_branch_reloc, /* special_function */
 454          "R_PPC64_REL14",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0,                     /* src_mask */
 457          0x0000fffc,            /* dst_mask */
 458          TRUE),                 /* pcrel_offset */
 459
 460   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 461      the branch is expected to be taken.  The lower two bits must be
 462      zero.  */
 463   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 464          0,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          16,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed, /* complain_on_overflow */
 470          ppc64_elf_brtaken_reloc, /* special_function */
 471          "R_PPC64_REL14_BRTAKEN", /* name */
 472          FALSE,                 /* partial_inplace */
 473          0,                     /* src_mask */
 474          0x0000fffc,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 478      the branch is not expected to be taken.  The lower two bits must
 479      be zero.  */
 480   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 481          0,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          16,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed, /* complain_on_overflow */
 487          ppc64_elf_brtaken_reloc, /* special_function */
 488          "R_PPC64_REL14_BRNTAKEN",/* name */
 489          FALSE,                 /* partial_inplace */
 490          0,                     /* src_mask */
 491          0x0000fffc,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 495      symbol.  */
 496   HOWTO (R_PPC64_GOT16,         /* type */
 497          0,                     /* rightshift */
 498          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_GOT16",       /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0xffff,                /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 511      the symbol.  */
 512   HOWTO (R_PPC64_GOT16_LO,      /* type */
 513          0,                     /* rightshift */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          16,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc, /* special_function */
 520          "R_PPC64_GOT16_LO",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          0xffff,                /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 527      the symbol.  */
 528   HOWTO (R_PPC64_GOT16_HI,      /* type */
 529          16,                    /* rightshift */
 530          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          16,                    /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed,/* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_GOT16_HI",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0xffff,                /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 543      the symbol.  */
 544   HOWTO (R_PPC64_GOT16_HA,      /* type */
 545          16,                    /* rightshift */
 546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          16,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,/* complain_on_overflow */
 551          ppc64_elf_unhandled_reloc, /* special_function */
 552          "R_PPC64_GOT16_HA",    /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0xffff,                /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* This is used only by the dynamic linker.  The symbol should exist
 559      both in the object being run and in some shared library.  The
 560      dynamic linker copies the data addressed by the symbol from the
 561      shared library into the object, because the object being
 562      run has to have the data at some particular address.  */
 563   HOWTO (R_PPC64_COPY,          /* type */
 564          0,                     /* rightshift */
 565          0,                     /* this one is variable size */
 566          0,                     /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          ppc64_elf_unhandled_reloc, /* special_function */
 571          "R_PPC64_COPY",        /* name */
 572          FALSE,                 /* partial_inplace */
 573          0,                     /* src_mask */
 574          0,                     /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* Like R_PPC64_ADDR64, but used when setting global offset table
 578      entries.  */
 579   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 580          0,                     /* rightshift */
 581          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 582          64,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          ppc64_elf_unhandled_reloc,  /* special_function */
 587          "R_PPC64_GLOB_DAT",    /* name */
 588          FALSE,                 /* partial_inplace */
 589          0,                     /* src_mask */
 590          ONES (64),             /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* Created by the link editor.  Marks a procedure linkage table
 594      entry for a symbol.  */
 595   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 596          0,                     /* rightshift */
 597          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          0,                     /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_dont, /* complain_on_overflow */
 602          ppc64_elf_unhandled_reloc, /* special_function */
 603          "R_PPC64_JMP_SLOT",    /* name */
 604          FALSE,                 /* partial_inplace */
 605          0,                     /* src_mask */
 606          0,                     /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* Used only by the dynamic linker.  When the object is run, this
 610      doubleword64 is set to the load address of the object, plus the
 611      addend.  */
 612   HOWTO (R_PPC64_RELATIVE,      /* type */
 613          0,                     /* rightshift */
 614          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 615          64,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_dont, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_RELATIVE",    /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          ONES (64),             /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR32,       /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          32,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR32",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffffffff,            /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 642   HOWTO (R_PPC64_UADDR16,       /* type */
 643          0,                     /* rightshift */
 644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          16,                    /* bitsize */
 646          FALSE,                 /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_bitfield, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_UADDR16",     /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffff,                /* dst_mask */
 654          FALSE),                /* pcrel_offset */
 655
 656   /* 32-bit PC relative.  */
 657   HOWTO (R_PPC64_REL32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_REL32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          TRUE),                 /* pcrel_offset */
 670
 671   /* 32-bit relocation to the symbol's procedure linkage table.  */
 672   HOWTO (R_PPC64_PLT32,         /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          ppc64_elf_unhandled_reloc, /* special_function */
 680          "R_PPC64_PLT32",       /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 687      FIXME: R_PPC64_PLTREL32 not supported.  */
 688   HOWTO (R_PPC64_PLTREL32,      /* type */
 689          0,                     /* rightshift */
 690          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 691          32,                    /* bitsize */
 692          TRUE,                  /* pc_relative */
 693          0,                     /* bitpos */
 694          complain_overflow_signed, /* complain_on_overflow */
 695          ppc64_elf_unhandled_reloc, /* special_function */
 696          "R_PPC64_PLTREL32",    /* name */
 697          FALSE,                 /* partial_inplace */
 698          0,                     /* src_mask */
 699          0xffffffff,            /* dst_mask */
 700          TRUE),                 /* pcrel_offset */
 701
 702   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 703      the symbol.  */
 704   HOWTO (R_PPC64_PLT16_LO,      /* type */
 705          0,                     /* rightshift */
 706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_dont, /* complain_on_overflow */
 711          ppc64_elf_unhandled_reloc, /* special_function */
 712          "R_PPC64_PLT16_LO",    /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffff,                /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 719      the symbol.  */
 720   HOWTO (R_PPC64_PLT16_HI,      /* type */
 721          16,                    /* rightshift */
 722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          FALSE,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_signed, /* complain_on_overflow */
 727          ppc64_elf_unhandled_reloc, /* special_function */
 728          "R_PPC64_PLT16_HI",    /* name */
 729          FALSE,                 /* partial_inplace */
 730          0,                     /* src_mask */
 731          0xffff,                /* dst_mask */
 732          FALSE),                /* pcrel_offset */
 733
 734   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 735      the symbol.  */
 736   HOWTO (R_PPC64_PLT16_HA,      /* type */
 737          16,                    /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_unhandled_reloc, /* special_function */
 744          "R_PPC64_PLT16_HA",    /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit section relative relocation.  */
 751   HOWTO (R_PPC64_SECTOFF,       /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF",     /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 766   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 767          0,                     /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_dont, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_LO",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HI",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* 16-bit upper half adjusted section relative relocation.  */
 796   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 797          16,                    /* rightshift */
 798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          FALSE,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          ppc64_elf_sectoff_ha_reloc, /* special_function */
 804          "R_PPC64_SECTOFF_HA",  /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xffff,                /* dst_mask */
 808          FALSE),                /* pcrel_offset */
 809
 810   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 811   HOWTO (R_PPC64_REL30,         /* type */
 812          2,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          30,                    /* bitsize */
 815          TRUE,                  /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_PPC64_REL30",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xfffffffc,            /* dst_mask */
 823          TRUE),                 /* pcrel_offset */
 824
 825   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 826
 827   /* A standard 64-bit relocation.  */
 828   HOWTO (R_PPC64_ADDR64,        /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR64",      /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          ONES (64),             /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address.  */
 843   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 844          32,                    /* rightshift */
 845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          16,                    /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_ADDR16_HIGHER", /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0xffff,                /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   /* The bits 32-47 of an address, plus 1 if the contents of the low
 858      16 bits, treated as a signed number, is negative.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 860          32,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          ppc64_elf_ha_reloc,    /* special_function */
 867          "R_PPC64_ADDR16_HIGHERA", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address.  */
 874   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 875          48,                    /* rightshift */
 876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          16,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          0,                     /* bitpos */
 880          complain_overflow_dont, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_PPC64_ADDR16_HIGHEST", /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffff,                /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* The bits 48-63 of an address, plus 1 if the contents of the low
 889      16 bits, treated as a signed number, is negative.  */
 890   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 891          48,                    /* rightshift */
 892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          ppc64_elf_ha_reloc,    /* special_function */
 898          "R_PPC64_ADDR16_HIGHESTA", /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0xffff,                /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* Like ADDR64, but may be unaligned.  */
 905   HOWTO (R_PPC64_UADDR64,       /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          FALSE,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_UADDR64",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          FALSE),                /* pcrel_offset */
 918
 919   /* 64-bit relative relocation.  */
 920   HOWTO (R_PPC64_REL64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          TRUE,                  /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_PPC64_REL64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          TRUE),                 /* pcrel_offset */
 933
 934   /* 64-bit relocation to the symbol's procedure linkage table.  */
 935   HOWTO (R_PPC64_PLT64,         /* type */
 936          0,                     /* rightshift */
 937          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 938          64,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_unhandled_reloc, /* special_function */
 943          "R_PPC64_PLT64",       /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          ONES (64),             /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 64-bit PC relative relocation to the symbol's procedure linkage
 950      table.  */
 951   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 952   HOWTO (R_PPC64_PLTREL64,      /* type */
 953          0,                     /* rightshift */
 954          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 955          64,                    /* bitsize */
 956          TRUE,                  /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_unhandled_reloc, /* special_function */
 960          "R_PPC64_PLTREL64",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          ONES (64),             /* dst_mask */
 964          TRUE),                 /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation.  */
 967
 968   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 969   HOWTO (R_PPC64_TOC16,         /* type */
 970          0,                     /* rightshift */
 971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 972          16,                    /* bitsize */
 973          FALSE,                 /* pc_relative */
 974          0,                     /* bitpos */
 975          complain_overflow_signed, /* complain_on_overflow */
 976          ppc64_elf_toc_reloc,   /* special_function */
 977          "R_PPC64_TOC16",       /* name */
 978          FALSE,                 /* partial_inplace */
 979          0,                     /* src_mask */
 980          0xffff,                /* dst_mask */
 981          FALSE),                /* pcrel_offset */
 982
 983   /* 16 bit TOC-relative relocation without overflow.  */
 984
 985   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 986   HOWTO (R_PPC64_TOC16_LO,      /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          FALSE,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          ppc64_elf_toc_reloc,   /* special_function */
 994          "R_PPC64_TOC16_LO",    /* name */
 995          FALSE,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          FALSE),                /* pcrel_offset */
 999
1000   /* 16 bit TOC-relative relocation, high 16 bits.  */
1001
1002   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1003   HOWTO (R_PPC64_TOC16_HI,      /* type */
1004          16,                    /* rightshift */
1005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          16,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_signed, /* complain_on_overflow */
1010          ppc64_elf_toc_reloc,   /* special_function */
1011          "R_PPC64_TOC16_HI",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0,                     /* src_mask */
1014          0xffff,                /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016
1017   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018      contents of the low 16 bits, treated as a signed number, is
1019      negative.  */
1020
1021   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1022   HOWTO (R_PPC64_TOC16_HA,      /* type */
1023          16,                    /* rightshift */
1024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1025          16,                    /* bitsize */
1026          FALSE,                 /* pc_relative */
1027          0,                     /* bitpos */
1028          complain_overflow_signed, /* complain_on_overflow */
1029          ppc64_elf_toc_ha_reloc, /* special_function */
1030          "R_PPC64_TOC16_HA",    /* name */
1031          FALSE,                 /* partial_inplace */
1032          0,                     /* src_mask */
1033          0xffff,                /* dst_mask */
1034          FALSE),                /* pcrel_offset */
1035
1036   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1037
1038   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1039   HOWTO (R_PPC64_TOC,           /* type */
1040          0,                     /* rightshift */
1041          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042          64,                    /* bitsize */
1043          FALSE,                 /* pc_relative */
1044          0,                     /* bitpos */
1045          complain_overflow_dont, /* complain_on_overflow */
1046          ppc64_elf_toc64_reloc, /* special_function */
1047          "R_PPC64_TOC",         /* name */
1048          FALSE,                 /* partial_inplace */
1049          0,                     /* src_mask */
1050          ONES (64),             /* dst_mask */
1051          FALSE),                /* pcrel_offset */
1052
1053   /* Like R_PPC64_GOT16, but also informs the link editor that the
1054      value to relocate may (!) refer to a PLT entry which the link
1055      editor (a) may replace with the symbol value.  If the link editor
1056      is unable to fully resolve the symbol, it may (b) create a PLT
1057      entry and store the address to the new PLT entry in the GOT.
1058      This permits lazy resolution of function symbols at run time.
1059      The link editor may also skip all of this and just (c) emit a
1060      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1061   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1062     HOWTO (R_PPC64_PLTGOT16,    /* type */
1063          0,                     /* rightshift */
1064          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_signed, /* complain_on_overflow */
1069          ppc64_elf_unhandled_reloc, /* special_function */
1070          "R_PPC64_PLTGOT16",    /* name */
1071          FALSE,                 /* partial_inplace */
1072          0,                     /* src_mask */
1073          0xffff,                /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1077   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1078   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1079          0,                     /* rightshift */
1080          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1081          16,                    /* bitsize */
1082          FALSE,                 /* pc_relative */
1083          0,                     /* bitpos */
1084          complain_overflow_dont, /* complain_on_overflow */
1085          ppc64_elf_unhandled_reloc, /* special_function */
1086          "R_PPC64_PLTGOT16_LO", /* name */
1087          FALSE,                 /* partial_inplace */
1088          0,                     /* src_mask */
1089          0xffff,                /* dst_mask */
1090          FALSE),                /* pcrel_offset */
1091
1092   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1093   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1094   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1095          16,                    /* rightshift */
1096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1097          16,                    /* bitsize */
1098          FALSE,                 /* pc_relative */
1099          0,                     /* bitpos */
1100          complain_overflow_signed, /* complain_on_overflow */
1101          ppc64_elf_unhandled_reloc, /* special_function */
1102          "R_PPC64_PLTGOT16_HI", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109      1 if the contents of the low 16 bits, treated as a signed number,
1110      is negative.  */
1111   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1112   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1113          16,                    /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          ppc64_elf_unhandled_reloc, /* special_function */
1120          "R_PPC64_PLTGOT16_HA", /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xffff,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_signed, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_DS",   /* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_dont,/* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_ADDR16_LO_DS",/* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_DS,      /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_signed, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_DS",    /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_GOT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont, /* complain_on_overflow */
1194          ppc64_elf_unhandled_reloc, /* special_function */
1195          "R_PPC64_PLT16_LO_DS", /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_signed, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_DS",  /* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont, /* complain_on_overflow */
1224          ppc64_elf_sectoff_reloc, /* special_function */
1225          "R_PPC64_SECTOFF_LO_DS",/* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_DS,      /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_signed, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_DS",    /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1247   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1248          0,                     /* rightshift */
1249          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          16,                    /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont, /* complain_on_overflow */
1254          ppc64_elf_toc_reloc,   /* special_function */
1255          "R_PPC64_TOC16_LO_DS", /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0xfffc,                /* dst_mask */
1259          FALSE),                /* pcrel_offset */
1260
1261   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1262   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1263   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1264          0,                     /* rightshift */
1265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          16,                    /* bitsize */
1267          FALSE,                 /* pc_relative */
1268          0,                     /* bitpos */
1269          complain_overflow_signed, /* complain_on_overflow */
1270          ppc64_elf_unhandled_reloc, /* special_function */
1271          "R_PPC64_PLTGOT16_DS", /* name */
1272          FALSE,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0xfffc,                /* dst_mask */
1275          FALSE),                /* pcrel_offset */
1276
1277   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1278   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1279   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280          0,                     /* rightshift */
1281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          16,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          ppc64_elf_unhandled_reloc, /* special_function */
1287          "R_PPC64_PLTGOT16_LO_DS",/* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xfffc,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* Marker relocs for TLS.  */
1294   HOWTO (R_PPC64_TLS,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLS",         /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TLSGD,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TLSGD",       /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   HOWTO (R_PPC64_TLSLD,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLSLD",       /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TOCSAVE,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TOCSAVE",     /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Computes the load module index of the load module that contains the
1351      definition of its TLS sym.  */
1352   HOWTO (R_PPC64_DTPMOD64,
1353          0,                     /* rightshift */
1354          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          64,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc64_elf_unhandled_reloc, /* special_function */
1360          "R_PPC64_DTPMOD64",    /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          ONES (64),             /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* Computes a dtv-relative displacement, the difference between the value
1367      of sym+add and the base address of the thread-local storage block that
1368      contains the definition of sym, minus 0x8000.  */
1369   HOWTO (R_PPC64_DTPREL64,
1370          0,                     /* rightshift */
1371          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          64,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL64",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          ONES (64),             /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* A 16 bit dtprel reloc.  */
1384   HOWTO (R_PPC64_DTPREL16,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16",    /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16, but no overflow.  */
1399   HOWTO (R_PPC64_DTPREL16_LO,
1400          0,                     /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_dont, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_LO", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HI,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HI", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HA,
1430          16,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_signed, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HA", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHER,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHER", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460          32,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHERA", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHEST", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1489   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490          48,                    /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_dont, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xffff,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16, but for insns with a DS field.  */
1504   HOWTO (R_PPC64_DTPREL16_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_signed, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Like DTPREL16_DS, but no overflow.  */
1519   HOWTO (R_PPC64_DTPREL16_LO_DS,
1520          0,                     /* rightshift */
1521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          16,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_dont, /* complain_on_overflow */
1526          ppc64_elf_unhandled_reloc, /* special_function */
1527          "R_PPC64_DTPREL16_LO_DS", /* name */
1528          FALSE,                 /* partial_inplace */
1529          0,                     /* src_mask */
1530          0xfffc,                /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   /* Computes a tp-relative displacement, the difference between the value of
1534      sym+add and the value of the thread pointer (r13).  */
1535   HOWTO (R_PPC64_TPREL64,
1536          0,                     /* rightshift */
1537          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          64,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_dont, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL64",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          ONES (64),             /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* A 16 bit tprel reloc.  */
1550   HOWTO (R_PPC64_TPREL16,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_signed, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16",     /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16, but no overflow.  */
1565   HOWTO (R_PPC64_TPREL16_LO,
1566          0,                     /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_dont, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_LO",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HI,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HI",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HA,
1596          16,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_signed, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HA",  /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHER,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHER",      /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHERA,
1626          32,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHERA", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHEST,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHEST", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1655   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656          48,                    /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_dont, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_HIGHESTA", /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xffff,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16, but for insns with a DS field.  */
1670   HOWTO (R_PPC64_TPREL16_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_signed, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_DS",  /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Like TPREL16_DS, but no overflow.  */
1685   HOWTO (R_PPC64_TPREL16_LO_DS,
1686          0,                     /* rightshift */
1687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1688          16,                    /* bitsize */
1689          FALSE,                 /* pc_relative */
1690          0,                     /* bitpos */
1691          complain_overflow_dont, /* complain_on_overflow */
1692          ppc64_elf_unhandled_reloc, /* special_function */
1693          "R_PPC64_TPREL16_LO_DS", /* name */
1694          FALSE,                 /* partial_inplace */
1695          0,                     /* src_mask */
1696          0xfffc,                /* dst_mask */
1697          FALSE),                /* pcrel_offset */
1698
1699   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701      to the first entry relative to the TOC base (r2).  */
1702   HOWTO (R_PPC64_GOT_TLSGD16,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_signed, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16, but no overflow.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_dont, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_LO", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HI", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1747   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_signed, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_TLSGD16_HA", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762      with values (sym+add)@dtpmod and zero, and computes the offset to the
1763      first entry relative to the TOC base (r2).  */
1764   HOWTO (R_PPC64_GOT_TLSLD16,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_signed, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16, but no overflow.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_dont, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_LO", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HI", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1809   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810          16,                    /* rightshift */
1811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1812          16,                    /* bitsize */
1813          FALSE,                 /* pc_relative */
1814          0,                     /* bitpos */
1815          complain_overflow_signed, /* complain_on_overflow */
1816          ppc64_elf_unhandled_reloc, /* special_function */
1817          "R_PPC64_GOT_TLSLD16_HA", /* name */
1818          FALSE,                 /* partial_inplace */
1819          0,                     /* src_mask */
1820          0xffff,                /* dst_mask */
1821          FALSE),                /* pcrel_offset */
1822
1823   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824      the offset to the entry relative to the TOC base (r2).  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_signed, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_DS, but no overflow.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841          0,                     /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_dont, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xfffc,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HI", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1870   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871          16,                    /* rightshift */
1872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1873          16,                    /* bitsize */
1874          FALSE,                 /* pc_relative */
1875          0,                     /* bitpos */
1876          complain_overflow_signed, /* complain_on_overflow */
1877          ppc64_elf_unhandled_reloc, /* special_function */
1878          "R_PPC64_GOT_DTPREL16_HA", /* name */
1879          FALSE,                 /* partial_inplace */
1880          0,                     /* src_mask */
1881          0xffff,                /* dst_mask */
1882          FALSE),                /* pcrel_offset */
1883
1884   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885      offset to the entry relative to the TOC base (r2).  */
1886   HOWTO (R_PPC64_GOT_TPREL16_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_signed, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_DS, but no overflow.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902          0,                     /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_dont, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xfffc,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HI,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HI", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1931   HOWTO (R_PPC64_GOT_TPREL16_HA,
1932          16,                    /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_signed, /* complain_on_overflow */
1938          ppc64_elf_unhandled_reloc, /* special_function */
1939          "R_PPC64_GOT_TPREL16_HA", /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   HOWTO (R_PPC64_JMP_IREL,      /* type */
1946          0,                     /* rightshift */
1947          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948          0,                     /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_dont, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_JMP_IREL",    /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0,                     /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   HOWTO (R_PPC64_IRELATIVE,     /* type */
1960          0,                     /* rightshift */
1961          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962          64,                    /* bitsize */
1963          FALSE,                 /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_dont, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_IRELATIVE",   /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          ONES (64),             /* dst_mask */
1971          FALSE),                /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation.  */
1974   HOWTO (R_PPC64_REL16,         /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_signed, /* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16",       /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* A 16 bit relative relocation without overflow.  */
1989   HOWTO (R_PPC64_REL16_LO,      /* type */
1990          0,                     /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_dont,/* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_LO",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address.  */
2004   HOWTO (R_PPC64_REL16_HI,      /* type */
2005          16,                    /* rightshift */
2006          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2007          16,                    /* bitsize */
2008          TRUE,                  /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_signed, /* complain_on_overflow */
2011          bfd_elf_generic_reloc, /* special_function */
2012          "R_PPC64_REL16_HI",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0xffff,                /* dst_mask */
2016          TRUE),                 /* pcrel_offset */
2017
2018   /* The high order 16 bits of a relative address, plus 1 if the contents of
2019      the low 16 bits, treated as a signed number, is negative.  */
2020   HOWTO (R_PPC64_REL16_HA,      /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          TRUE,                  /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_signed, /* complain_on_overflow */
2027          ppc64_elf_ha_reloc,    /* special_function */
2028          "R_PPC64_REL16_HA",    /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          TRUE),                 /* pcrel_offset */
2033
2034   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2035   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2036          16,                    /* rightshift */
2037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          TRUE,                  /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_signed, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_REL16DX_HA",  /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0x1fffc1,              /* dst_mask */
2047          TRUE),                 /* pcrel_offset */
2048
2049   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2050   HOWTO (R_PPC64_16DX_HA,       /* type */
2051          16,                    /* rightshift */
2052          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_signed, /* complain_on_overflow */
2057          ppc64_elf_ha_reloc,    /* special_function */
2058          "R_PPC64_16DX_HA",     /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0x1fffc1,              /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2065   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          bfd_elf_generic_reloc, /* special_function */
2073          "R_PPC64_ADDR16_HIGH", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2080   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_ha_reloc,    /* special_function */
2088          "R_PPC64_ADDR16_HIGHA",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2095   HOWTO (R_PPC64_DTPREL16_HIGH,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_DTPREL16_HIGH", /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2110   HOWTO (R_PPC64_DTPREL16_HIGHA,
2111          16,                    /* rightshift */
2112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2113          16,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          ppc64_elf_unhandled_reloc, /* special_function */
2118          "R_PPC64_DTPREL16_HIGHA", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          0xffff,                /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2125   HOWTO (R_PPC64_TPREL16_HIGH,
2126          16,                    /* rightshift */
2127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          16,                    /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          ppc64_elf_unhandled_reloc, /* special_function */
2133          "R_PPC64_TPREL16_HIGH",        /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0xffff,                /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2140   HOWTO (R_PPC64_TPREL16_HIGHA,
2141          16,                    /* rightshift */
2142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          16,                    /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          ppc64_elf_unhandled_reloc, /* special_function */
2148          "R_PPC64_TPREL16_HIGHA",       /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0xffff,                /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153
2154   /* Marker reloc on ELFv2 large-model function entry.  */
2155   HOWTO (R_PPC64_ENTRY,
2156          0,                     /* rightshift */
2157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2158          32,                    /* bitsize */
2159          FALSE,                 /* pc_relative */
2160          0,                     /* bitpos */
2161          complain_overflow_dont, /* complain_on_overflow */
2162          bfd_elf_generic_reloc, /* special_function */
2163          "R_PPC64_ENTRY",       /* name */
2164          FALSE,                 /* partial_inplace */
2165          0,                     /* src_mask */
2166          0,                     /* dst_mask */
2167          FALSE),                /* pcrel_offset */
2168
2169   /* Like ADDR64, but use local entry point of function.  */
2170   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2171          0,                     /* rightshift */
2172          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173          64,                    /* bitsize */
2174          FALSE,                 /* pc_relative */
2175          0,                     /* bitpos */
2176          complain_overflow_dont, /* complain_on_overflow */
2177          bfd_elf_generic_reloc, /* special_function */
2178          "R_PPC64_ADDR64_LOCAL", /* name */
2179          FALSE,                 /* partial_inplace */
2180          0,                     /* src_mask */
2181          ONES (64),             /* dst_mask */
2182          FALSE),                /* pcrel_offset */
2183
2184   /* GNU extension to record C++ vtable hierarchy.  */
2185   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186          0,                     /* rightshift */
2187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2188          0,                     /* bitsize */
2189          FALSE,                 /* pc_relative */
2190          0,                     /* bitpos */
2191          complain_overflow_dont, /* complain_on_overflow */
2192          NULL,                  /* special_function */
2193          "R_PPC64_GNU_VTINHERIT", /* name */
2194          FALSE,                 /* partial_inplace */
2195          0,                     /* src_mask */
2196          0,                     /* dst_mask */
2197          FALSE),                /* pcrel_offset */
2198
2199   /* GNU extension to record C++ vtable member usage.  */
2200   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2201          0,                     /* rightshift */
2202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          0,                     /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont, /* complain_on_overflow */
2207          NULL,                  /* special_function */
2208          "R_PPC64_GNU_VTENTRY", /* name */
2209          FALSE,                 /* partial_inplace */
2210          0,                     /* src_mask */
2211          0,                     /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213 };
2214
2215 \f
2216 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217    be done.  */
2218
2219 static void
2220 ppc_howto_init (void)
2221 {
2222   unsigned int i, type;
2223
2224   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225     {
2226       type = ppc64_elf_howto_raw[i].type;
2227       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2228       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229     }
2230 }
2231
2232 static reloc_howto_type *
2233 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234                              bfd_reloc_code_real_type code)
2235 {
2236   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237
2238   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239     /* Initialize howto table if needed.  */
2240     ppc_howto_init ();
2241
2242   switch (code)
2243     {
2244     default:
2245       return NULL;
2246
2247     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2248       break;
2249     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2250       break;
2251     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2252       break;
2253     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2254       break;
2255     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2256       break;
2257     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2258       break;
2259     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2260       break;
2261     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2262       break;
2263     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2264       break;
2265     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2266       break;
2267     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2268       break;
2269     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2270       break;
2271     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2272       break;
2273     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2274       break;
2275     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2278       break;
2279     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2280       break;
2281     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2282       break;
2283     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2284       break;
2285     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2286       break;
2287     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2288       break;
2289     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2290       break;
2291     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2292       break;
2293     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2294       break;
2295     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2296       break;
2297     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2298       break;
2299     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2300       break;
2301     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2302       break;
2303     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2304       break;
2305     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2306       break;
2307     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2308       break;
2309     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2310       break;
2311     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2312       break;
2313     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2314       break;
2315     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2316       break;
2317     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2318       break;
2319     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2322       break;
2323     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2324       break;
2325     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2326       break;
2327     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2328       break;
2329     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2330       break;
2331     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2332       break;
2333     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2334       break;
2335     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2336       break;
2337     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2338       break;
2339     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2340       break;
2341     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2342       break;
2343     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2348       break;
2349     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2350       break;
2351     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2352       break;
2353     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2358       break;
2359     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2362       break;
2363     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2364       break;
2365     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2366       break;
2367     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2368       break;
2369     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2370       break;
2371     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2372       break;
2373     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2374       break;
2375     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2376       break;
2377     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2378       break;
2379     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2380       break;
2381     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2388       break;
2389     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2390       break;
2391     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2392       break;
2393     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2394       break;
2395     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2402       break;
2403     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2408       break;
2409     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2428       break;
2429     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2436       break;
2437     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2438       break;
2439     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2440       break;
2441     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2448       break;
2449     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2450       break;
2451     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2452       break;
2453     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2460       break;
2461     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2462       break;
2463     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2464       break;
2465     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2466       break;
2467     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2468       break;
2469     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2470       break;
2471     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2472       break;
2473     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2474       break;
2475     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2476       break;
2477     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2478       break;
2479     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2480       break;
2481     }
2482
2483   return ppc64_elf_howto_table[r];
2484 };
2485
2486 static reloc_howto_type *
2487 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488                              const char *r_name)
2489 {
2490   unsigned int i;
2491
2492   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2493     if (ppc64_elf_howto_raw[i].name != NULL
2494         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495       return &ppc64_elf_howto_raw[i];
2496
2497   return NULL;
2498 }
2499
2500 /* Set the howto pointer for a PowerPC ELF reloc.  */
2501
2502 static void
2503 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2504                          Elf_Internal_Rela *dst)
2505 {
2506   unsigned int type;
2507
2508   /* Initialize howto table if needed.  */
2509   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2510     ppc_howto_init ();
2511
2512   type = ELF64_R_TYPE (dst->r_info);
2513   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514     {
2515       /* xgettext:c-format */
2516       _bfd_error_handler (_("%B: invalid relocation type %d"),
2517                           abfd, (int) type);
2518       type = R_PPC64_NONE;
2519     }
2520   cache_ptr->howto = ppc64_elf_howto_table[type];
2521 }
2522
2523 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                     void *data, asection *input_section,
2528                     bfd *output_bfd, char **error_message)
2529 {
2530   enum elf_ppc64_reloc_type r_type;
2531   long insn;
2532   bfd_size_type octets;
2533   bfd_vma value;
2534
2535   /* If this is a relocatable link (output_bfd test tells us), just
2536      call the generic function.  Any adjustment will be done at final
2537      link time.  */
2538   if (output_bfd != NULL)
2539     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540                                   input_section, output_bfd, error_message);
2541
2542   /* Adjust the addend for sign extension of the low 16 bits.
2543      We won't actually be using the low 16 bits, so trashing them
2544      doesn't matter.  */
2545   reloc_entry->addend += 0x8000;
2546   r_type = reloc_entry->howto->type;
2547   if (r_type != R_PPC64_REL16DX_HA)
2548     return bfd_reloc_continue;
2549
2550   value = 0;
2551   if (!bfd_is_com_section (symbol->section))
2552     value = symbol->value;
2553   value += (reloc_entry->addend
2554             + symbol->section->output_offset
2555             + symbol->section->output_section->vma);
2556   value -= (reloc_entry->address
2557             + input_section->output_offset
2558             + input_section->output_section->vma);
2559   value = (bfd_signed_vma) value >> 16;
2560
2561   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563   insn &= ~0x1fffc1;
2564   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2565   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2566   if (value + 0x8000 > 0xffff)
2567     return bfd_reloc_overflow;
2568   return bfd_reloc_ok;
2569 }
2570
2571 static bfd_reloc_status_type
2572 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573                         void *data, asection *input_section,
2574                         bfd *output_bfd, char **error_message)
2575 {
2576   if (output_bfd != NULL)
2577     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578                                   input_section, output_bfd, error_message);
2579
2580   if (strcmp (symbol->section->name, ".opd") == 0
2581       && (symbol->section->owner->flags & DYNAMIC) == 0)
2582     {
2583       bfd_vma dest = opd_entry_value (symbol->section,
2584                                       symbol->value + reloc_entry->addend,
2585                                       NULL, NULL, FALSE);
2586       if (dest != (bfd_vma) -1)
2587         reloc_entry->addend = dest - (symbol->value
2588                                       + symbol->section->output_section->vma
2589                                       + symbol->section->output_offset);
2590     }
2591   else
2592     {
2593       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595       if (symbol->section->owner != abfd
2596           && symbol->section->owner != NULL
2597           && abiversion (symbol->section->owner) >= 2)
2598         {
2599           unsigned int i;
2600
2601           for (i = 0; i < symbol->section->owner->symcount; ++i)
2602             {
2603               asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605               if (strcmp (symdef->name, symbol->name) == 0)
2606                 {
2607                   elfsym = (elf_symbol_type *) symdef;
2608                   break;
2609                 }
2610             }
2611         }
2612       reloc_entry->addend
2613         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614     }
2615   return bfd_reloc_continue;
2616 }
2617
2618 static bfd_reloc_status_type
2619 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620                          void *data, asection *input_section,
2621                          bfd *output_bfd, char **error_message)
2622 {
2623   long insn;
2624   enum elf_ppc64_reloc_type r_type;
2625   bfd_size_type octets;
2626   /* Assume 'at' branch hints.  */
2627   bfd_boolean is_isa_v2 = TRUE;
2628
2629   /* If this is a relocatable link (output_bfd test tells us), just
2630      call the generic function.  Any adjustment will be done at final
2631      link time.  */
2632   if (output_bfd != NULL)
2633     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2634                                   input_section, output_bfd, error_message);
2635
2636   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638   insn &= ~(0x01 << 21);
2639   r_type = reloc_entry->howto->type;
2640   if (r_type == R_PPC64_ADDR14_BRTAKEN
2641       || r_type == R_PPC64_REL14_BRTAKEN)
2642     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2643
2644   if (is_isa_v2)
2645     {
2646       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2647          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2649       if ((insn & (0x14 << 21)) == (0x04 << 21))
2650         insn |= 0x02 << 21;
2651       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652         insn |= 0x08 << 21;
2653       else
2654         goto out;
2655     }
2656   else
2657     {
2658       bfd_vma target = 0;
2659       bfd_vma from;
2660
2661       if (!bfd_is_com_section (symbol->section))
2662         target = symbol->value;
2663       target += symbol->section->output_section->vma;
2664       target += symbol->section->output_offset;
2665       target += reloc_entry->addend;
2666
2667       from = (reloc_entry->address
2668               + input_section->output_offset
2669               + input_section->output_section->vma);
2670
2671       /* Invert 'y' bit if not the default.  */
2672       if ((bfd_signed_vma) (target - from) < 0)
2673         insn ^= 0x01 << 21;
2674     }
2675   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676  out:
2677   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678                                  input_section, output_bfd, error_message);
2679 }
2680
2681 static bfd_reloc_status_type
2682 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683                          void *data, asection *input_section,
2684                          bfd *output_bfd, char **error_message)
2685 {
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   /* Subtract the symbol section base address.  */
2694   reloc_entry->addend -= symbol->section->output_section->vma;
2695   return bfd_reloc_continue;
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700                             void *data, asection *input_section,
2701                             bfd *output_bfd, char **error_message)
2702 {
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   /* Subtract the symbol section base address.  */
2711   reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713   /* Adjust the addend for sign extension of the low 16 bits.  */
2714   reloc_entry->addend += 0x8000;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                      void *data, asection *input_section,
2721                      bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738   return bfd_reloc_continue;
2739 }
2740
2741 static bfd_reloc_status_type
2742 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743                         void *data, asection *input_section,
2744                         bfd *output_bfd, char **error_message)
2745 {
2746   bfd_vma TOCstart;
2747
2748   /* If this is a relocatable link (output_bfd test tells us), just
2749      call the generic function.  Any adjustment will be done at final
2750      link time.  */
2751   if (output_bfd != NULL)
2752     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2753                                   input_section, output_bfd, error_message);
2754
2755   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756   if (TOCstart == 0)
2757     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758
2759   /* Subtract the TOC base address.  */
2760   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                        void *data, asection *input_section,
2770                        bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773   bfd_size_type octets;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788   return bfd_reloc_ok;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                            void *data, asection *input_section,
2794                            bfd *output_bfd, char **error_message)
2795 {
2796   /* If this is a relocatable link (output_bfd test tells us), just
2797      call the generic function.  Any adjustment will be done at final
2798      link time.  */
2799   if (output_bfd != NULL)
2800     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2801                                   input_section, output_bfd, error_message);
2802
2803   if (error_message != NULL)
2804     {
2805       static char buf[60];
2806       sprintf (buf, "generic linker can't handle %s",
2807                reloc_entry->howto->name);
2808       *error_message = buf;
2809     }
2810   return bfd_reloc_dangerous;
2811 }
2812
2813 /* Track GOT entries needed for a given symbol.  We might need more
2814    than one got entry per symbol.  */
2815 struct got_entry
2816 {
2817   struct got_entry *next;
2818
2819   /* The symbol addend that we'll be placing in the GOT.  */
2820   bfd_vma addend;
2821
2822   /* Unlike other ELF targets, we use separate GOT entries for the same
2823      symbol referenced from different input files.  This is to support
2824      automatic multiple TOC/GOT sections, where the TOC base can vary
2825      from one input file to another.  After partitioning into TOC groups
2826      we merge entries within the group.
2827
2828      Point to the BFD owning this GOT entry.  */
2829   bfd *owner;
2830
2831   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832      TLS_TPREL or TLS_DTPREL for tls entries.  */
2833   unsigned char tls_type;
2834
2835   /* Non-zero if got.ent points to real entry.  */
2836   unsigned char is_indirect;
2837
2838   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2839   union
2840     {
2841       bfd_signed_vma refcount;
2842       bfd_vma offset;
2843       struct got_entry *ent;
2844     } got;
2845 };
2846
2847 /* The same for PLT.  */
2848 struct plt_entry
2849 {
2850   struct plt_entry *next;
2851
2852   bfd_vma addend;
2853
2854   union
2855     {
2856       bfd_signed_vma refcount;
2857       bfd_vma offset;
2858     } plt;
2859 };
2860
2861 struct ppc64_elf_obj_tdata
2862 {
2863   struct elf_obj_tdata elf;
2864
2865   /* Shortcuts to dynamic linker sections.  */
2866   asection *got;
2867   asection *relgot;
2868
2869   /* Used during garbage collection.  We attach global symbols defined
2870      on removed .opd entries to this section so that the sym is removed.  */
2871   asection *deleted_section;
2872
2873   /* TLS local dynamic got entry handling.  Support for multiple GOT
2874      sections means we potentially need one of these for each input bfd.  */
2875   struct got_entry tlsld_got;
2876
2877   union {
2878     /* A copy of relocs before they are modified for --emit-relocs.  */
2879     Elf_Internal_Rela *relocs;
2880
2881     /* Section contents.  */
2882     bfd_byte *contents;
2883   } opd;
2884
2885   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886      the reloc to be in the range -32768 to 32767.  */
2887   unsigned int has_small_toc_reloc : 1;
2888
2889   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890      instruction not one we handle.  */
2891   unsigned int unexpected_toc_insn : 1;
2892 };
2893
2894 #define ppc64_elf_tdata(bfd) \
2895   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897 #define ppc64_tlsld_got(bfd) \
2898   (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
2900 #define is_ppc64_elf(bfd) \
2901   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2902    && elf_object_id (bfd) == PPC64_ELF_DATA)
2903
2904 /* Override the generic function because we store some extras.  */
2905
2906 static bfd_boolean
2907 ppc64_elf_mkobject (bfd *abfd)
2908 {
2909   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2910                                   PPC64_ELF_DATA);
2911 }
2912
2913 /* Fix bad default arch selected for a 64 bit input bfd when the
2914    default is 32 bit.  Also select arch based on apuinfo.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_object_p (bfd *abfd)
2918 {
2919   if (!abfd->arch_info->the_default)
2920     return TRUE;
2921
2922   if (abfd->arch_info->bits_per_word == 32)
2923     {
2924       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927         {
2928           /* Relies on arch after 32 bit default being 64 bit default.  */
2929           abfd->arch_info = abfd->arch_info->next;
2930           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931         }
2932     }
2933   return _bfd_elf_ppc_set_arch (abfd);
2934 }
2935
2936 /* Support for core dump NOTE sections.  */
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   size_t offset, size;
2942
2943   if (note->descsz != 504)
2944     return FALSE;
2945
2946   /* pr_cursig */
2947   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2948
2949   /* pr_pid */
2950   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2951
2952   /* pr_reg */
2953   offset = 112;
2954   size = 384;
2955
2956   /* Make a ".reg/999" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   if (note->descsz != 136)
2965     return FALSE;
2966
2967   elf_tdata (abfd)->core->pid
2968     = bfd_get_32 (abfd, note->descdata + 24);
2969   elf_tdata (abfd)->core->program
2970     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2971   elf_tdata (abfd)->core->command
2972     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974   return TRUE;
2975 }
2976
2977 static char *
2978 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979                            ...)
2980 {
2981   switch (note_type)
2982     {
2983     default:
2984       return NULL;
2985
2986     case NT_PRPSINFO:
2987       {
2988         char data[136];
2989         va_list ap;
2990
2991         va_start (ap, note_type);
2992         memset (data, 0, sizeof (data));
2993         strncpy (data + 40, va_arg (ap, const char *), 16);
2994         strncpy (data + 56, va_arg (ap, const char *), 80);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999
3000     case NT_PRSTATUS:
3001       {
3002         char data[504];
3003         va_list ap;
3004         long pid;
3005         int cursig;
3006         const void *greg;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, 112);
3010         pid = va_arg (ap, long);
3011         bfd_put_32 (abfd, pid, data + 32);
3012         cursig = va_arg (ap, int);
3013         bfd_put_16 (abfd, cursig, data + 12);
3014         greg = va_arg (ap, const void *);
3015         memcpy (data + 112, greg, 384);
3016         memset (data + 496, 0, 8);
3017         va_end (ap);
3018         return elfcore_write_note (abfd, buf, bufsiz,
3019                                    "CORE", note_type, data, sizeof (data));
3020       }
3021     }
3022 }
3023
3024 /* Add extra PPC sections.  */
3025
3026 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 {
3028   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3029   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3034   { NULL,                     0,  0, 0,            0 }
3035 };
3036
3037 enum _ppc64_sec_type {
3038   sec_normal = 0,
3039   sec_opd = 1,
3040   sec_toc = 2
3041 };
3042
3043 struct _ppc64_elf_section_data
3044 {
3045   struct bfd_elf_section_data elf;
3046
3047   union
3048   {
3049     /* An array with one entry for each opd function descriptor,
3050        and some spares since opd entries may be either 16 or 24 bytes.  */
3051 #define OPD_NDX(OFF) ((OFF) >> 4)
3052     struct _opd_sec_data
3053     {
3054       /* Points to the function code section for local opd entries.  */
3055       asection **func_sec;
3056
3057       /* After editing .opd, adjust references to opd local syms.  */
3058       long *adjust;
3059     } opd;
3060
3061     /* An array for toc sections, indexed by offset/8.  */
3062     struct _toc_sec_data
3063     {
3064       /* Specifies the relocation symbol index used at a given toc offset.  */
3065       unsigned *symndx;
3066
3067       /* And the relocation addend.  */
3068       bfd_vma *add;
3069     } toc;
3070   } u;
3071
3072   enum _ppc64_sec_type sec_type:2;
3073
3074   /* Flag set when small branches are detected.  Used to
3075      select suitable defaults for the stub group size.  */
3076   unsigned int has_14bit_branch:1;
3077 };
3078
3079 #define ppc64_elf_section_data(sec) \
3080   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3081
3082 static bfd_boolean
3083 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 {
3085   if (!sec->used_by_bfd)
3086     {
3087       struct _ppc64_elf_section_data *sdata;
3088       bfd_size_type amt = sizeof (*sdata);
3089
3090       sdata = bfd_zalloc (abfd, amt);
3091       if (sdata == NULL)
3092         return FALSE;
3093       sec->used_by_bfd = sdata;
3094     }
3095
3096   return _bfd_elf_new_section_hook (abfd, sec);
3097 }
3098
3099 static struct _opd_sec_data *
3100 get_opd_info (asection * sec)
3101 {
3102   if (sec != NULL
3103       && ppc64_elf_section_data (sec) != NULL
3104       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3105     return &ppc64_elf_section_data (sec)->u.opd;
3106   return NULL;
3107 }
3108 \f
3109 /* Parameters for the qsort hook.  */
3110 static bfd_boolean synthetic_relocatable;
3111 static asection *synthetic_opd;
3112
3113 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3114
3115 static int
3116 compare_symbols (const void *ap, const void *bp)
3117 {
3118   const asymbol *a = * (const asymbol **) ap;
3119   const asymbol *b = * (const asymbol **) bp;
3120
3121   /* Section symbols first.  */
3122   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123     return -1;
3124   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3125     return 1;
3126
3127   /* then .opd symbols.  */
3128   if (synthetic_opd != NULL)
3129     {
3130       if (strcmp (a->section->name, ".opd") == 0
3131           && strcmp (b->section->name, ".opd") != 0)
3132         return -1;
3133       if (strcmp (a->section->name, ".opd") != 0
3134           && strcmp (b->section->name, ".opd") == 0)
3135         return 1;
3136     }
3137
3138   /* then other code symbols.  */
3139   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140       == (SEC_CODE | SEC_ALLOC)
3141       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142          != (SEC_CODE | SEC_ALLOC))
3143     return -1;
3144
3145   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146       != (SEC_CODE | SEC_ALLOC)
3147       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148          == (SEC_CODE | SEC_ALLOC))
3149     return 1;
3150
3151   if (synthetic_relocatable)
3152     {
3153       if (a->section->id < b->section->id)
3154         return -1;
3155
3156       if (a->section->id > b->section->id)
3157         return 1;
3158     }
3159
3160   if (a->value + a->section->vma < b->value + b->section->vma)
3161     return -1;
3162
3163   if (a->value + a->section->vma > b->value + b->section->vma)
3164     return 1;
3165
3166   /* For syms with the same value, prefer strong dynamic global function
3167      syms over other syms.  */
3168   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169     return -1;
3170
3171   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172     return 1;
3173
3174   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175     return -1;
3176
3177   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178     return 1;
3179
3180   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181     return -1;
3182
3183   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184     return 1;
3185
3186   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190     return 1;
3191
3192   return a > b;
3193 }
3194
3195 /* Search SYMS for a symbol of the given VALUE.  */
3196
3197 static asymbol *
3198 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3199 {
3200   long mid;
3201
3202   if (id == (unsigned) -1)
3203     {
3204       while (lo < hi)
3205         {
3206           mid = (lo + hi) >> 1;
3207           if (syms[mid]->value + syms[mid]->section->vma < value)
3208             lo = mid + 1;
3209           else if (syms[mid]->value + syms[mid]->section->vma > value)
3210             hi = mid;
3211           else
3212             return syms[mid];
3213         }
3214     }
3215   else
3216     {
3217       while (lo < hi)
3218         {
3219           mid = (lo + hi) >> 1;
3220           if (syms[mid]->section->id < id)
3221             lo = mid + 1;
3222           else if (syms[mid]->section->id > id)
3223             hi = mid;
3224           else if (syms[mid]->value < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   return NULL;
3233 }
3234
3235 static bfd_boolean
3236 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 {
3238   bfd_vma vma = *(bfd_vma *) ptr;
3239   return ((section->flags & SEC_ALLOC) != 0
3240           && section->vma <= vma
3241           && vma < section->vma + section->size);
3242 }
3243
3244 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3245    entry syms.  Also generate @plt symbols for the glink branch table.
3246    Returns count of synthetic symbols in RET or -1 on error.  */
3247
3248 static long
3249 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250                                 long static_count, asymbol **static_syms,
3251                                 long dyn_count, asymbol **dyn_syms,
3252                                 asymbol **ret)
3253 {
3254   asymbol *s;
3255   long i;
3256   long count;
3257   char *names;
3258   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3259   asection *opd = NULL;
3260   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261   asymbol **syms;
3262   int abi = abiversion (abfd);
3263
3264   *ret = NULL;
3265
3266   if (abi < 2)
3267     {
3268       opd = bfd_get_section_by_name (abfd, ".opd");
3269       if (opd == NULL && abi == 1)
3270         return 0;
3271     }
3272
3273   symcount = static_count;
3274   if (!relocatable)
3275     symcount += dyn_count;
3276   if (symcount == 0)
3277     return 0;
3278
3279   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3280   if (syms == NULL)
3281     return -1;
3282
3283   if (!relocatable && static_count != 0 && dyn_count != 0)
3284     {
3285       /* Use both symbol tables.  */
3286       memcpy (syms, static_syms, static_count * sizeof (*syms));
3287       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288     }
3289   else if (!relocatable && static_count == 0)
3290     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291   else
3292     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293
3294   synthetic_relocatable = relocatable;
3295   synthetic_opd = opd;
3296   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3297
3298   if (!relocatable && symcount > 1)
3299     {
3300       long j;
3301       /* Trim duplicate syms, since we may have merged the normal and
3302          dynamic symbols.  Actually, we only care about syms that have
3303          different values, so trim any with the same value.  */
3304       for (i = 1, j = 1; i < symcount; ++i)
3305         if (syms[i - 1]->value + syms[i - 1]->section->vma
3306             != syms[i]->value + syms[i]->section->vma)
3307           syms[j++] = syms[i];
3308       symcount = j;
3309     }
3310
3311   i = 0;
3312   /* Note that here and in compare_symbols we can't compare opd and
3313      sym->section directly.  With separate debug info files, the
3314      symbols will be extracted from the debug file while abfd passed
3315      to this function is the real binary.  */
3316   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3317     ++i;
3318   codesecsym = i;
3319
3320   for (; i < symcount; ++i)
3321     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3322          != (SEC_CODE | SEC_ALLOC))
3323         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3324       break;
3325   codesecsymend = i;
3326
3327   for (; i < symcount; ++i)
3328     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3329       break;
3330   secsymend = i;
3331
3332   if (opd != NULL)
3333     for (; i < symcount; ++i)
3334       if (strcmp (syms[i]->section->name, ".opd") != 0)
3335         break;
3336   opdsymend = i;
3337
3338   for (; i < symcount; ++i)
3339     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3340         != (SEC_CODE | SEC_ALLOC))
3341       break;
3342   symcount = i;
3343
3344   count = 0;
3345
3346   if (relocatable)
3347     {
3348       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3349       arelent *r;
3350       size_t size;
3351       long relcount;
3352
3353       if (opdsymend == secsymend)
3354         goto done;
3355
3356       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3357       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3358       if (relcount == 0)
3359         goto done;
3360
3361       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       size = 0;
3368       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3369         {
3370           asymbol *sym;
3371
3372           while (r < opd->relocation + relcount
3373                  && r->address < syms[i]->value + opd->vma)
3374             ++r;
3375
3376           if (r == opd->relocation + relcount)
3377             break;
3378
3379           if (r->address != syms[i]->value + opd->vma)
3380             continue;
3381
3382           if (r->howto->type != R_PPC64_ADDR64)
3383             continue;
3384
3385           sym = *r->sym_ptr_ptr;
3386           if (!sym_exists_at (syms, opdsymend, symcount,
3387                               sym->section->id, sym->value + r->addend))
3388             {
3389               ++count;
3390               size += sizeof (asymbol);
3391               size += strlen (syms[i]->name) + 2;
3392             }
3393         }
3394
3395       if (size == 0)
3396         goto done;
3397       s = *ret = bfd_malloc (size);
3398       if (s == NULL)
3399         {
3400           count = -1;
3401           goto done;
3402         }
3403
3404       names = (char *) (s + count);
3405
3406       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3407         {
3408           asymbol *sym;
3409
3410           while (r < opd->relocation + relcount
3411                  && r->address < syms[i]->value + opd->vma)
3412             ++r;
3413
3414           if (r == opd->relocation + relcount)
3415             break;
3416
3417           if (r->address != syms[i]->value + opd->vma)
3418             continue;
3419
3420           if (r->howto->type != R_PPC64_ADDR64)
3421             continue;
3422
3423           sym = *r->sym_ptr_ptr;
3424           if (!sym_exists_at (syms, opdsymend, symcount,
3425                               sym->section->id, sym->value + r->addend))
3426             {
3427               size_t len;
3428
3429               *s = *syms[i];
3430               s->flags |= BSF_SYNTHETIC;
3431               s->section = sym->section;
3432               s->value = sym->value + r->addend;
3433               s->name = names;
3434               *names++ = '.';
3435               len = strlen (syms[i]->name);
3436               memcpy (names, syms[i]->name, len + 1);
3437               names += len + 1;
3438               /* Have udata.p point back to the original symbol this
3439                  synthetic symbol was derived from.  */
3440               s->udata.p = syms[i];
3441               s++;
3442             }
3443         }
3444     }
3445   else
3446     {
3447       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3448       bfd_byte *contents = NULL;
3449       size_t size;
3450       long plt_count = 0;
3451       bfd_vma glink_vma = 0, resolv_vma = 0;
3452       asection *dynamic, *glink = NULL, *relplt = NULL;
3453       arelent *p;
3454
3455       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3456         {
3457         free_contents_and_exit_err:
3458           count = -1;
3459         free_contents_and_exit:
3460           if (contents)
3461             free (contents);
3462           goto done;
3463         }
3464
3465       size = 0;
3466       for (i = secsymend; i < opdsymend; ++i)
3467         {
3468           bfd_vma ent;
3469
3470           /* Ignore bogus symbols.  */
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               ++count;
3478               size += sizeof (asymbol);
3479               size += strlen (syms[i]->name) + 2;
3480             }
3481         }
3482
3483       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3484       if (dyn_count != 0
3485           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3486         {
3487           bfd_byte *dynbuf, *extdyn, *extdynend;
3488           size_t extdynsize;
3489           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490
3491           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3492             goto free_contents_and_exit_err;
3493
3494           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3495           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3496
3497           extdyn = dynbuf;
3498           extdynend = extdyn + dynamic->size;
3499           for (; extdyn < extdynend; extdyn += extdynsize)
3500             {
3501               Elf_Internal_Dyn dyn;
3502               (*swap_dyn_in) (abfd, extdyn, &dyn);
3503
3504               if (dyn.d_tag == DT_NULL)
3505                 break;
3506
3507               if (dyn.d_tag == DT_PPC64_GLINK)
3508                 {
3509                   /* The first glink stub starts at offset 32; see
3510                      comment in ppc64_elf_finish_dynamic_sections. */
3511                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3512                   /* The .glink section usually does not survive the final
3513                      link; search for the section (usually .text) where the
3514                      glink stubs now reside.  */
3515                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3516                                                 &glink_vma);
3517                   break;
3518                 }
3519             }
3520
3521           free (dynbuf);
3522         }
3523
3524       if (glink != NULL)
3525         {
3526           /* Determine __glink trampoline by reading the relative branch
3527              from the first glink stub.  */
3528           bfd_byte buf[4];
3529           unsigned int off = 0;
3530
3531           while (bfd_get_section_contents (abfd, glink, buf,
3532                                            glink_vma + off - glink->vma, 4))
3533             {
3534               unsigned int insn = bfd_get_32 (abfd, buf);
3535               insn ^= B_DOT;
3536               if ((insn & ~0x3fffffc) == 0)
3537                 {
3538                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3539                   break;
3540                 }
3541               off += 4;
3542               if (off > 4)
3543                 break;
3544             }
3545
3546           if (resolv_vma)
3547             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3548
3549           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3550           if (relplt != NULL)
3551             {
3552               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3553               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3554                 goto free_contents_and_exit_err;
3555
3556               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3557               size += plt_count * sizeof (asymbol);
3558
3559               p = relplt->relocation;
3560               for (i = 0; i < plt_count; i++, p++)
3561                 {
3562                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563                   if (p->addend != 0)
3564                     size += sizeof ("+0x") - 1 + 16;
3565                 }
3566             }
3567         }
3568
3569       if (size == 0)
3570         goto free_contents_and_exit;
3571       s = *ret = bfd_malloc (size);
3572       if (s == NULL)
3573         goto free_contents_and_exit_err;
3574
3575       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3576
3577       for (i = secsymend; i < opdsymend; ++i)
3578         {
3579           bfd_vma ent;
3580
3581           if (syms[i]->value > opd->size - 8)
3582             continue;
3583
3584           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3585           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3586             {
3587               long lo, hi;
3588               size_t len;
3589               asection *sec = abfd->sections;
3590
3591               *s = *syms[i];
3592               lo = codesecsym;
3593               hi = codesecsymend;
3594               while (lo < hi)
3595                 {
3596                   long mid = (lo + hi) >> 1;
3597                   if (syms[mid]->section->vma < ent)
3598                     lo = mid + 1;
3599                   else if (syms[mid]->section->vma > ent)
3600                     hi = mid;
3601                   else
3602                     {
3603                       sec = syms[mid]->section;
3604                       break;
3605                     }
3606                 }
3607
3608               if (lo >= hi && lo > codesecsym)
3609                 sec = syms[lo - 1]->section;
3610
3611               for (; sec != NULL; sec = sec->next)
3612                 {
3613                   if (sec->vma > ent)
3614                     break;
3615                   /* SEC_LOAD may not be set if SEC is from a separate debug
3616                      info file.  */
3617                   if ((sec->flags & SEC_ALLOC) == 0)
3618                     break;
3619                   if ((sec->flags & SEC_CODE) != 0)
3620                     s->section = sec;
3621                 }
3622               s->flags |= BSF_SYNTHETIC;
3623               s->value = ent - s->section->vma;
3624               s->name = names;
3625               *names++ = '.';
3626               len = strlen (syms[i]->name);
3627               memcpy (names, syms[i]->name, len + 1);
3628               names += len + 1;
3629               /* Have udata.p point back to the original symbol this
3630                  synthetic symbol was derived from.  */
3631               s->udata.p = syms[i];
3632               s++;
3633             }
3634         }
3635       free (contents);
3636
3637       if (glink != NULL && relplt != NULL)
3638         {
3639           if (resolv_vma)
3640             {
3641               /* Add a symbol for the main glink trampoline.  */
3642               memset (s, 0, sizeof *s);
3643               s->the_bfd = abfd;
3644               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3645               s->section = glink;
3646               s->value = resolv_vma - glink->vma;
3647               s->name = names;
3648               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3649               names += sizeof ("__glink_PLTresolve");
3650               s++;
3651               count++;
3652             }
3653
3654           /* FIXME: It would be very much nicer to put sym@plt on the
3655              stub rather than on the glink branch table entry.  The
3656              objdump disassembler would then use a sensible symbol
3657              name on plt calls.  The difficulty in doing so is
3658              a) finding the stubs, and,
3659              b) matching stubs against plt entries, and,
3660              c) there can be multiple stubs for a given plt entry.
3661
3662              Solving (a) could be done by code scanning, but older
3663              ppc64 binaries used different stubs to current code.
3664              (b) is the tricky one since you need to known the toc
3665              pointer for at least one function that uses a pic stub to
3666              be able to calculate the plt address referenced.
3667              (c) means gdb would need to set multiple breakpoints (or
3668              find the glink branch itself) when setting breakpoints
3669              for pending shared library loads.  */
3670           p = relplt->relocation;
3671           for (i = 0; i < plt_count; i++, p++)
3672             {
3673               size_t len;
3674
3675               *s = **p->sym_ptr_ptr;
3676               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3677                  we are defining a symbol, ensure one of them is set.  */
3678               if ((s->flags & BSF_LOCAL) == 0)
3679                 s->flags |= BSF_GLOBAL;
3680               s->flags |= BSF_SYNTHETIC;
3681               s->section = glink;
3682               s->value = glink_vma - glink->vma;
3683               s->name = names;
3684               s->udata.p = NULL;
3685               len = strlen ((*p->sym_ptr_ptr)->name);
3686               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3687               names += len;
3688               if (p->addend != 0)
3689                 {
3690                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3691                   names += sizeof ("+0x") - 1;
3692                   bfd_sprintf_vma (abfd, names, p->addend);
3693                   names += strlen (names);
3694                 }
3695               memcpy (names, "@plt", sizeof ("@plt"));
3696               names += sizeof ("@plt");
3697               s++;
3698               if (abi < 2)
3699                 {
3700                   glink_vma += 8;
3701                   if (i >= 0x8000)
3702                     glink_vma += 4;
3703                 }
3704               else
3705                 glink_vma += 4;
3706             }
3707           count += plt_count;
3708         }
3709     }
3710
3711  done:
3712   free (syms);
3713   return count;
3714 }
3715 \f
3716 /* The following functions are specific to the ELF linker, while
3717    functions above are used generally.  Those named ppc64_elf_* are
3718    called by the main ELF linker code.  They appear in this file more
3719    or less in the order in which they are called.  eg.
3720    ppc64_elf_check_relocs is called early in the link process,
3721    ppc64_elf_finish_dynamic_sections is one of the last functions
3722    called.
3723
3724    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3725    functions have both a function code symbol and a function descriptor
3726    symbol.  A call to foo in a relocatable object file looks like:
3727
3728    .            .text
3729    .    x:
3730    .            bl      .foo
3731    .            nop
3732
3733    The function definition in another object file might be:
3734
3735    .            .section .opd
3736    .    foo:    .quad   .foo
3737    .            .quad   .TOC.@tocbase
3738    .            .quad   0
3739    .
3740    .            .text
3741    .    .foo:   blr
3742
3743    When the linker resolves the call during a static link, the branch
3744    unsurprisingly just goes to .foo and the .opd information is unused.
3745    If the function definition is in a shared library, things are a little
3746    different:  The call goes via a plt call stub, the opd information gets
3747    copied to the plt, and the linker patches the nop.
3748
3749    .    x:
3750    .            bl      .foo_stub
3751    .            ld      2,40(1)
3752    .
3753    .
3754    .    .foo_stub:
3755    .            std     2,40(1)                 # in practice, the call stub
3756    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3757    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3758    .            ld      12,0(11)
3759    .            ld      2,8(11)
3760    .            mtctr   12
3761    .            ld      11,16(11)
3762    .            bctr
3763    .
3764    .            .section .plt
3765    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3766
3767    The "reloc ()" notation is supposed to indicate that the linker emits
3768    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3769    copying.
3770
3771    What are the difficulties here?  Well, firstly, the relocations
3772    examined by the linker in check_relocs are against the function code
3773    sym .foo, while the dynamic relocation in the plt is emitted against
3774    the function descriptor symbol, foo.  Somewhere along the line, we need
3775    to carefully copy dynamic link information from one symbol to the other.
3776    Secondly, the generic part of the elf linker will make .foo a dynamic
3777    symbol as is normal for most other backends.  We need foo dynamic
3778    instead, at least for an application final link.  However, when
3779    creating a shared library containing foo, we need to have both symbols
3780    dynamic so that references to .foo are satisfied during the early
3781    stages of linking.  Otherwise the linker might decide to pull in a
3782    definition from some other object, eg. a static library.
3783
3784    Update: As of August 2004, we support a new convention.  Function
3785    calls may use the function descriptor symbol, ie. "bl foo".  This
3786    behaves exactly as "bl .foo".  */
3787
3788 /* Of those relocs that might be copied as dynamic relocs, this function
3789    selects those that must be copied when linking a shared library,
3790    even when the symbol is local.  */
3791
3792 static int
3793 must_be_dyn_reloc (struct bfd_link_info *info,
3794                    enum elf_ppc64_reloc_type r_type)
3795 {
3796   switch (r_type)
3797     {
3798     default:
3799       return 1;
3800
3801     case R_PPC64_REL32:
3802     case R_PPC64_REL64:
3803     case R_PPC64_REL30:
3804       return 0;
3805
3806     case R_PPC64_TPREL16:
3807     case R_PPC64_TPREL16_LO:
3808     case R_PPC64_TPREL16_HI:
3809     case R_PPC64_TPREL16_HA:
3810     case R_PPC64_TPREL16_DS:
3811     case R_PPC64_TPREL16_LO_DS:
3812     case R_PPC64_TPREL16_HIGH:
3813     case R_PPC64_TPREL16_HIGHA:
3814     case R_PPC64_TPREL16_HIGHER:
3815     case R_PPC64_TPREL16_HIGHERA:
3816     case R_PPC64_TPREL16_HIGHEST:
3817     case R_PPC64_TPREL16_HIGHESTA:
3818     case R_PPC64_TPREL64:
3819       return !bfd_link_executable (info);
3820     }
3821 }
3822
3823 /* Whether an undefined weak symbol should resolve to its link-time
3824    value, even in PIC or PIE objects.  */
3825 #define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H)             \
3826   ((H)->root.type == bfd_link_hash_undefweak            \
3827    && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT    \
3828        || (INFO)->dynamic_undefined_weak == 0))
3829
3830 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3831    copying dynamic variables from a shared lib into an app's dynbss
3832    section, and instead use a dynamic relocation to point into the
3833    shared lib.  With code that gcc generates, it's vital that this be
3834    enabled;  In the PowerPC64 ABI, the address of a function is actually
3835    the address of a function descriptor, which resides in the .opd
3836    section.  gcc uses the descriptor directly rather than going via the
3837    GOT as some other ABI's do, which means that initialized function
3838    pointers must reference the descriptor.  Thus, a function pointer
3839    initialized to the address of a function in a shared library will
3840    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3841    redefines the function descriptor symbol to point to the copy.  This
3842    presents a problem as a plt entry for that function is also
3843    initialized from the function descriptor symbol and the copy reloc
3844    may not be initialized first.  */
3845 #define ELIMINATE_COPY_RELOCS 1
3846
3847 /* Section name for stubs is the associated section name plus this
3848    string.  */
3849 #define STUB_SUFFIX ".stub"
3850
3851 /* Linker stubs.
3852    ppc_stub_long_branch:
3853    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3854    destination, but a 24 bit branch in a stub section will reach.
3855    .    b       dest
3856
3857    ppc_stub_plt_branch:
3858    Similar to the above, but a 24 bit branch in the stub section won't
3859    reach its destination.
3860    .    addis   %r11,%r2,xxx@toc@ha
3861    .    ld      %r12,xxx@toc@l(%r11)
3862    .    mtctr   %r12
3863    .    bctr
3864
3865    ppc_stub_plt_call:
3866    Used to call a function in a shared library.  If it so happens that
3867    the plt entry referenced crosses a 64k boundary, then an extra
3868    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3869    .    std     %r2,40(%r1)
3870    .    addis   %r11,%r2,xxx@toc@ha
3871    .    ld      %r12,xxx+0@toc@l(%r11)
3872    .    mtctr   %r12
3873    .    ld      %r2,xxx+8@toc@l(%r11)
3874    .    ld      %r11,xxx+16@toc@l(%r11)
3875    .    bctr
3876
3877    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3878    code to adjust the value and save r2 to support multiple toc sections.
3879    A ppc_stub_long_branch with an r2 offset looks like:
3880    .    std     %r2,40(%r1)
3881    .    addis   %r2,%r2,off@ha
3882    .    addi    %r2,%r2,off@l
3883    .    b       dest
3884
3885    A ppc_stub_plt_branch with an r2 offset looks like:
3886    .    std     %r2,40(%r1)
3887    .    addis   %r11,%r2,xxx@toc@ha
3888    .    ld      %r12,xxx@toc@l(%r11)
3889    .    addis   %r2,%r2,off@ha
3890    .    addi    %r2,%r2,off@l
3891    .    mtctr   %r12
3892    .    bctr
3893
3894    In cases where the "addis" instruction would add zero, the "addis" is
3895    omitted and following instructions modified slightly in some cases.
3896 */
3897
3898 enum ppc_stub_type {
3899   ppc_stub_none,
3900   ppc_stub_long_branch,
3901   ppc_stub_long_branch_r2off,
3902   ppc_stub_plt_branch,
3903   ppc_stub_plt_branch_r2off,
3904   ppc_stub_plt_call,
3905   ppc_stub_plt_call_r2save,
3906   ppc_stub_global_entry,
3907   ppc_stub_save_res
3908 };
3909
3910 /* Information on stub grouping.  */
3911 struct map_stub
3912 {
3913   /* The stub section.  */
3914   asection *stub_sec;
3915   /* This is the section to which stubs in the group will be attached.  */
3916   asection *link_sec;
3917   /* Next group.  */
3918   struct map_stub *next;
3919   /* Whether to emit a copy of register save/restore functions in this
3920      group.  */
3921   int needs_save_res;
3922   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3923      or -1u if no such stub with bctrl exists.  */
3924   unsigned int tls_get_addr_opt_bctrl;
3925 };
3926
3927 struct ppc_stub_hash_entry {
3928
3929   /* Base hash table entry structure.  */
3930   struct bfd_hash_entry root;
3931
3932   enum ppc_stub_type stub_type;
3933
3934   /* Group information.  */
3935   struct map_stub *group;
3936
3937   /* Offset within stub_sec of the beginning of this stub.  */
3938   bfd_vma stub_offset;
3939
3940   /* Given the symbol's value and its section we can determine its final
3941      value when building the stubs (so the stub knows where to jump.  */
3942   bfd_vma target_value;
3943   asection *target_section;
3944
3945   /* The symbol table entry, if any, that this was derived from.  */
3946   struct ppc_link_hash_entry *h;
3947   struct plt_entry *plt_ent;
3948
3949   /* Symbol st_other.  */
3950   unsigned char other;
3951 };
3952
3953 struct ppc_branch_hash_entry {
3954
3955   /* Base hash table entry structure.  */
3956   struct bfd_hash_entry root;
3957
3958   /* Offset within branch lookup table.  */
3959   unsigned int offset;
3960
3961   /* Generation marker.  */
3962   unsigned int iter;
3963 };
3964
3965 /* Used to track dynamic relocations for local symbols.  */
3966 struct ppc_dyn_relocs
3967 {
3968   struct ppc_dyn_relocs *next;
3969
3970   /* The input section of the reloc.  */
3971   asection *sec;
3972
3973   /* Total number of relocs copied for the input section.  */
3974   unsigned int count : 31;
3975
3976   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3977   unsigned int ifunc : 1;
3978 };
3979
3980 struct ppc_link_hash_entry
3981 {
3982   struct elf_link_hash_entry elf;
3983
3984   union {
3985     /* A pointer to the most recently used stub hash entry against this
3986        symbol.  */
3987     struct ppc_stub_hash_entry *stub_cache;
3988
3989     /* A pointer to the next symbol starting with a '.'  */
3990     struct ppc_link_hash_entry *next_dot_sym;
3991   } u;
3992
3993   /* Track dynamic relocs copied for this symbol.  */
3994   struct elf_dyn_relocs *dyn_relocs;
3995
3996   /* Chain of aliases referring to a weakdef.  */
3997   struct ppc_link_hash_entry *weakref;
3998
3999   /* Link between function code and descriptor symbols.  */
4000   struct ppc_link_hash_entry *oh;
4001
4002   /* Flag function code and descriptor symbols.  */
4003   unsigned int is_func:1;
4004   unsigned int is_func_descriptor:1;
4005   unsigned int fake:1;
4006
4007   /* Whether global opd/toc sym has been adjusted or not.
4008      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4009      should be set for all globals defined in any opd/toc section.  */
4010   unsigned int adjust_done:1;
4011
4012   /* Set if this is an out-of-line register save/restore function,
4013      with non-standard calling convention.  */
4014   unsigned int save_res:1;
4015
4016   /* Contexts in which symbol is used in the GOT (or TOC).
4017      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4018      corresponding relocs are encountered during check_relocs.
4019      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4020      indicate the corresponding GOT entry type is not needed.
4021      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4022      a TPREL one.  We use a separate flag rather than setting TPREL
4023      just for convenience in distinguishing the two cases.  */
4024 #define TLS_GD           1      /* GD reloc. */
4025 #define TLS_LD           2      /* LD reloc. */
4026 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4027 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4028 #define TLS_TLS         16      /* Any TLS reloc.  */
4029 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4030 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4031 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4032   unsigned char tls_mask;
4033 };
4034
4035 /* ppc64 ELF linker hash table.  */
4036
4037 struct ppc_link_hash_table
4038 {
4039   struct elf_link_hash_table elf;
4040
4041   /* The stub hash table.  */
4042   struct bfd_hash_table stub_hash_table;
4043
4044   /* Another hash table for plt_branch stubs.  */
4045   struct bfd_hash_table branch_hash_table;
4046
4047   /* Hash table for function prologue tocsave.  */
4048   htab_t tocsave_htab;
4049
4050   /* Various options and other info passed from the linker.  */
4051   struct ppc64_elf_params *params;
4052
4053   /* The size of sec_info below.  */
4054   unsigned int sec_info_arr_size;
4055
4056   /* Per-section array of extra section info.  Done this way rather
4057      than as part of ppc64_elf_section_data so we have the info for
4058      non-ppc64 sections.  */
4059   struct
4060   {
4061     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4062     bfd_vma toc_off;
4063
4064     union
4065     {
4066       /* The section group that this section belongs to.  */
4067       struct map_stub *group;
4068       /* A temp section list pointer.  */
4069       asection *list;
4070     } u;
4071   } *sec_info;
4072
4073   /* Linked list of groups.  */
4074   struct map_stub *group;
4075
4076   /* Temp used when calculating TOC pointers.  */
4077   bfd_vma toc_curr;
4078   bfd *toc_bfd;
4079   asection *toc_first_sec;
4080
4081   /* Used when adding symbols.  */
4082   struct ppc_link_hash_entry *dot_syms;
4083
4084   /* Shortcuts to get to dynamic linker sections.  */
4085   asection *glink;
4086   asection *sfpr;
4087   asection *brlt;
4088   asection *relbrlt;
4089   asection *glink_eh_frame;
4090
4091   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4092   struct ppc_link_hash_entry *tls_get_addr;
4093   struct ppc_link_hash_entry *tls_get_addr_fd;
4094
4095   /* The size of reliplt used by got entry relocs.  */
4096   bfd_size_type got_reli_size;
4097
4098   /* Statistics.  */
4099   unsigned long stub_count[ppc_stub_global_entry];
4100
4101   /* Number of stubs against global syms.  */
4102   unsigned long stub_globals;
4103
4104   /* Set if we're linking code with function descriptors.  */
4105   unsigned int opd_abi:1;
4106
4107   /* Support for multiple toc sections.  */
4108   unsigned int do_multi_toc:1;
4109   unsigned int multi_toc_needed:1;
4110   unsigned int second_toc_pass:1;
4111   unsigned int do_toc_opt:1;
4112
4113   /* Set on error.  */
4114   unsigned int stub_error:1;
4115
4116   /* Whether func_desc_adjust needs to be run over symbols.  */
4117   unsigned int need_func_desc_adj:1;
4118
4119   /* Whether there exist local gnu indirect function resolvers,
4120      referenced by dynamic relocations.  */
4121   unsigned int local_ifunc_resolver:1;
4122   unsigned int maybe_local_ifunc_resolver:1;
4123
4124   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4125   unsigned int has_plt_localentry0:1;
4126
4127   /* Incremented every time we size stubs.  */
4128   unsigned int stub_iteration;
4129
4130   /* Small local sym cache.  */
4131   struct sym_cache sym_cache;
4132 };
4133
4134 /* Rename some of the generic section flags to better document how they
4135    are used here.  */
4136
4137 /* Nonzero if this section has TLS related relocations.  */
4138 #define has_tls_reloc sec_flg0
4139
4140 /* Nonzero if this section has a call to __tls_get_addr.  */
4141 #define has_tls_get_addr_call sec_flg1
4142
4143 /* Nonzero if this section has any toc or got relocs.  */
4144 #define has_toc_reloc sec_flg2
4145
4146 /* Nonzero if this section has a call to another section that uses
4147    the toc or got.  */
4148 #define makes_toc_func_call sec_flg3
4149
4150 /* Recursion protection when determining above flag.  */
4151 #define call_check_in_progress sec_flg4
4152 #define call_check_done sec_flg5
4153
4154 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4155
4156 #define ppc_hash_table(p) \
4157   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4158   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4159
4160 #define ppc_stub_hash_lookup(table, string, create, copy) \
4161   ((struct ppc_stub_hash_entry *) \
4162    bfd_hash_lookup ((table), (string), (create), (copy)))
4163
4164 #define ppc_branch_hash_lookup(table, string, create, copy) \
4165   ((struct ppc_branch_hash_entry *) \
4166    bfd_hash_lookup ((table), (string), (create), (copy)))
4167
4168 /* Create an entry in the stub hash table.  */
4169
4170 static struct bfd_hash_entry *
4171 stub_hash_newfunc (struct bfd_hash_entry *entry,
4172                    struct bfd_hash_table *table,
4173                    const char *string)
4174 {
4175   /* Allocate the structure if it has not already been allocated by a
4176      subclass.  */
4177   if (entry == NULL)
4178     {
4179       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4180       if (entry == NULL)
4181         return entry;
4182     }
4183
4184   /* Call the allocation method of the superclass.  */
4185   entry = bfd_hash_newfunc (entry, table, string);
4186   if (entry != NULL)
4187     {
4188       struct ppc_stub_hash_entry *eh;
4189
4190       /* Initialize the local fields.  */
4191       eh = (struct ppc_stub_hash_entry *) entry;
4192       eh->stub_type = ppc_stub_none;
4193       eh->group = NULL;
4194       eh->stub_offset = 0;
4195       eh->target_value = 0;
4196       eh->target_section = NULL;
4197       eh->h = NULL;
4198       eh->plt_ent = NULL;
4199       eh->other = 0;
4200     }
4201
4202   return entry;
4203 }
4204
4205 /* Create an entry in the branch hash table.  */
4206
4207 static struct bfd_hash_entry *
4208 branch_hash_newfunc (struct bfd_hash_entry *entry,
4209                      struct bfd_hash_table *table,
4210                      const char *string)
4211 {
4212   /* Allocate the structure if it has not already been allocated by a
4213      subclass.  */
4214   if (entry == NULL)
4215     {
4216       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4217       if (entry == NULL)
4218         return entry;
4219     }
4220
4221   /* Call the allocation method of the superclass.  */
4222   entry = bfd_hash_newfunc (entry, table, string);
4223   if (entry != NULL)
4224     {
4225       struct ppc_branch_hash_entry *eh;
4226
4227       /* Initialize the local fields.  */
4228       eh = (struct ppc_branch_hash_entry *) entry;
4229       eh->offset = 0;
4230       eh->iter = 0;
4231     }
4232
4233   return entry;
4234 }
4235
4236 /* Create an entry in a ppc64 ELF linker hash table.  */
4237
4238 static struct bfd_hash_entry *
4239 link_hash_newfunc (struct bfd_hash_entry *entry,
4240                    struct bfd_hash_table *table,
4241                    const char *string)
4242 {
4243   /* Allocate the structure if it has not already been allocated by a
4244      subclass.  */
4245   if (entry == NULL)
4246     {
4247       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4248       if (entry == NULL)
4249         return entry;
4250     }
4251
4252   /* Call the allocation method of the superclass.  */
4253   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4254   if (entry != NULL)
4255     {
4256       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4257
4258       memset (&eh->u.stub_cache, 0,
4259               (sizeof (struct ppc_link_hash_entry)
4260                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4261
4262       /* When making function calls, old ABI code references function entry
4263          points (dot symbols), while new ABI code references the function
4264          descriptor symbol.  We need to make any combination of reference and
4265          definition work together, without breaking archive linking.
4266
4267          For a defined function "foo" and an undefined call to "bar":
4268          An old object defines "foo" and ".foo", references ".bar" (possibly
4269          "bar" too).
4270          A new object defines "foo" and references "bar".
4271
4272          A new object thus has no problem with its undefined symbols being
4273          satisfied by definitions in an old object.  On the other hand, the
4274          old object won't have ".bar" satisfied by a new object.
4275
4276          Keep a list of newly added dot-symbols.  */
4277
4278       if (string[0] == '.')
4279         {
4280           struct ppc_link_hash_table *htab;
4281
4282           htab = (struct ppc_link_hash_table *) table;
4283           eh->u.next_dot_sym = htab->dot_syms;
4284           htab->dot_syms = eh;
4285         }
4286     }
4287
4288   return entry;
4289 }
4290
4291 struct tocsave_entry {
4292   asection *sec;
4293   bfd_vma offset;
4294 };
4295
4296 static hashval_t
4297 tocsave_htab_hash (const void *p)
4298 {
4299   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4300   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4301 }
4302
4303 static int
4304 tocsave_htab_eq (const void *p1, const void *p2)
4305 {
4306   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4307   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4308   return e1->sec == e2->sec && e1->offset == e2->offset;
4309 }
4310
4311 /* Destroy a ppc64 ELF linker hash table.  */
4312
4313 static void
4314 ppc64_elf_link_hash_table_free (bfd *obfd)
4315 {
4316   struct ppc_link_hash_table *htab;
4317
4318   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4319   if (htab->tocsave_htab)
4320     htab_delete (htab->tocsave_htab);
4321   bfd_hash_table_free (&htab->branch_hash_table);
4322   bfd_hash_table_free (&htab->stub_hash_table);
4323   _bfd_elf_link_hash_table_free (obfd);
4324 }
4325
4326 /* Create a ppc64 ELF linker hash table.  */
4327
4328 static struct bfd_link_hash_table *
4329 ppc64_elf_link_hash_table_create (bfd *abfd)
4330 {
4331   struct ppc_link_hash_table *htab;
4332   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4333
4334   htab = bfd_zmalloc (amt);
4335   if (htab == NULL)
4336     return NULL;
4337
4338   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4339                                       sizeof (struct ppc_link_hash_entry),
4340                                       PPC64_ELF_DATA))
4341     {
4342       free (htab);
4343       return NULL;
4344     }
4345
4346   /* Init the stub hash table too.  */
4347   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4348                             sizeof (struct ppc_stub_hash_entry)))
4349     {
4350       _bfd_elf_link_hash_table_free (abfd);
4351       return NULL;
4352     }
4353
4354   /* And the branch hash table.  */
4355   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4356                             sizeof (struct ppc_branch_hash_entry)))
4357     {
4358       bfd_hash_table_free (&htab->stub_hash_table);
4359       _bfd_elf_link_hash_table_free (abfd);
4360       return NULL;
4361     }
4362
4363   htab->tocsave_htab = htab_try_create (1024,
4364                                         tocsave_htab_hash,
4365                                         tocsave_htab_eq,
4366                                         NULL);
4367   if (htab->tocsave_htab == NULL)
4368     {
4369       ppc64_elf_link_hash_table_free (abfd);
4370       return NULL;
4371     }
4372   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4373
4374   /* Initializing two fields of the union is just cosmetic.  We really
4375      only care about glist, but when compiled on a 32-bit host the
4376      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4377      debugger inspection of these fields look nicer.  */
4378   htab->elf.init_got_refcount.refcount = 0;
4379   htab->elf.init_got_refcount.glist = NULL;
4380   htab->elf.init_plt_refcount.refcount = 0;
4381   htab->elf.init_plt_refcount.glist = NULL;
4382   htab->elf.init_got_offset.offset = 0;
4383   htab->elf.init_got_offset.glist = NULL;
4384   htab->elf.init_plt_offset.offset = 0;
4385   htab->elf.init_plt_offset.glist = NULL;
4386
4387   return &htab->elf.root;
4388 }
4389
4390 /* Create sections for linker generated code.  */
4391
4392 static bfd_boolean
4393 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4394 {
4395   struct ppc_link_hash_table *htab;
4396   flagword flags;
4397
4398   htab = ppc_hash_table (info);
4399
4400   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4401            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4402   if (htab->params->save_restore_funcs)
4403     {
4404       /* Create .sfpr for code to save and restore fp regs.  */
4405       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4406                                                        flags);
4407       if (htab->sfpr == NULL
4408           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4409         return FALSE;
4410     }
4411
4412   if (bfd_link_relocatable (info))
4413     return TRUE;
4414
4415   /* Create .glink for lazy dynamic linking support.  */
4416   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4417                                                     flags);
4418   if (htab->glink == NULL
4419       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4420     return FALSE;
4421
4422   if (!info->no_ld_generated_unwind_info)
4423     {
4424       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4425                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4426       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4427                                                                  ".eh_frame",
4428                                                                  flags);
4429       if (htab->glink_eh_frame == NULL
4430           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4431         return FALSE;
4432     }
4433
4434   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4435   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4436   if (htab->elf.iplt == NULL
4437       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4438     return FALSE;
4439
4440   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4441            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4442   htab->elf.irelplt
4443     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4444   if (htab->elf.irelplt == NULL
4445       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4446     return FALSE;
4447
4448   /* Create branch lookup table for plt_branch stubs.  */
4449   flags = (SEC_ALLOC | SEC_LOAD
4450            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4451   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4452                                                    flags);
4453   if (htab->brlt == NULL
4454       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4455     return FALSE;
4456
4457   if (!bfd_link_pic (info))
4458     return TRUE;
4459
4460   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4461            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4462   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4463                                                       ".rela.branch_lt",
4464                                                       flags);
4465   if (htab->relbrlt == NULL
4466       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4467     return FALSE;
4468
4469   return TRUE;
4470 }
4471
4472 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4473
4474 bfd_boolean
4475 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4476                          struct ppc64_elf_params *params)
4477 {
4478   struct ppc_link_hash_table *htab;
4479
4480   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4481
4482 /* Always hook our dynamic sections into the first bfd, which is the
4483    linker created stub bfd.  This ensures that the GOT header is at
4484    the start of the output TOC section.  */
4485   htab = ppc_hash_table (info);
4486   htab->elf.dynobj = params->stub_bfd;
4487   htab->params = params;
4488
4489   return create_linkage_sections (htab->elf.dynobj, info);
4490 }
4491
4492 /* Build a name for an entry in the stub hash table.  */
4493
4494 static char *
4495 ppc_stub_name (const asection *input_section,
4496                const asection *sym_sec,
4497                const struct ppc_link_hash_entry *h,
4498                const Elf_Internal_Rela *rel)
4499 {
4500   char *stub_name;
4501   ssize_t len;
4502
4503   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4504      offsets from a sym as a branch target?  In fact, we could
4505      probably assume the addend is always zero.  */
4506   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4507
4508   if (h)
4509     {
4510       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4511       stub_name = bfd_malloc (len);
4512       if (stub_name == NULL)
4513         return stub_name;
4514
4515       len = sprintf (stub_name, "%08x.%s+%x",
4516                      input_section->id & 0xffffffff,
4517                      h->elf.root.root.string,
4518                      (int) rel->r_addend & 0xffffffff);
4519     }
4520   else
4521     {
4522       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4523       stub_name = bfd_malloc (len);
4524       if (stub_name == NULL)
4525         return stub_name;
4526
4527       len = sprintf (stub_name, "%08x.%x:%x+%x",
4528                      input_section->id & 0xffffffff,
4529                      sym_sec->id & 0xffffffff,
4530                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4531                      (int) rel->r_addend & 0xffffffff);
4532     }
4533   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4534     stub_name[len - 2] = 0;
4535   return stub_name;
4536 }
4537
4538 /* Look up an entry in the stub hash.  Stub entries are cached because
4539    creating the stub name takes a bit of time.  */
4540
4541 static struct ppc_stub_hash_entry *
4542 ppc_get_stub_entry (const asection *input_section,
4543                     const asection *sym_sec,
4544                     struct ppc_link_hash_entry *h,
4545                     const Elf_Internal_Rela *rel,
4546                     struct ppc_link_hash_table *htab)
4547 {
4548   struct ppc_stub_hash_entry *stub_entry;
4549   struct map_stub *group;
4550
4551   /* If this input section is part of a group of sections sharing one
4552      stub section, then use the id of the first section in the group.
4553      Stub names need to include a section id, as there may well be
4554      more than one stub used to reach say, printf, and we need to
4555      distinguish between them.  */
4556   group = htab->sec_info[input_section->id].u.group;
4557   if (group == NULL)
4558     return NULL;
4559
4560   if (h != NULL && h->u.stub_cache != NULL
4561       && h->u.stub_cache->h == h
4562       && h->u.stub_cache->group == group)
4563     {
4564       stub_entry = h->u.stub_cache;
4565     }
4566   else
4567     {
4568       char *stub_name;
4569
4570       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4571       if (stub_name == NULL)
4572         return NULL;
4573
4574       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4575                                          stub_name, FALSE, FALSE);
4576       if (h != NULL)
4577         h->u.stub_cache = stub_entry;
4578
4579       free (stub_name);
4580     }
4581
4582   return stub_entry;
4583 }
4584
4585 /* Add a new stub entry to the stub hash.  Not all fields of the new
4586    stub entry are initialised.  */
4587
4588 static struct ppc_stub_hash_entry *
4589 ppc_add_stub (const char *stub_name,
4590               asection *section,
4591               struct bfd_link_info *info)
4592 {
4593   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4594   struct map_stub *group;
4595   asection *link_sec;
4596   asection *stub_sec;
4597   struct ppc_stub_hash_entry *stub_entry;
4598
4599   group = htab->sec_info[section->id].u.group;
4600   link_sec = group->link_sec;
4601   stub_sec = group->stub_sec;
4602   if (stub_sec == NULL)
4603     {
4604       size_t namelen;
4605       bfd_size_type len;
4606       char *s_name;
4607
4608       namelen = strlen (link_sec->name);
4609       len = namelen + sizeof (STUB_SUFFIX);
4610       s_name = bfd_alloc (htab->params->stub_bfd, len);
4611       if (s_name == NULL)
4612         return NULL;
4613
4614       memcpy (s_name, link_sec->name, namelen);
4615       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4616       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4617       if (stub_sec == NULL)
4618         return NULL;
4619       group->stub_sec = stub_sec;
4620     }
4621
4622   /* Enter this entry into the linker stub hash table.  */
4623   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4624                                      TRUE, FALSE);
4625   if (stub_entry == NULL)
4626     {
4627       /* xgettext:c-format */
4628       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4629                               section->owner, stub_name);
4630       return NULL;
4631     }
4632
4633   stub_entry->group = group;
4634   stub_entry->stub_offset = 0;
4635   return stub_entry;
4636 }
4637
4638 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4639    not already done.  */
4640
4641 static bfd_boolean
4642 create_got_section (bfd *abfd, struct bfd_link_info *info)
4643 {
4644   asection *got, *relgot;
4645   flagword flags;
4646   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4647
4648   if (!is_ppc64_elf (abfd))
4649     return FALSE;
4650   if (htab == NULL)
4651     return FALSE;
4652
4653   if (!htab->elf.sgot
4654       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4655     return FALSE;
4656
4657   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4658            | SEC_LINKER_CREATED);
4659
4660   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4661   if (!got
4662       || !bfd_set_section_alignment (abfd, got, 3))
4663     return FALSE;
4664
4665   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4666                                                flags | SEC_READONLY);
4667   if (!relgot
4668       || ! bfd_set_section_alignment (abfd, relgot, 3))
4669     return FALSE;
4670
4671   ppc64_elf_tdata (abfd)->got = got;
4672   ppc64_elf_tdata (abfd)->relgot = relgot;
4673   return TRUE;
4674 }
4675
4676 /* Follow indirect and warning symbol links.  */
4677
4678 static inline struct bfd_link_hash_entry *
4679 follow_link (struct bfd_link_hash_entry *h)
4680 {
4681   while (h->type == bfd_link_hash_indirect
4682          || h->type == bfd_link_hash_warning)
4683     h = h->u.i.link;
4684   return h;
4685 }
4686
4687 static inline struct elf_link_hash_entry *
4688 elf_follow_link (struct elf_link_hash_entry *h)
4689 {
4690   return (struct elf_link_hash_entry *) follow_link (&h->root);
4691 }
4692
4693 static inline struct ppc_link_hash_entry *
4694 ppc_follow_link (struct ppc_link_hash_entry *h)
4695 {
4696   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4697 }
4698
4699 /* Merge PLT info on FROM with that on TO.  */
4700
4701 static void
4702 move_plt_plist (struct ppc_link_hash_entry *from,
4703                 struct ppc_link_hash_entry *to)
4704 {
4705   if (from->elf.plt.plist != NULL)
4706     {
4707       if (to->elf.plt.plist != NULL)
4708         {
4709           struct plt_entry **entp;
4710           struct plt_entry *ent;
4711
4712           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4713             {
4714               struct plt_entry *dent;
4715
4716               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4717                 if (dent->addend == ent->addend)
4718                   {
4719                     dent->plt.refcount += ent->plt.refcount;
4720                     *entp = ent->next;
4721                     break;
4722                   }
4723               if (dent == NULL)
4724                 entp = &ent->next;
4725             }
4726           *entp = to->elf.plt.plist;
4727         }
4728
4729       to->elf.plt.plist = from->elf.plt.plist;
4730       from->elf.plt.plist = NULL;
4731     }
4732 }
4733
4734 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4735
4736 static void
4737 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4738                                 struct elf_link_hash_entry *dir,
4739                                 struct elf_link_hash_entry *ind)
4740 {
4741   struct ppc_link_hash_entry *edir, *eind;
4742
4743   edir = (struct ppc_link_hash_entry *) dir;
4744   eind = (struct ppc_link_hash_entry *) ind;
4745
4746   edir->is_func |= eind->is_func;
4747   edir->is_func_descriptor |= eind->is_func_descriptor;
4748   edir->tls_mask |= eind->tls_mask;
4749   if (eind->oh != NULL)
4750     edir->oh = ppc_follow_link (eind->oh);
4751
4752   /* If called to transfer flags for a weakdef during processing
4753      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4754      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4755   if (!(ELIMINATE_COPY_RELOCS
4756         && eind->elf.root.type != bfd_link_hash_indirect
4757         && edir->elf.dynamic_adjusted))
4758     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4759
4760   if (edir->elf.versioned != versioned_hidden)
4761     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4762   edir->elf.ref_regular |= eind->elf.ref_regular;
4763   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4764   edir->elf.needs_plt |= eind->elf.needs_plt;
4765   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4766
4767   /* If we were called to copy over info for a weak sym, don't copy
4768      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4769      in order to simplify readonly_dynrelocs and save a field in the
4770      symbol hash entry, but that means dyn_relocs can't be used in any
4771      tests about a specific symbol, or affect other symbol flags which
4772      are then tested.
4773      Chain weakdefs so we can get from the weakdef back to an alias.
4774      The list is circular so that we don't need to use u.weakdef as
4775      well as this list to look at all aliases.  */
4776   if (eind->elf.root.type != bfd_link_hash_indirect)
4777     {
4778       struct ppc_link_hash_entry *cur, *add, *next;
4779
4780       add = eind;
4781       do
4782         {
4783           cur = edir->weakref;
4784           if (cur != NULL)
4785             {
4786               do
4787                 {
4788                   /* We can be called twice for the same symbols.
4789                      Don't make multiple loops.  */
4790                   if (cur == add)
4791                     return;
4792                   cur = cur->weakref;
4793                 } while (cur != edir);
4794             }
4795           next = add->weakref;
4796           if (cur != add)
4797             {
4798               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4799               edir->weakref = add;
4800             }
4801           add = next;
4802         } while (add != NULL && add != eind);
4803       return;
4804     }
4805
4806   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4807   if (eind->dyn_relocs != NULL)
4808     {
4809       if (edir->dyn_relocs != NULL)
4810         {
4811           struct elf_dyn_relocs **pp;
4812           struct elf_dyn_relocs *p;
4813
4814           /* Add reloc counts against the indirect sym to the direct sym
4815              list.  Merge any entries against the same section.  */
4816           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4817             {
4818               struct elf_dyn_relocs *q;
4819
4820               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4821                 if (q->sec == p->sec)
4822                   {
4823                     q->pc_count += p->pc_count;
4824                     q->count += p->count;
4825                     *pp = p->next;
4826                     break;
4827                   }
4828               if (q == NULL)
4829                 pp = &p->next;
4830             }
4831           *pp = edir->dyn_relocs;
4832         }
4833
4834       edir->dyn_relocs = eind->dyn_relocs;
4835       eind->dyn_relocs = NULL;
4836     }
4837
4838   /* Copy over got entries that we may have already seen to the
4839      symbol which just became indirect.  */
4840   if (eind->elf.got.glist != NULL)
4841     {
4842       if (edir->elf.got.glist != NULL)
4843         {
4844           struct got_entry **entp;
4845           struct got_entry *ent;
4846
4847           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4848             {
4849               struct got_entry *dent;
4850
4851               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4852                 if (dent->addend == ent->addend
4853                     && dent->owner == ent->owner
4854                     && dent->tls_type == ent->tls_type)
4855                   {
4856                     dent->got.refcount += ent->got.refcount;
4857                     *entp = ent->next;
4858                     break;
4859                   }
4860               if (dent == NULL)
4861                 entp = &ent->next;
4862             }
4863           *entp = edir->elf.got.glist;
4864         }
4865
4866       edir->elf.got.glist = eind->elf.got.glist;
4867       eind->elf.got.glist = NULL;
4868     }
4869
4870   /* And plt entries.  */
4871   move_plt_plist (eind, edir);
4872
4873   if (eind->elf.dynindx != -1)
4874     {
4875       if (edir->elf.dynindx != -1)
4876         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4877                                 edir->elf.dynstr_index);
4878       edir->elf.dynindx = eind->elf.dynindx;
4879       edir->elf.dynstr_index = eind->elf.dynstr_index;
4880       eind->elf.dynindx = -1;
4881       eind->elf.dynstr_index = 0;
4882     }
4883 }
4884
4885 /* Find the function descriptor hash entry from the given function code
4886    hash entry FH.  Link the entries via their OH fields.  */
4887
4888 static struct ppc_link_hash_entry *
4889 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4890 {
4891   struct ppc_link_hash_entry *fdh = fh->oh;
4892
4893   if (fdh == NULL)
4894     {
4895       const char *fd_name = fh->elf.root.root.string + 1;
4896
4897       fdh = (struct ppc_link_hash_entry *)
4898         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4899       if (fdh == NULL)
4900         return fdh;
4901
4902       fdh->is_func_descriptor = 1;
4903       fdh->oh = fh;
4904       fh->is_func = 1;
4905       fh->oh = fdh;
4906     }
4907
4908   fdh = ppc_follow_link (fdh);
4909   fdh->is_func_descriptor = 1;
4910   fdh->oh = fh;
4911   return fdh;
4912 }
4913
4914 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4915
4916 static struct ppc_link_hash_entry *
4917 make_fdh (struct bfd_link_info *info,
4918           struct ppc_link_hash_entry *fh)
4919 {
4920   bfd *abfd = fh->elf.root.u.undef.abfd;
4921   struct bfd_link_hash_entry *bh = NULL;
4922   struct ppc_link_hash_entry *fdh;
4923   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4924                     ? BSF_WEAK
4925                     : BSF_GLOBAL);
4926
4927   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4928                                          fh->elf.root.root.string + 1,
4929                                          flags, bfd_und_section_ptr, 0,
4930                                          NULL, FALSE, FALSE, &bh))
4931     return NULL;
4932
4933   fdh = (struct ppc_link_hash_entry *) bh;
4934   fdh->elf.non_elf = 0;
4935   fdh->fake = 1;
4936   fdh->is_func_descriptor = 1;
4937   fdh->oh = fh;
4938   fh->is_func = 1;
4939   fh->oh = fdh;
4940   return fdh;
4941 }
4942
4943 /* Fix function descriptor symbols defined in .opd sections to be
4944    function type.  */
4945
4946 static bfd_boolean
4947 ppc64_elf_add_symbol_hook (bfd *ibfd,
4948                            struct bfd_link_info *info,
4949                            Elf_Internal_Sym *isym,
4950                            const char **name,
4951                            flagword *flags ATTRIBUTE_UNUSED,
4952                            asection **sec,
4953                            bfd_vma *value)
4954 {
4955   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4956       && (ibfd->flags & DYNAMIC) == 0
4957       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4958     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4959
4960   if (*sec != NULL
4961       && strcmp ((*sec)->name, ".opd") == 0)
4962     {
4963       asection *code_sec;
4964
4965       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4966             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4967         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4968
4969       /* If the symbol is a function defined in .opd, and the function
4970          code is in a discarded group, let it appear to be undefined.  */
4971       if (!bfd_link_relocatable (info)
4972           && (*sec)->reloc_count != 0
4973           && opd_entry_value (*sec, *value, &code_sec, NULL,
4974                               FALSE) != (bfd_vma) -1
4975           && discarded_section (code_sec))
4976         {
4977           *sec = bfd_und_section_ptr;
4978           isym->st_shndx = SHN_UNDEF;
4979         }
4980     }
4981   else if (*sec != NULL
4982            && strcmp ((*sec)->name, ".toc") == 0
4983            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4984     {
4985       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4986       if (htab != NULL)
4987         htab->params->object_in_toc = 1;
4988     }
4989
4990   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4991     {
4992       if (abiversion (ibfd) == 0)
4993         set_abiversion (ibfd, 2);
4994       else if (abiversion (ibfd) == 1)
4995         {
4996           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4997                                     " for ABI version 1\n"), name);
4998           bfd_set_error (bfd_error_bad_value);
4999           return FALSE;
5000         }
5001     }
5002
5003   return TRUE;
5004 }
5005
5006 /* Merge non-visibility st_other attributes: local entry point.  */
5007
5008 static void
5009 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5010                                   const Elf_Internal_Sym *isym,
5011                                   bfd_boolean definition,
5012                                   bfd_boolean dynamic)
5013 {
5014   if (definition && (!dynamic || !h->def_regular))
5015     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5016                 | ELF_ST_VISIBILITY (h->other));
5017 }
5018
5019 /* Hook called on merging a symbol.  We use this to clear "fake" since
5020    we now have a real symbol.  */
5021
5022 static bfd_boolean
5023 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5024                         const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5025                         asection **psec ATTRIBUTE_UNUSED,
5026                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5027                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5028                         bfd *oldbfd ATTRIBUTE_UNUSED,
5029                         const asection *oldsec ATTRIBUTE_UNUSED)
5030 {
5031   ((struct ppc_link_hash_entry *) h)->fake = 0;
5032   return TRUE;
5033 }
5034
5035 /* This function makes an old ABI object reference to ".bar" cause the
5036    inclusion of a new ABI object archive that defines "bar".
5037    NAME is a symbol defined in an archive.  Return a symbol in the hash
5038    table that might be satisfied by the archive symbols.  */
5039
5040 static struct elf_link_hash_entry *
5041 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5042                                  struct bfd_link_info *info,
5043                                  const char *name)
5044 {
5045   struct elf_link_hash_entry *h;
5046   char *dot_name;
5047   size_t len;
5048
5049   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5050   if (h != NULL
5051       /* Don't return this sym if it is a fake function descriptor
5052          created by add_symbol_adjust.  */
5053       && !((struct ppc_link_hash_entry *) h)->fake)
5054     return h;
5055
5056   if (name[0] == '.')
5057     return h;
5058
5059   len = strlen (name);
5060   dot_name = bfd_alloc (abfd, len + 2);
5061   if (dot_name == NULL)
5062     return (struct elf_link_hash_entry *) 0 - 1;
5063   dot_name[0] = '.';
5064   memcpy (dot_name + 1, name, len + 1);
5065   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5066   bfd_release (abfd, dot_name);
5067   return h;
5068 }
5069
5070 /* This function satisfies all old ABI object references to ".bar" if a
5071    new ABI object defines "bar".  Well, at least, undefined dot symbols
5072    are made weak.  This stops later archive searches from including an
5073    object if we already have a function descriptor definition.  It also
5074    prevents the linker complaining about undefined symbols.
5075    We also check and correct mismatched symbol visibility here.  The
5076    most restrictive visibility of the function descriptor and the
5077    function entry symbol is used.  */
5078
5079 static bfd_boolean
5080 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5081 {
5082   struct ppc_link_hash_table *htab;
5083   struct ppc_link_hash_entry *fdh;
5084
5085   if (eh->elf.root.type == bfd_link_hash_warning)
5086     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5087
5088   if (eh->elf.root.type == bfd_link_hash_indirect)
5089     return TRUE;
5090
5091   if (eh->elf.root.root.string[0] != '.')
5092     abort ();
5093
5094   htab = ppc_hash_table (info);
5095   if (htab == NULL)
5096     return FALSE;
5097
5098   fdh = lookup_fdh (eh, htab);
5099   if (fdh == NULL
5100       && !bfd_link_relocatable (info)
5101       && (eh->elf.root.type == bfd_link_hash_undefined
5102           || eh->elf.root.type == bfd_link_hash_undefweak)
5103       && eh->elf.ref_regular)
5104     {
5105       /* Make an undefined function descriptor sym, in order to
5106          pull in an --as-needed shared lib.  Archives are handled
5107          elsewhere.  */
5108       fdh = make_fdh (info, eh);
5109       if (fdh == NULL)
5110         return FALSE;
5111     }
5112
5113   if (fdh != NULL)
5114     {
5115       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5116       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5117
5118       /* Make both descriptor and entry symbol have the most
5119          constraining visibility of either symbol.  */
5120       if (entry_vis < descr_vis)
5121         fdh->elf.other += entry_vis - descr_vis;
5122       else if (entry_vis > descr_vis)
5123         eh->elf.other += descr_vis - entry_vis;
5124
5125       /* Propagate reference flags from entry symbol to function
5126          descriptor symbol.  */
5127       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5128       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5129       fdh->elf.ref_regular |= eh->elf.ref_regular;
5130       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5131
5132       if (!fdh->elf.forced_local
5133           && fdh->elf.dynindx == -1
5134           && fdh->elf.versioned != versioned_hidden
5135           && (bfd_link_dll (info)
5136               || fdh->elf.def_dynamic
5137               || fdh->elf.ref_dynamic)
5138           && (eh->elf.ref_regular
5139               || eh->elf.def_regular))
5140         {
5141           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5142             return FALSE;
5143         }
5144     }
5145
5146   return TRUE;
5147 }
5148
5149 /* Set up opd section info and abiversion for IBFD, and process list
5150    of dot-symbols we made in link_hash_newfunc.  */
5151
5152 static bfd_boolean
5153 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5154 {
5155   struct ppc_link_hash_table *htab;
5156   struct ppc_link_hash_entry **p, *eh;
5157   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5158
5159   if (opd != NULL && opd->size != 0)
5160     {
5161       if (abiversion (ibfd) == 0)
5162         set_abiversion (ibfd, 1);
5163       else if (abiversion (ibfd) >= 2)
5164         {
5165           /* xgettext:c-format */
5166           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5167                                     " version %d\n"),
5168                                   ibfd, abiversion (ibfd));
5169           bfd_set_error (bfd_error_bad_value);
5170           return FALSE;
5171         }
5172
5173       if ((ibfd->flags & DYNAMIC) == 0
5174           && (opd->flags & SEC_RELOC) != 0
5175           && opd->reloc_count != 0
5176           && !bfd_is_abs_section (opd->output_section))
5177         {
5178           /* Garbage collection needs some extra help with .opd sections.
5179              We don't want to necessarily keep everything referenced by
5180              relocs in .opd, as that would keep all functions.  Instead,
5181              if we reference an .opd symbol (a function descriptor), we
5182              want to keep the function code symbol's section.  This is
5183              easy for global symbols, but for local syms we need to keep
5184              information about the associated function section.  */
5185           bfd_size_type amt;
5186           asection **opd_sym_map;
5187
5188           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5189           opd_sym_map = bfd_zalloc (ibfd, amt);
5190           if (opd_sym_map == NULL)
5191             return FALSE;
5192           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5193           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5194           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5195         }
5196     }
5197
5198   if (!is_ppc64_elf (info->output_bfd))
5199     return TRUE;
5200   htab = ppc_hash_table (info);
5201   if (htab == NULL)
5202     return FALSE;
5203
5204   /* For input files without an explicit abiversion in e_flags
5205      we should have flagged any with symbol st_other bits set
5206      as ELFv1 and above flagged those with .opd as ELFv2.
5207      Set the output abiversion if not yet set, and for any input
5208      still ambiguous, take its abiversion from the output.
5209      Differences in ABI are reported later.  */
5210   if (abiversion (info->output_bfd) == 0)
5211     set_abiversion (info->output_bfd, abiversion (ibfd));
5212   else if (abiversion (ibfd) == 0)
5213     set_abiversion (ibfd, abiversion (info->output_bfd));
5214
5215   p = &htab->dot_syms;
5216   while ((eh = *p) != NULL)
5217     {
5218       *p = NULL;
5219       if (&eh->elf == htab->elf.hgot)
5220         ;
5221       else if (htab->elf.hgot == NULL
5222                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5223         htab->elf.hgot = &eh->elf;
5224       else if (abiversion (ibfd) <= 1)
5225         {
5226           htab->need_func_desc_adj = 1;
5227           if (!add_symbol_adjust (eh, info))
5228             return FALSE;
5229         }
5230       p = &eh->u.next_dot_sym;
5231     }
5232   return TRUE;
5233 }
5234
5235 /* Undo hash table changes when an --as-needed input file is determined
5236    not to be needed.  */
5237
5238 static bfd_boolean
5239 ppc64_elf_notice_as_needed (bfd *ibfd,
5240                             struct bfd_link_info *info,
5241                             enum notice_asneeded_action act)
5242 {
5243   if (act == notice_not_needed)
5244     {
5245       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5246
5247       if (htab == NULL)
5248         return FALSE;
5249
5250       htab->dot_syms = NULL;
5251     }
5252   return _bfd_elf_notice_as_needed (ibfd, info, act);
5253 }
5254
5255 /* If --just-symbols against a final linked binary, then assume we need
5256    toc adjusting stubs when calling functions defined there.  */
5257
5258 static void
5259 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5260 {
5261   if ((sec->flags & SEC_CODE) != 0
5262       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5263       && is_ppc64_elf (sec->owner))
5264     {
5265       if (abiversion (sec->owner) >= 2
5266           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5267         sec->has_toc_reloc = 1;
5268     }
5269   _bfd_elf_link_just_syms (sec, info);
5270 }
5271
5272 static struct plt_entry **
5273 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5274                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5275 {
5276   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5277   struct plt_entry **local_plt;
5278   unsigned char *local_got_tls_masks;
5279
5280   if (local_got_ents == NULL)
5281     {
5282       bfd_size_type size = symtab_hdr->sh_info;
5283
5284       size *= (sizeof (*local_got_ents)
5285                + sizeof (*local_plt)
5286                + sizeof (*local_got_tls_masks));
5287       local_got_ents = bfd_zalloc (abfd, size);
5288       if (local_got_ents == NULL)
5289         return NULL;
5290       elf_local_got_ents (abfd) = local_got_ents;
5291     }
5292
5293   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5294     {
5295       struct got_entry *ent;
5296
5297       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5298         if (ent->addend == r_addend
5299             && ent->owner == abfd
5300             && ent->tls_type == tls_type)
5301           break;
5302       if (ent == NULL)
5303         {
5304           bfd_size_type amt = sizeof (*ent);
5305           ent = bfd_alloc (abfd, amt);
5306           if (ent == NULL)
5307             return FALSE;
5308           ent->next = local_got_ents[r_symndx];
5309           ent->addend = r_addend;
5310           ent->owner = abfd;
5311           ent->tls_type = tls_type;
5312           ent->is_indirect = FALSE;
5313           ent->got.refcount = 0;
5314           local_got_ents[r_symndx] = ent;
5315         }
5316       ent->got.refcount += 1;
5317     }
5318
5319   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5320   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5321   local_got_tls_masks[r_symndx] |= tls_type;
5322
5323   return local_plt + r_symndx;
5324 }
5325
5326 static bfd_boolean
5327 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5328 {
5329   struct plt_entry *ent;
5330
5331   for (ent = *plist; ent != NULL; ent = ent->next)
5332     if (ent->addend == addend)
5333       break;
5334   if (ent == NULL)
5335     {
5336       bfd_size_type amt = sizeof (*ent);
5337       ent = bfd_alloc (abfd, amt);
5338       if (ent == NULL)
5339         return FALSE;
5340       ent->next = *plist;
5341       ent->addend = addend;
5342       ent->plt.refcount = 0;
5343       *plist = ent;
5344     }
5345   ent->plt.refcount += 1;
5346   return TRUE;
5347 }
5348
5349 static bfd_boolean
5350 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5351 {
5352   return (r_type == R_PPC64_REL24
5353           || r_type == R_PPC64_REL14
5354           || r_type == R_PPC64_REL14_BRTAKEN
5355           || r_type == R_PPC64_REL14_BRNTAKEN
5356           || r_type == R_PPC64_ADDR24
5357           || r_type == R_PPC64_ADDR14
5358           || r_type == R_PPC64_ADDR14_BRTAKEN
5359           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5360 }
5361
5362 /* Look through the relocs for a section during the first phase, and
5363    calculate needed space in the global offset table, procedure
5364    linkage table, and dynamic reloc sections.  */
5365
5366 static bfd_boolean
5367 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5368                         asection *sec, const Elf_Internal_Rela *relocs)
5369 {
5370   struct ppc_link_hash_table *htab;
5371   Elf_Internal_Shdr *symtab_hdr;
5372   struct elf_link_hash_entry **sym_hashes;
5373   const Elf_Internal_Rela *rel;
5374   const Elf_Internal_Rela *rel_end;
5375   asection *sreloc;
5376   asection **opd_sym_map;
5377   struct elf_link_hash_entry *tga, *dottga;
5378
5379   if (bfd_link_relocatable (info))
5380     return TRUE;
5381
5382   /* Don't do anything special with non-loaded, non-alloced sections.
5383      In particular, any relocs in such sections should not affect GOT
5384      and PLT reference counting (ie. we don't allow them to create GOT
5385      or PLT entries), there's no possibility or desire to optimize TLS
5386      relocs, and there's not much point in propagating relocs to shared
5387      libs that the dynamic linker won't relocate.  */
5388   if ((sec->flags & SEC_ALLOC) == 0)
5389     return TRUE;
5390
5391   BFD_ASSERT (is_ppc64_elf (abfd));
5392
5393   htab = ppc_hash_table (info);
5394   if (htab == NULL)
5395     return FALSE;
5396
5397   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5398                               FALSE, FALSE, TRUE);
5399   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5400                                  FALSE, FALSE, TRUE);
5401   symtab_hdr = &elf_symtab_hdr (abfd);
5402   sym_hashes = elf_sym_hashes (abfd);
5403   sreloc = NULL;
5404   opd_sym_map = NULL;
5405   if (ppc64_elf_section_data (sec) != NULL
5406       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5407     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5408
5409   rel_end = relocs + sec->reloc_count;
5410   for (rel = relocs; rel < rel_end; rel++)
5411     {
5412       unsigned long r_symndx;
5413       struct elf_link_hash_entry *h;
5414       enum elf_ppc64_reloc_type r_type;
5415       int tls_type;
5416       struct _ppc64_elf_section_data *ppc64_sec;
5417       struct plt_entry **ifunc, **plt_list;
5418
5419       r_symndx = ELF64_R_SYM (rel->r_info);
5420       if (r_symndx < symtab_hdr->sh_info)
5421         h = NULL;
5422       else
5423         {
5424           struct ppc_link_hash_entry *eh;
5425
5426           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5427           h = elf_follow_link (h);
5428           eh = (struct ppc_link_hash_entry *) h;
5429
5430           /* PR15323, ref flags aren't set for references in the same
5431              object.  */
5432           h->root.non_ir_ref_regular = 1;
5433           if (eh->is_func && eh->oh != NULL)
5434             eh->oh->elf.root.non_ir_ref_regular = 1;
5435
5436           if (h == htab->elf.hgot)
5437             sec->has_toc_reloc = 1;
5438         }
5439
5440       tls_type = 0;
5441       ifunc = NULL;
5442       if (h != NULL)
5443         {
5444           if (h->type == STT_GNU_IFUNC)
5445             {
5446               h->needs_plt = 1;
5447               ifunc = &h->plt.plist;
5448             }
5449         }
5450       else
5451         {
5452           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5453                                                           abfd, r_symndx);
5454           if (isym == NULL)
5455             return FALSE;
5456
5457           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5458             {
5459               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5460                                              rel->r_addend, PLT_IFUNC);
5461               if (ifunc == NULL)
5462                 return FALSE;
5463             }
5464         }
5465
5466       r_type = ELF64_R_TYPE (rel->r_info);
5467       switch (r_type)
5468         {
5469         case R_PPC64_TLSGD:
5470         case R_PPC64_TLSLD:
5471           /* These special tls relocs tie a call to __tls_get_addr with
5472              its parameter symbol.  */
5473           break;
5474
5475         case R_PPC64_GOT_TLSLD16:
5476         case R_PPC64_GOT_TLSLD16_LO:
5477         case R_PPC64_GOT_TLSLD16_HI:
5478         case R_PPC64_GOT_TLSLD16_HA:
5479           tls_type = TLS_TLS | TLS_LD;
5480           goto dogottls;
5481
5482         case R_PPC64_GOT_TLSGD16:
5483         case R_PPC64_GOT_TLSGD16_LO:
5484         case R_PPC64_GOT_TLSGD16_HI:
5485         case R_PPC64_GOT_TLSGD16_HA:
5486           tls_type = TLS_TLS | TLS_GD;
5487           goto dogottls;
5488
5489         case R_PPC64_GOT_TPREL16_DS:
5490         case R_PPC64_GOT_TPREL16_LO_DS:
5491         case R_PPC64_GOT_TPREL16_HI:
5492         case R_PPC64_GOT_TPREL16_HA:
5493           if (bfd_link_pic (info))
5494             info->flags |= DF_STATIC_TLS;
5495           tls_type = TLS_TLS | TLS_TPREL;
5496           goto dogottls;
5497
5498         case R_PPC64_GOT_DTPREL16_DS:
5499         case R_PPC64_GOT_DTPREL16_LO_DS:
5500         case R_PPC64_GOT_DTPREL16_HI:
5501         case R_PPC64_GOT_DTPREL16_HA:
5502           tls_type = TLS_TLS | TLS_DTPREL;
5503         dogottls:
5504           sec->has_tls_reloc = 1;
5505           /* Fall through */
5506
5507         case R_PPC64_GOT16:
5508         case R_PPC64_GOT16_DS:
5509         case R_PPC64_GOT16_HA:
5510         case R_PPC64_GOT16_HI:
5511         case R_PPC64_GOT16_LO:
5512         case R_PPC64_GOT16_LO_DS:
5513           /* This symbol requires a global offset table entry.  */
5514           sec->has_toc_reloc = 1;
5515           if (r_type == R_PPC64_GOT_TLSLD16
5516               || r_type == R_PPC64_GOT_TLSGD16
5517               || r_type == R_PPC64_GOT_TPREL16_DS
5518               || r_type == R_PPC64_GOT_DTPREL16_DS
5519               || r_type == R_PPC64_GOT16
5520               || r_type == R_PPC64_GOT16_DS)
5521             {
5522               htab->do_multi_toc = 1;
5523               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5524             }
5525
5526           if (ppc64_elf_tdata (abfd)->got == NULL
5527               && !create_got_section (abfd, info))
5528             return FALSE;
5529
5530           if (h != NULL)
5531             {
5532               struct ppc_link_hash_entry *eh;
5533               struct got_entry *ent;
5534
5535               eh = (struct ppc_link_hash_entry *) h;
5536               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5537                 if (ent->addend == rel->r_addend
5538                     && ent->owner == abfd
5539                     && ent->tls_type == tls_type)
5540                   break;
5541               if (ent == NULL)
5542                 {
5543                   bfd_size_type amt = sizeof (*ent);
5544                   ent = bfd_alloc (abfd, amt);
5545                   if (ent == NULL)
5546                     return FALSE;
5547                   ent->next = eh->elf.got.glist;
5548                   ent->addend = rel->r_addend;
5549                   ent->owner = abfd;
5550                   ent->tls_type = tls_type;
5551                   ent->is_indirect = FALSE;
5552                   ent->got.refcount = 0;
5553                   eh->elf.got.glist = ent;
5554                 }
5555               ent->got.refcount += 1;
5556               eh->tls_mask |= tls_type;
5557             }
5558           else
5559             /* This is a global offset table entry for a local symbol.  */
5560             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5561                                         rel->r_addend, tls_type))
5562               return FALSE;
5563
5564           /* We may also need a plt entry if the symbol turns out to be
5565              an ifunc.  */
5566           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5567             {
5568               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5569                 return FALSE;
5570             }
5571           break;
5572
5573         case R_PPC64_PLT16_HA:
5574         case R_PPC64_PLT16_HI:
5575         case R_PPC64_PLT16_LO:
5576         case R_PPC64_PLT32:
5577         case R_PPC64_PLT64:
5578           /* This symbol requires a procedure linkage table entry.  */
5579           plt_list = ifunc;
5580           if (h != NULL)
5581             {
5582               h->needs_plt = 1;
5583               if (h->root.root.string[0] == '.'
5584                   && h->root.root.string[1] != '\0')
5585                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5586               plt_list = &h->plt.plist;
5587             }
5588           if (plt_list == NULL)
5589             {
5590               /* It does not make sense to have a procedure linkage
5591                  table entry for a non-ifunc local symbol.  */
5592               info->callbacks->einfo
5593                 /* xgettext:c-format */
5594                 (_("%H: %s reloc against local symbol\n"),
5595                  abfd, sec, rel->r_offset,
5596                  ppc64_elf_howto_table[r_type]->name);
5597               bfd_set_error (bfd_error_bad_value);
5598               return FALSE;
5599             }
5600           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5601             return FALSE;
5602           break;
5603
5604           /* The following relocations don't need to propagate the
5605              relocation if linking a shared object since they are
5606              section relative.  */
5607         case R_PPC64_SECTOFF:
5608         case R_PPC64_SECTOFF_LO:
5609         case R_PPC64_SECTOFF_HI:
5610         case R_PPC64_SECTOFF_HA:
5611         case R_PPC64_SECTOFF_DS:
5612         case R_PPC64_SECTOFF_LO_DS:
5613         case R_PPC64_DTPREL16:
5614         case R_PPC64_DTPREL16_LO:
5615         case R_PPC64_DTPREL16_HI:
5616         case R_PPC64_DTPREL16_HA:
5617         case R_PPC64_DTPREL16_DS:
5618         case R_PPC64_DTPREL16_LO_DS:
5619         case R_PPC64_DTPREL16_HIGH:
5620         case R_PPC64_DTPREL16_HIGHA:
5621         case R_PPC64_DTPREL16_HIGHER:
5622         case R_PPC64_DTPREL16_HIGHERA:
5623         case R_PPC64_DTPREL16_HIGHEST:
5624         case R_PPC64_DTPREL16_HIGHESTA:
5625           break;
5626
5627           /* Nor do these.  */
5628         case R_PPC64_REL16:
5629         case R_PPC64_REL16_LO:
5630         case R_PPC64_REL16_HI:
5631         case R_PPC64_REL16_HA:
5632         case R_PPC64_REL16DX_HA:
5633           break;
5634
5635           /* Not supported as a dynamic relocation.  */
5636         case R_PPC64_ADDR64_LOCAL:
5637           if (bfd_link_pic (info))
5638             {
5639               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5640                 ppc_howto_init ();
5641               /* xgettext:c-format */
5642               info->callbacks->einfo (_("%H: %s reloc unsupported "
5643                                         "in shared libraries and PIEs.\n"),
5644                                       abfd, sec, rel->r_offset,
5645                                       ppc64_elf_howto_table[r_type]->name);
5646               bfd_set_error (bfd_error_bad_value);
5647               return FALSE;
5648             }
5649           break;
5650
5651         case R_PPC64_TOC16:
5652         case R_PPC64_TOC16_DS:
5653           htab->do_multi_toc = 1;
5654           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5655           /* Fall through.  */
5656         case R_PPC64_TOC16_LO:
5657         case R_PPC64_TOC16_HI:
5658         case R_PPC64_TOC16_HA:
5659         case R_PPC64_TOC16_LO_DS:
5660           sec->has_toc_reloc = 1;
5661           break;
5662
5663           /* Marker reloc.  */
5664         case R_PPC64_ENTRY:
5665           break;
5666
5667           /* This relocation describes the C++ object vtable hierarchy.
5668              Reconstruct it for later use during GC.  */
5669         case R_PPC64_GNU_VTINHERIT:
5670           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5671             return FALSE;
5672           break;
5673
5674           /* This relocation describes which C++ vtable entries are actually
5675              used.  Record for later use during GC.  */
5676         case R_PPC64_GNU_VTENTRY:
5677           BFD_ASSERT (h != NULL);
5678           if (h != NULL
5679               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5680             return FALSE;
5681           break;
5682
5683         case R_PPC64_REL14:
5684         case R_PPC64_REL14_BRTAKEN:
5685         case R_PPC64_REL14_BRNTAKEN:
5686           {
5687             asection *dest = NULL;
5688
5689             /* Heuristic: If jumping outside our section, chances are
5690                we are going to need a stub.  */
5691             if (h != NULL)
5692               {
5693                 /* If the sym is weak it may be overridden later, so
5694                    don't assume we know where a weak sym lives.  */
5695                 if (h->root.type == bfd_link_hash_defined)
5696                   dest = h->root.u.def.section;
5697               }
5698             else
5699               {
5700                 Elf_Internal_Sym *isym;
5701
5702                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5703                                               abfd, r_symndx);
5704                 if (isym == NULL)
5705                   return FALSE;
5706
5707                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5708               }
5709
5710             if (dest != sec)
5711               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5712           }
5713           /* Fall through.  */
5714
5715         case R_PPC64_REL24:
5716           plt_list = ifunc;
5717           if (h != NULL)
5718             {
5719               h->needs_plt = 1;
5720               if (h->root.root.string[0] == '.'
5721                   && h->root.root.string[1] != '\0')
5722                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5723
5724               if (h == tga || h == dottga)
5725                 {
5726                   sec->has_tls_reloc = 1;
5727                   if (rel != relocs
5728                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5729                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5730                     /* We have a new-style __tls_get_addr call with
5731                        a marker reloc.  */
5732                     ;
5733                   else
5734                     /* Mark this section as having an old-style call.  */
5735                     sec->has_tls_get_addr_call = 1;
5736                 }
5737               plt_list = &h->plt.plist;
5738             }
5739
5740           /* We may need a .plt entry if the function this reloc
5741              refers to is in a shared lib.  */
5742           if (plt_list
5743               && !update_plt_info (abfd, plt_list, rel->r_addend))
5744             return FALSE;
5745           break;
5746
5747         case R_PPC64_ADDR14:
5748         case R_PPC64_ADDR14_BRNTAKEN:
5749         case R_PPC64_ADDR14_BRTAKEN:
5750         case R_PPC64_ADDR24:
5751           goto dodyn;
5752
5753         case R_PPC64_TPREL64:
5754           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5755           if (bfd_link_pic (info))
5756             info->flags |= DF_STATIC_TLS;
5757           goto dotlstoc;
5758
5759         case R_PPC64_DTPMOD64:
5760           if (rel + 1 < rel_end
5761               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5762               && rel[1].r_offset == rel->r_offset + 8)
5763             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5764           else
5765             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5766           goto dotlstoc;
5767
5768         case R_PPC64_DTPREL64:
5769           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5770           if (rel != relocs
5771               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5772               && rel[-1].r_offset == rel->r_offset - 8)
5773             /* This is the second reloc of a dtpmod, dtprel pair.
5774                Don't mark with TLS_DTPREL.  */
5775             goto dodyn;
5776
5777         dotlstoc:
5778           sec->has_tls_reloc = 1;
5779           if (h != NULL)
5780             {
5781               struct ppc_link_hash_entry *eh;
5782               eh = (struct ppc_link_hash_entry *) h;
5783               eh->tls_mask |= tls_type;
5784             }
5785           else
5786             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5787                                         rel->r_addend, tls_type))
5788               return FALSE;
5789
5790           ppc64_sec = ppc64_elf_section_data (sec);
5791           if (ppc64_sec->sec_type != sec_toc)
5792             {
5793               bfd_size_type amt;
5794
5795               /* One extra to simplify get_tls_mask.  */
5796               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5797               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5798               if (ppc64_sec->u.toc.symndx == NULL)
5799                 return FALSE;
5800               amt = sec->size * sizeof (bfd_vma) / 8;
5801               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5802               if (ppc64_sec->u.toc.add == NULL)
5803                 return FALSE;
5804               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5805               ppc64_sec->sec_type = sec_toc;
5806             }
5807           BFD_ASSERT (rel->r_offset % 8 == 0);
5808           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5809           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5810
5811           /* Mark the second slot of a GD or LD entry.
5812              -1 to indicate GD and -2 to indicate LD.  */
5813           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5814             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5815           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5816             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5817           goto dodyn;
5818
5819         case R_PPC64_TPREL16:
5820         case R_PPC64_TPREL16_LO:
5821         case R_PPC64_TPREL16_HI:
5822         case R_PPC64_TPREL16_HA:
5823         case R_PPC64_TPREL16_DS:
5824         case R_PPC64_TPREL16_LO_DS:
5825         case R_PPC64_TPREL16_HIGH:
5826         case R_PPC64_TPREL16_HIGHA:
5827         case R_PPC64_TPREL16_HIGHER:
5828         case R_PPC64_TPREL16_HIGHERA:
5829         case R_PPC64_TPREL16_HIGHEST:
5830         case R_PPC64_TPREL16_HIGHESTA:
5831           if (bfd_link_pic (info))
5832             {
5833               info->flags |= DF_STATIC_TLS;
5834               goto dodyn;
5835             }
5836           break;
5837
5838         case R_PPC64_ADDR64:
5839           if (opd_sym_map != NULL
5840               && rel + 1 < rel_end
5841               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5842             {
5843               if (h != NULL)
5844                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5845               else
5846                 {
5847                   asection *s;
5848                   Elf_Internal_Sym *isym;
5849
5850                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5851                                                 abfd, r_symndx);
5852                   if (isym == NULL)
5853                     return FALSE;
5854
5855                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5856                   if (s != NULL && s != sec)
5857                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5858                 }
5859             }
5860           /* Fall through.  */
5861
5862         case R_PPC64_ADDR16:
5863         case R_PPC64_ADDR16_DS:
5864         case R_PPC64_ADDR16_HA:
5865         case R_PPC64_ADDR16_HI:
5866         case R_PPC64_ADDR16_HIGH:
5867         case R_PPC64_ADDR16_HIGHA:
5868         case R_PPC64_ADDR16_HIGHER:
5869         case R_PPC64_ADDR16_HIGHERA:
5870         case R_PPC64_ADDR16_HIGHEST:
5871         case R_PPC64_ADDR16_HIGHESTA:
5872         case R_PPC64_ADDR16_LO:
5873         case R_PPC64_ADDR16_LO_DS:
5874           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5875               && rel->r_addend == 0)
5876             {
5877               /* We may need a .plt entry if this reloc refers to a
5878                  function in a shared lib.  */
5879               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5880                 return FALSE;
5881               h->pointer_equality_needed = 1;
5882             }
5883           /* Fall through.  */
5884
5885         case R_PPC64_REL30:
5886         case R_PPC64_REL32:
5887         case R_PPC64_REL64:
5888         case R_PPC64_ADDR32:
5889         case R_PPC64_UADDR16:
5890         case R_PPC64_UADDR32:
5891         case R_PPC64_UADDR64:
5892         case R_PPC64_TOC:
5893           if (h != NULL && !bfd_link_pic (info))
5894             /* We may need a copy reloc.  */
5895             h->non_got_ref = 1;
5896
5897           /* Don't propagate .opd relocs.  */
5898           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5899             break;
5900
5901           /* If we are creating a shared library, and this is a reloc
5902              against a global symbol, or a non PC relative reloc
5903              against a local symbol, then we need to copy the reloc
5904              into the shared library.  However, if we are linking with
5905              -Bsymbolic, we do not need to copy a reloc against a
5906              global symbol which is defined in an object we are
5907              including in the link (i.e., DEF_REGULAR is set).  At
5908              this point we have not seen all the input files, so it is
5909              possible that DEF_REGULAR is not set now but will be set
5910              later (it is never cleared).  In case of a weak definition,
5911              DEF_REGULAR may be cleared later by a strong definition in
5912              a shared library.  We account for that possibility below by
5913              storing information in the dyn_relocs field of the hash
5914              table entry.  A similar situation occurs when creating
5915              shared libraries and symbol visibility changes render the
5916              symbol local.
5917
5918              If on the other hand, we are creating an executable, we
5919              may need to keep relocations for symbols satisfied by a
5920              dynamic library if we manage to avoid copy relocs for the
5921              symbol.  */
5922         dodyn:
5923           if ((bfd_link_pic (info)
5924                && (must_be_dyn_reloc (info, r_type)
5925                    || (h != NULL
5926                        && (!SYMBOLIC_BIND (info, h)
5927                            || h->root.type == bfd_link_hash_defweak
5928                            || !h->def_regular))))
5929               || (ELIMINATE_COPY_RELOCS
5930                   && !bfd_link_pic (info)
5931                   && h != NULL
5932                   && (h->root.type == bfd_link_hash_defweak
5933                       || !h->def_regular))
5934               || (!bfd_link_pic (info)
5935                   && ifunc != NULL))
5936             {
5937               /* We must copy these reloc types into the output file.
5938                  Create a reloc section in dynobj and make room for
5939                  this reloc.  */
5940               if (sreloc == NULL)
5941                 {
5942                   sreloc = _bfd_elf_make_dynamic_reloc_section
5943                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5944
5945                   if (sreloc == NULL)
5946                     return FALSE;
5947                 }
5948
5949               /* If this is a global symbol, we count the number of
5950                  relocations we need for this symbol.  */
5951               if (h != NULL)
5952                 {
5953                   struct elf_dyn_relocs *p;
5954                   struct elf_dyn_relocs **head;
5955
5956                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5957                   p = *head;
5958                   if (p == NULL || p->sec != sec)
5959                     {
5960                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5961                       if (p == NULL)
5962                         return FALSE;
5963                       p->next = *head;
5964                       *head = p;
5965                       p->sec = sec;
5966                       p->count = 0;
5967                       p->pc_count = 0;
5968                     }
5969                   p->count += 1;
5970                   if (!must_be_dyn_reloc (info, r_type))
5971                     p->pc_count += 1;
5972                 }
5973               else
5974                 {
5975                   /* Track dynamic relocs needed for local syms too.
5976                      We really need local syms available to do this
5977                      easily.  Oh well.  */
5978                   struct ppc_dyn_relocs *p;
5979                   struct ppc_dyn_relocs **head;
5980                   bfd_boolean is_ifunc;
5981                   asection *s;
5982                   void *vpp;
5983                   Elf_Internal_Sym *isym;
5984
5985                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5986                                                 abfd, r_symndx);
5987                   if (isym == NULL)
5988                     return FALSE;
5989
5990                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5991                   if (s == NULL)
5992                     s = sec;
5993
5994                   vpp = &elf_section_data (s)->local_dynrel;
5995                   head = (struct ppc_dyn_relocs **) vpp;
5996                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5997                   p = *head;
5998                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5999                     p = p->next;
6000                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6001                     {
6002                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6003                       if (p == NULL)
6004                         return FALSE;
6005                       p->next = *head;
6006                       *head = p;
6007                       p->sec = sec;
6008                       p->ifunc = is_ifunc;
6009                       p->count = 0;
6010                     }
6011                   p->count += 1;
6012                 }
6013             }
6014           break;
6015
6016         default:
6017           break;
6018         }
6019     }
6020
6021   return TRUE;
6022 }
6023
6024 /* Merge backend specific data from an object file to the output
6025    object file when linking.  */
6026
6027 static bfd_boolean
6028 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6029 {
6030   bfd *obfd = info->output_bfd;
6031   unsigned long iflags, oflags;
6032
6033   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6034     return TRUE;
6035
6036   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6037     return TRUE;
6038
6039   if (!_bfd_generic_verify_endian_match (ibfd, info))
6040     return FALSE;
6041
6042   iflags = elf_elfheader (ibfd)->e_flags;
6043   oflags = elf_elfheader (obfd)->e_flags;
6044
6045   if (iflags & ~EF_PPC64_ABI)
6046     {
6047       _bfd_error_handler
6048         /* xgettext:c-format */
6049         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6050       bfd_set_error (bfd_error_bad_value);
6051       return FALSE;
6052     }
6053   else if (iflags != oflags && iflags != 0)
6054     {
6055       _bfd_error_handler
6056         /* xgettext:c-format */
6057         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6058          ibfd, iflags, oflags);
6059       bfd_set_error (bfd_error_bad_value);
6060       return FALSE;
6061     }
6062
6063   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6064
6065   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6066   _bfd_elf_merge_object_attributes (ibfd, info);
6067
6068   return TRUE;
6069 }
6070
6071 static bfd_boolean
6072 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6073 {
6074   /* Print normal ELF private data.  */
6075   _bfd_elf_print_private_bfd_data (abfd, ptr);
6076
6077   if (elf_elfheader (abfd)->e_flags != 0)
6078     {
6079       FILE *file = ptr;
6080
6081       fprintf (file, _("private flags = 0x%lx:"),
6082                elf_elfheader (abfd)->e_flags);
6083
6084       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6085         fprintf (file, _(" [abiv%ld]"),
6086                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6087       fputc ('\n', file);
6088     }
6089
6090   return TRUE;
6091 }
6092
6093 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6094    of the code entry point, and its section, which must be in the same
6095    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6096
6097 static bfd_vma
6098 opd_entry_value (asection *opd_sec,
6099                  bfd_vma offset,
6100                  asection **code_sec,
6101                  bfd_vma *code_off,
6102                  bfd_boolean in_code_sec)
6103 {
6104   bfd *opd_bfd = opd_sec->owner;
6105   Elf_Internal_Rela *relocs;
6106   Elf_Internal_Rela *lo, *hi, *look;
6107   bfd_vma val;
6108
6109   /* No relocs implies we are linking a --just-symbols object, or looking
6110      at a final linked executable with addr2line or somesuch.  */
6111   if (opd_sec->reloc_count == 0)
6112     {
6113       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6114
6115       if (contents == NULL)
6116         {
6117           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6118             return (bfd_vma) -1;
6119           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6120         }
6121
6122       /* PR 17512: file: 64b9dfbb.  */
6123       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6124         return (bfd_vma) -1;
6125
6126       val = bfd_get_64 (opd_bfd, contents + offset);
6127       if (code_sec != NULL)
6128         {
6129           asection *sec, *likely = NULL;
6130
6131           if (in_code_sec)
6132             {
6133               sec = *code_sec;
6134               if (sec->vma <= val
6135                   && val < sec->vma + sec->size)
6136                 likely = sec;
6137               else
6138                 val = -1;
6139             }
6140           else
6141             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6142               if (sec->vma <= val
6143                   && (sec->flags & SEC_LOAD) != 0
6144                   && (sec->flags & SEC_ALLOC) != 0)
6145                 likely = sec;
6146           if (likely != NULL)
6147             {
6148               *code_sec = likely;
6149               if (code_off != NULL)
6150                 *code_off = val - likely->vma;
6151             }
6152         }
6153       return val;
6154     }
6155
6156   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6157
6158   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6159   if (relocs == NULL)
6160     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6161   /* PR 17512: file: df8e1fd6.  */
6162   if (relocs == NULL)
6163     return (bfd_vma) -1;
6164
6165   /* Go find the opd reloc at the sym address.  */
6166   lo = relocs;
6167   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6168   val = (bfd_vma) -1;
6169   while (lo < hi)
6170     {
6171       look = lo + (hi - lo) / 2;
6172       if (look->r_offset < offset)
6173         lo = look + 1;
6174       else if (look->r_offset > offset)
6175         hi = look;
6176       else
6177         {
6178           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6179
6180           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6181               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6182             {
6183               unsigned long symndx = ELF64_R_SYM (look->r_info);
6184               asection *sec = NULL;
6185
6186               if (symndx >= symtab_hdr->sh_info
6187                   && elf_sym_hashes (opd_bfd) != NULL)
6188                 {
6189                   struct elf_link_hash_entry **sym_hashes;
6190                   struct elf_link_hash_entry *rh;
6191
6192                   sym_hashes = elf_sym_hashes (opd_bfd);
6193                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6194                   if (rh != NULL)
6195                     {
6196                       rh = elf_follow_link (rh);
6197                       if (rh->root.type != bfd_link_hash_defined
6198                           && rh->root.type != bfd_link_hash_defweak)
6199                         break;
6200                       if (rh->root.u.def.section->owner == opd_bfd)
6201                         {
6202                           val = rh->root.u.def.value;
6203                           sec = rh->root.u.def.section;
6204                         }
6205                     }
6206                 }
6207
6208               if (sec == NULL)
6209                 {
6210                   Elf_Internal_Sym *sym;
6211
6212                   if (symndx < symtab_hdr->sh_info)
6213                     {
6214                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6215                       if (sym == NULL)
6216                         {
6217                           size_t symcnt = symtab_hdr->sh_info;
6218                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6219                                                       symcnt, 0,
6220                                                       NULL, NULL, NULL);
6221                           if (sym == NULL)
6222                             break;
6223                           symtab_hdr->contents = (bfd_byte *) sym;
6224                         }
6225                       sym += symndx;
6226                     }
6227                   else
6228                     {
6229                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6230                                                   1, symndx,
6231                                                   NULL, NULL, NULL);
6232                       if (sym == NULL)
6233                         break;
6234                     }
6235                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6236                   if (sec == NULL)
6237                     break;
6238                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6239                   val = sym->st_value;
6240                 }
6241
6242               val += look->r_addend;
6243               if (code_off != NULL)
6244                 *code_off = val;
6245               if (code_sec != NULL)
6246                 {
6247                   if (in_code_sec && *code_sec != sec)
6248                     return -1;
6249                   else
6250                     *code_sec = sec;
6251                 }
6252               if (sec->output_section != NULL)
6253                 val += sec->output_section->vma + sec->output_offset;
6254             }
6255           break;
6256         }
6257     }
6258
6259   return val;
6260 }
6261
6262 /* If the ELF symbol SYM might be a function in SEC, return the
6263    function size and set *CODE_OFF to the function's entry point,
6264    otherwise return zero.  */
6265
6266 static bfd_size_type
6267 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6268                               bfd_vma *code_off)
6269 {
6270   bfd_size_type size;
6271
6272   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6273                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6274     return 0;
6275
6276   size = 0;
6277   if (!(sym->flags & BSF_SYNTHETIC))
6278     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6279
6280   if (strcmp (sym->section->name, ".opd") == 0)
6281     {
6282       struct _opd_sec_data *opd = get_opd_info (sym->section);
6283       bfd_vma symval = sym->value;
6284
6285       if (opd != NULL
6286           && opd->adjust != NULL
6287           && elf_section_data (sym->section)->relocs != NULL)
6288         {
6289           /* opd_entry_value will use cached relocs that have been
6290              adjusted, but with raw symbols.  That means both local
6291              and global symbols need adjusting.  */
6292           long adjust = opd->adjust[OPD_NDX (symval)];
6293           if (adjust == -1)
6294             return 0;
6295           symval += adjust;
6296         }
6297
6298       if (opd_entry_value (sym->section, symval,
6299                            &sec, code_off, TRUE) == (bfd_vma) -1)
6300         return 0;
6301       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6302          symbol.  This size has nothing to do with the code size of the
6303          function, which is what we're supposed to return, but the
6304          code size isn't available without looking up the dot-sym.
6305          However, doing that would be a waste of time particularly
6306          since elf_find_function will look at the dot-sym anyway.
6307          Now, elf_find_function will keep the largest size of any
6308          function sym found at the code address of interest, so return
6309          1 here to avoid it incorrectly caching a larger function size
6310          for a small function.  This does mean we return the wrong
6311          size for a new-ABI function of size 24, but all that does is
6312          disable caching for such functions.  */
6313       if (size == 24)
6314         size = 1;
6315     }
6316   else
6317     {
6318       if (sym->section != sec)
6319         return 0;
6320       *code_off = sym->value;
6321     }
6322   if (size == 0)
6323     size = 1;
6324   return size;
6325 }
6326
6327 /* Return true if symbol is a strong function defined in an ELFv2
6328    object with st_other localentry bits of zero, ie. its local entry
6329    point coincides with its global entry point.  */
6330
6331 static bfd_boolean
6332 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6333 {
6334   return (h != NULL
6335           && h->type == STT_FUNC
6336           && h->root.type == bfd_link_hash_defined
6337           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6338           && is_ppc64_elf (h->root.u.def.section->owner)
6339           && abiversion (h->root.u.def.section->owner) >= 2);
6340 }
6341
6342 /* Return true if symbol is defined in a regular object file.  */
6343
6344 static bfd_boolean
6345 is_static_defined (struct elf_link_hash_entry *h)
6346 {
6347   return ((h->root.type == bfd_link_hash_defined
6348            || h->root.type == bfd_link_hash_defweak)
6349           && h->root.u.def.section != NULL
6350           && h->root.u.def.section->output_section != NULL);
6351 }
6352
6353 /* If FDH is a function descriptor symbol, return the associated code
6354    entry symbol if it is defined.  Return NULL otherwise.  */
6355
6356 static struct ppc_link_hash_entry *
6357 defined_code_entry (struct ppc_link_hash_entry *fdh)
6358 {
6359   if (fdh->is_func_descriptor)
6360     {
6361       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6362       if (fh->elf.root.type == bfd_link_hash_defined
6363           || fh->elf.root.type == bfd_link_hash_defweak)
6364         return fh;
6365     }
6366   return NULL;
6367 }
6368
6369 /* If FH is a function code entry symbol, return the associated
6370    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6371
6372 static struct ppc_link_hash_entry *
6373 defined_func_desc (struct ppc_link_hash_entry *fh)
6374 {
6375   if (fh->oh != NULL
6376       && fh->oh->is_func_descriptor)
6377     {
6378       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6379       if (fdh->elf.root.type == bfd_link_hash_defined
6380           || fdh->elf.root.type == bfd_link_hash_defweak)
6381         return fdh;
6382     }
6383   return NULL;
6384 }
6385
6386 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6387
6388 /* Garbage collect sections, after first dealing with dot-symbols.  */
6389
6390 static bfd_boolean
6391 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6392 {
6393   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6394
6395   if (htab != NULL && htab->need_func_desc_adj)
6396     {
6397       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6398       htab->need_func_desc_adj = 0;
6399     }
6400   return bfd_elf_gc_sections (abfd, info);
6401 }
6402
6403 /* Mark all our entry sym sections, both opd and code section.  */
6404
6405 static void
6406 ppc64_elf_gc_keep (struct bfd_link_info *info)
6407 {
6408   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6409   struct bfd_sym_chain *sym;
6410
6411   if (htab == NULL)
6412     return;
6413
6414   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6415     {
6416       struct ppc_link_hash_entry *eh, *fh;
6417       asection *sec;
6418
6419       eh = (struct ppc_link_hash_entry *)
6420         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6421       if (eh == NULL)
6422         continue;
6423       if (eh->elf.root.type != bfd_link_hash_defined
6424           && eh->elf.root.type != bfd_link_hash_defweak)
6425         continue;
6426
6427       fh = defined_code_entry (eh);
6428       if (fh != NULL)
6429         {
6430           sec = fh->elf.root.u.def.section;
6431           sec->flags |= SEC_KEEP;
6432         }
6433       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6434                && opd_entry_value (eh->elf.root.u.def.section,
6435                                    eh->elf.root.u.def.value,
6436                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6437         sec->flags |= SEC_KEEP;
6438
6439       sec = eh->elf.root.u.def.section;
6440       sec->flags |= SEC_KEEP;
6441     }
6442 }
6443
6444 /* Mark sections containing dynamically referenced symbols.  When
6445    building shared libraries, we must assume that any visible symbol is
6446    referenced.  */
6447
6448 static bfd_boolean
6449 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6450 {
6451   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6452   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6453   struct ppc_link_hash_entry *fdh;
6454   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6455
6456   /* Dynamic linking info is on the func descriptor sym.  */
6457   fdh = defined_func_desc (eh);
6458   if (fdh != NULL)
6459     eh = fdh;
6460
6461   if ((eh->elf.root.type == bfd_link_hash_defined
6462        || eh->elf.root.type == bfd_link_hash_defweak)
6463       && (eh->elf.ref_dynamic
6464           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6465               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6466               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6467               && (!bfd_link_executable (info)
6468                   || info->gc_keep_exported
6469                   || info->export_dynamic
6470                   || (eh->elf.dynamic
6471                       && d != NULL
6472                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6473               && (eh->elf.versioned >= versioned
6474                   || !bfd_hide_sym_by_version (info->version_info,
6475                                                eh->elf.root.root.string)))))
6476     {
6477       asection *code_sec;
6478       struct ppc_link_hash_entry *fh;
6479
6480       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6481
6482       /* Function descriptor syms cause the associated
6483          function code sym section to be marked.  */
6484       fh = defined_code_entry (eh);
6485       if (fh != NULL)
6486         {
6487           code_sec = fh->elf.root.u.def.section;
6488           code_sec->flags |= SEC_KEEP;
6489         }
6490       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6491                && opd_entry_value (eh->elf.root.u.def.section,
6492                                    eh->elf.root.u.def.value,
6493                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6494         code_sec->flags |= SEC_KEEP;
6495     }
6496
6497   return TRUE;
6498 }
6499
6500 /* Return the section that should be marked against GC for a given
6501    relocation.  */
6502
6503 static asection *
6504 ppc64_elf_gc_mark_hook (asection *sec,
6505                         struct bfd_link_info *info,
6506                         Elf_Internal_Rela *rel,
6507                         struct elf_link_hash_entry *h,
6508                         Elf_Internal_Sym *sym)
6509 {
6510   asection *rsec;
6511
6512   /* Syms return NULL if we're marking .opd, so we avoid marking all
6513      function sections, as all functions are referenced in .opd.  */
6514   rsec = NULL;
6515   if (get_opd_info (sec) != NULL)
6516     return rsec;
6517
6518   if (h != NULL)
6519     {
6520       enum elf_ppc64_reloc_type r_type;
6521       struct ppc_link_hash_entry *eh, *fh, *fdh;
6522
6523       r_type = ELF64_R_TYPE (rel->r_info);
6524       switch (r_type)
6525         {
6526         case R_PPC64_GNU_VTINHERIT:
6527         case R_PPC64_GNU_VTENTRY:
6528           break;
6529
6530         default:
6531           switch (h->root.type)
6532             {
6533             case bfd_link_hash_defined:
6534             case bfd_link_hash_defweak:
6535               eh = (struct ppc_link_hash_entry *) h;
6536               fdh = defined_func_desc (eh);
6537               if (fdh != NULL)
6538                 {
6539                   /* -mcall-aixdesc code references the dot-symbol on
6540                      a call reloc.  Mark the function descriptor too
6541                      against garbage collection.  */
6542                   fdh->elf.mark = 1;
6543                   if (fdh->elf.u.weakdef != NULL)
6544                     fdh->elf.u.weakdef->mark = 1;
6545                   eh = fdh;
6546                 }
6547
6548               /* Function descriptor syms cause the associated
6549                  function code sym section to be marked.  */
6550               fh = defined_code_entry (eh);
6551               if (fh != NULL)
6552                 {
6553                   /* They also mark their opd section.  */
6554                   eh->elf.root.u.def.section->gc_mark = 1;
6555
6556                   rsec = fh->elf.root.u.def.section;
6557                 }
6558               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6559                        && opd_entry_value (eh->elf.root.u.def.section,
6560                                            eh->elf.root.u.def.value,
6561                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6562                 eh->elf.root.u.def.section->gc_mark = 1;
6563               else
6564                 rsec = h->root.u.def.section;
6565               break;
6566
6567             case bfd_link_hash_common:
6568               rsec = h->root.u.c.p->section;
6569               break;
6570
6571             default:
6572               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6573             }
6574         }
6575     }
6576   else
6577     {
6578       struct _opd_sec_data *opd;
6579
6580       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6581       opd = get_opd_info (rsec);
6582       if (opd != NULL && opd->func_sec != NULL)
6583         {
6584           rsec->gc_mark = 1;
6585
6586           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6587         }
6588     }
6589
6590   return rsec;
6591 }
6592
6593 /* Update the .got, .plt. and dynamic reloc reference counts for the
6594    section being removed.  */
6595
6596 static bfd_boolean
6597 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6598                          asection *sec, const Elf_Internal_Rela *relocs)
6599 {
6600   struct ppc_link_hash_table *htab;
6601   Elf_Internal_Shdr *symtab_hdr;
6602   struct elf_link_hash_entry **sym_hashes;
6603   struct got_entry **local_got_ents;
6604   const Elf_Internal_Rela *rel, *relend;
6605
6606   if (bfd_link_relocatable (info))
6607     return TRUE;
6608
6609   if ((sec->flags & SEC_ALLOC) == 0)
6610     return TRUE;
6611
6612   elf_section_data (sec)->local_dynrel = NULL;
6613
6614   htab = ppc_hash_table (info);
6615   if (htab == NULL)
6616     return FALSE;
6617
6618   symtab_hdr = &elf_symtab_hdr (abfd);
6619   sym_hashes = elf_sym_hashes (abfd);
6620   local_got_ents = elf_local_got_ents (abfd);
6621
6622   relend = relocs + sec->reloc_count;
6623   for (rel = relocs; rel < relend; rel++)
6624     {
6625       unsigned long r_symndx;
6626       enum elf_ppc64_reloc_type r_type;
6627       struct elf_link_hash_entry *h = NULL;
6628       struct plt_entry **plt_list = NULL;
6629       unsigned char tls_type = 0;
6630
6631       r_symndx = ELF64_R_SYM (rel->r_info);
6632       r_type = ELF64_R_TYPE (rel->r_info);
6633       if (r_symndx >= symtab_hdr->sh_info)
6634         {
6635           struct ppc_link_hash_entry *eh;
6636           struct elf_dyn_relocs **pp;
6637           struct elf_dyn_relocs *p;
6638
6639           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6640           h = elf_follow_link (h);
6641           eh = (struct ppc_link_hash_entry *) h;
6642
6643           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6644             if (p->sec == sec)
6645               {
6646                 /* Everything must go for SEC.  */
6647                 *pp = p->next;
6648                 break;
6649               }
6650         }
6651
6652       switch (r_type)
6653         {
6654         case R_PPC64_GOT_TLSLD16:
6655         case R_PPC64_GOT_TLSLD16_LO:
6656         case R_PPC64_GOT_TLSLD16_HI:
6657         case R_PPC64_GOT_TLSLD16_HA:
6658           tls_type = TLS_TLS | TLS_LD;
6659           goto dogot;
6660
6661         case R_PPC64_GOT_TLSGD16:
6662         case R_PPC64_GOT_TLSGD16_LO:
6663         case R_PPC64_GOT_TLSGD16_HI:
6664         case R_PPC64_GOT_TLSGD16_HA:
6665           tls_type = TLS_TLS | TLS_GD;
6666           goto dogot;
6667
6668         case R_PPC64_GOT_TPREL16_DS:
6669         case R_PPC64_GOT_TPREL16_LO_DS:
6670         case R_PPC64_GOT_TPREL16_HI:
6671         case R_PPC64_GOT_TPREL16_HA:
6672           tls_type = TLS_TLS | TLS_TPREL;
6673           goto dogot;
6674
6675         case R_PPC64_GOT_DTPREL16_DS:
6676         case R_PPC64_GOT_DTPREL16_LO_DS:
6677         case R_PPC64_GOT_DTPREL16_HI:
6678         case R_PPC64_GOT_DTPREL16_HA:
6679           tls_type = TLS_TLS | TLS_DTPREL;
6680           goto dogot;
6681
6682         case R_PPC64_GOT16:
6683         case R_PPC64_GOT16_DS:
6684         case R_PPC64_GOT16_HA:
6685         case R_PPC64_GOT16_HI:
6686         case R_PPC64_GOT16_LO:
6687         case R_PPC64_GOT16_LO_DS:
6688         dogot:
6689           {
6690             struct got_entry *ent;
6691
6692             if (h != NULL)
6693               ent = h->got.glist;
6694             else
6695               ent = local_got_ents[r_symndx];
6696
6697             for (; ent != NULL; ent = ent->next)
6698               if (ent->addend == rel->r_addend
6699                   && ent->owner == abfd
6700                   && ent->tls_type == tls_type)
6701                 break;
6702             if (ent == NULL)
6703               abort ();
6704             if (ent->got.refcount > 0)
6705               ent->got.refcount -= 1;
6706           }
6707           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6708             plt_list = &h->plt.plist;
6709           break;
6710
6711         case R_PPC64_PLT16_HA:
6712         case R_PPC64_PLT16_HI:
6713         case R_PPC64_PLT16_LO:
6714         case R_PPC64_PLT32:
6715         case R_PPC64_PLT64:
6716         case R_PPC64_REL14:
6717         case R_PPC64_REL14_BRNTAKEN:
6718         case R_PPC64_REL14_BRTAKEN:
6719         case R_PPC64_REL24:
6720           if (h != NULL)
6721             plt_list = &h->plt.plist;
6722           else if (local_got_ents != NULL)
6723             {
6724               struct plt_entry **local_plt = (struct plt_entry **)
6725                 (local_got_ents + symtab_hdr->sh_info);
6726               unsigned char *local_got_tls_masks = (unsigned char *)
6727                 (local_plt + symtab_hdr->sh_info);
6728               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6729                 plt_list = local_plt + r_symndx;
6730             }
6731           break;
6732
6733         case R_PPC64_ADDR64:
6734         case R_PPC64_ADDR16:
6735         case R_PPC64_ADDR16_DS:
6736         case R_PPC64_ADDR16_HA:
6737         case R_PPC64_ADDR16_HI:
6738         case R_PPC64_ADDR16_HIGH:
6739         case R_PPC64_ADDR16_HIGHA:
6740         case R_PPC64_ADDR16_HIGHER:
6741         case R_PPC64_ADDR16_HIGHERA:
6742         case R_PPC64_ADDR16_HIGHEST:
6743         case R_PPC64_ADDR16_HIGHESTA:
6744         case R_PPC64_ADDR16_LO:
6745         case R_PPC64_ADDR16_LO_DS:
6746           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6747               && rel->r_addend == 0)
6748             plt_list = &h->plt.plist;
6749           break;
6750
6751         default:
6752           break;
6753         }
6754       if (plt_list != NULL)
6755         {
6756           struct plt_entry *ent;
6757
6758           for (ent = *plt_list; ent != NULL; ent = ent->next)
6759             if (ent->addend == rel->r_addend)
6760               break;
6761           if (ent != NULL && ent->plt.refcount > 0)
6762             ent->plt.refcount -= 1;
6763         }
6764     }
6765   return TRUE;
6766 }
6767
6768 /* The maximum size of .sfpr.  */
6769 #define SFPR_MAX (218*4)
6770
6771 struct sfpr_def_parms
6772 {
6773   const char name[12];
6774   unsigned char lo, hi;
6775   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6776   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6777 };
6778
6779 /* Auto-generate _save*, _rest* functions in .sfpr.
6780    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6781    instead.  */
6782
6783 static bfd_boolean
6784 sfpr_define (struct bfd_link_info *info,
6785              const struct sfpr_def_parms *parm,
6786              asection *stub_sec)
6787 {
6788   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6789   unsigned int i;
6790   size_t len = strlen (parm->name);
6791   bfd_boolean writing = FALSE;
6792   char sym[16];
6793
6794   if (htab == NULL)
6795     return FALSE;
6796
6797   memcpy (sym, parm->name, len);
6798   sym[len + 2] = 0;
6799
6800   for (i = parm->lo; i <= parm->hi; i++)
6801     {
6802       struct ppc_link_hash_entry *h;
6803
6804       sym[len + 0] = i / 10 + '0';
6805       sym[len + 1] = i % 10 + '0';
6806       h = (struct ppc_link_hash_entry *)
6807         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6808       if (stub_sec != NULL)
6809         {
6810           if (h != NULL
6811               && h->elf.root.type == bfd_link_hash_defined
6812               && h->elf.root.u.def.section == htab->sfpr)
6813             {
6814               struct elf_link_hash_entry *s;
6815               char buf[32];
6816               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6817               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6818               if (s == NULL)
6819                 return FALSE;
6820               if (s->root.type == bfd_link_hash_new
6821                   || (s->root.type = bfd_link_hash_defined
6822                       && s->root.u.def.section == stub_sec))
6823                 {
6824                   s->root.type = bfd_link_hash_defined;
6825                   s->root.u.def.section = stub_sec;
6826                   s->root.u.def.value = (stub_sec->size
6827                                          + h->elf.root.u.def.value);
6828                   s->ref_regular = 1;
6829                   s->def_regular = 1;
6830                   s->ref_regular_nonweak = 1;
6831                   s->forced_local = 1;
6832                   s->non_elf = 0;
6833                   s->root.linker_def = 1;
6834                 }
6835             }
6836           continue;
6837         }
6838       if (h != NULL)
6839         {
6840           h->save_res = 1;
6841           if (!h->elf.def_regular)
6842             {
6843               h->elf.root.type = bfd_link_hash_defined;
6844               h->elf.root.u.def.section = htab->sfpr;
6845               h->elf.root.u.def.value = htab->sfpr->size;
6846               h->elf.type = STT_FUNC;
6847               h->elf.def_regular = 1;
6848               h->elf.non_elf = 0;
6849               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6850               writing = TRUE;
6851               if (htab->sfpr->contents == NULL)
6852                 {
6853                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6854                   if (htab->sfpr->contents == NULL)
6855                     return FALSE;
6856                 }
6857             }
6858         }
6859       if (writing)
6860         {
6861           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6862           if (i != parm->hi)
6863             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6864           else
6865             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6866           htab->sfpr->size = p - htab->sfpr->contents;
6867         }
6868     }
6869
6870   return TRUE;
6871 }
6872
6873 static bfd_byte *
6874 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6875 {
6876   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6877   return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6882 {
6883   p = savegpr0 (abfd, p, r);
6884   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6885   p = p + 4;
6886   bfd_put_32 (abfd, BLR, p);
6887   return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6892 {
6893   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6894   return p + 4;
6895 }
6896
6897 static bfd_byte *
6898 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6899 {
6900   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6901   p = p + 4;
6902   p = restgpr0 (abfd, p, r);
6903   bfd_put_32 (abfd, MTLR_R0, p);
6904   p = p + 4;
6905   if (r == 29)
6906     {
6907       p = restgpr0 (abfd, p, 30);
6908       p = restgpr0 (abfd, p, 31);
6909     }
6910   bfd_put_32 (abfd, BLR, p);
6911   return p + 4;
6912 }
6913
6914 static bfd_byte *
6915 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6916 {
6917   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6918   return p + 4;
6919 }
6920
6921 static bfd_byte *
6922 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6923 {
6924   p = savegpr1 (abfd, p, r);
6925   bfd_put_32 (abfd, BLR, p);
6926   return p + 4;
6927 }
6928
6929 static bfd_byte *
6930 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6931 {
6932   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6933   return p + 4;
6934 }
6935
6936 static bfd_byte *
6937 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6938 {
6939   p = restgpr1 (abfd, p, r);
6940   bfd_put_32 (abfd, BLR, p);
6941   return p + 4;
6942 }
6943
6944 static bfd_byte *
6945 savefpr (bfd *abfd, bfd_byte *p, int r)
6946 {
6947   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6948   return p + 4;
6949 }
6950
6951 static bfd_byte *
6952 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6953 {
6954   p = savefpr (abfd, p, r);
6955   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6956   p = p + 4;
6957   bfd_put_32 (abfd, BLR, p);
6958   return p + 4;
6959 }
6960
6961 static bfd_byte *
6962 restfpr (bfd *abfd, bfd_byte *p, int r)
6963 {
6964   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6965   return p + 4;
6966 }
6967
6968 static bfd_byte *
6969 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6970 {
6971   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6972   p = p + 4;
6973   p = restfpr (abfd, p, r);
6974   bfd_put_32 (abfd, MTLR_R0, p);
6975   p = p + 4;
6976   if (r == 29)
6977     {
6978       p = restfpr (abfd, p, 30);
6979       p = restfpr (abfd, p, 31);
6980     }
6981   bfd_put_32 (abfd, BLR, p);
6982   return p + 4;
6983 }
6984
6985 static bfd_byte *
6986 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6987 {
6988   p = savefpr (abfd, p, r);
6989   bfd_put_32 (abfd, BLR, p);
6990   return p + 4;
6991 }
6992
6993 static bfd_byte *
6994 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6995 {
6996   p = restfpr (abfd, p, r);
6997   bfd_put_32 (abfd, BLR, p);
6998   return p + 4;
6999 }
7000
7001 static bfd_byte *
7002 savevr (bfd *abfd, bfd_byte *p, int r)
7003 {
7004   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7005   p = p + 4;
7006   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7007   return p + 4;
7008 }
7009
7010 static bfd_byte *
7011 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7012 {
7013   p = savevr (abfd, p, r);
7014   bfd_put_32 (abfd, BLR, p);
7015   return p + 4;
7016 }
7017
7018 static bfd_byte *
7019 restvr (bfd *abfd, bfd_byte *p, int r)
7020 {
7021   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7022   p = p + 4;
7023   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7024   return p + 4;
7025 }
7026
7027 static bfd_byte *
7028 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7029 {
7030   p = restvr (abfd, p, r);
7031   bfd_put_32 (abfd, BLR, p);
7032   return p + 4;
7033 }
7034
7035 /* Called via elf_link_hash_traverse to transfer dynamic linking
7036    information on function code symbol entries to their corresponding
7037    function descriptor symbol entries.  */
7038
7039 static bfd_boolean
7040 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7041 {
7042   struct bfd_link_info *info;
7043   struct ppc_link_hash_table *htab;
7044   struct ppc_link_hash_entry *fh;
7045   struct ppc_link_hash_entry *fdh;
7046   bfd_boolean force_local;
7047
7048   fh = (struct ppc_link_hash_entry *) h;
7049   if (fh->elf.root.type == bfd_link_hash_indirect)
7050     return TRUE;
7051
7052   if (!fh->is_func)
7053     return TRUE;
7054
7055   if (fh->elf.root.root.string[0] != '.'
7056       || fh->elf.root.root.string[1] == '\0')
7057     return TRUE;
7058
7059   info = inf;
7060   htab = ppc_hash_table (info);
7061   if (htab == NULL)
7062     return FALSE;
7063
7064   /* Find the corresponding function descriptor symbol.  */
7065   fdh = lookup_fdh (fh, htab);
7066
7067   /* Resolve undefined references to dot-symbols as the value
7068      in the function descriptor, if we have one in a regular object.
7069      This is to satisfy cases like ".quad .foo".  Calls to functions
7070      in dynamic objects are handled elsewhere.  */
7071   if ((fh->elf.root.type == bfd_link_hash_undefined
7072        || fh->elf.root.type == bfd_link_hash_undefweak)
7073       && (fdh->elf.root.type == bfd_link_hash_defined
7074           || fdh->elf.root.type == bfd_link_hash_defweak)
7075       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7076       && opd_entry_value (fdh->elf.root.u.def.section,
7077                           fdh->elf.root.u.def.value,
7078                           &fh->elf.root.u.def.section,
7079                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7080     {
7081       fh->elf.root.type = fdh->elf.root.type;
7082       fh->elf.forced_local = 1;
7083       fh->elf.def_regular = fdh->elf.def_regular;
7084       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7085     }
7086
7087   if (!fh->elf.dynamic)
7088     {
7089       struct plt_entry *ent;
7090
7091       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7092         if (ent->plt.refcount > 0)
7093           break;
7094       if (ent == NULL)
7095         return TRUE;
7096     }
7097
7098   /* Create a descriptor as undefined if necessary.  */
7099   if (fdh == NULL
7100       && !bfd_link_executable (info)
7101       && (fh->elf.root.type == bfd_link_hash_undefined
7102           || fh->elf.root.type == bfd_link_hash_undefweak))
7103     {
7104       fdh = make_fdh (info, fh);
7105       if (fdh == NULL)
7106         return FALSE;
7107     }
7108
7109   /* We can't support overriding of symbols on a fake descriptor.  */
7110   if (fdh != NULL
7111       && fdh->fake
7112       && (fh->elf.root.type == bfd_link_hash_defined
7113           || fh->elf.root.type == bfd_link_hash_defweak))
7114     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7115
7116   /* Transfer dynamic linking information to the function descriptor.  */
7117   if (fdh != NULL)
7118     {
7119       fdh->elf.ref_regular |= fh->elf.ref_regular;
7120       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7121       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7122       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7123       fdh->elf.dynamic |= fh->elf.dynamic;
7124       fdh->elf.needs_plt |= (fh->elf.needs_plt
7125                              || fh->elf.type == STT_FUNC
7126                              || fh->elf.type == STT_GNU_IFUNC);
7127       move_plt_plist (fh, fdh);
7128
7129       if (!fdh->elf.forced_local
7130           && fh->elf.dynindx != -1)
7131         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7132           return FALSE;
7133     }
7134
7135   /* Now that the info is on the function descriptor, clear the
7136      function code sym info.  Any function code syms for which we
7137      don't have a definition in a regular file, we force local.
7138      This prevents a shared library from exporting syms that have
7139      been imported from another library.  Function code syms that
7140      are really in the library we must leave global to prevent the
7141      linker dragging in a definition from a static library.  */
7142   force_local = (!fh->elf.def_regular
7143                  || fdh == NULL
7144                  || !fdh->elf.def_regular
7145                  || fdh->elf.forced_local);
7146   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7147
7148   return TRUE;
7149 }
7150
7151 static const struct sfpr_def_parms save_res_funcs[] =
7152   {
7153     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7154     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7155     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7156     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7157     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7158     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7159     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7160     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7161     { "._savef", 14, 31, savefpr, savefpr1_tail },
7162     { "._restf", 14, 31, restfpr, restfpr1_tail },
7163     { "_savevr_", 20, 31, savevr, savevr_tail },
7164     { "_restvr_", 20, 31, restvr, restvr_tail }
7165   };
7166
7167 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7168    this hook to a) provide some gcc support functions, and b) transfer
7169    dynamic linking information gathered so far on function code symbol
7170    entries, to their corresponding function descriptor symbol entries.  */
7171
7172 static bfd_boolean
7173 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7174                             struct bfd_link_info *info)
7175 {
7176   struct ppc_link_hash_table *htab;
7177
7178   htab = ppc_hash_table (info);
7179   if (htab == NULL)
7180     return FALSE;
7181
7182   /* Provide any missing _save* and _rest* functions.  */
7183   if (htab->sfpr != NULL)
7184     {
7185       unsigned int i;
7186
7187       htab->sfpr->size = 0;
7188       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7189         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7190           return FALSE;
7191       if (htab->sfpr->size == 0)
7192         htab->sfpr->flags |= SEC_EXCLUDE;
7193     }
7194
7195   if (bfd_link_relocatable (info))
7196     return TRUE;
7197
7198   if (htab->elf.hgot != NULL)
7199     {
7200       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7201       /* Make .TOC. defined so as to prevent it being made dynamic.
7202          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7203       if (!htab->elf.hgot->def_regular
7204           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7205         {
7206           htab->elf.hgot->root.type = bfd_link_hash_defined;
7207           htab->elf.hgot->root.u.def.value = 0;
7208           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7209           htab->elf.hgot->def_regular = 1;
7210           htab->elf.hgot->root.linker_def = 1;
7211         }
7212       htab->elf.hgot->type = STT_OBJECT;
7213       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7214                                | STV_HIDDEN);
7215     }
7216
7217   if (htab->need_func_desc_adj)
7218     {
7219       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7220       htab->need_func_desc_adj = 0;
7221     }
7222
7223   return TRUE;
7224 }
7225
7226 /* Return true if we have dynamic relocs against H that apply to
7227    read-only sections.  */
7228
7229 static bfd_boolean
7230 readonly_dynrelocs (struct elf_link_hash_entry *h)
7231 {
7232   struct ppc_link_hash_entry *eh;
7233   struct elf_dyn_relocs *p;
7234
7235   eh = (struct ppc_link_hash_entry *) h;
7236   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7237     {
7238       asection *s = p->sec->output_section;
7239
7240       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7241         return TRUE;
7242     }
7243   return FALSE;
7244 }
7245
7246 /* Return true if we have dynamic relocs against H or any of its weak
7247    aliases, that apply to read-only sections.  */
7248
7249 static bfd_boolean
7250 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7251 {
7252   struct ppc_link_hash_entry *eh;
7253
7254   eh = (struct ppc_link_hash_entry *) h;
7255   do
7256     {
7257       if (readonly_dynrelocs (&eh->elf))
7258         return TRUE;
7259       eh = eh->weakref;
7260     } while (eh != NULL && &eh->elf != h);
7261
7262   return FALSE;
7263 }
7264
7265 /* Return whether EH has pc-relative dynamic relocs.  */
7266
7267 static bfd_boolean
7268 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7269 {
7270   struct elf_dyn_relocs *p;
7271
7272   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7273     if (p->pc_count != 0)
7274       return TRUE;
7275   return FALSE;
7276 }
7277
7278 /* Return true if a global entry stub will be created for H.  Valid
7279    for ELFv2 before plt entries have been allocated.  */
7280
7281 static bfd_boolean
7282 global_entry_stub (struct elf_link_hash_entry *h)
7283 {
7284   struct plt_entry *pent;
7285
7286   if (!h->pointer_equality_needed
7287       || h->def_regular)
7288     return FALSE;
7289
7290   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7291     if (pent->plt.refcount > 0
7292         && pent->addend == 0)
7293       return TRUE;
7294
7295   return FALSE;
7296 }
7297
7298 /* Adjust a symbol defined by a dynamic object and referenced by a
7299    regular object.  The current definition is in some section of the
7300    dynamic object, but we're not including those sections.  We have to
7301    change the definition to something the rest of the link can
7302    understand.  */
7303
7304 static bfd_boolean
7305 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7306                                  struct elf_link_hash_entry *h)
7307 {
7308   struct ppc_link_hash_table *htab;
7309   asection *s, *srel;
7310
7311   htab = ppc_hash_table (info);
7312   if (htab == NULL)
7313     return FALSE;
7314
7315   /* Deal with function syms.  */
7316   if (h->type == STT_FUNC
7317       || h->type == STT_GNU_IFUNC
7318       || h->needs_plt)
7319     {
7320       /* Clear procedure linkage table information for any symbol that
7321          won't need a .plt entry.  */
7322       struct plt_entry *ent;
7323       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7324         if (ent->plt.refcount > 0)
7325           break;
7326       if (ent == NULL
7327           || (h->type != STT_GNU_IFUNC
7328               && (SYMBOL_CALLS_LOCAL (info, h)
7329                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7330           || ((struct ppc_link_hash_entry *) h)->save_res)
7331         {
7332           h->plt.plist = NULL;
7333           h->needs_plt = 0;
7334           h->pointer_equality_needed = 0;
7335         }
7336       else if (abiversion (info->output_bfd) >= 2)
7337         {
7338           /* Taking a function's address in a read/write section
7339              doesn't require us to define the function symbol in the
7340              executable on a global entry stub.  A dynamic reloc can
7341              be used instead.  The reason we prefer a few more dynamic
7342              relocs is that calling via a global entry stub costs a
7343              few more instructions, and pointer_equality_needed causes
7344              extra work in ld.so when resolving these symbols.  */
7345           if (global_entry_stub (h)
7346               && !alias_readonly_dynrelocs (h))
7347             {
7348               h->pointer_equality_needed = 0;
7349               /* After adjust_dynamic_symbol, non_got_ref set in
7350                  the non-pic case means that dyn_relocs for this
7351                  symbol should be discarded.  */
7352               h->non_got_ref = 0;
7353             }
7354
7355           /* If making a plt entry, then we don't need copy relocs.  */
7356           return TRUE;
7357         }
7358     }
7359   else
7360     h->plt.plist = NULL;
7361
7362   /* If this is a weak symbol, and there is a real definition, the
7363      processor independent code will have arranged for us to see the
7364      real definition first, and we can just use the same value.  */
7365   if (h->u.weakdef != NULL)
7366     {
7367       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7368                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7369       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7370       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7371       if (ELIMINATE_COPY_RELOCS)
7372         h->non_got_ref = h->u.weakdef->non_got_ref;
7373       return TRUE;
7374     }
7375
7376   /* If we are creating a shared library, we must presume that the
7377      only references to the symbol are via the global offset table.
7378      For such cases we need not do anything here; the relocations will
7379      be handled correctly by relocate_section.  */
7380   if (bfd_link_pic (info))
7381     return TRUE;
7382
7383   /* If there are no references to this symbol that do not use the
7384      GOT, we don't need to generate a copy reloc.  */
7385   if (!h->non_got_ref)
7386     return TRUE;
7387
7388   /* Don't generate a copy reloc for symbols defined in the executable.  */
7389   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7390
7391       /* If -z nocopyreloc was given, don't generate them either.  */
7392       || info->nocopyreloc
7393
7394       /* If we didn't find any dynamic relocs in read-only sections, then
7395          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7396       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7397
7398       /* Protected variables do not work with .dynbss.  The copy in
7399          .dynbss won't be used by the shared library with the protected
7400          definition for the variable.  Text relocations are preferable
7401          to an incorrect program.  */
7402       || h->protected_def)
7403     {
7404       h->non_got_ref = 0;
7405       return TRUE;
7406     }
7407
7408   if (h->plt.plist != NULL)
7409     {
7410       /* We should never get here, but unfortunately there are versions
7411          of gcc out there that improperly (for this ABI) put initialized
7412          function pointers, vtable refs and suchlike in read-only
7413          sections.  Allow them to proceed, but warn that this might
7414          break at runtime.  */
7415       info->callbacks->einfo
7416         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7417            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7418          h->root.root.string);
7419     }
7420
7421   /* This is a reference to a symbol defined by a dynamic object which
7422      is not a function.  */
7423
7424   /* We must allocate the symbol in our .dynbss section, which will
7425      become part of the .bss section of the executable.  There will be
7426      an entry for this symbol in the .dynsym section.  The dynamic
7427      object will contain position independent code, so all references
7428      from the dynamic object to this symbol will go through the global
7429      offset table.  The dynamic linker will use the .dynsym entry to
7430      determine the address it must put in the global offset table, so
7431      both the dynamic object and the regular object will refer to the
7432      same memory location for the variable.  */
7433
7434   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7435      to copy the initial value out of the dynamic object and into the
7436      runtime process image.  We need to remember the offset into the
7437      .rela.bss section we are going to use.  */
7438   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7439     {
7440       s = htab->elf.sdynrelro;
7441       srel = htab->elf.sreldynrelro;
7442     }
7443   else
7444     {
7445       s = htab->elf.sdynbss;
7446       srel = htab->elf.srelbss;
7447     }
7448   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7449     {
7450       srel->size += sizeof (Elf64_External_Rela);
7451       h->needs_copy = 1;
7452     }
7453
7454   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7455 }
7456
7457 /* If given a function descriptor symbol, hide both the function code
7458    sym and the descriptor.  */
7459 static void
7460 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7461                        struct elf_link_hash_entry *h,
7462                        bfd_boolean force_local)
7463 {
7464   struct ppc_link_hash_entry *eh;
7465   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7466
7467   eh = (struct ppc_link_hash_entry *) h;
7468   if (eh->is_func_descriptor)
7469     {
7470       struct ppc_link_hash_entry *fh = eh->oh;
7471
7472       if (fh == NULL)
7473         {
7474           const char *p, *q;
7475           struct elf_link_hash_table *htab = elf_hash_table (info);
7476           char save;
7477
7478           /* We aren't supposed to use alloca in BFD because on
7479              systems which do not have alloca the version in libiberty
7480              calls xmalloc, which might cause the program to crash
7481              when it runs out of memory.  This function doesn't have a
7482              return status, so there's no way to gracefully return an
7483              error.  So cheat.  We know that string[-1] can be safely
7484              accessed;  It's either a string in an ELF string table,
7485              or allocated in an objalloc structure.  */
7486
7487           p = eh->elf.root.root.string - 1;
7488           save = *p;
7489           *(char *) p = '.';
7490           fh = (struct ppc_link_hash_entry *)
7491             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7492           *(char *) p = save;
7493
7494           /* Unfortunately, if it so happens that the string we were
7495              looking for was allocated immediately before this string,
7496              then we overwrote the string terminator.  That's the only
7497              reason the lookup should fail.  */
7498           if (fh == NULL)
7499             {
7500               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7501               while (q >= eh->elf.root.root.string && *q == *p)
7502                 --q, --p;
7503               if (q < eh->elf.root.root.string && *p == '.')
7504                 fh = (struct ppc_link_hash_entry *)
7505                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7506             }
7507           if (fh != NULL)
7508             {
7509               eh->oh = fh;
7510               fh->oh = eh;
7511             }
7512         }
7513       if (fh != NULL)
7514         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7515     }
7516 }
7517
7518 static bfd_boolean
7519 get_sym_h (struct elf_link_hash_entry **hp,
7520            Elf_Internal_Sym **symp,
7521            asection **symsecp,
7522            unsigned char **tls_maskp,
7523            Elf_Internal_Sym **locsymsp,
7524            unsigned long r_symndx,
7525            bfd *ibfd)
7526 {
7527   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7528
7529   if (r_symndx >= symtab_hdr->sh_info)
7530     {
7531       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7532       struct elf_link_hash_entry *h;
7533
7534       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7535       h = elf_follow_link (h);
7536
7537       if (hp != NULL)
7538         *hp = h;
7539
7540       if (symp != NULL)
7541         *symp = NULL;
7542
7543       if (symsecp != NULL)
7544         {
7545           asection *symsec = NULL;
7546           if (h->root.type == bfd_link_hash_defined
7547               || h->root.type == bfd_link_hash_defweak)
7548             symsec = h->root.u.def.section;
7549           *symsecp = symsec;
7550         }
7551
7552       if (tls_maskp != NULL)
7553         {
7554           struct ppc_link_hash_entry *eh;
7555
7556           eh = (struct ppc_link_hash_entry *) h;
7557           *tls_maskp = &eh->tls_mask;
7558         }
7559     }
7560   else
7561     {
7562       Elf_Internal_Sym *sym;
7563       Elf_Internal_Sym *locsyms = *locsymsp;
7564
7565       if (locsyms == NULL)
7566         {
7567           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7568           if (locsyms == NULL)
7569             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7570                                             symtab_hdr->sh_info,
7571                                             0, NULL, NULL, NULL);
7572           if (locsyms == NULL)
7573             return FALSE;
7574           *locsymsp = locsyms;
7575         }
7576       sym = locsyms + r_symndx;
7577
7578       if (hp != NULL)
7579         *hp = NULL;
7580
7581       if (symp != NULL)
7582         *symp = sym;
7583
7584       if (symsecp != NULL)
7585         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7586
7587       if (tls_maskp != NULL)
7588         {
7589           struct got_entry **lgot_ents;
7590           unsigned char *tls_mask;
7591
7592           tls_mask = NULL;
7593           lgot_ents = elf_local_got_ents (ibfd);
7594           if (lgot_ents != NULL)
7595             {
7596               struct plt_entry **local_plt = (struct plt_entry **)
7597                 (lgot_ents + symtab_hdr->sh_info);
7598               unsigned char *lgot_masks = (unsigned char *)
7599                 (local_plt + symtab_hdr->sh_info);
7600               tls_mask = &lgot_masks[r_symndx];
7601             }
7602           *tls_maskp = tls_mask;
7603         }
7604     }
7605   return TRUE;
7606 }
7607
7608 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7609    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7610    type suitable for optimization, and 1 otherwise.  */
7611
7612 static int
7613 get_tls_mask (unsigned char **tls_maskp,
7614               unsigned long *toc_symndx,
7615               bfd_vma *toc_addend,
7616               Elf_Internal_Sym **locsymsp,
7617               const Elf_Internal_Rela *rel,
7618               bfd *ibfd)
7619 {
7620   unsigned long r_symndx;
7621   int next_r;
7622   struct elf_link_hash_entry *h;
7623   Elf_Internal_Sym *sym;
7624   asection *sec;
7625   bfd_vma off;
7626
7627   r_symndx = ELF64_R_SYM (rel->r_info);
7628   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7629     return 0;
7630
7631   if ((*tls_maskp != NULL && **tls_maskp != 0)
7632       || sec == NULL
7633       || ppc64_elf_section_data (sec) == NULL
7634       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7635     return 1;
7636
7637   /* Look inside a TOC section too.  */
7638   if (h != NULL)
7639     {
7640       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7641       off = h->root.u.def.value;
7642     }
7643   else
7644     off = sym->st_value;
7645   off += rel->r_addend;
7646   BFD_ASSERT (off % 8 == 0);
7647   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7648   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7649   if (toc_symndx != NULL)
7650     *toc_symndx = r_symndx;
7651   if (toc_addend != NULL)
7652     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7653   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7654     return 0;
7655   if ((h == NULL || is_static_defined (h))
7656       && (next_r == -1 || next_r == -2))
7657     return 1 - next_r;
7658   return 1;
7659 }
7660
7661 /* Find (or create) an entry in the tocsave hash table.  */
7662
7663 static struct tocsave_entry *
7664 tocsave_find (struct ppc_link_hash_table *htab,
7665               enum insert_option insert,
7666               Elf_Internal_Sym **local_syms,
7667               const Elf_Internal_Rela *irela,
7668               bfd *ibfd)
7669 {
7670   unsigned long r_indx;
7671   struct elf_link_hash_entry *h;
7672   Elf_Internal_Sym *sym;
7673   struct tocsave_entry ent, *p;
7674   hashval_t hash;
7675   struct tocsave_entry **slot;
7676
7677   r_indx = ELF64_R_SYM (irela->r_info);
7678   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7679     return NULL;
7680   if (ent.sec == NULL || ent.sec->output_section == NULL)
7681     {
7682       _bfd_error_handler
7683         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7684       return NULL;
7685     }
7686
7687   if (h != NULL)
7688     ent.offset = h->root.u.def.value;
7689   else
7690     ent.offset = sym->st_value;
7691   ent.offset += irela->r_addend;
7692
7693   hash = tocsave_htab_hash (&ent);
7694   slot = ((struct tocsave_entry **)
7695           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7696   if (slot == NULL)
7697     return NULL;
7698
7699   if (*slot == NULL)
7700     {
7701       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7702       if (p == NULL)
7703         return NULL;
7704       *p = ent;
7705       *slot = p;
7706     }
7707   return *slot;
7708 }
7709
7710 /* Adjust all global syms defined in opd sections.  In gcc generated
7711    code for the old ABI, these will already have been done.  */
7712
7713 static bfd_boolean
7714 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7715 {
7716   struct ppc_link_hash_entry *eh;
7717   asection *sym_sec;
7718   struct _opd_sec_data *opd;
7719
7720   if (h->root.type == bfd_link_hash_indirect)
7721     return TRUE;
7722
7723   if (h->root.type != bfd_link_hash_defined
7724       && h->root.type != bfd_link_hash_defweak)
7725     return TRUE;
7726
7727   eh = (struct ppc_link_hash_entry *) h;
7728   if (eh->adjust_done)
7729     return TRUE;
7730
7731   sym_sec = eh->elf.root.u.def.section;
7732   opd = get_opd_info (sym_sec);
7733   if (opd != NULL && opd->adjust != NULL)
7734     {
7735       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7736       if (adjust == -1)
7737         {
7738           /* This entry has been deleted.  */
7739           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7740           if (dsec == NULL)
7741             {
7742               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7743                 if (discarded_section (dsec))
7744                   {
7745                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7746                     break;
7747                   }
7748             }
7749           eh->elf.root.u.def.value = 0;
7750           eh->elf.root.u.def.section = dsec;
7751         }
7752       else
7753         eh->elf.root.u.def.value += adjust;
7754       eh->adjust_done = 1;
7755     }
7756   return TRUE;
7757 }
7758
7759 /* Handles decrementing dynamic reloc counts for the reloc specified by
7760    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7761    have already been determined.  */
7762
7763 static bfd_boolean
7764 dec_dynrel_count (bfd_vma r_info,
7765                   asection *sec,
7766                   struct bfd_link_info *info,
7767                   Elf_Internal_Sym **local_syms,
7768                   struct elf_link_hash_entry *h,
7769                   Elf_Internal_Sym *sym)
7770 {
7771   enum elf_ppc64_reloc_type r_type;
7772   asection *sym_sec = NULL;
7773
7774   /* Can this reloc be dynamic?  This switch, and later tests here
7775      should be kept in sync with the code in check_relocs.  */
7776   r_type = ELF64_R_TYPE (r_info);
7777   switch (r_type)
7778     {
7779     default:
7780       return TRUE;
7781
7782     case R_PPC64_TPREL16:
7783     case R_PPC64_TPREL16_LO:
7784     case R_PPC64_TPREL16_HI:
7785     case R_PPC64_TPREL16_HA:
7786     case R_PPC64_TPREL16_DS:
7787     case R_PPC64_TPREL16_LO_DS:
7788     case R_PPC64_TPREL16_HIGH:
7789     case R_PPC64_TPREL16_HIGHA:
7790     case R_PPC64_TPREL16_HIGHER:
7791     case R_PPC64_TPREL16_HIGHERA:
7792     case R_PPC64_TPREL16_HIGHEST:
7793     case R_PPC64_TPREL16_HIGHESTA:
7794       if (!bfd_link_pic (info))
7795         return TRUE;
7796
7797     case R_PPC64_TPREL64:
7798     case R_PPC64_DTPMOD64:
7799     case R_PPC64_DTPREL64:
7800     case R_PPC64_ADDR64:
7801     case R_PPC64_REL30:
7802     case R_PPC64_REL32:
7803     case R_PPC64_REL64:
7804     case R_PPC64_ADDR14:
7805     case R_PPC64_ADDR14_BRNTAKEN:
7806     case R_PPC64_ADDR14_BRTAKEN:
7807     case R_PPC64_ADDR16:
7808     case R_PPC64_ADDR16_DS:
7809     case R_PPC64_ADDR16_HA:
7810     case R_PPC64_ADDR16_HI:
7811     case R_PPC64_ADDR16_HIGH:
7812     case R_PPC64_ADDR16_HIGHA:
7813     case R_PPC64_ADDR16_HIGHER:
7814     case R_PPC64_ADDR16_HIGHERA:
7815     case R_PPC64_ADDR16_HIGHEST:
7816     case R_PPC64_ADDR16_HIGHESTA:
7817     case R_PPC64_ADDR16_LO:
7818     case R_PPC64_ADDR16_LO_DS:
7819     case R_PPC64_ADDR24:
7820     case R_PPC64_ADDR32:
7821     case R_PPC64_UADDR16:
7822     case R_PPC64_UADDR32:
7823     case R_PPC64_UADDR64:
7824     case R_PPC64_TOC:
7825       break;
7826     }
7827
7828   if (local_syms != NULL)
7829     {
7830       unsigned long r_symndx;
7831       bfd *ibfd = sec->owner;
7832
7833       r_symndx = ELF64_R_SYM (r_info);
7834       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7835         return FALSE;
7836     }
7837
7838   if ((bfd_link_pic (info)
7839        && (must_be_dyn_reloc (info, r_type)
7840            || (h != NULL
7841                && (!SYMBOLIC_BIND (info, h)
7842                    || h->root.type == bfd_link_hash_defweak
7843                    || !h->def_regular))))
7844       || (ELIMINATE_COPY_RELOCS
7845           && !bfd_link_pic (info)
7846           && h != NULL
7847           && (h->root.type == bfd_link_hash_defweak
7848               || !h->def_regular)))
7849     ;
7850   else
7851     return TRUE;
7852
7853   if (h != NULL)
7854     {
7855       struct elf_dyn_relocs *p;
7856       struct elf_dyn_relocs **pp;
7857       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7858
7859       /* elf_gc_sweep may have already removed all dyn relocs associated
7860          with local syms for a given section.  Also, symbol flags are
7861          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7862          report a dynreloc miscount.  */
7863       if (*pp == NULL && info->gc_sections)
7864         return TRUE;
7865
7866       while ((p = *pp) != NULL)
7867         {
7868           if (p->sec == sec)
7869             {
7870               if (!must_be_dyn_reloc (info, r_type))
7871                 p->pc_count -= 1;
7872               p->count -= 1;
7873               if (p->count == 0)
7874                 *pp = p->next;
7875               return TRUE;
7876             }
7877           pp = &p->next;
7878         }
7879     }
7880   else
7881     {
7882       struct ppc_dyn_relocs *p;
7883       struct ppc_dyn_relocs **pp;
7884       void *vpp;
7885       bfd_boolean is_ifunc;
7886
7887       if (local_syms == NULL)
7888         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7889       if (sym_sec == NULL)
7890         sym_sec = sec;
7891
7892       vpp = &elf_section_data (sym_sec)->local_dynrel;
7893       pp = (struct ppc_dyn_relocs **) vpp;
7894
7895       if (*pp == NULL && info->gc_sections)
7896         return TRUE;
7897
7898       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7899       while ((p = *pp) != NULL)
7900         {
7901           if (p->sec == sec && p->ifunc == is_ifunc)
7902             {
7903               p->count -= 1;
7904               if (p->count == 0)
7905                 *pp = p->next;
7906               return TRUE;
7907             }
7908           pp = &p->next;
7909         }
7910     }
7911
7912   /* xgettext:c-format */
7913   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7914                           sec->owner, sec);
7915   bfd_set_error (bfd_error_bad_value);
7916   return FALSE;
7917 }
7918
7919 /* Remove unused Official Procedure Descriptor entries.  Currently we
7920    only remove those associated with functions in discarded link-once
7921    sections, or weakly defined functions that have been overridden.  It
7922    would be possible to remove many more entries for statically linked
7923    applications.  */
7924
7925 bfd_boolean
7926 ppc64_elf_edit_opd (struct bfd_link_info *info)
7927 {
7928   bfd *ibfd;
7929   bfd_boolean some_edited = FALSE;
7930   asection *need_pad = NULL;
7931   struct ppc_link_hash_table *htab;
7932
7933   htab = ppc_hash_table (info);
7934   if (htab == NULL)
7935     return FALSE;
7936
7937   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7938     {
7939       asection *sec;
7940       Elf_Internal_Rela *relstart, *rel, *relend;
7941       Elf_Internal_Shdr *symtab_hdr;
7942       Elf_Internal_Sym *local_syms;
7943       struct _opd_sec_data *opd;
7944       bfd_boolean need_edit, add_aux_fields, broken;
7945       bfd_size_type cnt_16b = 0;
7946
7947       if (!is_ppc64_elf (ibfd))
7948         continue;
7949
7950       sec = bfd_get_section_by_name (ibfd, ".opd");
7951       if (sec == NULL || sec->size == 0)
7952         continue;
7953
7954       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7955         continue;
7956
7957       if (sec->output_section == bfd_abs_section_ptr)
7958         continue;
7959
7960       /* Look through the section relocs.  */
7961       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7962         continue;
7963
7964       local_syms = NULL;
7965       symtab_hdr = &elf_symtab_hdr (ibfd);
7966
7967       /* Read the relocations.  */
7968       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7969                                             info->keep_memory);
7970       if (relstart == NULL)
7971         return FALSE;
7972
7973       /* First run through the relocs to check they are sane, and to
7974          determine whether we need to edit this opd section.  */
7975       need_edit = FALSE;
7976       broken = FALSE;
7977       need_pad = sec;
7978       relend = relstart + sec->reloc_count;
7979       for (rel = relstart; rel < relend; )
7980         {
7981           enum elf_ppc64_reloc_type r_type;
7982           unsigned long r_symndx;
7983           asection *sym_sec;
7984           struct elf_link_hash_entry *h;
7985           Elf_Internal_Sym *sym;
7986           bfd_vma offset;
7987
7988           /* .opd contains an array of 16 or 24 byte entries.  We're
7989              only interested in the reloc pointing to a function entry
7990              point.  */
7991           offset = rel->r_offset;
7992           if (rel + 1 == relend
7993               || rel[1].r_offset != offset + 8)
7994             {
7995               /* If someone messes with .opd alignment then after a
7996                  "ld -r" we might have padding in the middle of .opd.
7997                  Also, there's nothing to prevent someone putting
7998                  something silly in .opd with the assembler.  No .opd
7999                  optimization for them!  */
8000             broken_opd:
8001               _bfd_error_handler
8002                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
8003               broken = TRUE;
8004               break;
8005             }
8006
8007           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8008               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8009             {
8010               _bfd_error_handler
8011                 /* xgettext:c-format */
8012                 (_("%B: unexpected reloc type %u in .opd section"),
8013                  ibfd, r_type);
8014               broken = TRUE;
8015               break;
8016             }
8017
8018           r_symndx = ELF64_R_SYM (rel->r_info);
8019           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8020                           r_symndx, ibfd))
8021             goto error_ret;
8022
8023           if (sym_sec == NULL || sym_sec->owner == NULL)
8024             {
8025               const char *sym_name;
8026               if (h != NULL)
8027                 sym_name = h->root.root.string;
8028               else
8029                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8030                                              sym_sec);
8031
8032               _bfd_error_handler
8033                 /* xgettext:c-format */
8034                 (_("%B: undefined sym `%s' in .opd section"),
8035                  ibfd, sym_name);
8036               broken = TRUE;
8037               break;
8038             }
8039
8040           /* opd entries are always for functions defined in the
8041              current input bfd.  If the symbol isn't defined in the
8042              input bfd, then we won't be using the function in this
8043              bfd;  It must be defined in a linkonce section in another
8044              bfd, or is weak.  It's also possible that we are
8045              discarding the function due to a linker script /DISCARD/,
8046              which we test for via the output_section.  */
8047           if (sym_sec->owner != ibfd
8048               || sym_sec->output_section == bfd_abs_section_ptr)
8049             need_edit = TRUE;
8050
8051           rel += 2;
8052           if (rel + 1 == relend
8053               || (rel + 2 < relend
8054                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8055             ++rel;
8056
8057           if (rel == relend)
8058             {
8059               if (sec->size == offset + 24)
8060                 {
8061                   need_pad = NULL;
8062                   break;
8063                 }
8064               if (sec->size == offset + 16)
8065                 {
8066                   cnt_16b++;
8067                   break;
8068                 }
8069               goto broken_opd;
8070             }
8071           else if (rel + 1 < relend
8072                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8073                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8074             {
8075               if (rel[0].r_offset == offset + 16)
8076                 cnt_16b++;
8077               else if (rel[0].r_offset != offset + 24)
8078                 goto broken_opd;
8079             }
8080           else
8081             goto broken_opd;
8082         }
8083
8084       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8085
8086       if (!broken && (need_edit || add_aux_fields))
8087         {
8088           Elf_Internal_Rela *write_rel;
8089           Elf_Internal_Shdr *rel_hdr;
8090           bfd_byte *rptr, *wptr;
8091           bfd_byte *new_contents;
8092           bfd_size_type amt;
8093
8094           new_contents = NULL;
8095           amt = OPD_NDX (sec->size) * sizeof (long);
8096           opd = &ppc64_elf_section_data (sec)->u.opd;
8097           opd->adjust = bfd_zalloc (sec->owner, amt);
8098           if (opd->adjust == NULL)
8099             return FALSE;
8100           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8101
8102           /* This seems a waste of time as input .opd sections are all
8103              zeros as generated by gcc, but I suppose there's no reason
8104              this will always be so.  We might start putting something in
8105              the third word of .opd entries.  */
8106           if ((sec->flags & SEC_IN_MEMORY) == 0)
8107             {
8108               bfd_byte *loc;
8109               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8110                 {
8111                   if (loc != NULL)
8112                     free (loc);
8113                 error_ret:
8114                   if (local_syms != NULL
8115                       && symtab_hdr->contents != (unsigned char *) local_syms)
8116                     free (local_syms);
8117                   if (elf_section_data (sec)->relocs != relstart)
8118                     free (relstart);
8119                   return FALSE;
8120                 }
8121               sec->contents = loc;
8122               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8123             }
8124
8125           elf_section_data (sec)->relocs = relstart;
8126
8127           new_contents = sec->contents;
8128           if (add_aux_fields)
8129             {
8130               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8131               if (new_contents == NULL)
8132                 return FALSE;
8133               need_pad = NULL;
8134             }
8135           wptr = new_contents;
8136           rptr = sec->contents;
8137           write_rel = relstart;
8138           for (rel = relstart; rel < relend; )
8139             {
8140               unsigned long r_symndx;
8141               asection *sym_sec;
8142               struct elf_link_hash_entry *h;
8143               struct ppc_link_hash_entry *fdh = NULL;
8144               Elf_Internal_Sym *sym;
8145               long opd_ent_size;
8146               Elf_Internal_Rela *next_rel;
8147               bfd_boolean skip;
8148
8149               r_symndx = ELF64_R_SYM (rel->r_info);
8150               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8151                               r_symndx, ibfd))
8152                 goto error_ret;
8153
8154               next_rel = rel + 2;
8155               if (next_rel + 1 == relend
8156                   || (next_rel + 2 < relend
8157                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8158                 ++next_rel;
8159
8160               /* See if the .opd entry is full 24 byte or
8161                  16 byte (with fd_aux entry overlapped with next
8162                  fd_func).  */
8163               opd_ent_size = 24;
8164               if (next_rel == relend)
8165                 {
8166                   if (sec->size == rel->r_offset + 16)
8167                     opd_ent_size = 16;
8168                 }
8169               else if (next_rel->r_offset == rel->r_offset + 16)
8170                 opd_ent_size = 16;
8171
8172               if (h != NULL
8173                   && h->root.root.string[0] == '.')
8174                 {
8175                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8176                   if (fdh != NULL)
8177                     {
8178                       fdh = ppc_follow_link (fdh);
8179                       if (fdh->elf.root.type != bfd_link_hash_defined
8180                           && fdh->elf.root.type != bfd_link_hash_defweak)
8181                         fdh = NULL;
8182                     }
8183                 }
8184
8185               skip = (sym_sec->owner != ibfd
8186                       || sym_sec->output_section == bfd_abs_section_ptr);
8187               if (skip)
8188                 {
8189                   if (fdh != NULL && sym_sec->owner == ibfd)
8190                     {
8191                       /* Arrange for the function descriptor sym
8192                          to be dropped.  */
8193                       fdh->elf.root.u.def.value = 0;
8194                       fdh->elf.root.u.def.section = sym_sec;
8195                     }
8196                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8197
8198                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8199                     rel = next_rel;
8200                   else
8201                     while (1)
8202                       {
8203                         if (!dec_dynrel_count (rel->r_info, sec, info,
8204                                                NULL, h, sym))
8205                           goto error_ret;
8206
8207                         if (++rel == next_rel)
8208                           break;
8209
8210                         r_symndx = ELF64_R_SYM (rel->r_info);
8211                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8212                                         r_symndx, ibfd))
8213                           goto error_ret;
8214                       }
8215                 }
8216               else
8217                 {
8218                   /* We'll be keeping this opd entry.  */
8219                   long adjust;
8220
8221                   if (fdh != NULL)
8222                     {
8223                       /* Redefine the function descriptor symbol to
8224                          this location in the opd section.  It is
8225                          necessary to update the value here rather
8226                          than using an array of adjustments as we do
8227                          for local symbols, because various places
8228                          in the generic ELF code use the value
8229                          stored in u.def.value.  */
8230                       fdh->elf.root.u.def.value = wptr - new_contents;
8231                       fdh->adjust_done = 1;
8232                     }
8233
8234                   /* Local syms are a bit tricky.  We could
8235                      tweak them as they can be cached, but
8236                      we'd need to look through the local syms
8237                      for the function descriptor sym which we
8238                      don't have at the moment.  So keep an
8239                      array of adjustments.  */
8240                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8241                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8242
8243                   if (wptr != rptr)
8244                     memcpy (wptr, rptr, opd_ent_size);
8245                   wptr += opd_ent_size;
8246                   if (add_aux_fields && opd_ent_size == 16)
8247                     {
8248                       memset (wptr, '\0', 8);
8249                       wptr += 8;
8250                     }
8251
8252                   /* We need to adjust any reloc offsets to point to the
8253                      new opd entries.  */
8254                   for ( ; rel != next_rel; ++rel)
8255                     {
8256                       rel->r_offset += adjust;
8257                       if (write_rel != rel)
8258                         memcpy (write_rel, rel, sizeof (*rel));
8259                       ++write_rel;
8260                     }
8261                 }
8262
8263               rptr += opd_ent_size;
8264             }
8265
8266           sec->size = wptr - new_contents;
8267           sec->reloc_count = write_rel - relstart;
8268           if (add_aux_fields)
8269             {
8270               free (sec->contents);
8271               sec->contents = new_contents;
8272             }
8273
8274           /* Fudge the header size too, as this is used later in
8275              elf_bfd_final_link if we are emitting relocs.  */
8276           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8277           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8278           some_edited = TRUE;
8279         }
8280       else if (elf_section_data (sec)->relocs != relstart)
8281         free (relstart);
8282
8283       if (local_syms != NULL
8284           && symtab_hdr->contents != (unsigned char *) local_syms)
8285         {
8286           if (!info->keep_memory)
8287             free (local_syms);
8288           else
8289             symtab_hdr->contents = (unsigned char *) local_syms;
8290         }
8291     }
8292
8293   if (some_edited)
8294     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8295
8296   /* If we are doing a final link and the last .opd entry is just 16 byte
8297      long, add a 8 byte padding after it.  */
8298   if (need_pad != NULL && !bfd_link_relocatable (info))
8299     {
8300       bfd_byte *p;
8301
8302       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8303         {
8304           BFD_ASSERT (need_pad->size > 0);
8305
8306           p = bfd_malloc (need_pad->size + 8);
8307           if (p == NULL)
8308             return FALSE;
8309
8310           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8311                                           p, 0, need_pad->size))
8312             return FALSE;
8313
8314           need_pad->contents = p;
8315           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8316         }
8317       else
8318         {
8319           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8320           if (p == NULL)
8321             return FALSE;
8322
8323           need_pad->contents = p;
8324         }
8325
8326       memset (need_pad->contents + need_pad->size, 0, 8);
8327       need_pad->size += 8;
8328     }
8329
8330   return TRUE;
8331 }
8332
8333 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8334
8335 asection *
8336 ppc64_elf_tls_setup (struct bfd_link_info *info)
8337 {
8338   struct ppc_link_hash_table *htab;
8339
8340   htab = ppc_hash_table (info);
8341   if (htab == NULL)
8342     return NULL;
8343
8344   if (abiversion (info->output_bfd) == 1)
8345     htab->opd_abi = 1;
8346
8347   if (htab->params->no_multi_toc)
8348     htab->do_multi_toc = 0;
8349   else if (!htab->do_multi_toc)
8350     htab->params->no_multi_toc = 1;
8351
8352   if (htab->params->plt_localentry0 < 0)
8353     htab->params->plt_localentry0
8354       = elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8355                               FALSE, FALSE, FALSE) != NULL;
8356
8357   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8358                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8359                                               FALSE, FALSE, TRUE));
8360   /* Move dynamic linking info to the function descriptor sym.  */
8361   if (htab->tls_get_addr != NULL)
8362     func_desc_adjust (&htab->tls_get_addr->elf, info);
8363   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8364                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8365                                                  FALSE, FALSE, TRUE));
8366   if (htab->params->tls_get_addr_opt)
8367     {
8368       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8369
8370       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8371                                   FALSE, FALSE, TRUE);
8372       if (opt != NULL)
8373         func_desc_adjust (opt, info);
8374       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8375                                      FALSE, FALSE, TRUE);
8376       if (opt_fd != NULL
8377           && (opt_fd->root.type == bfd_link_hash_defined
8378               || opt_fd->root.type == bfd_link_hash_defweak))
8379         {
8380           /* If glibc supports an optimized __tls_get_addr call stub,
8381              signalled by the presence of __tls_get_addr_opt, and we'll
8382              be calling __tls_get_addr via a plt call stub, then
8383              make __tls_get_addr point to __tls_get_addr_opt.  */
8384           tga_fd = &htab->tls_get_addr_fd->elf;
8385           if (htab->elf.dynamic_sections_created
8386               && tga_fd != NULL
8387               && (tga_fd->type == STT_FUNC
8388                   || tga_fd->needs_plt)
8389               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8390                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8391             {
8392               struct plt_entry *ent;
8393
8394               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8395                 if (ent->plt.refcount > 0)
8396                   break;
8397               if (ent != NULL)
8398                 {
8399                   tga_fd->root.type = bfd_link_hash_indirect;
8400                   tga_fd->root.u.i.link = &opt_fd->root;
8401                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8402                   opt_fd->mark = 1;
8403                   if (opt_fd->dynindx != -1)
8404                     {
8405                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8406                       opt_fd->dynindx = -1;
8407                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8408                                               opt_fd->dynstr_index);
8409                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8410                         return NULL;
8411                     }
8412                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8413                   tga = &htab->tls_get_addr->elf;
8414                   if (opt != NULL && tga != NULL)
8415                     {
8416                       tga->root.type = bfd_link_hash_indirect;
8417                       tga->root.u.i.link = &opt->root;
8418                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8419                       opt->mark = 1;
8420                       _bfd_elf_link_hash_hide_symbol (info, opt,
8421                                                       tga->forced_local);
8422                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8423                     }
8424                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8425                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8426                   if (htab->tls_get_addr != NULL)
8427                     {
8428                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8429                       htab->tls_get_addr->is_func = 1;
8430                     }
8431                 }
8432             }
8433         }
8434       else if (htab->params->tls_get_addr_opt < 0)
8435         htab->params->tls_get_addr_opt = 0;
8436     }
8437   return _bfd_elf_tls_setup (info->output_bfd, info);
8438 }
8439
8440 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8441    HASH1 or HASH2.  */
8442
8443 static bfd_boolean
8444 branch_reloc_hash_match (const bfd *ibfd,
8445                          const Elf_Internal_Rela *rel,
8446                          const struct ppc_link_hash_entry *hash1,
8447                          const struct ppc_link_hash_entry *hash2)
8448 {
8449   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8450   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8451   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8452
8453   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8454     {
8455       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8456       struct elf_link_hash_entry *h;
8457
8458       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8459       h = elf_follow_link (h);
8460       if (h == &hash1->elf || h == &hash2->elf)
8461         return TRUE;
8462     }
8463   return FALSE;
8464 }
8465
8466 /* Run through all the TLS relocs looking for optimization
8467    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8468    a preliminary section layout so that we know the TLS segment
8469    offsets.  We can't optimize earlier because some optimizations need
8470    to know the tp offset, and we need to optimize before allocating
8471    dynamic relocations.  */
8472
8473 bfd_boolean
8474 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8475 {
8476   bfd *ibfd;
8477   asection *sec;
8478   struct ppc_link_hash_table *htab;
8479   unsigned char *toc_ref;
8480   int pass;
8481
8482   if (!bfd_link_executable (info))
8483     return TRUE;
8484
8485   htab = ppc_hash_table (info);
8486   if (htab == NULL)
8487     return FALSE;
8488
8489   /* Make two passes over the relocs.  On the first pass, mark toc
8490      entries involved with tls relocs, and check that tls relocs
8491      involved in setting up a tls_get_addr call are indeed followed by
8492      such a call.  If they are not, we can't do any tls optimization.
8493      On the second pass twiddle tls_mask flags to notify
8494      relocate_section that optimization can be done, and adjust got
8495      and plt refcounts.  */
8496   toc_ref = NULL;
8497   for (pass = 0; pass < 2; ++pass)
8498     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8499       {
8500         Elf_Internal_Sym *locsyms = NULL;
8501         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8502
8503         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8504           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8505             {
8506               Elf_Internal_Rela *relstart, *rel, *relend;
8507               bfd_boolean found_tls_get_addr_arg = 0;
8508
8509               /* Read the relocations.  */
8510               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8511                                                     info->keep_memory);
8512               if (relstart == NULL)
8513                 {
8514                   free (toc_ref);
8515                   return FALSE;
8516                 }
8517
8518               relend = relstart + sec->reloc_count;
8519               for (rel = relstart; rel < relend; rel++)
8520                 {
8521                   enum elf_ppc64_reloc_type r_type;
8522                   unsigned long r_symndx;
8523                   struct elf_link_hash_entry *h;
8524                   Elf_Internal_Sym *sym;
8525                   asection *sym_sec;
8526                   unsigned char *tls_mask;
8527                   unsigned char tls_set, tls_clear, tls_type = 0;
8528                   bfd_vma value;
8529                   bfd_boolean ok_tprel, is_local;
8530                   long toc_ref_index = 0;
8531                   int expecting_tls_get_addr = 0;
8532                   bfd_boolean ret = FALSE;
8533
8534                   r_symndx = ELF64_R_SYM (rel->r_info);
8535                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8536                                   r_symndx, ibfd))
8537                     {
8538                     err_free_rel:
8539                       if (elf_section_data (sec)->relocs != relstart)
8540                         free (relstart);
8541                       if (toc_ref != NULL)
8542                         free (toc_ref);
8543                       if (locsyms != NULL
8544                           && (elf_symtab_hdr (ibfd).contents
8545                               != (unsigned char *) locsyms))
8546                         free (locsyms);
8547                       return ret;
8548                     }
8549
8550                   if (h != NULL)
8551                     {
8552                       if (h->root.type == bfd_link_hash_defined
8553                           || h->root.type == bfd_link_hash_defweak)
8554                         value = h->root.u.def.value;
8555                       else if (h->root.type == bfd_link_hash_undefweak)
8556                         value = 0;
8557                       else
8558                         {
8559                           found_tls_get_addr_arg = 0;
8560                           continue;
8561                         }
8562                     }
8563                   else
8564                     /* Symbols referenced by TLS relocs must be of type
8565                        STT_TLS.  So no need for .opd local sym adjust.  */
8566                     value = sym->st_value;
8567
8568                   ok_tprel = FALSE;
8569                   is_local = FALSE;
8570                   if (h == NULL
8571                       || !h->def_dynamic)
8572                     {
8573                       is_local = TRUE;
8574                       if (h != NULL
8575                           && h->root.type == bfd_link_hash_undefweak)
8576                         ok_tprel = TRUE;
8577                       else if (sym_sec != NULL
8578                                && sym_sec->output_section != NULL)
8579                         {
8580                           value += sym_sec->output_offset;
8581                           value += sym_sec->output_section->vma;
8582                           value -= htab->elf.tls_sec->vma;
8583                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8584                                       < (bfd_vma) 1 << 32);
8585                         }
8586                     }
8587
8588                   r_type = ELF64_R_TYPE (rel->r_info);
8589                   /* If this section has old-style __tls_get_addr calls
8590                      without marker relocs, then check that each
8591                      __tls_get_addr call reloc is preceded by a reloc
8592                      that conceivably belongs to the __tls_get_addr arg
8593                      setup insn.  If we don't find matching arg setup
8594                      relocs, don't do any tls optimization.  */
8595                   if (pass == 0
8596                       && sec->has_tls_get_addr_call
8597                       && h != NULL
8598                       && (h == &htab->tls_get_addr->elf
8599                           || h == &htab->tls_get_addr_fd->elf)
8600                       && !found_tls_get_addr_arg
8601                       && is_branch_reloc (r_type))
8602                     {
8603                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8604                                                 "TLS optimization disabled\n"),
8605                                               ibfd, sec, rel->r_offset);
8606                       ret = TRUE;
8607                       goto err_free_rel;
8608                     }
8609
8610                   found_tls_get_addr_arg = 0;
8611                   switch (r_type)
8612                     {
8613                     case R_PPC64_GOT_TLSLD16:
8614                     case R_PPC64_GOT_TLSLD16_LO:
8615                       expecting_tls_get_addr = 1;
8616                       found_tls_get_addr_arg = 1;
8617                       /* Fall through.  */
8618
8619                     case R_PPC64_GOT_TLSLD16_HI:
8620                     case R_PPC64_GOT_TLSLD16_HA:
8621                       /* These relocs should never be against a symbol
8622                          defined in a shared lib.  Leave them alone if
8623                          that turns out to be the case.  */
8624                       if (!is_local)
8625                         continue;
8626
8627                       /* LD -> LE */
8628                       tls_set = 0;
8629                       tls_clear = TLS_LD;
8630                       tls_type = TLS_TLS | TLS_LD;
8631                       break;
8632
8633                     case R_PPC64_GOT_TLSGD16:
8634                     case R_PPC64_GOT_TLSGD16_LO:
8635                       expecting_tls_get_addr = 1;
8636                       found_tls_get_addr_arg = 1;
8637                       /* Fall through. */
8638
8639                     case R_PPC64_GOT_TLSGD16_HI:
8640                     case R_PPC64_GOT_TLSGD16_HA:
8641                       if (ok_tprel)
8642                         /* GD -> LE */
8643                         tls_set = 0;
8644                       else
8645                         /* GD -> IE */
8646                         tls_set = TLS_TLS | TLS_TPRELGD;
8647                       tls_clear = TLS_GD;
8648                       tls_type = TLS_TLS | TLS_GD;
8649                       break;
8650
8651                     case R_PPC64_GOT_TPREL16_DS:
8652                     case R_PPC64_GOT_TPREL16_LO_DS:
8653                     case R_PPC64_GOT_TPREL16_HI:
8654                     case R_PPC64_GOT_TPREL16_HA:
8655                       if (ok_tprel)
8656                         {
8657                           /* IE -> LE */
8658                           tls_set = 0;
8659                           tls_clear = TLS_TPREL;
8660                           tls_type = TLS_TLS | TLS_TPREL;
8661                           break;
8662                         }
8663                       continue;
8664
8665                     case R_PPC64_TLSGD:
8666                     case R_PPC64_TLSLD:
8667                       found_tls_get_addr_arg = 1;
8668                       /* Fall through.  */
8669
8670                     case R_PPC64_TLS:
8671                     case R_PPC64_TOC16:
8672                     case R_PPC64_TOC16_LO:
8673                       if (sym_sec == NULL || sym_sec != toc)
8674                         continue;
8675
8676                       /* Mark this toc entry as referenced by a TLS
8677                          code sequence.  We can do that now in the
8678                          case of R_PPC64_TLS, and after checking for
8679                          tls_get_addr for the TOC16 relocs.  */
8680                       if (toc_ref == NULL)
8681                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8682                       if (toc_ref == NULL)
8683                         goto err_free_rel;
8684
8685                       if (h != NULL)
8686                         value = h->root.u.def.value;
8687                       else
8688                         value = sym->st_value;
8689                       value += rel->r_addend;
8690                       if (value % 8 != 0)
8691                         continue;
8692                       BFD_ASSERT (value < toc->size
8693                                   && toc->output_offset % 8 == 0);
8694                       toc_ref_index = (value + toc->output_offset) / 8;
8695                       if (r_type == R_PPC64_TLS
8696                           || r_type == R_PPC64_TLSGD
8697                           || r_type == R_PPC64_TLSLD)
8698                         {
8699                           toc_ref[toc_ref_index] = 1;
8700                           continue;
8701                         }
8702
8703                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8704                         continue;
8705
8706                       tls_set = 0;
8707                       tls_clear = 0;
8708                       expecting_tls_get_addr = 2;
8709                       break;
8710
8711                     case R_PPC64_TPREL64:
8712                       if (pass == 0
8713                           || sec != toc
8714                           || toc_ref == NULL
8715                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8716                         continue;
8717                       if (ok_tprel)
8718                         {
8719                           /* IE -> LE */
8720                           tls_set = TLS_EXPLICIT;
8721                           tls_clear = TLS_TPREL;
8722                           break;
8723                         }
8724                       continue;
8725
8726                     case R_PPC64_DTPMOD64:
8727                       if (pass == 0
8728                           || sec != toc
8729                           || toc_ref == NULL
8730                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8731                         continue;
8732                       if (rel + 1 < relend
8733                           && (rel[1].r_info
8734                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8735                           && rel[1].r_offset == rel->r_offset + 8)
8736                         {
8737                           if (ok_tprel)
8738                             /* GD -> LE */
8739                             tls_set = TLS_EXPLICIT | TLS_GD;
8740                           else
8741                             /* GD -> IE */
8742                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8743                           tls_clear = TLS_GD;
8744                         }
8745                       else
8746                         {
8747                           if (!is_local)
8748                             continue;
8749
8750                           /* LD -> LE */
8751                           tls_set = TLS_EXPLICIT;
8752                           tls_clear = TLS_LD;
8753                         }
8754                       break;
8755
8756                     default:
8757                       continue;
8758                     }
8759
8760                   if (pass == 0)
8761                     {
8762                       if (!expecting_tls_get_addr
8763                           || !sec->has_tls_get_addr_call)
8764                         continue;
8765
8766                       if (rel + 1 < relend
8767                           && branch_reloc_hash_match (ibfd, rel + 1,
8768                                                       htab->tls_get_addr,
8769                                                       htab->tls_get_addr_fd))
8770                         {
8771                           if (expecting_tls_get_addr == 2)
8772                             {
8773                               /* Check for toc tls entries.  */
8774                               unsigned char *toc_tls;
8775                               int retval;
8776
8777                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8778                                                      &locsyms,
8779                                                      rel, ibfd);
8780                               if (retval == 0)
8781                                 goto err_free_rel;
8782                               if (toc_tls != NULL)
8783                                 {
8784                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8785                                     found_tls_get_addr_arg = 1;
8786                                   if (retval > 1)
8787                                     toc_ref[toc_ref_index] = 1;
8788                                 }
8789                             }
8790                           continue;
8791                         }
8792
8793                       if (expecting_tls_get_addr != 1)
8794                         continue;
8795
8796                       /* Uh oh, we didn't find the expected call.  We
8797                          could just mark this symbol to exclude it
8798                          from tls optimization but it's safer to skip
8799                          the entire optimization.  */
8800                       /* xgettext:c-format */
8801                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8802                                                 "TLS optimization disabled\n"),
8803                                               ibfd, sec, rel->r_offset);
8804                       ret = TRUE;
8805                       goto err_free_rel;
8806                     }
8807
8808                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8809                     {
8810                       struct plt_entry *ent;
8811                       for (ent = htab->tls_get_addr->elf.plt.plist;
8812                            ent != NULL;
8813                            ent = ent->next)
8814                         if (ent->addend == 0)
8815                           {
8816                             if (ent->plt.refcount > 0)
8817                               {
8818                                 ent->plt.refcount -= 1;
8819                                 expecting_tls_get_addr = 0;
8820                               }
8821                             break;
8822                           }
8823                     }
8824
8825                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8826                     {
8827                       struct plt_entry *ent;
8828                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8829                            ent != NULL;
8830                            ent = ent->next)
8831                         if (ent->addend == 0)
8832                           {
8833                             if (ent->plt.refcount > 0)
8834                               ent->plt.refcount -= 1;
8835                             break;
8836                           }
8837                     }
8838
8839                   if (tls_clear == 0)
8840                     continue;
8841
8842                   if ((tls_set & TLS_EXPLICIT) == 0)
8843                     {
8844                       struct got_entry *ent;
8845
8846                       /* Adjust got entry for this reloc.  */
8847                       if (h != NULL)
8848                         ent = h->got.glist;
8849                       else
8850                         ent = elf_local_got_ents (ibfd)[r_symndx];
8851
8852                       for (; ent != NULL; ent = ent->next)
8853                         if (ent->addend == rel->r_addend
8854                             && ent->owner == ibfd
8855                             && ent->tls_type == tls_type)
8856                           break;
8857                       if (ent == NULL)
8858                         abort ();
8859
8860                       if (tls_set == 0)
8861                         {
8862                           /* We managed to get rid of a got entry.  */
8863                           if (ent->got.refcount > 0)
8864                             ent->got.refcount -= 1;
8865                         }
8866                     }
8867                   else
8868                     {
8869                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8870                          we'll lose one or two dyn relocs.  */
8871                       if (!dec_dynrel_count (rel->r_info, sec, info,
8872                                              NULL, h, sym))
8873                         return FALSE;
8874
8875                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8876                         {
8877                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8878                                                  NULL, h, sym))
8879                             return FALSE;
8880                         }
8881                     }
8882
8883                   *tls_mask |= tls_set;
8884                   *tls_mask &= ~tls_clear;
8885                 }
8886
8887               if (elf_section_data (sec)->relocs != relstart)
8888                 free (relstart);
8889             }
8890
8891         if (locsyms != NULL
8892             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8893           {
8894             if (!info->keep_memory)
8895               free (locsyms);
8896             else
8897               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8898           }
8899       }
8900
8901   if (toc_ref != NULL)
8902     free (toc_ref);
8903   return TRUE;
8904 }
8905
8906 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8907    the values of any global symbols in a toc section that has been
8908    edited.  Globals in toc sections should be a rarity, so this function
8909    sets a flag if any are found in toc sections other than the one just
8910    edited, so that further hash table traversals can be avoided.  */
8911
8912 struct adjust_toc_info
8913 {
8914   asection *toc;
8915   unsigned long *skip;
8916   bfd_boolean global_toc_syms;
8917 };
8918
8919 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8920
8921 static bfd_boolean
8922 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8923 {
8924   struct ppc_link_hash_entry *eh;
8925   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8926   unsigned long i;
8927
8928   if (h->root.type != bfd_link_hash_defined
8929       && h->root.type != bfd_link_hash_defweak)
8930     return TRUE;
8931
8932   eh = (struct ppc_link_hash_entry *) h;
8933   if (eh->adjust_done)
8934     return TRUE;
8935
8936   if (eh->elf.root.u.def.section == toc_inf->toc)
8937     {
8938       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8939         i = toc_inf->toc->rawsize >> 3;
8940       else
8941         i = eh->elf.root.u.def.value >> 3;
8942
8943       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8944         {
8945           _bfd_error_handler
8946             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8947           do
8948             ++i;
8949           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8950           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8951         }
8952
8953       eh->elf.root.u.def.value -= toc_inf->skip[i];
8954       eh->adjust_done = 1;
8955     }
8956   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8957     toc_inf->global_toc_syms = TRUE;
8958
8959   return TRUE;
8960 }
8961
8962 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8963    on a _LO variety toc/got reloc.  */
8964
8965 static bfd_boolean
8966 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8967 {
8968   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8969           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8970           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8971           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8972           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8973           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8974           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8975           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8976           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8977           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8978           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8979           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8980           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8981           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8982           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8983           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8984           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8985               /* Exclude lfqu by testing reloc.  If relocs are ever
8986                  defined for the reduced D field in psq_lu then those
8987                  will need testing too.  */
8988               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8989           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8990               && (insn & 1) == 0)
8991           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8992           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8993               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8994               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8995           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8996               && (insn & 1) == 0));
8997 }
8998
8999 /* Examine all relocs referencing .toc sections in order to remove
9000    unused .toc entries.  */
9001
9002 bfd_boolean
9003 ppc64_elf_edit_toc (struct bfd_link_info *info)
9004 {
9005   bfd *ibfd;
9006   struct adjust_toc_info toc_inf;
9007   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9008
9009   htab->do_toc_opt = 1;
9010   toc_inf.global_toc_syms = TRUE;
9011   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9012     {
9013       asection *toc, *sec;
9014       Elf_Internal_Shdr *symtab_hdr;
9015       Elf_Internal_Sym *local_syms;
9016       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9017       unsigned long *skip, *drop;
9018       unsigned char *used;
9019       unsigned char *keep, last, some_unused;
9020
9021       if (!is_ppc64_elf (ibfd))
9022         continue;
9023
9024       toc = bfd_get_section_by_name (ibfd, ".toc");
9025       if (toc == NULL
9026           || toc->size == 0
9027           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9028           || discarded_section (toc))
9029         continue;
9030
9031       toc_relocs = NULL;
9032       local_syms = NULL;
9033       symtab_hdr = &elf_symtab_hdr (ibfd);
9034
9035       /* Look at sections dropped from the final link.  */
9036       skip = NULL;
9037       relstart = NULL;
9038       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9039         {
9040           if (sec->reloc_count == 0
9041               || !discarded_section (sec)
9042               || get_opd_info (sec)
9043               || (sec->flags & SEC_ALLOC) == 0
9044               || (sec->flags & SEC_DEBUGGING) != 0)
9045             continue;
9046
9047           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9048           if (relstart == NULL)
9049             goto error_ret;
9050
9051           /* Run through the relocs to see which toc entries might be
9052              unused.  */
9053           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9054             {
9055               enum elf_ppc64_reloc_type r_type;
9056               unsigned long r_symndx;
9057               asection *sym_sec;
9058               struct elf_link_hash_entry *h;
9059               Elf_Internal_Sym *sym;
9060               bfd_vma val;
9061
9062               r_type = ELF64_R_TYPE (rel->r_info);
9063               switch (r_type)
9064                 {
9065                 default:
9066                   continue;
9067
9068                 case R_PPC64_TOC16:
9069                 case R_PPC64_TOC16_LO:
9070                 case R_PPC64_TOC16_HI:
9071                 case R_PPC64_TOC16_HA:
9072                 case R_PPC64_TOC16_DS:
9073                 case R_PPC64_TOC16_LO_DS:
9074                   break;
9075                 }
9076
9077               r_symndx = ELF64_R_SYM (rel->r_info);
9078               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9079                               r_symndx, ibfd))
9080                 goto error_ret;
9081
9082               if (sym_sec != toc)
9083                 continue;
9084
9085               if (h != NULL)
9086                 val = h->root.u.def.value;
9087               else
9088                 val = sym->st_value;
9089               val += rel->r_addend;
9090
9091               if (val >= toc->size)
9092                 continue;
9093
9094               /* Anything in the toc ought to be aligned to 8 bytes.
9095                  If not, don't mark as unused.  */
9096               if (val & 7)
9097                 continue;
9098
9099               if (skip == NULL)
9100                 {
9101                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9102                   if (skip == NULL)
9103                     goto error_ret;
9104                 }
9105
9106               skip[val >> 3] = ref_from_discarded;
9107             }
9108
9109           if (elf_section_data (sec)->relocs != relstart)
9110             free (relstart);
9111         }
9112
9113       /* For largetoc loads of address constants, we can convert
9114          .  addis rx,2,addr@got@ha
9115          .  ld ry,addr@got@l(rx)
9116          to
9117          .  addis rx,2,addr@toc@ha
9118          .  addi ry,rx,addr@toc@l
9119          when addr is within 2G of the toc pointer.  This then means
9120          that the word storing "addr" in the toc is no longer needed.  */
9121
9122       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9123           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9124           && toc->reloc_count != 0)
9125         {
9126           /* Read toc relocs.  */
9127           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9128                                                   info->keep_memory);
9129           if (toc_relocs == NULL)
9130             goto error_ret;
9131
9132           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9133             {
9134               enum elf_ppc64_reloc_type r_type;
9135               unsigned long r_symndx;
9136               asection *sym_sec;
9137               struct elf_link_hash_entry *h;
9138               Elf_Internal_Sym *sym;
9139               bfd_vma val, addr;
9140
9141               r_type = ELF64_R_TYPE (rel->r_info);
9142               if (r_type != R_PPC64_ADDR64)
9143                 continue;
9144
9145               r_symndx = ELF64_R_SYM (rel->r_info);
9146               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9147                               r_symndx, ibfd))
9148                 goto error_ret;
9149
9150               if (sym_sec == NULL
9151                   || sym_sec->output_section == NULL
9152                   || discarded_section (sym_sec))
9153                 continue;
9154
9155               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9156                 continue;
9157
9158               if (h != NULL)
9159                 {
9160                   if (h->type == STT_GNU_IFUNC)
9161                     continue;
9162                   val = h->root.u.def.value;
9163                 }
9164               else
9165                 {
9166                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9167                     continue;
9168                   val = sym->st_value;
9169                 }
9170               val += rel->r_addend;
9171               val += sym_sec->output_section->vma + sym_sec->output_offset;
9172
9173               /* We don't yet know the exact toc pointer value, but we
9174                  know it will be somewhere in the toc section.  Don't
9175                  optimize if the difference from any possible toc
9176                  pointer is outside [ff..f80008000, 7fff7fff].  */
9177               addr = toc->output_section->vma + TOC_BASE_OFF;
9178               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9179                 continue;
9180
9181               addr = toc->output_section->vma + toc->output_section->rawsize;
9182               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9183                 continue;
9184
9185               if (skip == NULL)
9186                 {
9187                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9188                   if (skip == NULL)
9189                     goto error_ret;
9190                 }
9191
9192               skip[rel->r_offset >> 3]
9193                 |= can_optimize | ((rel - toc_relocs) << 2);
9194             }
9195         }
9196
9197       if (skip == NULL)
9198         continue;
9199
9200       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9201       if (used == NULL)
9202         {
9203         error_ret:
9204           if (local_syms != NULL
9205               && symtab_hdr->contents != (unsigned char *) local_syms)
9206             free (local_syms);
9207           if (sec != NULL
9208               && relstart != NULL
9209               && elf_section_data (sec)->relocs != relstart)
9210             free (relstart);
9211           if (toc_relocs != NULL
9212               && elf_section_data (toc)->relocs != toc_relocs)
9213             free (toc_relocs);
9214           if (skip != NULL)
9215             free (skip);
9216           return FALSE;
9217         }
9218
9219       /* Now check all kept sections that might reference the toc.
9220          Check the toc itself last.  */
9221       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9222                   : ibfd->sections);
9223            sec != NULL;
9224            sec = (sec == toc ? NULL
9225                   : sec->next == NULL ? toc
9226                   : sec->next == toc && toc->next ? toc->next
9227                   : sec->next))
9228         {
9229           int repeat;
9230
9231           if (sec->reloc_count == 0
9232               || discarded_section (sec)
9233               || get_opd_info (sec)
9234               || (sec->flags & SEC_ALLOC) == 0
9235               || (sec->flags & SEC_DEBUGGING) != 0)
9236             continue;
9237
9238           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9239                                                 info->keep_memory);
9240           if (relstart == NULL)
9241             {
9242               free (used);
9243               goto error_ret;
9244             }
9245
9246           /* Mark toc entries referenced as used.  */
9247           do
9248             {
9249               repeat = 0;
9250               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9251                 {
9252                   enum elf_ppc64_reloc_type r_type;
9253                   unsigned long r_symndx;
9254                   asection *sym_sec;
9255                   struct elf_link_hash_entry *h;
9256                   Elf_Internal_Sym *sym;
9257                   bfd_vma val;
9258                   enum {no_check, check_lo, check_ha} insn_check;
9259
9260                   r_type = ELF64_R_TYPE (rel->r_info);
9261                   switch (r_type)
9262                     {
9263                     default:
9264                       insn_check = no_check;
9265                       break;
9266
9267                     case R_PPC64_GOT_TLSLD16_HA:
9268                     case R_PPC64_GOT_TLSGD16_HA:
9269                     case R_PPC64_GOT_TPREL16_HA:
9270                     case R_PPC64_GOT_DTPREL16_HA:
9271                     case R_PPC64_GOT16_HA:
9272                     case R_PPC64_TOC16_HA:
9273                       insn_check = check_ha;
9274                       break;
9275
9276                     case R_PPC64_GOT_TLSLD16_LO:
9277                     case R_PPC64_GOT_TLSGD16_LO:
9278                     case R_PPC64_GOT_TPREL16_LO_DS:
9279                     case R_PPC64_GOT_DTPREL16_LO_DS:
9280                     case R_PPC64_GOT16_LO:
9281                     case R_PPC64_GOT16_LO_DS:
9282                     case R_PPC64_TOC16_LO:
9283                     case R_PPC64_TOC16_LO_DS:
9284                       insn_check = check_lo;
9285                       break;
9286                     }
9287
9288                   if (insn_check != no_check)
9289                     {
9290                       bfd_vma off = rel->r_offset & ~3;
9291                       unsigned char buf[4];
9292                       unsigned int insn;
9293
9294                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9295                         {
9296                           free (used);
9297                           goto error_ret;
9298                         }
9299                       insn = bfd_get_32 (ibfd, buf);
9300                       if (insn_check == check_lo
9301                           ? !ok_lo_toc_insn (insn, r_type)
9302                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9303                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9304                         {
9305                           char str[12];
9306
9307                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9308                           sprintf (str, "%#08x", insn);
9309                           info->callbacks->einfo
9310                             /* xgettext:c-format */
9311                             (_("%H: toc optimization is not supported for"
9312                                " %s instruction.\n"),
9313                              ibfd, sec, rel->r_offset & ~3, str);
9314                         }
9315                     }
9316
9317                   switch (r_type)
9318                     {
9319                     case R_PPC64_TOC16:
9320                     case R_PPC64_TOC16_LO:
9321                     case R_PPC64_TOC16_HI:
9322                     case R_PPC64_TOC16_HA:
9323                     case R_PPC64_TOC16_DS:
9324                     case R_PPC64_TOC16_LO_DS:
9325                       /* In case we're taking addresses of toc entries.  */
9326                     case R_PPC64_ADDR64:
9327                       break;
9328
9329                     default:
9330                       continue;
9331                     }
9332
9333                   r_symndx = ELF64_R_SYM (rel->r_info);
9334                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9335                                   r_symndx, ibfd))
9336                     {
9337                       free (used);
9338                       goto error_ret;
9339                     }
9340
9341                   if (sym_sec != toc)
9342                     continue;
9343
9344                   if (h != NULL)
9345                     val = h->root.u.def.value;
9346                   else
9347                     val = sym->st_value;
9348                   val += rel->r_addend;
9349
9350                   if (val >= toc->size)
9351                     continue;
9352
9353                   if ((skip[val >> 3] & can_optimize) != 0)
9354                     {
9355                       bfd_vma off;
9356                       unsigned char opc;
9357
9358                       switch (r_type)
9359                         {
9360                         case R_PPC64_TOC16_HA:
9361                           break;
9362
9363                         case R_PPC64_TOC16_LO_DS:
9364                           off = rel->r_offset;
9365                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9366                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9367                                                          off, 1))
9368                             {
9369                               free (used);
9370                               goto error_ret;
9371                             }
9372                           if ((opc & (0x3f << 2)) == (58u << 2))
9373                             break;
9374                           /* Fall through.  */
9375
9376                         default:
9377                           /* Wrong sort of reloc, or not a ld.  We may
9378                              as well clear ref_from_discarded too.  */
9379                           skip[val >> 3] = 0;
9380                         }
9381                     }
9382
9383                   if (sec != toc)
9384                     used[val >> 3] = 1;
9385                   /* For the toc section, we only mark as used if this
9386                      entry itself isn't unused.  */
9387                   else if ((used[rel->r_offset >> 3]
9388                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9389                            && !used[val >> 3])
9390                     {
9391                       /* Do all the relocs again, to catch reference
9392                          chains.  */
9393                       repeat = 1;
9394                       used[val >> 3] = 1;
9395                     }
9396                 }
9397             }
9398           while (repeat);
9399
9400           if (elf_section_data (sec)->relocs != relstart)
9401             free (relstart);
9402         }
9403
9404       /* Merge the used and skip arrays.  Assume that TOC
9405          doublewords not appearing as either used or unused belong
9406          to an entry more than one doubleword in size.  */
9407       for (drop = skip, keep = used, last = 0, some_unused = 0;
9408            drop < skip + (toc->size + 7) / 8;
9409            ++drop, ++keep)
9410         {
9411           if (*keep)
9412             {
9413               *drop &= ~ref_from_discarded;
9414               if ((*drop & can_optimize) != 0)
9415                 some_unused = 1;
9416               last = 0;
9417             }
9418           else if ((*drop & ref_from_discarded) != 0)
9419             {
9420               some_unused = 1;
9421               last = ref_from_discarded;
9422             }
9423           else
9424             *drop = last;
9425         }
9426
9427       free (used);
9428
9429       if (some_unused)
9430         {
9431           bfd_byte *contents, *src;
9432           unsigned long off;
9433           Elf_Internal_Sym *sym;
9434           bfd_boolean local_toc_syms = FALSE;
9435
9436           /* Shuffle the toc contents, and at the same time convert the
9437              skip array from booleans into offsets.  */
9438           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9439             goto error_ret;
9440
9441           elf_section_data (toc)->this_hdr.contents = contents;
9442
9443           for (src = contents, off = 0, drop = skip;
9444                src < contents + toc->size;
9445                src += 8, ++drop)
9446             {
9447               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9448                 off += 8;
9449               else if (off != 0)
9450                 {
9451                   *drop = off;
9452                   memcpy (src - off, src, 8);
9453                 }
9454             }
9455           *drop = off;
9456           toc->rawsize = toc->size;
9457           toc->size = src - contents - off;
9458
9459           /* Adjust addends for relocs against the toc section sym,
9460              and optimize any accesses we can.  */
9461           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9462             {
9463               if (sec->reloc_count == 0
9464                   || discarded_section (sec))
9465                 continue;
9466
9467               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9468                                                     info->keep_memory);
9469               if (relstart == NULL)
9470                 goto error_ret;
9471
9472               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9473                 {
9474                   enum elf_ppc64_reloc_type r_type;
9475                   unsigned long r_symndx;
9476                   asection *sym_sec;
9477                   struct elf_link_hash_entry *h;
9478                   bfd_vma val;
9479
9480                   r_type = ELF64_R_TYPE (rel->r_info);
9481                   switch (r_type)
9482                     {
9483                     default:
9484                       continue;
9485
9486                     case R_PPC64_TOC16:
9487                     case R_PPC64_TOC16_LO:
9488                     case R_PPC64_TOC16_HI:
9489                     case R_PPC64_TOC16_HA:
9490                     case R_PPC64_TOC16_DS:
9491                     case R_PPC64_TOC16_LO_DS:
9492                     case R_PPC64_ADDR64:
9493                       break;
9494                     }
9495
9496                   r_symndx = ELF64_R_SYM (rel->r_info);
9497                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9498                                   r_symndx, ibfd))
9499                     goto error_ret;
9500
9501                   if (sym_sec != toc)
9502                     continue;
9503
9504                   if (h != NULL)
9505                     val = h->root.u.def.value;
9506                   else
9507                     {
9508                       val = sym->st_value;
9509                       if (val != 0)
9510                         local_toc_syms = TRUE;
9511                     }
9512
9513                   val += rel->r_addend;
9514
9515                   if (val > toc->rawsize)
9516                     val = toc->rawsize;
9517                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9518                     continue;
9519                   else if ((skip[val >> 3] & can_optimize) != 0)
9520                     {
9521                       Elf_Internal_Rela *tocrel
9522                         = toc_relocs + (skip[val >> 3] >> 2);
9523                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9524
9525                       switch (r_type)
9526                         {
9527                         case R_PPC64_TOC16_HA:
9528                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9529                           break;
9530
9531                         case R_PPC64_TOC16_LO_DS:
9532                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9533                           break;
9534
9535                         default:
9536                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9537                             ppc_howto_init ();
9538                           info->callbacks->einfo
9539                             /* xgettext:c-format */
9540                             (_("%H: %s references "
9541                                "optimized away TOC entry\n"),
9542                              ibfd, sec, rel->r_offset,
9543                              ppc64_elf_howto_table[r_type]->name);
9544                           bfd_set_error (bfd_error_bad_value);
9545                           goto error_ret;
9546                         }
9547                       rel->r_addend = tocrel->r_addend;
9548                       elf_section_data (sec)->relocs = relstart;
9549                       continue;
9550                     }
9551
9552                   if (h != NULL || sym->st_value != 0)
9553                     continue;
9554
9555                   rel->r_addend -= skip[val >> 3];
9556                   elf_section_data (sec)->relocs = relstart;
9557                 }
9558
9559               if (elf_section_data (sec)->relocs != relstart)
9560                 free (relstart);
9561             }
9562
9563           /* We shouldn't have local or global symbols defined in the TOC,
9564              but handle them anyway.  */
9565           if (local_syms != NULL)
9566             for (sym = local_syms;
9567                  sym < local_syms + symtab_hdr->sh_info;
9568                  ++sym)
9569               if (sym->st_value != 0
9570                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9571                 {
9572                   unsigned long i;
9573
9574                   if (sym->st_value > toc->rawsize)
9575                     i = toc->rawsize >> 3;
9576                   else
9577                     i = sym->st_value >> 3;
9578
9579                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9580                     {
9581                       if (local_toc_syms)
9582                         _bfd_error_handler
9583                           (_("%s defined on removed toc entry"),
9584                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9585                       do
9586                         ++i;
9587                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9588                       sym->st_value = (bfd_vma) i << 3;
9589                     }
9590
9591                   sym->st_value -= skip[i];
9592                   symtab_hdr->contents = (unsigned char *) local_syms;
9593                 }
9594
9595           /* Adjust any global syms defined in this toc input section.  */
9596           if (toc_inf.global_toc_syms)
9597             {
9598               toc_inf.toc = toc;
9599               toc_inf.skip = skip;
9600               toc_inf.global_toc_syms = FALSE;
9601               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9602                                       &toc_inf);
9603             }
9604
9605           if (toc->reloc_count != 0)
9606             {
9607               Elf_Internal_Shdr *rel_hdr;
9608               Elf_Internal_Rela *wrel;
9609               bfd_size_type sz;
9610
9611               /* Remove unused toc relocs, and adjust those we keep.  */
9612               if (toc_relocs == NULL)
9613                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9614                                                         info->keep_memory);
9615               if (toc_relocs == NULL)
9616                 goto error_ret;
9617
9618               wrel = toc_relocs;
9619               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9620                 if ((skip[rel->r_offset >> 3]
9621                      & (ref_from_discarded | can_optimize)) == 0)
9622                   {
9623                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9624                     wrel->r_info = rel->r_info;
9625                     wrel->r_addend = rel->r_addend;
9626                     ++wrel;
9627                   }
9628                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9629                                             &local_syms, NULL, NULL))
9630                   goto error_ret;
9631
9632               elf_section_data (toc)->relocs = toc_relocs;
9633               toc->reloc_count = wrel - toc_relocs;
9634               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9635               sz = rel_hdr->sh_entsize;
9636               rel_hdr->sh_size = toc->reloc_count * sz;
9637             }
9638         }
9639       else if (toc_relocs != NULL
9640                && elf_section_data (toc)->relocs != toc_relocs)
9641         free (toc_relocs);
9642
9643       if (local_syms != NULL
9644           && symtab_hdr->contents != (unsigned char *) local_syms)
9645         {
9646           if (!info->keep_memory)
9647             free (local_syms);
9648           else
9649             symtab_hdr->contents = (unsigned char *) local_syms;
9650         }
9651       free (skip);
9652     }
9653
9654   return TRUE;
9655 }
9656
9657 /* Return true iff input section I references the TOC using
9658    instructions limited to +/-32k offsets.  */
9659
9660 bfd_boolean
9661 ppc64_elf_has_small_toc_reloc (asection *i)
9662 {
9663   return (is_ppc64_elf (i->owner)
9664           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9665 }
9666
9667 /* Allocate space for one GOT entry.  */
9668
9669 static void
9670 allocate_got (struct elf_link_hash_entry *h,
9671               struct bfd_link_info *info,
9672               struct got_entry *gent)
9673 {
9674   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9675   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9676   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9677                  ? 16 : 8);
9678   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9679                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9680   asection *got = ppc64_elf_tdata (gent->owner)->got;
9681
9682   gent->got.offset = got->size;
9683   got->size += entsize;
9684
9685   if (h->type == STT_GNU_IFUNC)
9686     {
9687       htab->elf.irelplt->size += rentsize;
9688       htab->got_reli_size += rentsize;
9689     }
9690   else if ((bfd_link_pic (info)
9691             || (htab->elf.dynamic_sections_created
9692                 && h->dynindx != -1
9693                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9694            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9695     {
9696       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9697       relgot->size += rentsize;
9698     }
9699 }
9700
9701 /* This function merges got entries in the same toc group.  */
9702
9703 static void
9704 merge_got_entries (struct got_entry **pent)
9705 {
9706   struct got_entry *ent, *ent2;
9707
9708   for (ent = *pent; ent != NULL; ent = ent->next)
9709     if (!ent->is_indirect)
9710       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9711         if (!ent2->is_indirect
9712             && ent2->addend == ent->addend
9713             && ent2->tls_type == ent->tls_type
9714             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9715           {
9716             ent2->is_indirect = TRUE;
9717             ent2->got.ent = ent;
9718           }
9719 }
9720
9721 /* If H is undefined weak, make it dynamic if that makes sense.  */
9722
9723 static bfd_boolean
9724 ensure_undefweak_dynamic (struct bfd_link_info *info,
9725                           struct elf_link_hash_entry *h)
9726 {
9727   struct elf_link_hash_table *htab = elf_hash_table (info);
9728
9729   if (htab->dynamic_sections_created
9730       && info->dynamic_undefined_weak != 0
9731       && h->root.type == bfd_link_hash_undefweak
9732       && h->dynindx == -1
9733       && !h->forced_local
9734       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9735     return bfd_elf_link_record_dynamic_symbol (info, h);
9736   return TRUE;
9737 }
9738
9739 /* Allocate space in .plt, .got and associated reloc sections for
9740    dynamic relocs.  */
9741
9742 static bfd_boolean
9743 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9744 {
9745   struct bfd_link_info *info;
9746   struct ppc_link_hash_table *htab;
9747   asection *s;
9748   struct ppc_link_hash_entry *eh;
9749   struct got_entry **pgent, *gent;
9750
9751   if (h->root.type == bfd_link_hash_indirect)
9752     return TRUE;
9753
9754   info = (struct bfd_link_info *) inf;
9755   htab = ppc_hash_table (info);
9756   if (htab == NULL)
9757     return FALSE;
9758
9759   eh = (struct ppc_link_hash_entry *) h;
9760   /* Run through the TLS GD got entries first if we're changing them
9761      to TPREL.  */
9762   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9763     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9764       if (gent->got.refcount > 0
9765           && (gent->tls_type & TLS_GD) != 0)
9766         {
9767           /* This was a GD entry that has been converted to TPREL.  If
9768              there happens to be a TPREL entry we can use that one.  */
9769           struct got_entry *ent;
9770           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9771             if (ent->got.refcount > 0
9772                 && (ent->tls_type & TLS_TPREL) != 0
9773                 && ent->addend == gent->addend
9774                 && ent->owner == gent->owner)
9775               {
9776                 gent->got.refcount = 0;
9777                 break;
9778               }
9779
9780           /* If not, then we'll be using our own TPREL entry.  */
9781           if (gent->got.refcount != 0)
9782             gent->tls_type = TLS_TLS | TLS_TPREL;
9783         }
9784
9785   /* Remove any list entry that won't generate a word in the GOT before
9786      we call merge_got_entries.  Otherwise we risk merging to empty
9787      entries.  */
9788   pgent = &h->got.glist;
9789   while ((gent = *pgent) != NULL)
9790     if (gent->got.refcount > 0)
9791       {
9792         if ((gent->tls_type & TLS_LD) != 0
9793             && !h->def_dynamic)
9794           {
9795             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9796             *pgent = gent->next;
9797           }
9798         else
9799           pgent = &gent->next;
9800       }
9801     else
9802       *pgent = gent->next;
9803
9804   if (!htab->do_multi_toc)
9805     merge_got_entries (&h->got.glist);
9806
9807   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9808     if (!gent->is_indirect)
9809       {
9810         /* Make sure this symbol is output as a dynamic symbol.
9811            Undefined weak syms won't yet be marked as dynamic.  */
9812         if (!ensure_undefweak_dynamic (info, h))
9813           return FALSE;
9814
9815         if (!is_ppc64_elf (gent->owner))
9816           abort ();
9817
9818         allocate_got (h, info, gent);
9819       }
9820
9821   /* If no dynamic sections we can't have dynamic relocs, except for
9822      IFUNCs which are handled even in static executables.  */
9823   if (!htab->elf.dynamic_sections_created
9824       && h->type != STT_GNU_IFUNC)
9825     eh->dyn_relocs = NULL;
9826
9827   /* Also discard relocs on undefined weak syms with non-default
9828      visibility, or when dynamic_undefined_weak says so.  */
9829   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9830     eh->dyn_relocs = NULL;
9831
9832   if (eh->dyn_relocs != NULL)
9833     {
9834       struct elf_dyn_relocs *p, **pp;
9835
9836       /* In the shared -Bsymbolic case, discard space allocated for
9837          dynamic pc-relative relocs against symbols which turn out to
9838          be defined in regular objects.  For the normal shared case,
9839          discard space for relocs that have become local due to symbol
9840          visibility changes.  */
9841
9842       if (bfd_link_pic (info))
9843         {
9844           /* Relocs that use pc_count are those that appear on a call
9845              insn, or certain REL relocs (see must_be_dyn_reloc) that
9846              can be generated via assembly.  We want calls to
9847              protected symbols to resolve directly to the function
9848              rather than going via the plt.  If people want function
9849              pointer comparisons to work as expected then they should
9850              avoid writing weird assembly.  */
9851           if (SYMBOL_CALLS_LOCAL (info, h))
9852             {
9853               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9854                 {
9855                   p->count -= p->pc_count;
9856                   p->pc_count = 0;
9857                   if (p->count == 0)
9858                     *pp = p->next;
9859                   else
9860                     pp = &p->next;
9861                 }
9862             }
9863
9864           if (eh->dyn_relocs != NULL)
9865             {
9866               /* Make sure this symbol is output as a dynamic symbol.
9867                  Undefined weak syms won't yet be marked as dynamic.  */
9868               if (!ensure_undefweak_dynamic (info, h))
9869                 return FALSE;
9870             }
9871         }
9872       else if (h->type == STT_GNU_IFUNC)
9873         {
9874           /* A plt entry is always created when making direct calls to
9875              an ifunc, even when building a static executable, but
9876              that doesn't cover all cases.  We may have only an ifunc
9877              initialised function pointer for a given ifunc symbol.
9878
9879              For ELFv2, dynamic relocations are not required when
9880              generating a global entry PLT stub.  */
9881           if (abiversion (info->output_bfd) >= 2)
9882             {
9883               if (global_entry_stub (h))
9884                 eh->dyn_relocs = NULL;
9885             }
9886
9887           /* For ELFv1 we have function descriptors.  Descriptors need
9888              to be treated like PLT entries and thus have dynamic
9889              relocations.  One exception is when the function
9890              descriptor is copied into .dynbss (which should only
9891              happen with ancient versions of gcc).  */
9892           else if (h->needs_copy)
9893             eh->dyn_relocs = NULL;
9894         }
9895       else if (ELIMINATE_COPY_RELOCS)
9896         {
9897           /* For the non-pic case, discard space for relocs against
9898              symbols which turn out to need copy relocs or are not
9899              dynamic.  */
9900           if (!h->non_got_ref
9901               && !h->def_regular)
9902             {
9903               /* Make sure this symbol is output as a dynamic symbol.
9904                  Undefined weak syms won't yet be marked as dynamic.  */
9905               if (!ensure_undefweak_dynamic (info, h))
9906                 return FALSE;
9907
9908               if (h->dynindx == -1)
9909                 eh->dyn_relocs = NULL;
9910             }
9911           else
9912             eh->dyn_relocs = NULL;
9913         }
9914
9915       /* Finally, allocate space.  */
9916       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9917         {
9918           asection *sreloc = elf_section_data (p->sec)->sreloc;
9919           if (eh->elf.type == STT_GNU_IFUNC)
9920             sreloc = htab->elf.irelplt;
9921           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9922         }
9923     }
9924
9925   if ((htab->elf.dynamic_sections_created
9926        && h->dynindx != -1)
9927       || h->type == STT_GNU_IFUNC)
9928     {
9929       struct plt_entry *pent;
9930       bfd_boolean doneone = FALSE;
9931       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9932         if (pent->plt.refcount > 0)
9933           {
9934             if (!htab->elf.dynamic_sections_created
9935                 || h->dynindx == -1)
9936               {
9937                 s = htab->elf.iplt;
9938                 pent->plt.offset = s->size;
9939                 s->size += PLT_ENTRY_SIZE (htab);
9940                 s = htab->elf.irelplt;
9941               }
9942             else
9943               {
9944                 /* If this is the first .plt entry, make room for the special
9945                    first entry.  */
9946                 s = htab->elf.splt;
9947                 if (s->size == 0)
9948                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9949
9950                 pent->plt.offset = s->size;
9951
9952                 /* Make room for this entry.  */
9953                 s->size += PLT_ENTRY_SIZE (htab);
9954
9955                 /* Make room for the .glink code.  */
9956                 s = htab->glink;
9957                 if (s->size == 0)
9958                   s->size += GLINK_CALL_STUB_SIZE;
9959                 if (htab->opd_abi)
9960                   {
9961                     /* We need bigger stubs past index 32767.  */
9962                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9963                       s->size += 4;
9964                     s->size += 2*4;
9965                   }
9966                 else
9967                   s->size += 4;
9968
9969                 /* We also need to make an entry in the .rela.plt section.  */
9970                 s = htab->elf.srelplt;
9971               }
9972             s->size += sizeof (Elf64_External_Rela);
9973             doneone = TRUE;
9974           }
9975         else
9976           pent->plt.offset = (bfd_vma) -1;
9977       if (!doneone)
9978         {
9979           h->plt.plist = NULL;
9980           h->needs_plt = 0;
9981         }
9982     }
9983   else
9984     {
9985       h->plt.plist = NULL;
9986       h->needs_plt = 0;
9987     }
9988
9989   return TRUE;
9990 }
9991
9992 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9993    to set up space for global entry stubs.  These are put in glink,
9994    after the branch table.  */
9995
9996 static bfd_boolean
9997 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9998 {
9999   struct bfd_link_info *info;
10000   struct ppc_link_hash_table *htab;
10001   struct plt_entry *pent;
10002   asection *s;
10003
10004   if (h->root.type == bfd_link_hash_indirect)
10005     return TRUE;
10006
10007   if (!h->pointer_equality_needed)
10008     return TRUE;
10009
10010   if (h->def_regular)
10011     return TRUE;
10012
10013   info = inf;
10014   htab = ppc_hash_table (info);
10015   if (htab == NULL)
10016     return FALSE;
10017
10018   s = htab->glink;
10019   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10020     if (pent->plt.offset != (bfd_vma) -1
10021         && pent->addend == 0)
10022       {
10023         /* For ELFv2, if this symbol is not defined in a regular file
10024            and we are not generating a shared library or pie, then we
10025            need to define the symbol in the executable on a call stub.
10026            This is to avoid text relocations.  */
10027         s->size = (s->size + 15) & -16;
10028         h->root.type = bfd_link_hash_defined;
10029         h->root.u.def.section = s;
10030         h->root.u.def.value = s->size;
10031         s->size += 16;
10032         break;
10033       }
10034   return TRUE;
10035 }
10036
10037 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10038    read-only sections.  */
10039
10040 static bfd_boolean
10041 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10042 {
10043   if (h->root.type == bfd_link_hash_indirect)
10044     return TRUE;
10045
10046   if (readonly_dynrelocs (h))
10047     {
10048       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10049
10050       /* Not an error, just cut short the traversal.  */
10051       return FALSE;
10052     }
10053   return TRUE;
10054 }
10055
10056 /* Set the sizes of the dynamic sections.  */
10057
10058 static bfd_boolean
10059 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10060                                  struct bfd_link_info *info)
10061 {
10062   struct ppc_link_hash_table *htab;
10063   bfd *dynobj;
10064   asection *s;
10065   bfd_boolean relocs;
10066   bfd *ibfd;
10067   struct got_entry *first_tlsld;
10068
10069   htab = ppc_hash_table (info);
10070   if (htab == NULL)
10071     return FALSE;
10072
10073   dynobj = htab->elf.dynobj;
10074   if (dynobj == NULL)
10075     abort ();
10076
10077   if (htab->elf.dynamic_sections_created)
10078     {
10079       /* Set the contents of the .interp section to the interpreter.  */
10080       if (bfd_link_executable (info) && !info->nointerp)
10081         {
10082           s = bfd_get_linker_section (dynobj, ".interp");
10083           if (s == NULL)
10084             abort ();
10085           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10086           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10087         }
10088     }
10089
10090   /* Set up .got offsets for local syms, and space for local dynamic
10091      relocs.  */
10092   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10093     {
10094       struct got_entry **lgot_ents;
10095       struct got_entry **end_lgot_ents;
10096       struct plt_entry **local_plt;
10097       struct plt_entry **end_local_plt;
10098       unsigned char *lgot_masks;
10099       bfd_size_type locsymcount;
10100       Elf_Internal_Shdr *symtab_hdr;
10101
10102       if (!is_ppc64_elf (ibfd))
10103         continue;
10104
10105       for (s = ibfd->sections; s != NULL; s = s->next)
10106         {
10107           struct ppc_dyn_relocs *p;
10108
10109           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10110             {
10111               if (!bfd_is_abs_section (p->sec)
10112                   && bfd_is_abs_section (p->sec->output_section))
10113                 {
10114                   /* Input section has been discarded, either because
10115                      it is a copy of a linkonce section or due to
10116                      linker script /DISCARD/, so we'll be discarding
10117                      the relocs too.  */
10118                 }
10119               else if (p->count != 0)
10120                 {
10121                   asection *srel = elf_section_data (p->sec)->sreloc;
10122                   if (p->ifunc)
10123                     srel = htab->elf.irelplt;
10124                   srel->size += p->count * sizeof (Elf64_External_Rela);
10125                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10126                     info->flags |= DF_TEXTREL;
10127                 }
10128             }
10129         }
10130
10131       lgot_ents = elf_local_got_ents (ibfd);
10132       if (!lgot_ents)
10133         continue;
10134
10135       symtab_hdr = &elf_symtab_hdr (ibfd);
10136       locsymcount = symtab_hdr->sh_info;
10137       end_lgot_ents = lgot_ents + locsymcount;
10138       local_plt = (struct plt_entry **) end_lgot_ents;
10139       end_local_plt = local_plt + locsymcount;
10140       lgot_masks = (unsigned char *) end_local_plt;
10141       s = ppc64_elf_tdata (ibfd)->got;
10142       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10143         {
10144           struct got_entry **pent, *ent;
10145
10146           pent = lgot_ents;
10147           while ((ent = *pent) != NULL)
10148             if (ent->got.refcount > 0)
10149               {
10150                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10151                   {
10152                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10153                     *pent = ent->next;
10154                   }
10155                 else
10156                   {
10157                     unsigned int ent_size = 8;
10158                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10159
10160                     ent->got.offset = s->size;
10161                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10162                       {
10163                         ent_size *= 2;
10164                         rel_size *= 2;
10165                       }
10166                     s->size += ent_size;
10167                     if ((*lgot_masks & PLT_IFUNC) != 0)
10168                       {
10169                         htab->elf.irelplt->size += rel_size;
10170                         htab->got_reli_size += rel_size;
10171                       }
10172                     else if (bfd_link_pic (info))
10173                       {
10174                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10175                         srel->size += rel_size;
10176                       }
10177                     pent = &ent->next;
10178                   }
10179               }
10180             else
10181               *pent = ent->next;
10182         }
10183
10184       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10185       for (; local_plt < end_local_plt; ++local_plt)
10186         {
10187           struct plt_entry *ent;
10188
10189           for (ent = *local_plt; ent != NULL; ent = ent->next)
10190             if (ent->plt.refcount > 0)
10191               {
10192                 s = htab->elf.iplt;
10193                 ent->plt.offset = s->size;
10194                 s->size += PLT_ENTRY_SIZE (htab);
10195
10196                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10197               }
10198             else
10199               ent->plt.offset = (bfd_vma) -1;
10200         }
10201     }
10202
10203   /* Allocate global sym .plt and .got entries, and space for global
10204      sym dynamic relocs.  */
10205   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10206   /* Stash the end of glink branch table.  */
10207   if (htab->glink != NULL)
10208     htab->glink->rawsize = htab->glink->size;
10209
10210   if (!htab->opd_abi && !bfd_link_pic (info))
10211     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10212
10213   first_tlsld = NULL;
10214   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10215     {
10216       struct got_entry *ent;
10217
10218       if (!is_ppc64_elf (ibfd))
10219         continue;
10220
10221       ent = ppc64_tlsld_got (ibfd);
10222       if (ent->got.refcount > 0)
10223         {
10224           if (!htab->do_multi_toc && first_tlsld != NULL)
10225             {
10226               ent->is_indirect = TRUE;
10227               ent->got.ent = first_tlsld;
10228             }
10229           else
10230             {
10231               if (first_tlsld == NULL)
10232                 first_tlsld = ent;
10233               s = ppc64_elf_tdata (ibfd)->got;
10234               ent->got.offset = s->size;
10235               ent->owner = ibfd;
10236               s->size += 16;
10237               if (bfd_link_pic (info))
10238                 {
10239                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10240                   srel->size += sizeof (Elf64_External_Rela);
10241                 }
10242             }
10243         }
10244       else
10245         ent->got.offset = (bfd_vma) -1;
10246     }
10247
10248   /* We now have determined the sizes of the various dynamic sections.
10249      Allocate memory for them.  */
10250   relocs = FALSE;
10251   for (s = dynobj->sections; s != NULL; s = s->next)
10252     {
10253       if ((s->flags & SEC_LINKER_CREATED) == 0)
10254         continue;
10255
10256       if (s == htab->brlt || s == htab->relbrlt)
10257         /* These haven't been allocated yet;  don't strip.  */
10258         continue;
10259       else if (s == htab->elf.sgot
10260                || s == htab->elf.splt
10261                || s == htab->elf.iplt
10262                || s == htab->glink
10263                || s == htab->elf.sdynbss
10264                || s == htab->elf.sdynrelro)
10265         {
10266           /* Strip this section if we don't need it; see the
10267              comment below.  */
10268         }
10269       else if (s == htab->glink_eh_frame)
10270         {
10271           if (!bfd_is_abs_section (s->output_section))
10272             /* Not sized yet.  */
10273             continue;
10274         }
10275       else if (CONST_STRNEQ (s->name, ".rela"))
10276         {
10277           if (s->size != 0)
10278             {
10279               if (s != htab->elf.srelplt)
10280                 relocs = TRUE;
10281
10282               /* We use the reloc_count field as a counter if we need
10283                  to copy relocs into the output file.  */
10284               s->reloc_count = 0;
10285             }
10286         }
10287       else
10288         {
10289           /* It's not one of our sections, so don't allocate space.  */
10290           continue;
10291         }
10292
10293       if (s->size == 0)
10294         {
10295           /* If we don't need this section, strip it from the
10296              output file.  This is mostly to handle .rela.bss and
10297              .rela.plt.  We must create both sections in
10298              create_dynamic_sections, because they must be created
10299              before the linker maps input sections to output
10300              sections.  The linker does that before
10301              adjust_dynamic_symbol is called, and it is that
10302              function which decides whether anything needs to go
10303              into these sections.  */
10304           s->flags |= SEC_EXCLUDE;
10305           continue;
10306         }
10307
10308       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10309         continue;
10310
10311       /* Allocate memory for the section contents.  We use bfd_zalloc
10312          here in case unused entries are not reclaimed before the
10313          section's contents are written out.  This should not happen,
10314          but this way if it does we get a R_PPC64_NONE reloc in .rela
10315          sections instead of garbage.
10316          We also rely on the section contents being zero when writing
10317          the GOT and .dynrelro.  */
10318       s->contents = bfd_zalloc (dynobj, s->size);
10319       if (s->contents == NULL)
10320         return FALSE;
10321     }
10322
10323   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10324     {
10325       if (!is_ppc64_elf (ibfd))
10326         continue;
10327
10328       s = ppc64_elf_tdata (ibfd)->got;
10329       if (s != NULL && s != htab->elf.sgot)
10330         {
10331           if (s->size == 0)
10332             s->flags |= SEC_EXCLUDE;
10333           else
10334             {
10335               s->contents = bfd_zalloc (ibfd, s->size);
10336               if (s->contents == NULL)
10337                 return FALSE;
10338             }
10339         }
10340       s = ppc64_elf_tdata (ibfd)->relgot;
10341       if (s != NULL)
10342         {
10343           if (s->size == 0)
10344             s->flags |= SEC_EXCLUDE;
10345           else
10346             {
10347               s->contents = bfd_zalloc (ibfd, s->size);
10348               if (s->contents == NULL)
10349                 return FALSE;
10350               relocs = TRUE;
10351               s->reloc_count = 0;
10352             }
10353         }
10354     }
10355
10356   if (htab->elf.dynamic_sections_created)
10357     {
10358       bfd_boolean tls_opt;
10359
10360       /* Add some entries to the .dynamic section.  We fill in the
10361          values later, in ppc64_elf_finish_dynamic_sections, but we
10362          must add the entries now so that we get the correct size for
10363          the .dynamic section.  The DT_DEBUG entry is filled in by the
10364          dynamic linker and used by the debugger.  */
10365 #define add_dynamic_entry(TAG, VAL) \
10366   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10367
10368       if (bfd_link_executable (info))
10369         {
10370           if (!add_dynamic_entry (DT_DEBUG, 0))
10371             return FALSE;
10372         }
10373
10374       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10375         {
10376           if (!add_dynamic_entry (DT_PLTGOT, 0)
10377               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10378               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10379               || !add_dynamic_entry (DT_JMPREL, 0)
10380               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10381             return FALSE;
10382         }
10383
10384       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10385         {
10386           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10387               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10388             return FALSE;
10389         }
10390
10391       tls_opt = (htab->params->tls_get_addr_opt
10392                  && htab->tls_get_addr_fd != NULL
10393                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10394       if (tls_opt || !htab->opd_abi)
10395         {
10396           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10397             return FALSE;
10398         }
10399
10400       if (relocs)
10401         {
10402           if (!add_dynamic_entry (DT_RELA, 0)
10403               || !add_dynamic_entry (DT_RELASZ, 0)
10404               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10405             return FALSE;
10406
10407           /* If any dynamic relocs apply to a read-only section,
10408              then we need a DT_TEXTREL entry.  */
10409           if ((info->flags & DF_TEXTREL) == 0)
10410             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10411
10412           if ((info->flags & DF_TEXTREL) != 0)
10413             {
10414               if (!add_dynamic_entry (DT_TEXTREL, 0))
10415                 return FALSE;
10416             }
10417         }
10418     }
10419 #undef add_dynamic_entry
10420
10421   return TRUE;
10422 }
10423
10424 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10425
10426 static bfd_boolean
10427 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10428 {
10429   if (h->plt.plist != NULL
10430       && !h->def_regular
10431       && !h->pointer_equality_needed)
10432     return FALSE;
10433
10434   return _bfd_elf_hash_symbol (h);
10435 }
10436
10437 /* Determine the type of stub needed, if any, for a call.  */
10438
10439 static inline enum ppc_stub_type
10440 ppc_type_of_stub (asection *input_sec,
10441                   const Elf_Internal_Rela *rel,
10442                   struct ppc_link_hash_entry **hash,
10443                   struct plt_entry **plt_ent,
10444                   bfd_vma destination,
10445                   unsigned long local_off)
10446 {
10447   struct ppc_link_hash_entry *h = *hash;
10448   bfd_vma location;
10449   bfd_vma branch_offset;
10450   bfd_vma max_branch_offset;
10451   enum elf_ppc64_reloc_type r_type;
10452
10453   if (h != NULL)
10454     {
10455       struct plt_entry *ent;
10456       struct ppc_link_hash_entry *fdh = h;
10457       if (h->oh != NULL
10458           && h->oh->is_func_descriptor)
10459         {
10460           fdh = ppc_follow_link (h->oh);
10461           *hash = fdh;
10462         }
10463
10464       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10465         if (ent->addend == rel->r_addend
10466             && ent->plt.offset != (bfd_vma) -1)
10467           {
10468             *plt_ent = ent;
10469             return ppc_stub_plt_call;
10470           }
10471
10472       /* Here, we know we don't have a plt entry.  If we don't have a
10473          either a defined function descriptor or a defined entry symbol
10474          in a regular object file, then it is pointless trying to make
10475          any other type of stub.  */
10476       if (!is_static_defined (&fdh->elf)
10477           && !is_static_defined (&h->elf))
10478         return ppc_stub_none;
10479     }
10480   else if (elf_local_got_ents (input_sec->owner) != NULL)
10481     {
10482       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10483       struct plt_entry **local_plt = (struct plt_entry **)
10484         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10485       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10486
10487       if (local_plt[r_symndx] != NULL)
10488         {
10489           struct plt_entry *ent;
10490
10491           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10492             if (ent->addend == rel->r_addend
10493                 && ent->plt.offset != (bfd_vma) -1)
10494               {
10495                 *plt_ent = ent;
10496                 return ppc_stub_plt_call;
10497               }
10498         }
10499     }
10500
10501   /* Determine where the call point is.  */
10502   location = (input_sec->output_offset
10503               + input_sec->output_section->vma
10504               + rel->r_offset);
10505
10506   branch_offset = destination - location;
10507   r_type = ELF64_R_TYPE (rel->r_info);
10508
10509   /* Determine if a long branch stub is needed.  */
10510   max_branch_offset = 1 << 25;
10511   if (r_type != R_PPC64_REL24)
10512     max_branch_offset = 1 << 15;
10513
10514   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10515     /* We need a stub.  Figure out whether a long_branch or plt_branch
10516        is needed later.  */
10517     return ppc_stub_long_branch;
10518
10519   return ppc_stub_none;
10520 }
10521
10522 /* With power7 weakly ordered memory model, it is possible for ld.so
10523    to update a plt entry in one thread and have another thread see a
10524    stale zero toc entry.  To avoid this we need some sort of acquire
10525    barrier in the call stub.  One solution is to make the load of the
10526    toc word seem to appear to depend on the load of the function entry
10527    word.  Another solution is to test for r2 being zero, and branch to
10528    the appropriate glink entry if so.
10529
10530    .    fake dep barrier        compare
10531    .    ld 12,xxx(2)            ld 12,xxx(2)
10532    .    mtctr 12                mtctr 12
10533    .    xor 11,12,12            ld 2,xxx+8(2)
10534    .    add 2,2,11              cmpldi 2,0
10535    .    ld 2,xxx+8(2)           bnectr+
10536    .    bctr                    b <glink_entry>
10537
10538    The solution involving the compare turns out to be faster, so
10539    that's what we use unless the branch won't reach.  */
10540
10541 #define ALWAYS_USE_FAKE_DEP 0
10542 #define ALWAYS_EMIT_R2SAVE 0
10543
10544 #define PPC_LO(v) ((v) & 0xffff)
10545 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10546 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10547
10548 static inline unsigned int
10549 plt_stub_size (struct ppc_link_hash_table *htab,
10550                struct ppc_stub_hash_entry *stub_entry,
10551                bfd_vma off)
10552 {
10553   unsigned size = 12;
10554
10555   if (ALWAYS_EMIT_R2SAVE
10556       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10557     size += 4;
10558   if (PPC_HA (off) != 0)
10559     size += 4;
10560   if (htab->opd_abi)
10561     {
10562       size += 4;
10563       if (htab->params->plt_static_chain)
10564         size += 4;
10565       if (htab->params->plt_thread_safe
10566           && htab->elf.dynamic_sections_created
10567           && stub_entry->h != NULL
10568           && stub_entry->h->elf.dynindx != -1)
10569         size += 8;
10570       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10571         size += 4;
10572     }
10573   if (stub_entry->h != NULL
10574       && (stub_entry->h == htab->tls_get_addr_fd
10575           || stub_entry->h == htab->tls_get_addr)
10576       && htab->params->tls_get_addr_opt)
10577     {
10578       size += 7 * 4;
10579       if (ALWAYS_EMIT_R2SAVE
10580           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10581         size += 6 * 4;
10582     }
10583   return size;
10584 }
10585
10586 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10587    then return the padding needed to do so.  */
10588 static inline unsigned int
10589 plt_stub_pad (struct ppc_link_hash_table *htab,
10590               struct ppc_stub_hash_entry *stub_entry,
10591               bfd_vma plt_off)
10592 {
10593   int stub_align = 1 << htab->params->plt_stub_align;
10594   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10595   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10596
10597   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10598       > ((stub_size - 1) & -stub_align))
10599     return stub_align - (stub_off & (stub_align - 1));
10600   return 0;
10601 }
10602
10603 /* Build a .plt call stub.  */
10604
10605 static inline bfd_byte *
10606 build_plt_stub (struct ppc_link_hash_table *htab,
10607                 struct ppc_stub_hash_entry *stub_entry,
10608                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10609 {
10610   bfd *obfd = htab->params->stub_bfd;
10611   bfd_boolean plt_load_toc = htab->opd_abi;
10612   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10613   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10614                                  && htab->elf.dynamic_sections_created
10615                                  && stub_entry->h != NULL
10616                                  && stub_entry->h->elf.dynindx != -1);
10617   bfd_boolean use_fake_dep = plt_thread_safe;
10618   bfd_vma cmp_branch_off = 0;
10619
10620   if (!ALWAYS_USE_FAKE_DEP
10621       && plt_load_toc
10622       && plt_thread_safe
10623       && !((stub_entry->h == htab->tls_get_addr_fd
10624             || stub_entry->h == htab->tls_get_addr)
10625            && htab->params->tls_get_addr_opt))
10626     {
10627       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10628       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10629                           / PLT_ENTRY_SIZE (htab));
10630       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10631       bfd_vma to, from;
10632
10633       if (pltindex > 32768)
10634         glinkoff += (pltindex - 32768) * 4;
10635       to = (glinkoff
10636             + htab->glink->output_offset
10637             + htab->glink->output_section->vma);
10638       from = (p - stub_entry->group->stub_sec->contents
10639               + 4 * (ALWAYS_EMIT_R2SAVE
10640                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10641               + 4 * (PPC_HA (offset) != 0)
10642               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10643                      != PPC_HA (offset))
10644               + 4 * (plt_static_chain != 0)
10645               + 20
10646               + stub_entry->group->stub_sec->output_offset
10647               + stub_entry->group->stub_sec->output_section->vma);
10648       cmp_branch_off = to - from;
10649       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10650     }
10651
10652   if (PPC_HA (offset) != 0)
10653     {
10654       if (r != NULL)
10655         {
10656           if (ALWAYS_EMIT_R2SAVE
10657               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10658             r[0].r_offset += 4;
10659           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10660           r[1].r_offset = r[0].r_offset + 4;
10661           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10662           r[1].r_addend = r[0].r_addend;
10663           if (plt_load_toc)
10664             {
10665               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10666                 {
10667                   r[2].r_offset = r[1].r_offset + 4;
10668                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10669                   r[2].r_addend = r[0].r_addend;
10670                 }
10671               else
10672                 {
10673                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10674                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10675                   r[2].r_addend = r[0].r_addend + 8;
10676                   if (plt_static_chain)
10677                     {
10678                       r[3].r_offset = r[2].r_offset + 4;
10679                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10680                       r[3].r_addend = r[0].r_addend + 16;
10681                     }
10682                 }
10683             }
10684         }
10685       if (ALWAYS_EMIT_R2SAVE
10686           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10687         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10688       if (plt_load_toc)
10689         {
10690           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10691           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10692         }
10693       else
10694         {
10695           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10696           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10697         }
10698       if (plt_load_toc
10699           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10700         {
10701           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10702           offset = 0;
10703         }
10704       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10705       if (plt_load_toc)
10706         {
10707           if (use_fake_dep)
10708             {
10709               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10710               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10711             }
10712           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10713           if (plt_static_chain)
10714             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10715         }
10716     }
10717   else
10718     {
10719       if (r != NULL)
10720         {
10721           if (ALWAYS_EMIT_R2SAVE
10722               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10723             r[0].r_offset += 4;
10724           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10725           if (plt_load_toc)
10726             {
10727               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10728                 {
10729                   r[1].r_offset = r[0].r_offset + 4;
10730                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10731                   r[1].r_addend = r[0].r_addend;
10732                 }
10733               else
10734                 {
10735                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10736                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10737                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10738                   if (plt_static_chain)
10739                     {
10740                       r[2].r_offset = r[1].r_offset + 4;
10741                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10742                       r[2].r_addend = r[0].r_addend + 8;
10743                     }
10744                 }
10745             }
10746         }
10747       if (ALWAYS_EMIT_R2SAVE
10748           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10749         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10750       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10751       if (plt_load_toc
10752           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10753         {
10754           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10755           offset = 0;
10756         }
10757       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10758       if (plt_load_toc)
10759         {
10760           if (use_fake_dep)
10761             {
10762               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10763               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10764             }
10765           if (plt_static_chain)
10766             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10767           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10768         }
10769     }
10770   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10771     {
10772       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10773       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10774       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10775     }
10776   else
10777     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10778   return p;
10779 }
10780
10781 /* Build a special .plt call stub for __tls_get_addr.  */
10782
10783 #define LD_R11_0R3      0xe9630000
10784 #define LD_R12_0R3      0xe9830000
10785 #define MR_R0_R3        0x7c601b78
10786 #define CMPDI_R11_0     0x2c2b0000
10787 #define ADD_R3_R12_R13  0x7c6c6a14
10788 #define BEQLR           0x4d820020
10789 #define MR_R3_R0        0x7c030378
10790 #define STD_R11_0R1     0xf9610000
10791 #define BCTRL           0x4e800421
10792 #define LD_R11_0R1      0xe9610000
10793 #define MTLR_R11        0x7d6803a6
10794
10795 static inline bfd_byte *
10796 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10797                          struct ppc_stub_hash_entry *stub_entry,
10798                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10799 {
10800   bfd *obfd = htab->params->stub_bfd;
10801
10802   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10803   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10804   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10805   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10806   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10807   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10808   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10809   if (r != NULL)
10810     r[0].r_offset += 7 * 4;
10811   if (!ALWAYS_EMIT_R2SAVE
10812       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10813     return build_plt_stub (htab, stub_entry, p, offset, r);
10814
10815   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10816   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10817
10818   if (r != NULL)
10819     r[0].r_offset += 2 * 4;
10820   p = build_plt_stub (htab, stub_entry, p, offset, r);
10821   bfd_put_32 (obfd, BCTRL, p - 4);
10822
10823   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10824   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10825   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10826   bfd_put_32 (obfd, BLR, p),                    p += 4;
10827
10828   return p;
10829 }
10830
10831 static Elf_Internal_Rela *
10832 get_relocs (asection *sec, int count)
10833 {
10834   Elf_Internal_Rela *relocs;
10835   struct bfd_elf_section_data *elfsec_data;
10836
10837   elfsec_data = elf_section_data (sec);
10838   relocs = elfsec_data->relocs;
10839   if (relocs == NULL)
10840     {
10841       bfd_size_type relsize;
10842       relsize = sec->reloc_count * sizeof (*relocs);
10843       relocs = bfd_alloc (sec->owner, relsize);
10844       if (relocs == NULL)
10845         return NULL;
10846       elfsec_data->relocs = relocs;
10847       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10848                                           sizeof (Elf_Internal_Shdr));
10849       if (elfsec_data->rela.hdr == NULL)
10850         return NULL;
10851       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10852                                         * sizeof (Elf64_External_Rela));
10853       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10854       sec->reloc_count = 0;
10855     }
10856   relocs += sec->reloc_count;
10857   sec->reloc_count += count;
10858   return relocs;
10859 }
10860
10861 static bfd_vma
10862 get_r2off (struct bfd_link_info *info,
10863            struct ppc_stub_hash_entry *stub_entry)
10864 {
10865   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10866   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10867
10868   if (r2off == 0)
10869     {
10870       /* Support linking -R objects.  Get the toc pointer from the
10871          opd entry.  */
10872       char buf[8];
10873       if (!htab->opd_abi)
10874         return r2off;
10875       asection *opd = stub_entry->h->elf.root.u.def.section;
10876       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10877
10878       if (strcmp (opd->name, ".opd") != 0
10879           || opd->reloc_count != 0)
10880         {
10881           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10882                                   stub_entry->h->elf.root.root.string);
10883           bfd_set_error (bfd_error_bad_value);
10884           return (bfd_vma) -1;
10885         }
10886       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10887         return (bfd_vma) -1;
10888       r2off = bfd_get_64 (opd->owner, buf);
10889       r2off -= elf_gp (info->output_bfd);
10890     }
10891   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10892   return r2off;
10893 }
10894
10895 static bfd_boolean
10896 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10897 {
10898   struct ppc_stub_hash_entry *stub_entry;
10899   struct ppc_branch_hash_entry *br_entry;
10900   struct bfd_link_info *info;
10901   struct ppc_link_hash_table *htab;
10902   bfd_byte *loc;
10903   bfd_byte *p;
10904   bfd_vma dest, off;
10905   int size;
10906   Elf_Internal_Rela *r;
10907   asection *plt;
10908
10909   /* Massage our args to the form they really have.  */
10910   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10911   info = in_arg;
10912
10913   htab = ppc_hash_table (info);
10914   if (htab == NULL)
10915     return FALSE;
10916
10917   /* Make a note of the offset within the stubs for this entry.  */
10918   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10919   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10920
10921   htab->stub_count[stub_entry->stub_type - 1] += 1;
10922   switch (stub_entry->stub_type)
10923     {
10924     case ppc_stub_long_branch:
10925     case ppc_stub_long_branch_r2off:
10926       /* Branches are relative.  This is where we are going to.  */
10927       dest = (stub_entry->target_value
10928               + stub_entry->target_section->output_offset
10929               + stub_entry->target_section->output_section->vma);
10930       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10931       off = dest;
10932
10933       /* And this is where we are coming from.  */
10934       off -= (stub_entry->stub_offset
10935               + stub_entry->group->stub_sec->output_offset
10936               + stub_entry->group->stub_sec->output_section->vma);
10937
10938       size = 4;
10939       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10940         {
10941           bfd_vma r2off = get_r2off (info, stub_entry);
10942
10943           if (r2off == (bfd_vma) -1)
10944             {
10945               htab->stub_error = TRUE;
10946               return FALSE;
10947             }
10948           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10949           loc += 4;
10950           size = 8;
10951           if (PPC_HA (r2off) != 0)
10952             {
10953               bfd_put_32 (htab->params->stub_bfd,
10954                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10955               loc += 4;
10956               size += 4;
10957             }
10958           if (PPC_LO (r2off) != 0)
10959             {
10960               bfd_put_32 (htab->params->stub_bfd,
10961                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10962               loc += 4;
10963               size += 4;
10964             }
10965           off -= size - 4;
10966         }
10967       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10968
10969       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10970         {
10971           info->callbacks->einfo
10972             (_("%P: long branch stub `%s' offset overflow\n"),
10973              stub_entry->root.string);
10974           htab->stub_error = TRUE;
10975           return FALSE;
10976         }
10977
10978       if (info->emitrelocations)
10979         {
10980           r = get_relocs (stub_entry->group->stub_sec, 1);
10981           if (r == NULL)
10982             return FALSE;
10983           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10984           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10985           r->r_addend = dest;
10986           if (stub_entry->h != NULL)
10987             {
10988               struct elf_link_hash_entry **hashes;
10989               unsigned long symndx;
10990               struct ppc_link_hash_entry *h;
10991
10992               hashes = elf_sym_hashes (htab->params->stub_bfd);
10993               if (hashes == NULL)
10994                 {
10995                   bfd_size_type hsize;
10996
10997                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10998                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10999                   if (hashes == NULL)
11000                     return FALSE;
11001                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11002                   htab->stub_globals = 1;
11003                 }
11004               symndx = htab->stub_globals++;
11005               h = stub_entry->h;
11006               hashes[symndx] = &h->elf;
11007               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11008               if (h->oh != NULL && h->oh->is_func)
11009                 h = ppc_follow_link (h->oh);
11010               if (h->elf.root.u.def.section != stub_entry->target_section)
11011                 /* H is an opd symbol.  The addend must be zero.  */
11012                 r->r_addend = 0;
11013               else
11014                 {
11015                   off = (h->elf.root.u.def.value
11016                          + h->elf.root.u.def.section->output_offset
11017                          + h->elf.root.u.def.section->output_section->vma);
11018                   r->r_addend -= off;
11019                 }
11020             }
11021         }
11022       break;
11023
11024     case ppc_stub_plt_branch:
11025     case ppc_stub_plt_branch_r2off:
11026       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11027                                          stub_entry->root.string + 9,
11028                                          FALSE, FALSE);
11029       if (br_entry == NULL)
11030         {
11031           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
11032                                   stub_entry->root.string);
11033           htab->stub_error = TRUE;
11034           return FALSE;
11035         }
11036
11037       dest = (stub_entry->target_value
11038               + stub_entry->target_section->output_offset
11039               + stub_entry->target_section->output_section->vma);
11040       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11041         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11042
11043       bfd_put_64 (htab->brlt->owner, dest,
11044                   htab->brlt->contents + br_entry->offset);
11045
11046       if (br_entry->iter == htab->stub_iteration)
11047         {
11048           br_entry->iter = 0;
11049
11050           if (htab->relbrlt != NULL)
11051             {
11052               /* Create a reloc for the branch lookup table entry.  */
11053               Elf_Internal_Rela rela;
11054               bfd_byte *rl;
11055
11056               rela.r_offset = (br_entry->offset
11057                                + htab->brlt->output_offset
11058                                + htab->brlt->output_section->vma);
11059               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11060               rela.r_addend = dest;
11061
11062               rl = htab->relbrlt->contents;
11063               rl += (htab->relbrlt->reloc_count++
11064                      * sizeof (Elf64_External_Rela));
11065               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11066             }
11067           else if (info->emitrelocations)
11068             {
11069               r = get_relocs (htab->brlt, 1);
11070               if (r == NULL)
11071                 return FALSE;
11072               /* brlt, being SEC_LINKER_CREATED does not go through the
11073                  normal reloc processing.  Symbols and offsets are not
11074                  translated from input file to output file form, so
11075                  set up the offset per the output file.  */
11076               r->r_offset = (br_entry->offset
11077                              + htab->brlt->output_offset
11078                              + htab->brlt->output_section->vma);
11079               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11080               r->r_addend = dest;
11081             }
11082         }
11083
11084       dest = (br_entry->offset
11085               + htab->brlt->output_offset
11086               + htab->brlt->output_section->vma);
11087
11088       off = (dest
11089              - elf_gp (htab->brlt->output_section->owner)
11090              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11091
11092       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11093         {
11094           info->callbacks->einfo
11095             (_("%P: linkage table error against `%T'\n"),
11096              stub_entry->root.string);
11097           bfd_set_error (bfd_error_bad_value);
11098           htab->stub_error = TRUE;
11099           return FALSE;
11100         }
11101
11102       if (info->emitrelocations)
11103         {
11104           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11105           if (r == NULL)
11106             return FALSE;
11107           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11108           if (bfd_big_endian (info->output_bfd))
11109             r[0].r_offset += 2;
11110           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11111             r[0].r_offset += 4;
11112           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11113           r[0].r_addend = dest;
11114           if (PPC_HA (off) != 0)
11115             {
11116               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11117               r[1].r_offset = r[0].r_offset + 4;
11118               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11119               r[1].r_addend = r[0].r_addend;
11120             }
11121         }
11122
11123       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11124         {
11125           if (PPC_HA (off) != 0)
11126             {
11127               size = 16;
11128               bfd_put_32 (htab->params->stub_bfd,
11129                           ADDIS_R12_R2 | PPC_HA (off), loc);
11130               loc += 4;
11131               bfd_put_32 (htab->params->stub_bfd,
11132                           LD_R12_0R12 | PPC_LO (off), loc);
11133             }
11134           else
11135             {
11136               size = 12;
11137               bfd_put_32 (htab->params->stub_bfd,
11138                           LD_R12_0R2 | PPC_LO (off), loc);
11139             }
11140         }
11141       else
11142         {
11143           bfd_vma r2off = get_r2off (info, stub_entry);
11144
11145           if (r2off == (bfd_vma) -1)
11146             {
11147               htab->stub_error = TRUE;
11148               return FALSE;
11149             }
11150
11151           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11152           loc += 4;
11153           size = 16;
11154           if (PPC_HA (off) != 0)
11155             {
11156               size += 4;
11157               bfd_put_32 (htab->params->stub_bfd,
11158                           ADDIS_R12_R2 | PPC_HA (off), loc);
11159               loc += 4;
11160               bfd_put_32 (htab->params->stub_bfd,
11161                           LD_R12_0R12 | PPC_LO (off), loc);
11162             }
11163           else
11164             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11165
11166           if (PPC_HA (r2off) != 0)
11167             {
11168               size += 4;
11169               loc += 4;
11170               bfd_put_32 (htab->params->stub_bfd,
11171                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11172             }
11173           if (PPC_LO (r2off) != 0)
11174             {
11175               size += 4;
11176               loc += 4;
11177               bfd_put_32 (htab->params->stub_bfd,
11178                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11179             }
11180         }
11181       loc += 4;
11182       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11183       loc += 4;
11184       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11185       break;
11186
11187     case ppc_stub_plt_call:
11188     case ppc_stub_plt_call_r2save:
11189       if (stub_entry->h != NULL
11190           && stub_entry->h->is_func_descriptor
11191           && stub_entry->h->oh != NULL)
11192         {
11193           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11194
11195           /* If the old-ABI "dot-symbol" is undefined make it weak so
11196              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11197           if (fh->elf.root.type == bfd_link_hash_undefined
11198               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11199                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11200             fh->elf.root.type = bfd_link_hash_undefweak;
11201         }
11202
11203       /* Now build the stub.  */
11204       dest = stub_entry->plt_ent->plt.offset & ~1;
11205       if (dest >= (bfd_vma) -2)
11206         abort ();
11207
11208       plt = htab->elf.splt;
11209       if (!htab->elf.dynamic_sections_created
11210           || stub_entry->h == NULL
11211           || stub_entry->h->elf.dynindx == -1)
11212         plt = htab->elf.iplt;
11213
11214       dest += plt->output_offset + plt->output_section->vma;
11215
11216       if (stub_entry->h == NULL
11217           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11218         {
11219           Elf_Internal_Rela rela;
11220           bfd_byte *rl;
11221
11222           rela.r_offset = dest;
11223           if (htab->opd_abi)
11224             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11225           else
11226             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11227           rela.r_addend = (stub_entry->target_value
11228                            + stub_entry->target_section->output_offset
11229                            + stub_entry->target_section->output_section->vma);
11230
11231           rl = (htab->elf.irelplt->contents
11232                 + (htab->elf.irelplt->reloc_count++
11233                    * sizeof (Elf64_External_Rela)));
11234           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11235           stub_entry->plt_ent->plt.offset |= 1;
11236           htab->local_ifunc_resolver = 1;
11237         }
11238
11239       off = (dest
11240              - elf_gp (plt->output_section->owner)
11241              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11242
11243       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11244         {
11245           info->callbacks->einfo
11246             /* xgettext:c-format */
11247             (_("%P: linkage table error against `%T'\n"),
11248              stub_entry->h != NULL
11249              ? stub_entry->h->elf.root.root.string
11250              : "<local sym>");
11251           bfd_set_error (bfd_error_bad_value);
11252           htab->stub_error = TRUE;
11253           return FALSE;
11254         }
11255
11256       if (htab->params->plt_stub_align != 0)
11257         {
11258           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11259
11260           stub_entry->group->stub_sec->size += pad;
11261           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11262           loc += pad;
11263         }
11264
11265       r = NULL;
11266       if (info->emitrelocations)
11267         {
11268           r = get_relocs (stub_entry->group->stub_sec,
11269                           ((PPC_HA (off) != 0)
11270                            + (htab->opd_abi
11271                               ? 2 + (htab->params->plt_static_chain
11272                                      && PPC_HA (off + 16) == PPC_HA (off))
11273                               : 1)));
11274           if (r == NULL)
11275             return FALSE;
11276           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11277           if (bfd_big_endian (info->output_bfd))
11278             r[0].r_offset += 2;
11279           r[0].r_addend = dest;
11280         }
11281       if (stub_entry->h != NULL
11282           && (stub_entry->h == htab->tls_get_addr_fd
11283               || stub_entry->h == htab->tls_get_addr)
11284           && htab->params->tls_get_addr_opt)
11285         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11286       else
11287         p = build_plt_stub (htab, stub_entry, loc, off, r);
11288       size = p - loc;
11289       break;
11290
11291     case ppc_stub_save_res:
11292       return TRUE;
11293
11294     default:
11295       BFD_FAIL ();
11296       return FALSE;
11297     }
11298
11299   stub_entry->group->stub_sec->size += size;
11300
11301   if (htab->params->emit_stub_syms)
11302     {
11303       struct elf_link_hash_entry *h;
11304       size_t len1, len2;
11305       char *name;
11306       const char *const stub_str[] = { "long_branch",
11307                                        "long_branch_r2off",
11308                                        "plt_branch",
11309                                        "plt_branch_r2off",
11310                                        "plt_call",
11311                                        "plt_call" };
11312
11313       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11314       len2 = strlen (stub_entry->root.string);
11315       name = bfd_malloc (len1 + len2 + 2);
11316       if (name == NULL)
11317         return FALSE;
11318       memcpy (name, stub_entry->root.string, 9);
11319       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11320       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11321       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11322       if (h == NULL)
11323         return FALSE;
11324       if (h->root.type == bfd_link_hash_new)
11325         {
11326           h->root.type = bfd_link_hash_defined;
11327           h->root.u.def.section = stub_entry->group->stub_sec;
11328           h->root.u.def.value = stub_entry->stub_offset;
11329           h->ref_regular = 1;
11330           h->def_regular = 1;
11331           h->ref_regular_nonweak = 1;
11332           h->forced_local = 1;
11333           h->non_elf = 0;
11334           h->root.linker_def = 1;
11335         }
11336     }
11337
11338   return TRUE;
11339 }
11340
11341 /* As above, but don't actually build the stub.  Just bump offset so
11342    we know stub section sizes, and select plt_branch stubs where
11343    long_branch stubs won't do.  */
11344
11345 static bfd_boolean
11346 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11347 {
11348   struct ppc_stub_hash_entry *stub_entry;
11349   struct bfd_link_info *info;
11350   struct ppc_link_hash_table *htab;
11351   bfd_vma off;
11352   int size;
11353
11354   /* Massage our args to the form they really have.  */
11355   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11356   info = in_arg;
11357
11358   htab = ppc_hash_table (info);
11359   if (htab == NULL)
11360     return FALSE;
11361
11362   if (stub_entry->h != NULL
11363       && stub_entry->h->save_res
11364       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11365       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11366     {
11367       /* Don't make stubs to out-of-line register save/restore
11368          functions.  Instead, emit copies of the functions.  */
11369       stub_entry->group->needs_save_res = 1;
11370       stub_entry->stub_type = ppc_stub_save_res;
11371       return TRUE;
11372     }
11373
11374   if (stub_entry->stub_type == ppc_stub_plt_call
11375       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11376     {
11377       asection *plt;
11378       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11379       if (off >= (bfd_vma) -2)
11380         abort ();
11381       plt = htab->elf.splt;
11382       if (!htab->elf.dynamic_sections_created
11383           || stub_entry->h == NULL
11384           || stub_entry->h->elf.dynindx == -1)
11385         plt = htab->elf.iplt;
11386       off += (plt->output_offset
11387               + plt->output_section->vma
11388               - elf_gp (plt->output_section->owner)
11389               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11390
11391       size = plt_stub_size (htab, stub_entry, off);
11392       if (stub_entry->h != NULL
11393           && (stub_entry->h == htab->tls_get_addr_fd
11394               || stub_entry->h == htab->tls_get_addr)
11395           && htab->params->tls_get_addr_opt
11396           && (ALWAYS_EMIT_R2SAVE
11397               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11398         stub_entry->group->tls_get_addr_opt_bctrl
11399           = stub_entry->group->stub_sec->size + size - 5 * 4;
11400
11401       if (htab->params->plt_stub_align)
11402         size += plt_stub_pad (htab, stub_entry, off);
11403       if (info->emitrelocations)
11404         {
11405           stub_entry->group->stub_sec->reloc_count
11406             += ((PPC_HA (off) != 0)
11407                 + (htab->opd_abi
11408                    ? 2 + (htab->params->plt_static_chain
11409                           && PPC_HA (off + 16) == PPC_HA (off))
11410                    : 1));
11411           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11412         }
11413     }
11414   else
11415     {
11416       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11417          variants.  */
11418       bfd_vma r2off = 0;
11419       bfd_vma local_off = 0;
11420
11421       off = (stub_entry->target_value
11422              + stub_entry->target_section->output_offset
11423              + stub_entry->target_section->output_section->vma);
11424       off -= (stub_entry->group->stub_sec->size
11425               + stub_entry->group->stub_sec->output_offset
11426               + stub_entry->group->stub_sec->output_section->vma);
11427
11428       /* Reset the stub type from the plt variant in case we now
11429          can reach with a shorter stub.  */
11430       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11431         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11432
11433       size = 4;
11434       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11435         {
11436           r2off = get_r2off (info, stub_entry);
11437           if (r2off == (bfd_vma) -1)
11438             {
11439               htab->stub_error = TRUE;
11440               return FALSE;
11441             }
11442           size = 8;
11443           if (PPC_HA (r2off) != 0)
11444             size += 4;
11445           if (PPC_LO (r2off) != 0)
11446             size += 4;
11447           off -= size - 4;
11448         }
11449
11450       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11451
11452       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11453          Do the same for -R objects without function descriptors.  */
11454       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11455           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11456               && r2off == 0
11457               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11458         {
11459           struct ppc_branch_hash_entry *br_entry;
11460
11461           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11462                                              stub_entry->root.string + 9,
11463                                              TRUE, FALSE);
11464           if (br_entry == NULL)
11465             {
11466               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11467                                       stub_entry->root.string);
11468               htab->stub_error = TRUE;
11469               return FALSE;
11470             }
11471
11472           if (br_entry->iter != htab->stub_iteration)
11473             {
11474               br_entry->iter = htab->stub_iteration;
11475               br_entry->offset = htab->brlt->size;
11476               htab->brlt->size += 8;
11477
11478               if (htab->relbrlt != NULL)
11479                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11480               else if (info->emitrelocations)
11481                 {
11482                   htab->brlt->reloc_count += 1;
11483                   htab->brlt->flags |= SEC_RELOC;
11484                 }
11485             }
11486
11487           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11488           off = (br_entry->offset
11489                  + htab->brlt->output_offset
11490                  + htab->brlt->output_section->vma
11491                  - elf_gp (htab->brlt->output_section->owner)
11492                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11493
11494           if (info->emitrelocations)
11495             {
11496               stub_entry->group->stub_sec->reloc_count
11497                 += 1 + (PPC_HA (off) != 0);
11498               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11499             }
11500
11501           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11502             {
11503               size = 12;
11504               if (PPC_HA (off) != 0)
11505                 size = 16;
11506             }
11507           else
11508             {
11509               size = 16;
11510               if (PPC_HA (off) != 0)
11511                 size += 4;
11512
11513               if (PPC_HA (r2off) != 0)
11514                 size += 4;
11515               if (PPC_LO (r2off) != 0)
11516                 size += 4;
11517             }
11518         }
11519       else if (info->emitrelocations)
11520         {
11521           stub_entry->group->stub_sec->reloc_count += 1;
11522           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11523         }
11524     }
11525
11526   stub_entry->group->stub_sec->size += size;
11527   return TRUE;
11528 }
11529
11530 /* Set up various things so that we can make a list of input sections
11531    for each output section included in the link.  Returns -1 on error,
11532    0 when no stubs will be needed, and 1 on success.  */
11533
11534 int
11535 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11536 {
11537   unsigned int id;
11538   bfd_size_type amt;
11539   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11540
11541   if (htab == NULL)
11542     return -1;
11543
11544   htab->sec_info_arr_size = bfd_get_next_section_id ();
11545   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11546   htab->sec_info = bfd_zmalloc (amt);
11547   if (htab->sec_info == NULL)
11548     return -1;
11549
11550   /* Set toc_off for com, und, abs and ind sections.  */
11551   for (id = 0; id < 3; id++)
11552     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11553
11554   return 1;
11555 }
11556
11557 /* Set up for first pass at multitoc partitioning.  */
11558
11559 void
11560 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11561 {
11562   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11563
11564   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11565   htab->toc_bfd = NULL;
11566   htab->toc_first_sec = NULL;
11567 }
11568
11569 /* The linker repeatedly calls this function for each TOC input section
11570    and linker generated GOT section.  Group input bfds such that the toc
11571    within a group is less than 64k in size.  */
11572
11573 bfd_boolean
11574 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11575 {
11576   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11577   bfd_vma addr, off, limit;
11578
11579   if (htab == NULL)
11580     return FALSE;
11581
11582   if (!htab->second_toc_pass)
11583     {
11584       /* Keep track of the first .toc or .got section for this input bfd.  */
11585       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11586
11587       if (new_bfd)
11588         {
11589           htab->toc_bfd = isec->owner;
11590           htab->toc_first_sec = isec;
11591         }
11592
11593       addr = isec->output_offset + isec->output_section->vma;
11594       off = addr - htab->toc_curr;
11595       limit = 0x80008000;
11596       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11597         limit = 0x10000;
11598       if (off + isec->size > limit)
11599         {
11600           addr = (htab->toc_first_sec->output_offset
11601                   + htab->toc_first_sec->output_section->vma);
11602           htab->toc_curr = addr;
11603           htab->toc_curr &= -TOC_BASE_ALIGN;
11604         }
11605
11606       /* toc_curr is the base address of this toc group.  Set elf_gp
11607          for the input section to be the offset relative to the
11608          output toc base plus 0x8000.  Making the input elf_gp an
11609          offset allows us to move the toc as a whole without
11610          recalculating input elf_gp.  */
11611       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11612       off += TOC_BASE_OFF;
11613
11614       /* Die if someone uses a linker script that doesn't keep input
11615          file .toc and .got together.  */
11616       if (new_bfd
11617           && elf_gp (isec->owner) != 0
11618           && elf_gp (isec->owner) != off)
11619         return FALSE;
11620
11621       elf_gp (isec->owner) = off;
11622       return TRUE;
11623     }
11624
11625   /* During the second pass toc_first_sec points to the start of
11626      a toc group, and toc_curr is used to track the old elf_gp.
11627      We use toc_bfd to ensure we only look at each bfd once.  */
11628   if (htab->toc_bfd == isec->owner)
11629     return TRUE;
11630   htab->toc_bfd = isec->owner;
11631
11632   if (htab->toc_first_sec == NULL
11633       || htab->toc_curr != elf_gp (isec->owner))
11634     {
11635       htab->toc_curr = elf_gp (isec->owner);
11636       htab->toc_first_sec = isec;
11637     }
11638   addr = (htab->toc_first_sec->output_offset
11639           + htab->toc_first_sec->output_section->vma);
11640   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11641   elf_gp (isec->owner) = off;
11642
11643   return TRUE;
11644 }
11645
11646 /* Called via elf_link_hash_traverse to merge GOT entries for global
11647    symbol H.  */
11648
11649 static bfd_boolean
11650 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11651 {
11652   if (h->root.type == bfd_link_hash_indirect)
11653     return TRUE;
11654
11655   merge_got_entries (&h->got.glist);
11656
11657   return TRUE;
11658 }
11659
11660 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11661    symbol H.  */
11662
11663 static bfd_boolean
11664 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11665 {
11666   struct got_entry *gent;
11667
11668   if (h->root.type == bfd_link_hash_indirect)
11669     return TRUE;
11670
11671   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11672     if (!gent->is_indirect)
11673       allocate_got (h, (struct bfd_link_info *) inf, gent);
11674   return TRUE;
11675 }
11676
11677 /* Called on the first multitoc pass after the last call to
11678    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11679    entries.  */
11680
11681 bfd_boolean
11682 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11683 {
11684   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11685   struct bfd *ibfd, *ibfd2;
11686   bfd_boolean done_something;
11687
11688   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11689
11690   if (!htab->do_multi_toc)
11691     return FALSE;
11692
11693   /* Merge global sym got entries within a toc group.  */
11694   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11695
11696   /* And tlsld_got.  */
11697   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11698     {
11699       struct got_entry *ent, *ent2;
11700
11701       if (!is_ppc64_elf (ibfd))
11702         continue;
11703
11704       ent = ppc64_tlsld_got (ibfd);
11705       if (!ent->is_indirect
11706           && ent->got.offset != (bfd_vma) -1)
11707         {
11708           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11709             {
11710               if (!is_ppc64_elf (ibfd2))
11711                 continue;
11712
11713               ent2 = ppc64_tlsld_got (ibfd2);
11714               if (!ent2->is_indirect
11715                   && ent2->got.offset != (bfd_vma) -1
11716                   && elf_gp (ibfd2) == elf_gp (ibfd))
11717                 {
11718                   ent2->is_indirect = TRUE;
11719                   ent2->got.ent = ent;
11720                 }
11721             }
11722         }
11723     }
11724
11725   /* Zap sizes of got sections.  */
11726   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11727   htab->elf.irelplt->size -= htab->got_reli_size;
11728   htab->got_reli_size = 0;
11729
11730   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11731     {
11732       asection *got, *relgot;
11733
11734       if (!is_ppc64_elf (ibfd))
11735         continue;
11736
11737       got = ppc64_elf_tdata (ibfd)->got;
11738       if (got != NULL)
11739         {
11740           got->rawsize = got->size;
11741           got->size = 0;
11742           relgot = ppc64_elf_tdata (ibfd)->relgot;
11743           relgot->rawsize = relgot->size;
11744           relgot->size = 0;
11745         }
11746     }
11747
11748   /* Now reallocate the got, local syms first.  We don't need to
11749      allocate section contents again since we never increase size.  */
11750   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11751     {
11752       struct got_entry **lgot_ents;
11753       struct got_entry **end_lgot_ents;
11754       struct plt_entry **local_plt;
11755       struct plt_entry **end_local_plt;
11756       unsigned char *lgot_masks;
11757       bfd_size_type locsymcount;
11758       Elf_Internal_Shdr *symtab_hdr;
11759       asection *s;
11760
11761       if (!is_ppc64_elf (ibfd))
11762         continue;
11763
11764       lgot_ents = elf_local_got_ents (ibfd);
11765       if (!lgot_ents)
11766         continue;
11767
11768       symtab_hdr = &elf_symtab_hdr (ibfd);
11769       locsymcount = symtab_hdr->sh_info;
11770       end_lgot_ents = lgot_ents + locsymcount;
11771       local_plt = (struct plt_entry **) end_lgot_ents;
11772       end_local_plt = local_plt + locsymcount;
11773       lgot_masks = (unsigned char *) end_local_plt;
11774       s = ppc64_elf_tdata (ibfd)->got;
11775       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11776         {
11777           struct got_entry *ent;
11778
11779           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11780             {
11781               unsigned int ent_size = 8;
11782               unsigned int rel_size = sizeof (Elf64_External_Rela);
11783
11784               ent->got.offset = s->size;
11785               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11786                 {
11787                   ent_size *= 2;
11788                   rel_size *= 2;
11789                 }
11790               s->size += ent_size;
11791               if ((*lgot_masks & PLT_IFUNC) != 0)
11792                 {
11793                   htab->elf.irelplt->size += rel_size;
11794                   htab->got_reli_size += rel_size;
11795                 }
11796               else if (bfd_link_pic (info))
11797                 {
11798                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11799                   srel->size += rel_size;
11800                 }
11801             }
11802         }
11803     }
11804
11805   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11806
11807   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11808     {
11809       struct got_entry *ent;
11810
11811       if (!is_ppc64_elf (ibfd))
11812         continue;
11813
11814       ent = ppc64_tlsld_got (ibfd);
11815       if (!ent->is_indirect
11816           && ent->got.offset != (bfd_vma) -1)
11817         {
11818           asection *s = ppc64_elf_tdata (ibfd)->got;
11819           ent->got.offset = s->size;
11820           s->size += 16;
11821           if (bfd_link_pic (info))
11822             {
11823               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11824               srel->size += sizeof (Elf64_External_Rela);
11825             }
11826         }
11827     }
11828
11829   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11830   if (!done_something)
11831     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11832       {
11833         asection *got;
11834
11835         if (!is_ppc64_elf (ibfd))
11836           continue;
11837
11838         got = ppc64_elf_tdata (ibfd)->got;
11839         if (got != NULL)
11840           {
11841             done_something = got->rawsize != got->size;
11842             if (done_something)
11843               break;
11844           }
11845       }
11846
11847   if (done_something)
11848     (*htab->params->layout_sections_again) ();
11849
11850   /* Set up for second pass over toc sections to recalculate elf_gp
11851      on input sections.  */
11852   htab->toc_bfd = NULL;
11853   htab->toc_first_sec = NULL;
11854   htab->second_toc_pass = TRUE;
11855   return done_something;
11856 }
11857
11858 /* Called after second pass of multitoc partitioning.  */
11859
11860 void
11861 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11862 {
11863   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11864
11865   /* After the second pass, toc_curr tracks the TOC offset used
11866      for code sections below in ppc64_elf_next_input_section.  */
11867   htab->toc_curr = TOC_BASE_OFF;
11868 }
11869
11870 /* No toc references were found in ISEC.  If the code in ISEC makes no
11871    calls, then there's no need to use toc adjusting stubs when branching
11872    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11873    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11874    needed, and 2 if a cyclical call-graph was found but no other reason
11875    for a stub was detected.  If called from the top level, a return of
11876    2 means the same as a return of 0.  */
11877
11878 static int
11879 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11880 {
11881   int ret;
11882
11883   /* Mark this section as checked.  */
11884   isec->call_check_done = 1;
11885
11886   /* We know none of our code bearing sections will need toc stubs.  */
11887   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11888     return 0;
11889
11890   if (isec->size == 0)
11891     return 0;
11892
11893   if (isec->output_section == NULL)
11894     return 0;
11895
11896   ret = 0;
11897   if (isec->reloc_count != 0)
11898     {
11899       Elf_Internal_Rela *relstart, *rel;
11900       Elf_Internal_Sym *local_syms;
11901       struct ppc_link_hash_table *htab;
11902
11903       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11904                                             info->keep_memory);
11905       if (relstart == NULL)
11906         return -1;
11907
11908       /* Look for branches to outside of this section.  */
11909       local_syms = NULL;
11910       htab = ppc_hash_table (info);
11911       if (htab == NULL)
11912         return -1;
11913
11914       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11915         {
11916           enum elf_ppc64_reloc_type r_type;
11917           unsigned long r_symndx;
11918           struct elf_link_hash_entry *h;
11919           struct ppc_link_hash_entry *eh;
11920           Elf_Internal_Sym *sym;
11921           asection *sym_sec;
11922           struct _opd_sec_data *opd;
11923           bfd_vma sym_value;
11924           bfd_vma dest;
11925
11926           r_type = ELF64_R_TYPE (rel->r_info);
11927           if (r_type != R_PPC64_REL24
11928               && r_type != R_PPC64_REL14
11929               && r_type != R_PPC64_REL14_BRTAKEN
11930               && r_type != R_PPC64_REL14_BRNTAKEN)
11931             continue;
11932
11933           r_symndx = ELF64_R_SYM (rel->r_info);
11934           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11935                           isec->owner))
11936             {
11937               ret = -1;
11938               break;
11939             }
11940
11941           /* Calls to dynamic lib functions go through a plt call stub
11942              that uses r2.  */
11943           eh = (struct ppc_link_hash_entry *) h;
11944           if (eh != NULL
11945               && (eh->elf.plt.plist != NULL
11946                   || (eh->oh != NULL
11947                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11948             {
11949               ret = 1;
11950               break;
11951             }
11952
11953           if (sym_sec == NULL)
11954             /* Ignore other undefined symbols.  */
11955             continue;
11956
11957           /* Assume branches to other sections not included in the
11958              link need stubs too, to cover -R and absolute syms.  */
11959           if (sym_sec->output_section == NULL)
11960             {
11961               ret = 1;
11962               break;
11963             }
11964
11965           if (h == NULL)
11966             sym_value = sym->st_value;
11967           else
11968             {
11969               if (h->root.type != bfd_link_hash_defined
11970                   && h->root.type != bfd_link_hash_defweak)
11971                 abort ();
11972               sym_value = h->root.u.def.value;
11973             }
11974           sym_value += rel->r_addend;
11975
11976           /* If this branch reloc uses an opd sym, find the code section.  */
11977           opd = get_opd_info (sym_sec);
11978           if (opd != NULL)
11979             {
11980               if (h == NULL && opd->adjust != NULL)
11981                 {
11982                   long adjust;
11983
11984                   adjust = opd->adjust[OPD_NDX (sym_value)];
11985                   if (adjust == -1)
11986                     /* Assume deleted functions won't ever be called.  */
11987                     continue;
11988                   sym_value += adjust;
11989                 }
11990
11991               dest = opd_entry_value (sym_sec, sym_value,
11992                                       &sym_sec, NULL, FALSE);
11993               if (dest == (bfd_vma) -1)
11994                 continue;
11995             }
11996           else
11997             dest = (sym_value
11998                     + sym_sec->output_offset
11999                     + sym_sec->output_section->vma);
12000
12001           /* Ignore branch to self.  */
12002           if (sym_sec == isec)
12003             continue;
12004
12005           /* If the called function uses the toc, we need a stub.  */
12006           if (sym_sec->has_toc_reloc
12007               || sym_sec->makes_toc_func_call)
12008             {
12009               ret = 1;
12010               break;
12011             }
12012
12013           /* Assume any branch that needs a long branch stub might in fact
12014              need a plt_branch stub.  A plt_branch stub uses r2.  */
12015           else if (dest - (isec->output_offset
12016                            + isec->output_section->vma
12017                            + rel->r_offset) + (1 << 25)
12018                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12019                                                              ? h->other
12020                                                              : sym->st_other))
12021             {
12022               ret = 1;
12023               break;
12024             }
12025
12026           /* If calling back to a section in the process of being
12027              tested, we can't say for sure that no toc adjusting stubs
12028              are needed, so don't return zero.  */
12029           else if (sym_sec->call_check_in_progress)
12030             ret = 2;
12031
12032           /* Branches to another section that itself doesn't have any TOC
12033              references are OK.  Recursively call ourselves to check.  */
12034           else if (!sym_sec->call_check_done)
12035             {
12036               int recur;
12037
12038               /* Mark current section as indeterminate, so that other
12039                  sections that call back to current won't be marked as
12040                  known.  */
12041               isec->call_check_in_progress = 1;
12042               recur = toc_adjusting_stub_needed (info, sym_sec);
12043               isec->call_check_in_progress = 0;
12044
12045               if (recur != 0)
12046                 {
12047                   ret = recur;
12048                   if (recur != 2)
12049                     break;
12050                 }
12051             }
12052         }
12053
12054       if (local_syms != NULL
12055           && (elf_symtab_hdr (isec->owner).contents
12056               != (unsigned char *) local_syms))
12057         free (local_syms);
12058       if (elf_section_data (isec)->relocs != relstart)
12059         free (relstart);
12060     }
12061
12062   if ((ret & 1) == 0
12063       && isec->map_head.s != NULL
12064       && (strcmp (isec->output_section->name, ".init") == 0
12065           || strcmp (isec->output_section->name, ".fini") == 0))
12066     {
12067       if (isec->map_head.s->has_toc_reloc
12068           || isec->map_head.s->makes_toc_func_call)
12069         ret = 1;
12070       else if (!isec->map_head.s->call_check_done)
12071         {
12072           int recur;
12073           isec->call_check_in_progress = 1;
12074           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12075           isec->call_check_in_progress = 0;
12076           if (recur != 0)
12077             ret = recur;
12078         }
12079     }
12080
12081   if (ret == 1)
12082     isec->makes_toc_func_call = 1;
12083
12084   return ret;
12085 }
12086
12087 /* The linker repeatedly calls this function for each input section,
12088    in the order that input sections are linked into output sections.
12089    Build lists of input sections to determine groupings between which
12090    we may insert linker stubs.  */
12091
12092 bfd_boolean
12093 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12094 {
12095   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12096
12097   if (htab == NULL)
12098     return FALSE;
12099
12100   if ((isec->output_section->flags & SEC_CODE) != 0
12101       && isec->output_section->id < htab->sec_info_arr_size)
12102     {
12103       /* This happens to make the list in reverse order,
12104          which is what we want.  */
12105       htab->sec_info[isec->id].u.list
12106         = htab->sec_info[isec->output_section->id].u.list;
12107       htab->sec_info[isec->output_section->id].u.list = isec;
12108     }
12109
12110   if (htab->multi_toc_needed)
12111     {
12112       /* Analyse sections that aren't already flagged as needing a
12113          valid toc pointer.  Exclude .fixup for the linux kernel.
12114          .fixup contains branches, but only back to the function that
12115          hit an exception.  */
12116       if (!(isec->has_toc_reloc
12117             || (isec->flags & SEC_CODE) == 0
12118             || strcmp (isec->name, ".fixup") == 0
12119             || isec->call_check_done))
12120         {
12121           if (toc_adjusting_stub_needed (info, isec) < 0)
12122             return FALSE;
12123         }
12124       /* Make all sections use the TOC assigned for this object file.
12125          This will be wrong for pasted sections;  We fix that in
12126          check_pasted_section().  */
12127       if (elf_gp (isec->owner) != 0)
12128         htab->toc_curr = elf_gp (isec->owner);
12129     }
12130
12131   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12132   return TRUE;
12133 }
12134
12135 /* Check that all .init and .fini sections use the same toc, if they
12136    have toc relocs.  */
12137
12138 static bfd_boolean
12139 check_pasted_section (struct bfd_link_info *info, const char *name)
12140 {
12141   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12142
12143   if (o != NULL)
12144     {
12145       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12146       bfd_vma toc_off = 0;
12147       asection *i;
12148
12149       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12150         if (i->has_toc_reloc)
12151           {
12152             if (toc_off == 0)
12153               toc_off = htab->sec_info[i->id].toc_off;
12154             else if (toc_off != htab->sec_info[i->id].toc_off)
12155               return FALSE;
12156           }
12157
12158       if (toc_off == 0)
12159         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12160           if (i->makes_toc_func_call)
12161             {
12162               toc_off = htab->sec_info[i->id].toc_off;
12163               break;
12164             }
12165
12166       /* Make sure the whole pasted function uses the same toc offset.  */
12167       if (toc_off != 0)
12168         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12169           htab->sec_info[i->id].toc_off = toc_off;
12170     }
12171   return TRUE;
12172 }
12173
12174 bfd_boolean
12175 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12176 {
12177   return (check_pasted_section (info, ".init")
12178           & check_pasted_section (info, ".fini"));
12179 }
12180
12181 /* See whether we can group stub sections together.  Grouping stub
12182    sections may result in fewer stubs.  More importantly, we need to
12183    put all .init* and .fini* stubs at the beginning of the .init or
12184    .fini output sections respectively, because glibc splits the
12185    _init and _fini functions into multiple parts.  Putting a stub in
12186    the middle of a function is not a good idea.  */
12187
12188 static bfd_boolean
12189 group_sections (struct bfd_link_info *info,
12190                 bfd_size_type stub_group_size,
12191                 bfd_boolean stubs_always_before_branch)
12192 {
12193   struct ppc_link_hash_table *htab;
12194   asection *osec;
12195   bfd_boolean suppress_size_errors;
12196
12197   htab = ppc_hash_table (info);
12198   if (htab == NULL)
12199     return FALSE;
12200
12201   suppress_size_errors = FALSE;
12202   if (stub_group_size == 1)
12203     {
12204       /* Default values.  */
12205       if (stubs_always_before_branch)
12206         stub_group_size = 0x1e00000;
12207       else
12208         stub_group_size = 0x1c00000;
12209       suppress_size_errors = TRUE;
12210     }
12211
12212   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12213     {
12214       asection *tail;
12215
12216       if (osec->id >= htab->sec_info_arr_size)
12217         continue;
12218
12219       tail = htab->sec_info[osec->id].u.list;
12220       while (tail != NULL)
12221         {
12222           asection *curr;
12223           asection *prev;
12224           bfd_size_type total;
12225           bfd_boolean big_sec;
12226           bfd_vma curr_toc;
12227           struct map_stub *group;
12228           bfd_size_type group_size;
12229
12230           curr = tail;
12231           total = tail->size;
12232           group_size = (ppc64_elf_section_data (tail) != NULL
12233                         && ppc64_elf_section_data (tail)->has_14bit_branch
12234                         ? stub_group_size >> 10 : stub_group_size);
12235
12236           big_sec = total > group_size;
12237           if (big_sec && !suppress_size_errors)
12238             /* xgettext:c-format */
12239             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12240                                 tail->owner, tail);
12241           curr_toc = htab->sec_info[tail->id].toc_off;
12242
12243           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12244                  && ((total += curr->output_offset - prev->output_offset)
12245                      < (ppc64_elf_section_data (prev) != NULL
12246                         && ppc64_elf_section_data (prev)->has_14bit_branch
12247                         ? (group_size = stub_group_size >> 10) : group_size))
12248                  && htab->sec_info[prev->id].toc_off == curr_toc)
12249             curr = prev;
12250
12251           /* OK, the size from the start of CURR to the end is less
12252              than group_size and thus can be handled by one stub
12253              section.  (or the tail section is itself larger than
12254              group_size, in which case we may be toast.)  We should
12255              really be keeping track of the total size of stubs added
12256              here, as stubs contribute to the final output section
12257              size.  That's a little tricky, and this way will only
12258              break if stubs added make the total size more than 2^25,
12259              ie. for the default stub_group_size, if stubs total more
12260              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12261           group = bfd_alloc (curr->owner, sizeof (*group));
12262           if (group == NULL)
12263             return FALSE;
12264           group->link_sec = curr;
12265           group->stub_sec = NULL;
12266           group->needs_save_res = 0;
12267           group->tls_get_addr_opt_bctrl = -1u;
12268           group->next = htab->group;
12269           htab->group = group;
12270           do
12271             {
12272               prev = htab->sec_info[tail->id].u.list;
12273               /* Set up this stub group.  */
12274               htab->sec_info[tail->id].u.group = group;
12275             }
12276           while (tail != curr && (tail = prev) != NULL);
12277
12278           /* But wait, there's more!  Input sections up to group_size
12279              bytes before the stub section can be handled by it too.
12280              Don't do this if we have a really large section after the
12281              stubs, as adding more stubs increases the chance that
12282              branches may not reach into the stub section.  */
12283           if (!stubs_always_before_branch && !big_sec)
12284             {
12285               total = 0;
12286               while (prev != NULL
12287                      && ((total += tail->output_offset - prev->output_offset)
12288                          < (ppc64_elf_section_data (prev) != NULL
12289                             && ppc64_elf_section_data (prev)->has_14bit_branch
12290                             ? (group_size = stub_group_size >> 10) : group_size))
12291                      && htab->sec_info[prev->id].toc_off == curr_toc)
12292                 {
12293                   tail = prev;
12294                   prev = htab->sec_info[tail->id].u.list;
12295                   htab->sec_info[tail->id].u.group = group;
12296                 }
12297             }
12298           tail = prev;
12299         }
12300     }
12301   return TRUE;
12302 }
12303
12304 static const unsigned char glink_eh_frame_cie[] =
12305 {
12306   0, 0, 0, 16,                          /* length.  */
12307   0, 0, 0, 0,                           /* id.  */
12308   1,                                    /* CIE version.  */
12309   'z', 'R', 0,                          /* Augmentation string.  */
12310   4,                                    /* Code alignment.  */
12311   0x78,                                 /* Data alignment.  */
12312   65,                                   /* RA reg.  */
12313   1,                                    /* Augmentation size.  */
12314   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12315   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12316 };
12317
12318 static size_t
12319 stub_eh_frame_size (struct map_stub *group, size_t align)
12320 {
12321   size_t this_size = 17;
12322   if (group->tls_get_addr_opt_bctrl != -1u)
12323     {
12324       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12325       if (to_bctrl < 64)
12326         this_size += 1;
12327       else if (to_bctrl < 256)
12328         this_size += 2;
12329       else if (to_bctrl < 65536)
12330         this_size += 3;
12331       else
12332         this_size += 5;
12333       this_size += 6;
12334     }
12335   this_size = (this_size + align - 1) & -align;
12336   return this_size;
12337 }
12338
12339 /* Stripping output sections is normally done before dynamic section
12340    symbols have been allocated.  This function is called later, and
12341    handles cases like htab->brlt which is mapped to its own output
12342    section.  */
12343
12344 static void
12345 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12346 {
12347   if (isec->size == 0
12348       && isec->output_section->size == 0
12349       && !(isec->output_section->flags & SEC_KEEP)
12350       && !bfd_section_removed_from_list (info->output_bfd,
12351                                          isec->output_section)
12352       && elf_section_data (isec->output_section)->dynindx == 0)
12353     {
12354       isec->output_section->flags |= SEC_EXCLUDE;
12355       bfd_section_list_remove (info->output_bfd, isec->output_section);
12356       info->output_bfd->section_count--;
12357     }
12358 }
12359
12360 /* Determine and set the size of the stub section for a final link.
12361
12362    The basic idea here is to examine all the relocations looking for
12363    PC-relative calls to a target that is unreachable with a "bl"
12364    instruction.  */
12365
12366 bfd_boolean
12367 ppc64_elf_size_stubs (struct bfd_link_info *info)
12368 {
12369   bfd_size_type stub_group_size;
12370   bfd_boolean stubs_always_before_branch;
12371   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12372
12373   if (htab == NULL)
12374     return FALSE;
12375
12376   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12377     htab->params->plt_thread_safe = 1;
12378   if (!htab->opd_abi)
12379     htab->params->plt_thread_safe = 0;
12380   else if (htab->params->plt_thread_safe == -1)
12381     {
12382       static const char *const thread_starter[] =
12383         {
12384           "pthread_create",
12385           /* libstdc++ */
12386           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12387           /* librt */
12388           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12389           "mq_notify", "create_timer",
12390           /* libanl */
12391           "getaddrinfo_a",
12392           /* libgomp */
12393           "GOMP_parallel",
12394           "GOMP_parallel_start",
12395           "GOMP_parallel_loop_static",
12396           "GOMP_parallel_loop_static_start",
12397           "GOMP_parallel_loop_dynamic",
12398           "GOMP_parallel_loop_dynamic_start",
12399           "GOMP_parallel_loop_guided",
12400           "GOMP_parallel_loop_guided_start",
12401           "GOMP_parallel_loop_runtime",
12402           "GOMP_parallel_loop_runtime_start",
12403           "GOMP_parallel_sections",
12404           "GOMP_parallel_sections_start",
12405           /* libgo */
12406           "__go_go",
12407         };
12408       unsigned i;
12409
12410       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12411         {
12412           struct elf_link_hash_entry *h;
12413           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12414                                     FALSE, FALSE, TRUE);
12415           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12416           if (htab->params->plt_thread_safe)
12417             break;
12418         }
12419     }
12420   stubs_always_before_branch = htab->params->group_size < 0;
12421   if (htab->params->group_size < 0)
12422     stub_group_size = -htab->params->group_size;
12423   else
12424     stub_group_size = htab->params->group_size;
12425
12426   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12427     return FALSE;
12428
12429 #define STUB_SHRINK_ITER 20
12430   /* Loop until no stubs added.  After iteration 20 of this loop we may
12431      exit on a stub section shrinking.  This is to break out of a
12432      pathological case where adding stubs on one iteration decreases
12433      section gaps (perhaps due to alignment), which then requires
12434      fewer or smaller stubs on the next iteration.  */
12435
12436   while (1)
12437     {
12438       bfd *input_bfd;
12439       unsigned int bfd_indx;
12440       struct map_stub *group;
12441
12442       htab->stub_iteration += 1;
12443
12444       for (input_bfd = info->input_bfds, bfd_indx = 0;
12445            input_bfd != NULL;
12446            input_bfd = input_bfd->link.next, bfd_indx++)
12447         {
12448           Elf_Internal_Shdr *symtab_hdr;
12449           asection *section;
12450           Elf_Internal_Sym *local_syms = NULL;
12451
12452           if (!is_ppc64_elf (input_bfd))
12453             continue;
12454
12455           /* We'll need the symbol table in a second.  */
12456           symtab_hdr = &elf_symtab_hdr (input_bfd);
12457           if (symtab_hdr->sh_info == 0)
12458             continue;
12459
12460           /* Walk over each section attached to the input bfd.  */
12461           for (section = input_bfd->sections;
12462                section != NULL;
12463                section = section->next)
12464             {
12465               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12466
12467               /* If there aren't any relocs, then there's nothing more
12468                  to do.  */
12469               if ((section->flags & SEC_RELOC) == 0
12470                   || (section->flags & SEC_ALLOC) == 0
12471                   || (section->flags & SEC_LOAD) == 0
12472                   || (section->flags & SEC_CODE) == 0
12473                   || section->reloc_count == 0)
12474                 continue;
12475
12476               /* If this section is a link-once section that will be
12477                  discarded, then don't create any stubs.  */
12478               if (section->output_section == NULL
12479                   || section->output_section->owner != info->output_bfd)
12480                 continue;
12481
12482               /* Get the relocs.  */
12483               internal_relocs
12484                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12485                                              info->keep_memory);
12486               if (internal_relocs == NULL)
12487                 goto error_ret_free_local;
12488
12489               /* Now examine each relocation.  */
12490               irela = internal_relocs;
12491               irelaend = irela + section->reloc_count;
12492               for (; irela < irelaend; irela++)
12493                 {
12494                   enum elf_ppc64_reloc_type r_type;
12495                   unsigned int r_indx;
12496                   enum ppc_stub_type stub_type;
12497                   struct ppc_stub_hash_entry *stub_entry;
12498                   asection *sym_sec, *code_sec;
12499                   bfd_vma sym_value, code_value;
12500                   bfd_vma destination;
12501                   unsigned long local_off;
12502                   bfd_boolean ok_dest;
12503                   struct ppc_link_hash_entry *hash;
12504                   struct ppc_link_hash_entry *fdh;
12505                   struct elf_link_hash_entry *h;
12506                   Elf_Internal_Sym *sym;
12507                   char *stub_name;
12508                   const asection *id_sec;
12509                   struct _opd_sec_data *opd;
12510                   struct plt_entry *plt_ent;
12511
12512                   r_type = ELF64_R_TYPE (irela->r_info);
12513                   r_indx = ELF64_R_SYM (irela->r_info);
12514
12515                   if (r_type >= R_PPC64_max)
12516                     {
12517                       bfd_set_error (bfd_error_bad_value);
12518                       goto error_ret_free_internal;
12519                     }
12520
12521                   /* Only look for stubs on branch instructions.  */
12522                   if (r_type != R_PPC64_REL24
12523                       && r_type != R_PPC64_REL14
12524                       && r_type != R_PPC64_REL14_BRTAKEN
12525                       && r_type != R_PPC64_REL14_BRNTAKEN)
12526                     continue;
12527
12528                   /* Now determine the call target, its name, value,
12529                      section.  */
12530                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12531                                   r_indx, input_bfd))
12532                     goto error_ret_free_internal;
12533                   hash = (struct ppc_link_hash_entry *) h;
12534
12535                   ok_dest = FALSE;
12536                   fdh = NULL;
12537                   sym_value = 0;
12538                   if (hash == NULL)
12539                     {
12540                       sym_value = sym->st_value;
12541                       if (sym_sec != NULL
12542                           && sym_sec->output_section != NULL)
12543                         ok_dest = TRUE;
12544                     }
12545                   else if (hash->elf.root.type == bfd_link_hash_defined
12546                            || hash->elf.root.type == bfd_link_hash_defweak)
12547                     {
12548                       sym_value = hash->elf.root.u.def.value;
12549                       if (sym_sec->output_section != NULL)
12550                         ok_dest = TRUE;
12551                     }
12552                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12553                            || hash->elf.root.type == bfd_link_hash_undefined)
12554                     {
12555                       /* Recognise an old ABI func code entry sym, and
12556                          use the func descriptor sym instead if it is
12557                          defined.  */
12558                       if (hash->elf.root.root.string[0] == '.'
12559                           && hash->oh != NULL)
12560                         {
12561                           fdh = ppc_follow_link (hash->oh);
12562                           if (fdh->elf.root.type == bfd_link_hash_defined
12563                               || fdh->elf.root.type == bfd_link_hash_defweak)
12564                             {
12565                               sym_sec = fdh->elf.root.u.def.section;
12566                               sym_value = fdh->elf.root.u.def.value;
12567                               if (sym_sec->output_section != NULL)
12568                                 ok_dest = TRUE;
12569                             }
12570                           else
12571                             fdh = NULL;
12572                         }
12573                     }
12574                   else
12575                     {
12576                       bfd_set_error (bfd_error_bad_value);
12577                       goto error_ret_free_internal;
12578                     }
12579
12580                   destination = 0;
12581                   local_off = 0;
12582                   if (ok_dest)
12583                     {
12584                       sym_value += irela->r_addend;
12585                       destination = (sym_value
12586                                      + sym_sec->output_offset
12587                                      + sym_sec->output_section->vma);
12588                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12589                                                             ? hash->elf.other
12590                                                             : sym->st_other);
12591                     }
12592
12593                   code_sec = sym_sec;
12594                   code_value = sym_value;
12595                   opd = get_opd_info (sym_sec);
12596                   if (opd != NULL)
12597                     {
12598                       bfd_vma dest;
12599
12600                       if (hash == NULL && opd->adjust != NULL)
12601                         {
12602                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12603                           if (adjust == -1)
12604                             continue;
12605                           code_value += adjust;
12606                           sym_value += adjust;
12607                         }
12608                       dest = opd_entry_value (sym_sec, sym_value,
12609                                               &code_sec, &code_value, FALSE);
12610                       if (dest != (bfd_vma) -1)
12611                         {
12612                           destination = dest;
12613                           if (fdh != NULL)
12614                             {
12615                               /* Fixup old ABI sym to point at code
12616                                  entry.  */
12617                               hash->elf.root.type = bfd_link_hash_defweak;
12618                               hash->elf.root.u.def.section = code_sec;
12619                               hash->elf.root.u.def.value = code_value;
12620                             }
12621                         }
12622                     }
12623
12624                   /* Determine what (if any) linker stub is needed.  */
12625                   plt_ent = NULL;
12626                   stub_type = ppc_type_of_stub (section, irela, &hash,
12627                                                 &plt_ent, destination,
12628                                                 local_off);
12629
12630                   if (stub_type != ppc_stub_plt_call)
12631                     {
12632                       /* Check whether we need a TOC adjusting stub.
12633                          Since the linker pastes together pieces from
12634                          different object files when creating the
12635                          _init and _fini functions, it may be that a
12636                          call to what looks like a local sym is in
12637                          fact a call needing a TOC adjustment.  */
12638                       if (code_sec != NULL
12639                           && code_sec->output_section != NULL
12640                           && (htab->sec_info[code_sec->id].toc_off
12641                               != htab->sec_info[section->id].toc_off)
12642                           && (code_sec->has_toc_reloc
12643                               || code_sec->makes_toc_func_call))
12644                         stub_type = ppc_stub_long_branch_r2off;
12645                     }
12646
12647                   if (stub_type == ppc_stub_none)
12648                     continue;
12649
12650                   /* __tls_get_addr calls might be eliminated.  */
12651                   if (stub_type != ppc_stub_plt_call
12652                       && hash != NULL
12653                       && (hash == htab->tls_get_addr
12654                           || hash == htab->tls_get_addr_fd)
12655                       && section->has_tls_reloc
12656                       && irela != internal_relocs)
12657                     {
12658                       /* Get tls info.  */
12659                       unsigned char *tls_mask;
12660
12661                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12662                                          irela - 1, input_bfd))
12663                         goto error_ret_free_internal;
12664                       if (*tls_mask != 0)
12665                         continue;
12666                     }
12667
12668                   if (stub_type == ppc_stub_plt_call)
12669                     {
12670                       if (!htab->opd_abi
12671                           && htab->params->plt_localentry0 != 0
12672                           && is_elfv2_localentry0 (&hash->elf))
12673                         htab->has_plt_localentry0 = 1;
12674                       else if (irela + 1 < irelaend
12675                                && irela[1].r_offset == irela->r_offset + 4
12676                                && (ELF64_R_TYPE (irela[1].r_info)
12677                                    == R_PPC64_TOCSAVE))
12678                         {
12679                           if (!tocsave_find (htab, INSERT,
12680                                              &local_syms, irela + 1, input_bfd))
12681                             goto error_ret_free_internal;
12682                         }
12683                       else
12684                         stub_type = ppc_stub_plt_call_r2save;
12685                     }
12686
12687                   /* Support for grouping stub sections.  */
12688                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12689
12690                   /* Get the name of this stub.  */
12691                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12692                   if (!stub_name)
12693                     goto error_ret_free_internal;
12694
12695                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12696                                                      stub_name, FALSE, FALSE);
12697                   if (stub_entry != NULL)
12698                     {
12699                       /* The proper stub has already been created.  */
12700                       free (stub_name);
12701                       if (stub_type == ppc_stub_plt_call_r2save)
12702                         stub_entry->stub_type = stub_type;
12703                       continue;
12704                     }
12705
12706                   stub_entry = ppc_add_stub (stub_name, section, info);
12707                   if (stub_entry == NULL)
12708                     {
12709                       free (stub_name);
12710                     error_ret_free_internal:
12711                       if (elf_section_data (section)->relocs == NULL)
12712                         free (internal_relocs);
12713                     error_ret_free_local:
12714                       if (local_syms != NULL
12715                           && (symtab_hdr->contents
12716                               != (unsigned char *) local_syms))
12717                         free (local_syms);
12718                       return FALSE;
12719                     }
12720
12721                   stub_entry->stub_type = stub_type;
12722                   if (stub_type != ppc_stub_plt_call
12723                       && stub_type != ppc_stub_plt_call_r2save)
12724                     {
12725                       stub_entry->target_value = code_value;
12726                       stub_entry->target_section = code_sec;
12727                     }
12728                   else
12729                     {
12730                       stub_entry->target_value = sym_value;
12731                       stub_entry->target_section = sym_sec;
12732                     }
12733                   stub_entry->h = hash;
12734                   stub_entry->plt_ent = plt_ent;
12735                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12736
12737                   if (stub_entry->h != NULL)
12738                     htab->stub_globals += 1;
12739                 }
12740
12741               /* We're done with the internal relocs, free them.  */
12742               if (elf_section_data (section)->relocs != internal_relocs)
12743                 free (internal_relocs);
12744             }
12745
12746           if (local_syms != NULL
12747               && symtab_hdr->contents != (unsigned char *) local_syms)
12748             {
12749               if (!info->keep_memory)
12750                 free (local_syms);
12751               else
12752                 symtab_hdr->contents = (unsigned char *) local_syms;
12753             }
12754         }
12755
12756       /* We may have added some stubs.  Find out the new size of the
12757          stub sections.  */
12758       for (group = htab->group; group != NULL; group = group->next)
12759         if (group->stub_sec != NULL)
12760           {
12761             asection *stub_sec = group->stub_sec;
12762
12763             if (htab->stub_iteration <= STUB_SHRINK_ITER
12764                 || stub_sec->rawsize < stub_sec->size)
12765               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12766               stub_sec->rawsize = stub_sec->size;
12767             stub_sec->size = 0;
12768             stub_sec->reloc_count = 0;
12769             stub_sec->flags &= ~SEC_RELOC;
12770           }
12771
12772       htab->brlt->size = 0;
12773       htab->brlt->reloc_count = 0;
12774       htab->brlt->flags &= ~SEC_RELOC;
12775       if (htab->relbrlt != NULL)
12776         htab->relbrlt->size = 0;
12777
12778       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12779
12780       for (group = htab->group; group != NULL; group = group->next)
12781         if (group->needs_save_res)
12782           group->stub_sec->size += htab->sfpr->size;
12783
12784       if (info->emitrelocations
12785           && htab->glink != NULL && htab->glink->size != 0)
12786         {
12787           htab->glink->reloc_count = 1;
12788           htab->glink->flags |= SEC_RELOC;
12789         }
12790
12791       if (htab->glink_eh_frame != NULL
12792           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12793           && htab->glink_eh_frame->output_section->size != 0)
12794         {
12795           size_t size = 0, align = 4;
12796
12797           for (group = htab->group; group != NULL; group = group->next)
12798             if (group->stub_sec != NULL)
12799               size += stub_eh_frame_size (group, align);
12800           if (htab->glink != NULL && htab->glink->size != 0)
12801             size += (24 + align - 1) & -align;
12802           if (size != 0)
12803             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12804           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12805           size = (size + align - 1) & -align;
12806           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12807           htab->glink_eh_frame->size = size;
12808         }
12809
12810       if (htab->params->plt_stub_align != 0)
12811         for (group = htab->group; group != NULL; group = group->next)
12812           if (group->stub_sec != NULL)
12813             group->stub_sec->size = ((group->stub_sec->size
12814                                       + (1 << htab->params->plt_stub_align) - 1)
12815                                      & -(1 << htab->params->plt_stub_align));
12816
12817       for (group = htab->group; group != NULL; group = group->next)
12818         if (group->stub_sec != NULL
12819             && group->stub_sec->rawsize != group->stub_sec->size
12820             && (htab->stub_iteration <= STUB_SHRINK_ITER
12821                 || group->stub_sec->rawsize < group->stub_sec->size))
12822           break;
12823
12824       if (group == NULL
12825           && (htab->glink_eh_frame == NULL
12826               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12827         break;
12828
12829       /* Ask the linker to do its stuff.  */
12830       (*htab->params->layout_sections_again) ();
12831     }
12832
12833   if (htab->glink_eh_frame != NULL
12834       && htab->glink_eh_frame->size != 0)
12835     {
12836       bfd_vma val;
12837       bfd_byte *p, *last_fde;
12838       size_t last_fde_len, size, align, pad;
12839       struct map_stub *group;
12840
12841       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12842       if (p == NULL)
12843         return FALSE;
12844       htab->glink_eh_frame->contents = p;
12845       last_fde = p;
12846       align = 4;
12847
12848       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12849       /* CIE length (rewrite in case little-endian).  */
12850       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12851       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12852       p += last_fde_len + 4;
12853
12854       for (group = htab->group; group != NULL; group = group->next)
12855         if (group->stub_sec != NULL)
12856           {
12857             last_fde = p;
12858             last_fde_len = stub_eh_frame_size (group, align) - 4;
12859             /* FDE length.  */
12860             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12861             p += 4;
12862             /* CIE pointer.  */
12863             val = p - htab->glink_eh_frame->contents;
12864             bfd_put_32 (htab->elf.dynobj, val, p);
12865             p += 4;
12866             /* Offset to stub section, written later.  */
12867             p += 4;
12868             /* stub section size.  */
12869             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12870             p += 4;
12871             /* Augmentation.  */
12872             p += 1;
12873             if (group->tls_get_addr_opt_bctrl != -1u)
12874               {
12875                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12876
12877                 /* This FDE needs more than just the default.
12878                    Describe __tls_get_addr_opt stub LR.  */
12879                 if (to_bctrl < 64)
12880                   *p++ = DW_CFA_advance_loc + to_bctrl;
12881                 else if (to_bctrl < 256)
12882                   {
12883                     *p++ = DW_CFA_advance_loc1;
12884                     *p++ = to_bctrl;
12885                   }
12886                 else if (to_bctrl < 65536)
12887                   {
12888                     *p++ = DW_CFA_advance_loc2;
12889                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12890                     p += 2;
12891                   }
12892                 else
12893                   {
12894                     *p++ = DW_CFA_advance_loc4;
12895                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12896                     p += 4;
12897                   }
12898                 *p++ = DW_CFA_offset_extended_sf;
12899                 *p++ = 65;
12900                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12901                 *p++ = DW_CFA_advance_loc + 4;
12902                 *p++ = DW_CFA_restore_extended;
12903                 *p++ = 65;
12904               }
12905             /* Pad.  */
12906             p = last_fde + last_fde_len + 4;
12907           }
12908       if (htab->glink != NULL && htab->glink->size != 0)
12909         {
12910           last_fde = p;
12911           last_fde_len = ((24 + align - 1) & -align) - 4;
12912           /* FDE length.  */
12913           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12914           p += 4;
12915           /* CIE pointer.  */
12916           val = p - htab->glink_eh_frame->contents;
12917           bfd_put_32 (htab->elf.dynobj, val, p);
12918           p += 4;
12919           /* Offset to .glink, written later.  */
12920           p += 4;
12921           /* .glink size.  */
12922           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12923           p += 4;
12924           /* Augmentation.  */
12925           p += 1;
12926
12927           *p++ = DW_CFA_advance_loc + 1;
12928           *p++ = DW_CFA_register;
12929           *p++ = 65;
12930           *p++ = htab->opd_abi ? 12 : 0;
12931           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12932           *p++ = DW_CFA_restore_extended;
12933           *p++ = 65;
12934           p += ((24 + align - 1) & -align) - 24;
12935         }
12936       /* Subsume any padding into the last FDE if user .eh_frame
12937          sections are aligned more than glink_eh_frame.  Otherwise any
12938          zero padding will be seen as a terminator.  */
12939       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12940       size = p - htab->glink_eh_frame->contents;
12941       pad = ((size + align - 1) & -align) - size;
12942       htab->glink_eh_frame->size = size + pad;
12943       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12944     }
12945
12946   maybe_strip_output (info, htab->brlt);
12947   if (htab->glink_eh_frame != NULL)
12948     maybe_strip_output (info, htab->glink_eh_frame);
12949
12950   return TRUE;
12951 }
12952
12953 /* Called after we have determined section placement.  If sections
12954    move, we'll be called again.  Provide a value for TOCstart.  */
12955
12956 bfd_vma
12957 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12958 {
12959   asection *s;
12960   bfd_vma TOCstart, adjust;
12961
12962   if (info != NULL)
12963     {
12964       struct elf_link_hash_entry *h;
12965       struct elf_link_hash_table *htab = elf_hash_table (info);
12966
12967       if (is_elf_hash_table (htab)
12968           && htab->hgot != NULL)
12969         h = htab->hgot;
12970       else
12971         {
12972           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12973           if (is_elf_hash_table (htab))
12974             htab->hgot = h;
12975         }
12976       if (h != NULL
12977           && h->root.type == bfd_link_hash_defined
12978           && !h->root.linker_def
12979           && (!is_elf_hash_table (htab)
12980               || h->def_regular))
12981         {
12982           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12983                       + h->root.u.def.section->output_offset
12984                       + h->root.u.def.section->output_section->vma);
12985           _bfd_set_gp_value (obfd, TOCstart);
12986           return TOCstart;
12987         }
12988     }
12989
12990   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12991      order.  The TOC starts where the first of these sections starts.  */
12992   s = bfd_get_section_by_name (obfd, ".got");
12993   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12994     s = bfd_get_section_by_name (obfd, ".toc");
12995   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12996     s = bfd_get_section_by_name (obfd, ".tocbss");
12997   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12998     s = bfd_get_section_by_name (obfd, ".plt");
12999   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13000     {
13001       /* This may happen for
13002          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13003          .toc directive
13004          o  bad linker script
13005          o --gc-sections and empty TOC sections
13006
13007          FIXME: Warn user?  */
13008
13009       /* Look for a likely section.  We probably won't even be
13010          using TOCstart.  */
13011       for (s = obfd->sections; s != NULL; s = s->next)
13012         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13013                          | SEC_EXCLUDE))
13014             == (SEC_ALLOC | SEC_SMALL_DATA))
13015           break;
13016       if (s == NULL)
13017         for (s = obfd->sections; s != NULL; s = s->next)
13018           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13019               == (SEC_ALLOC | SEC_SMALL_DATA))
13020             break;
13021       if (s == NULL)
13022         for (s = obfd->sections; s != NULL; s = s->next)
13023           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13024               == SEC_ALLOC)
13025             break;
13026       if (s == NULL)
13027         for (s = obfd->sections; s != NULL; s = s->next)
13028           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13029             break;
13030     }
13031
13032   TOCstart = 0;
13033   if (s != NULL)
13034     TOCstart = s->output_section->vma + s->output_offset;
13035
13036   /* Force alignment.  */
13037   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13038   TOCstart -= adjust;
13039   _bfd_set_gp_value (obfd, TOCstart);
13040
13041   if (info != NULL && s != NULL)
13042     {
13043       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13044
13045       if (htab != NULL)
13046         {
13047           if (htab->elf.hgot != NULL)
13048             {
13049               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13050               htab->elf.hgot->root.u.def.section = s;
13051             }
13052         }
13053       else
13054         {
13055           struct bfd_link_hash_entry *bh = NULL;
13056           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13057                                             s, TOC_BASE_OFF - adjust,
13058                                             NULL, FALSE, FALSE, &bh);
13059         }
13060     }
13061   return TOCstart;
13062 }
13063
13064 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13065    write out any global entry stubs.  */
13066
13067 static bfd_boolean
13068 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13069 {
13070   struct bfd_link_info *info;
13071   struct ppc_link_hash_table *htab;
13072   struct plt_entry *pent;
13073   asection *s;
13074
13075   if (h->root.type == bfd_link_hash_indirect)
13076     return TRUE;
13077
13078   if (!h->pointer_equality_needed)
13079     return TRUE;
13080
13081   if (h->def_regular)
13082     return TRUE;
13083
13084   info = inf;
13085   htab = ppc_hash_table (info);
13086   if (htab == NULL)
13087     return FALSE;
13088
13089   s = htab->glink;
13090   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13091     if (pent->plt.offset != (bfd_vma) -1
13092         && pent->addend == 0)
13093       {
13094         bfd_byte *p;
13095         asection *plt;
13096         bfd_vma off;
13097
13098         p = s->contents + h->root.u.def.value;
13099         plt = htab->elf.splt;
13100         if (!htab->elf.dynamic_sections_created
13101             || h->dynindx == -1)
13102           plt = htab->elf.iplt;
13103         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13104         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13105
13106         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13107           {
13108             info->callbacks->einfo
13109               (_("%P: linkage table error against `%T'\n"),
13110                h->root.root.string);
13111             bfd_set_error (bfd_error_bad_value);
13112             htab->stub_error = TRUE;
13113           }
13114
13115         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13116         if (htab->params->emit_stub_syms)
13117           {
13118             size_t len = strlen (h->root.root.string);
13119             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13120
13121             if (name == NULL)
13122               return FALSE;
13123
13124             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13125             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13126             if (h == NULL)
13127               return FALSE;
13128             if (h->root.type == bfd_link_hash_new)
13129               {
13130                 h->root.type = bfd_link_hash_defined;
13131                 h->root.u.def.section = s;
13132                 h->root.u.def.value = p - s->contents;
13133                 h->ref_regular = 1;
13134                 h->def_regular = 1;
13135                 h->ref_regular_nonweak = 1;
13136                 h->forced_local = 1;
13137                 h->non_elf = 0;
13138                 h->root.linker_def = 1;
13139               }
13140           }
13141
13142         if (PPC_HA (off) != 0)
13143           {
13144             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13145             p += 4;
13146           }
13147         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13148         p += 4;
13149         bfd_put_32 (s->owner, MTCTR_R12, p);
13150         p += 4;
13151         bfd_put_32 (s->owner, BCTR, p);
13152         break;
13153       }
13154   return TRUE;
13155 }
13156
13157 /* Build all the stubs associated with the current output file.
13158    The stubs are kept in a hash table attached to the main linker
13159    hash table.  This function is called via gldelf64ppc_finish.  */
13160
13161 bfd_boolean
13162 ppc64_elf_build_stubs (struct bfd_link_info *info,
13163                        char **stats)
13164 {
13165   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13166   struct map_stub *group;
13167   asection *stub_sec;
13168   bfd_byte *p;
13169   int stub_sec_count = 0;
13170
13171   if (htab == NULL)
13172     return FALSE;
13173
13174   /* Allocate memory to hold the linker stubs.  */
13175   for (group = htab->group; group != NULL; group = group->next)
13176     if ((stub_sec = group->stub_sec) != NULL
13177         && stub_sec->size != 0)
13178       {
13179         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13180         if (stub_sec->contents == NULL)
13181           return FALSE;
13182         stub_sec->size = 0;
13183       }
13184
13185   if (htab->glink != NULL && htab->glink->size != 0)
13186     {
13187       unsigned int indx;
13188       bfd_vma plt0;
13189
13190       /* Build the .glink plt call stub.  */
13191       if (htab->params->emit_stub_syms)
13192         {
13193           struct elf_link_hash_entry *h;
13194           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13195                                     TRUE, FALSE, FALSE);
13196           if (h == NULL)
13197             return FALSE;
13198           if (h->root.type == bfd_link_hash_new)
13199             {
13200               h->root.type = bfd_link_hash_defined;
13201               h->root.u.def.section = htab->glink;
13202               h->root.u.def.value = 8;
13203               h->ref_regular = 1;
13204               h->def_regular = 1;
13205               h->ref_regular_nonweak = 1;
13206               h->forced_local = 1;
13207               h->non_elf = 0;
13208               h->root.linker_def = 1;
13209             }
13210         }
13211       plt0 = (htab->elf.splt->output_section->vma
13212               + htab->elf.splt->output_offset
13213               - 16);
13214       if (info->emitrelocations)
13215         {
13216           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13217           if (r == NULL)
13218             return FALSE;
13219           r->r_offset = (htab->glink->output_offset
13220                          + htab->glink->output_section->vma);
13221           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13222           r->r_addend = plt0;
13223         }
13224       p = htab->glink->contents;
13225       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13226       bfd_put_64 (htab->glink->owner, plt0, p);
13227       p += 8;
13228       if (htab->opd_abi)
13229         {
13230           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13231           p += 4;
13232           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13233           p += 4;
13234           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13235           p += 4;
13236           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13237           p += 4;
13238           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13239           p += 4;
13240           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13241           p += 4;
13242           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13243           p += 4;
13244           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13245           p += 4;
13246           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13247           p += 4;
13248           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13249           p += 4;
13250         }
13251       else
13252         {
13253           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13254           p += 4;
13255           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13256           p += 4;
13257           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13258           p += 4;
13259           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13260           p += 4;
13261           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13262           p += 4;
13263           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13264           p += 4;
13265           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13266           p += 4;
13267           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13268           p += 4;
13269           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13270           p += 4;
13271           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13272           p += 4;
13273           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13274           p += 4;
13275           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13276           p += 4;
13277           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13278           p += 4;
13279         }
13280       bfd_put_32 (htab->glink->owner, BCTR, p);
13281       p += 4;
13282       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13283         {
13284           bfd_put_32 (htab->glink->owner, NOP, p);
13285           p += 4;
13286         }
13287
13288       /* Build the .glink lazy link call stubs.  */
13289       indx = 0;
13290       while (p < htab->glink->contents + htab->glink->rawsize)
13291         {
13292           if (htab->opd_abi)
13293             {
13294               if (indx < 0x8000)
13295                 {
13296                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13297                   p += 4;
13298                 }
13299               else
13300                 {
13301                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13302                   p += 4;
13303                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13304                               p);
13305                   p += 4;
13306                 }
13307             }
13308           bfd_put_32 (htab->glink->owner,
13309                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13310           indx++;
13311           p += 4;
13312         }
13313
13314       /* Build .glink global entry stubs.  */
13315       if (htab->glink->size > htab->glink->rawsize)
13316         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13317     }
13318
13319   if (htab->brlt != NULL && htab->brlt->size != 0)
13320     {
13321       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13322                                          htab->brlt->size);
13323       if (htab->brlt->contents == NULL)
13324         return FALSE;
13325     }
13326   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13327     {
13328       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13329                                             htab->relbrlt->size);
13330       if (htab->relbrlt->contents == NULL)
13331         return FALSE;
13332     }
13333
13334   /* Build the stubs as directed by the stub hash table.  */
13335   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13336
13337   for (group = htab->group; group != NULL; group = group->next)
13338     if (group->needs_save_res)
13339       {
13340         stub_sec = group->stub_sec;
13341         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13342                 htab->sfpr->size);
13343         if (htab->params->emit_stub_syms)
13344           {
13345             unsigned int i;
13346
13347             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13348               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13349                 return FALSE;
13350           }
13351         stub_sec->size += htab->sfpr->size;
13352       }
13353
13354   if (htab->relbrlt != NULL)
13355     htab->relbrlt->reloc_count = 0;
13356
13357   if (htab->params->plt_stub_align != 0)
13358     for (group = htab->group; group != NULL; group = group->next)
13359       if ((stub_sec = group->stub_sec) != NULL)
13360         stub_sec->size = ((stub_sec->size
13361                            + (1 << htab->params->plt_stub_align) - 1)
13362                           & -(1 << htab->params->plt_stub_align));
13363
13364   for (group = htab->group; group != NULL; group = group->next)
13365     if ((stub_sec = group->stub_sec) != NULL)
13366       {
13367         stub_sec_count += 1;
13368         if (stub_sec->rawsize != stub_sec->size
13369             && (htab->stub_iteration <= STUB_SHRINK_ITER
13370                 || stub_sec->rawsize < stub_sec->size))
13371           break;
13372       }
13373
13374   /* Note that the glink_eh_frame check here is not only testing that
13375      the generated size matched the calculated size but also that
13376      bfd_elf_discard_info didn't make any changes to the section.  */
13377   if (group != NULL
13378       || (htab->glink_eh_frame != NULL
13379           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13380     {
13381       htab->stub_error = TRUE;
13382       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13383     }
13384
13385   if (htab->stub_error)
13386     return FALSE;
13387
13388   if (stats != NULL)
13389     {
13390       *stats = bfd_malloc (500);
13391       if (*stats == NULL)
13392         return FALSE;
13393
13394       sprintf (*stats, _("linker stubs in %u group%s\n"
13395                          "  branch       %lu\n"
13396                          "  toc adjust   %lu\n"
13397                          "  long branch  %lu\n"
13398                          "  long toc adj %lu\n"
13399                          "  plt call     %lu\n"
13400                          "  plt call toc %lu\n"
13401                          "  global entry %lu"),
13402                stub_sec_count,
13403                stub_sec_count == 1 ? "" : "s",
13404                htab->stub_count[ppc_stub_long_branch - 1],
13405                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13406                htab->stub_count[ppc_stub_plt_branch - 1],
13407                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13408                htab->stub_count[ppc_stub_plt_call - 1],
13409                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13410                htab->stub_count[ppc_stub_global_entry - 1]);
13411     }
13412   return TRUE;
13413 }
13414
13415 /* What to do when ld finds relocations against symbols defined in
13416    discarded sections.  */
13417
13418 static unsigned int
13419 ppc64_elf_action_discarded (asection *sec)
13420 {
13421   if (strcmp (".opd", sec->name) == 0)
13422     return 0;
13423
13424   if (strcmp (".toc", sec->name) == 0)
13425     return 0;
13426
13427   if (strcmp (".toc1", sec->name) == 0)
13428     return 0;
13429
13430   return _bfd_elf_default_action_discarded (sec);
13431 }
13432
13433 /* The RELOCATE_SECTION function is called by the ELF backend linker
13434    to handle the relocations for a section.
13435
13436    The relocs are always passed as Rela structures; if the section
13437    actually uses Rel structures, the r_addend field will always be
13438    zero.
13439
13440    This function is responsible for adjust the section contents as
13441    necessary, and (if using Rela relocs and generating a
13442    relocatable output file) adjusting the reloc addend as
13443    necessary.
13444
13445    This function does not have to worry about setting the reloc
13446    address or the reloc symbol index.
13447
13448    LOCAL_SYMS is a pointer to the swapped in local symbols.
13449
13450    LOCAL_SECTIONS is an array giving the section in the input file
13451    corresponding to the st_shndx field of each local symbol.
13452
13453    The global hash table entry for the global symbols can be found
13454    via elf_sym_hashes (input_bfd).
13455
13456    When generating relocatable output, this function must handle
13457    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13458    going to be the section symbol corresponding to the output
13459    section, which means that the addend must be adjusted
13460    accordingly.  */
13461
13462 static bfd_boolean
13463 ppc64_elf_relocate_section (bfd *output_bfd,
13464                             struct bfd_link_info *info,
13465                             bfd *input_bfd,
13466                             asection *input_section,
13467                             bfd_byte *contents,
13468                             Elf_Internal_Rela *relocs,
13469                             Elf_Internal_Sym *local_syms,
13470                             asection **local_sections)
13471 {
13472   struct ppc_link_hash_table *htab;
13473   Elf_Internal_Shdr *symtab_hdr;
13474   struct elf_link_hash_entry **sym_hashes;
13475   Elf_Internal_Rela *rel;
13476   Elf_Internal_Rela *wrel;
13477   Elf_Internal_Rela *relend;
13478   Elf_Internal_Rela outrel;
13479   bfd_byte *loc;
13480   struct got_entry **local_got_ents;
13481   bfd_vma TOCstart;
13482   bfd_boolean ret = TRUE;
13483   bfd_boolean is_opd;
13484   /* Assume 'at' branch hints.  */
13485   bfd_boolean is_isa_v2 = TRUE;
13486   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13487
13488   /* Initialize howto table if needed.  */
13489   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13490     ppc_howto_init ();
13491
13492   htab = ppc_hash_table (info);
13493   if (htab == NULL)
13494     return FALSE;
13495
13496   /* Don't relocate stub sections.  */
13497   if (input_section->owner == htab->params->stub_bfd)
13498     return TRUE;
13499
13500   BFD_ASSERT (is_ppc64_elf (input_bfd));
13501
13502   local_got_ents = elf_local_got_ents (input_bfd);
13503   TOCstart = elf_gp (output_bfd);
13504   symtab_hdr = &elf_symtab_hdr (input_bfd);
13505   sym_hashes = elf_sym_hashes (input_bfd);
13506   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13507
13508   rel = wrel = relocs;
13509   relend = relocs + input_section->reloc_count;
13510   for (; rel < relend; wrel++, rel++)
13511     {
13512       enum elf_ppc64_reloc_type r_type;
13513       bfd_vma addend;
13514       bfd_reloc_status_type r;
13515       Elf_Internal_Sym *sym;
13516       asection *sec;
13517       struct elf_link_hash_entry *h_elf;
13518       struct ppc_link_hash_entry *h;
13519       struct ppc_link_hash_entry *fdh;
13520       const char *sym_name;
13521       unsigned long r_symndx, toc_symndx;
13522       bfd_vma toc_addend;
13523       unsigned char tls_mask, tls_gd, tls_type;
13524       unsigned char sym_type;
13525       bfd_vma relocation;
13526       bfd_boolean unresolved_reloc;
13527       bfd_boolean warned;
13528       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13529       unsigned int insn;
13530       unsigned int mask;
13531       struct ppc_stub_hash_entry *stub_entry;
13532       bfd_vma max_br_offset;
13533       bfd_vma from;
13534       Elf_Internal_Rela orig_rel;
13535       reloc_howto_type *howto;
13536       struct reloc_howto_struct alt_howto;
13537
13538     again:
13539       orig_rel = *rel;
13540
13541       r_type = ELF64_R_TYPE (rel->r_info);
13542       r_symndx = ELF64_R_SYM (rel->r_info);
13543
13544       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13545          symbol of the previous ADDR64 reloc.  The symbol gives us the
13546          proper TOC base to use.  */
13547       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13548           && wrel != relocs
13549           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13550           && is_opd)
13551         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13552
13553       sym = NULL;
13554       sec = NULL;
13555       h_elf = NULL;
13556       sym_name = NULL;
13557       unresolved_reloc = FALSE;
13558       warned = FALSE;
13559
13560       if (r_symndx < symtab_hdr->sh_info)
13561         {
13562           /* It's a local symbol.  */
13563           struct _opd_sec_data *opd;
13564
13565           sym = local_syms + r_symndx;
13566           sec = local_sections[r_symndx];
13567           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13568           sym_type = ELF64_ST_TYPE (sym->st_info);
13569           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13570           opd = get_opd_info (sec);
13571           if (opd != NULL && opd->adjust != NULL)
13572             {
13573               long adjust = opd->adjust[OPD_NDX (sym->st_value
13574                                                  + rel->r_addend)];
13575               if (adjust == -1)
13576                 relocation = 0;
13577               else
13578                 {
13579                   /* If this is a relocation against the opd section sym
13580                      and we have edited .opd, adjust the reloc addend so
13581                      that ld -r and ld --emit-relocs output is correct.
13582                      If it is a reloc against some other .opd symbol,
13583                      then the symbol value will be adjusted later.  */
13584                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13585                     rel->r_addend += adjust;
13586                   else
13587                     relocation += adjust;
13588                 }
13589             }
13590         }
13591       else
13592         {
13593           bfd_boolean ignored;
13594
13595           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13596                                    r_symndx, symtab_hdr, sym_hashes,
13597                                    h_elf, sec, relocation,
13598                                    unresolved_reloc, warned, ignored);
13599           sym_name = h_elf->root.root.string;
13600           sym_type = h_elf->type;
13601           if (sec != NULL
13602               && sec->owner == output_bfd
13603               && strcmp (sec->name, ".opd") == 0)
13604             {
13605               /* This is a symbol defined in a linker script.  All
13606                  such are defined in output sections, even those
13607                  defined by simple assignment from a symbol defined in
13608                  an input section.  Transfer the symbol to an
13609                  appropriate input .opd section, so that a branch to
13610                  this symbol will be mapped to the location specified
13611                  by the opd entry.  */
13612               struct bfd_link_order *lo;
13613               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13614                 if (lo->type == bfd_indirect_link_order)
13615                   {
13616                     asection *isec = lo->u.indirect.section;
13617                     if (h_elf->root.u.def.value >= isec->output_offset
13618                         && h_elf->root.u.def.value < (isec->output_offset
13619                                                       + isec->size))
13620                       {
13621                         h_elf->root.u.def.value -= isec->output_offset;
13622                         h_elf->root.u.def.section = isec;
13623                         sec = isec;
13624                         break;
13625                       }
13626                   }
13627             }
13628         }
13629       h = (struct ppc_link_hash_entry *) h_elf;
13630
13631       if (sec != NULL && discarded_section (sec))
13632         {
13633           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13634                                input_bfd, input_section,
13635                                contents + rel->r_offset);
13636           wrel->r_offset = rel->r_offset;
13637           wrel->r_info = 0;
13638           wrel->r_addend = 0;
13639
13640           /* For ld -r, remove relocations in debug sections against
13641              sections defined in discarded sections.  Not done for
13642              non-debug to preserve relocs in .eh_frame which the
13643              eh_frame editing code expects to be present.  */
13644           if (bfd_link_relocatable (info)
13645               && (input_section->flags & SEC_DEBUGGING))
13646             wrel--;
13647
13648           continue;
13649         }
13650
13651       if (bfd_link_relocatable (info))
13652         goto copy_reloc;
13653
13654       if (h != NULL && &h->elf == htab->elf.hgot)
13655         {
13656           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13657           sec = bfd_abs_section_ptr;
13658           unresolved_reloc = FALSE;
13659         }
13660
13661       /* TLS optimizations.  Replace instruction sequences and relocs
13662          based on information we collected in tls_optimize.  We edit
13663          RELOCS so that --emit-relocs will output something sensible
13664          for the final instruction stream.  */
13665       tls_mask = 0;
13666       tls_gd = 0;
13667       toc_symndx = 0;
13668       if (h != NULL)
13669         tls_mask = h->tls_mask;
13670       else if (local_got_ents != NULL)
13671         {
13672           struct plt_entry **local_plt = (struct plt_entry **)
13673             (local_got_ents + symtab_hdr->sh_info);
13674           unsigned char *lgot_masks = (unsigned char *)
13675             (local_plt + symtab_hdr->sh_info);
13676           tls_mask = lgot_masks[r_symndx];
13677         }
13678       if (tls_mask == 0
13679           && (r_type == R_PPC64_TLS
13680               || r_type == R_PPC64_TLSGD
13681               || r_type == R_PPC64_TLSLD))
13682         {
13683           /* Check for toc tls entries.  */
13684           unsigned char *toc_tls;
13685
13686           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13687                              &local_syms, rel, input_bfd))
13688             return FALSE;
13689
13690           if (toc_tls)
13691             tls_mask = *toc_tls;
13692         }
13693
13694       /* Check that tls relocs are used with tls syms, and non-tls
13695          relocs are used with non-tls syms.  */
13696       if (r_symndx != STN_UNDEF
13697           && r_type != R_PPC64_NONE
13698           && (h == NULL
13699               || h->elf.root.type == bfd_link_hash_defined
13700               || h->elf.root.type == bfd_link_hash_defweak)
13701           && (IS_PPC64_TLS_RELOC (r_type)
13702               != (sym_type == STT_TLS
13703                   || (sym_type == STT_SECTION
13704                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13705         {
13706           if (tls_mask != 0
13707               && (r_type == R_PPC64_TLS
13708                   || r_type == R_PPC64_TLSGD
13709                   || r_type == R_PPC64_TLSLD))
13710             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13711             ;
13712           else
13713             info->callbacks->einfo
13714               (!IS_PPC64_TLS_RELOC (r_type)
13715                /* xgettext:c-format */
13716                ? _("%H: %s used with TLS symbol `%T'\n")
13717                /* xgettext:c-format */
13718                : _("%H: %s used with non-TLS symbol `%T'\n"),
13719                input_bfd, input_section, rel->r_offset,
13720                ppc64_elf_howto_table[r_type]->name,
13721                sym_name);
13722         }
13723
13724       /* Ensure reloc mapping code below stays sane.  */
13725       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13726           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13727           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13728           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13729           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13730           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13731           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13732           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13733           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13734           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13735         abort ();
13736
13737       switch (r_type)
13738         {
13739         default:
13740           break;
13741
13742         case R_PPC64_LO_DS_OPT:
13743           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13744           if ((insn & (0x3f << 26)) != 58u << 26)
13745             abort ();
13746           insn += (14u << 26) - (58u << 26);
13747           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13748           r_type = R_PPC64_TOC16_LO;
13749           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13750           break;
13751
13752         case R_PPC64_TOC16:
13753         case R_PPC64_TOC16_LO:
13754         case R_PPC64_TOC16_DS:
13755         case R_PPC64_TOC16_LO_DS:
13756           {
13757             /* Check for toc tls entries.  */
13758             unsigned char *toc_tls;
13759             int retval;
13760
13761             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13762                                    &local_syms, rel, input_bfd);
13763             if (retval == 0)
13764               return FALSE;
13765
13766             if (toc_tls)
13767               {
13768                 tls_mask = *toc_tls;
13769                 if (r_type == R_PPC64_TOC16_DS
13770                     || r_type == R_PPC64_TOC16_LO_DS)
13771                   {
13772                     if (tls_mask != 0
13773                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13774                       goto toctprel;
13775                   }
13776                 else
13777                   {
13778                     /* If we found a GD reloc pair, then we might be
13779                        doing a GD->IE transition.  */
13780                     if (retval == 2)
13781                       {
13782                         tls_gd = TLS_TPRELGD;
13783                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13784                           goto tls_ldgd_opt;
13785                       }
13786                     else if (retval == 3)
13787                       {
13788                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13789                           goto tls_ldgd_opt;
13790                       }
13791                   }
13792               }
13793           }
13794           break;
13795
13796         case R_PPC64_GOT_TPREL16_HI:
13797         case R_PPC64_GOT_TPREL16_HA:
13798           if (tls_mask != 0
13799               && (tls_mask & TLS_TPREL) == 0)
13800             {
13801               rel->r_offset -= d_offset;
13802               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13803               r_type = R_PPC64_NONE;
13804               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13805             }
13806           break;
13807
13808         case R_PPC64_GOT_TPREL16_DS:
13809         case R_PPC64_GOT_TPREL16_LO_DS:
13810           if (tls_mask != 0
13811               && (tls_mask & TLS_TPREL) == 0)
13812             {
13813             toctprel:
13814               insn = bfd_get_32 (input_bfd,
13815                                  contents + rel->r_offset - d_offset);
13816               insn &= 31 << 21;
13817               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13818               bfd_put_32 (input_bfd, insn,
13819                           contents + rel->r_offset - d_offset);
13820               r_type = R_PPC64_TPREL16_HA;
13821               if (toc_symndx != 0)
13822                 {
13823                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13824                   rel->r_addend = toc_addend;
13825                   /* We changed the symbol.  Start over in order to
13826                      get h, sym, sec etc. right.  */
13827                   goto again;
13828                 }
13829               else
13830                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13831             }
13832           break;
13833
13834         case R_PPC64_TLS:
13835           if (tls_mask != 0
13836               && (tls_mask & TLS_TPREL) == 0)
13837             {
13838               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13839               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13840               if (insn == 0)
13841                 abort ();
13842               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13843               /* Was PPC64_TLS which sits on insn boundary, now
13844                  PPC64_TPREL16_LO which is at low-order half-word.  */
13845               rel->r_offset += d_offset;
13846               r_type = R_PPC64_TPREL16_LO;
13847               if (toc_symndx != 0)
13848                 {
13849                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13850                   rel->r_addend = toc_addend;
13851                   /* We changed the symbol.  Start over in order to
13852                      get h, sym, sec etc. right.  */
13853                   goto again;
13854                 }
13855               else
13856                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13857             }
13858           break;
13859
13860         case R_PPC64_GOT_TLSGD16_HI:
13861         case R_PPC64_GOT_TLSGD16_HA:
13862           tls_gd = TLS_TPRELGD;
13863           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13864             goto tls_gdld_hi;
13865           break;
13866
13867         case R_PPC64_GOT_TLSLD16_HI:
13868         case R_PPC64_GOT_TLSLD16_HA:
13869           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13870             {
13871             tls_gdld_hi:
13872               if ((tls_mask & tls_gd) != 0)
13873                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13874                           + R_PPC64_GOT_TPREL16_DS);
13875               else
13876                 {
13877                   rel->r_offset -= d_offset;
13878                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13879                   r_type = R_PPC64_NONE;
13880                 }
13881               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13882             }
13883           break;
13884
13885         case R_PPC64_GOT_TLSGD16:
13886         case R_PPC64_GOT_TLSGD16_LO:
13887           tls_gd = TLS_TPRELGD;
13888           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13889             goto tls_ldgd_opt;
13890           break;
13891
13892         case R_PPC64_GOT_TLSLD16:
13893         case R_PPC64_GOT_TLSLD16_LO:
13894           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13895             {
13896               unsigned int insn1, insn2, insn3;
13897               bfd_vma offset;
13898
13899             tls_ldgd_opt:
13900               offset = (bfd_vma) -1;
13901               /* If not using the newer R_PPC64_TLSGD/LD to mark
13902                  __tls_get_addr calls, we must trust that the call
13903                  stays with its arg setup insns, ie. that the next
13904                  reloc is the __tls_get_addr call associated with
13905                  the current reloc.  Edit both insns.  */
13906               if (input_section->has_tls_get_addr_call
13907                   && rel + 1 < relend
13908                   && branch_reloc_hash_match (input_bfd, rel + 1,
13909                                               htab->tls_get_addr,
13910                                               htab->tls_get_addr_fd))
13911                 offset = rel[1].r_offset;
13912               /* We read the low GOT_TLS (or TOC16) insn because we
13913                  need to keep the destination reg.  It may be
13914                  something other than the usual r3, and moved to r3
13915                  before the call by intervening code.  */
13916               insn1 = bfd_get_32 (input_bfd,
13917                                   contents + rel->r_offset - d_offset);
13918               if ((tls_mask & tls_gd) != 0)
13919                 {
13920                   /* IE */
13921                   insn1 &= (0x1f << 21) | (0x1f << 16);
13922                   insn1 |= 58 << 26;    /* ld */
13923                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13924                   if (offset != (bfd_vma) -1)
13925                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13926                   if ((tls_mask & TLS_EXPLICIT) == 0)
13927                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13928                               + R_PPC64_GOT_TPREL16_DS);
13929                   else
13930                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13931                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13932                 }
13933               else
13934                 {
13935                   /* LE */
13936                   insn1 &= 0x1f << 21;
13937                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13938                   insn2 = 0x38630000;   /* addi 3,3,0 */
13939                   if (tls_gd == 0)
13940                     {
13941                       /* Was an LD reloc.  */
13942                       if (toc_symndx)
13943                         sec = local_sections[toc_symndx];
13944                       for (r_symndx = 0;
13945                            r_symndx < symtab_hdr->sh_info;
13946                            r_symndx++)
13947                         if (local_sections[r_symndx] == sec)
13948                           break;
13949                       if (r_symndx >= symtab_hdr->sh_info)
13950                         r_symndx = STN_UNDEF;
13951                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13952                       if (r_symndx != STN_UNDEF)
13953                         rel->r_addend -= (local_syms[r_symndx].st_value
13954                                           + sec->output_offset
13955                                           + sec->output_section->vma);
13956                     }
13957                   else if (toc_symndx != 0)
13958                     {
13959                       r_symndx = toc_symndx;
13960                       rel->r_addend = toc_addend;
13961                     }
13962                   r_type = R_PPC64_TPREL16_HA;
13963                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13964                   if (offset != (bfd_vma) -1)
13965                     {
13966                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13967                                                     R_PPC64_TPREL16_LO);
13968                       rel[1].r_offset = offset + d_offset;
13969                       rel[1].r_addend = rel->r_addend;
13970                     }
13971                 }
13972               bfd_put_32 (input_bfd, insn1,
13973                           contents + rel->r_offset - d_offset);
13974               if (offset != (bfd_vma) -1)
13975                 {
13976                   insn3 = bfd_get_32 (input_bfd,
13977                                       contents + offset + 4);
13978                   if (insn3 == NOP
13979                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13980                     {
13981                       rel[1].r_offset += 4;
13982                       bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13983                       insn2 = NOP;
13984                     }
13985                   bfd_put_32 (input_bfd, insn2, contents + offset);
13986                 }
13987               if ((tls_mask & tls_gd) == 0
13988                   && (tls_gd == 0 || toc_symndx != 0))
13989                 {
13990                   /* We changed the symbol.  Start over in order
13991                      to get h, sym, sec etc. right.  */
13992                   goto again;
13993                 }
13994             }
13995           break;
13996
13997         case R_PPC64_TLSGD:
13998           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13999             {
14000               unsigned int insn2, insn3;
14001               bfd_vma offset = rel->r_offset;
14002
14003               if ((tls_mask & TLS_TPRELGD) != 0)
14004                 {
14005                   /* IE */
14006                   r_type = R_PPC64_NONE;
14007                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14008                 }
14009               else
14010                 {
14011                   /* LE */
14012                   if (toc_symndx != 0)
14013                     {
14014                       r_symndx = toc_symndx;
14015                       rel->r_addend = toc_addend;
14016                     }
14017                   r_type = R_PPC64_TPREL16_LO;
14018                   rel->r_offset = offset + d_offset;
14019                   insn2 = 0x38630000;   /* addi 3,3,0 */
14020                 }
14021               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14022               /* Zap the reloc on the _tls_get_addr call too.  */
14023               BFD_ASSERT (offset == rel[1].r_offset);
14024               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14025               insn3 = bfd_get_32 (input_bfd,
14026                                   contents + offset + 4);
14027               if (insn3 == NOP
14028                   || insn3 == CROR_151515 || insn3 == CROR_313131)
14029                 {
14030                   rel->r_offset += 4;
14031                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
14032                   insn2 = NOP;
14033                 }
14034               bfd_put_32 (input_bfd, insn2, contents + offset);
14035               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14036                 goto again;
14037             }
14038           break;
14039
14040         case R_PPC64_TLSLD:
14041           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14042             {
14043               unsigned int insn2, insn3;
14044               bfd_vma offset = rel->r_offset;
14045
14046               if (toc_symndx)
14047                 sec = local_sections[toc_symndx];
14048               for (r_symndx = 0;
14049                    r_symndx < symtab_hdr->sh_info;
14050                    r_symndx++)
14051                 if (local_sections[r_symndx] == sec)
14052                   break;
14053               if (r_symndx >= symtab_hdr->sh_info)
14054                 r_symndx = STN_UNDEF;
14055               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14056               if (r_symndx != STN_UNDEF)
14057                 rel->r_addend -= (local_syms[r_symndx].st_value
14058                                   + sec->output_offset
14059                                   + sec->output_section->vma);
14060
14061               r_type = R_PPC64_TPREL16_LO;
14062               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14063               rel->r_offset = offset + d_offset;
14064               /* Zap the reloc on the _tls_get_addr call too.  */
14065               BFD_ASSERT (offset == rel[1].r_offset);
14066               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14067               insn2 = 0x38630000;       /* addi 3,3,0 */
14068               insn3 = bfd_get_32 (input_bfd,
14069                                   contents + offset + 4);
14070               if (insn3 == NOP
14071                   || insn3 == CROR_151515 || insn3 == CROR_313131)
14072                 {
14073                   rel->r_offset += 4;
14074                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
14075                   insn2 = NOP;
14076                 }
14077               bfd_put_32 (input_bfd, insn2, contents + offset);
14078               goto again;
14079             }
14080           break;
14081
14082         case R_PPC64_DTPMOD64:
14083           if (rel + 1 < relend
14084               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14085               && rel[1].r_offset == rel->r_offset + 8)
14086             {
14087               if ((tls_mask & TLS_GD) == 0)
14088                 {
14089                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14090                   if ((tls_mask & TLS_TPRELGD) != 0)
14091                     r_type = R_PPC64_TPREL64;
14092                   else
14093                     {
14094                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14095                       r_type = R_PPC64_NONE;
14096                     }
14097                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14098                 }
14099             }
14100           else
14101             {
14102               if ((tls_mask & TLS_LD) == 0)
14103                 {
14104                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14105                   r_type = R_PPC64_NONE;
14106                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14107                 }
14108             }
14109           break;
14110
14111         case R_PPC64_TPREL64:
14112           if ((tls_mask & TLS_TPREL) == 0)
14113             {
14114               r_type = R_PPC64_NONE;
14115               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14116             }
14117           break;
14118
14119         case R_PPC64_ENTRY:
14120           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14121           if (!bfd_link_pic (info)
14122               && !info->traditional_format
14123               && relocation + 0x80008000 <= 0xffffffff)
14124             {
14125               unsigned int insn1, insn2;
14126
14127               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14128               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14129               if ((insn1 & ~0xfffc) == LD_R2_0R12
14130                   && insn2 == ADD_R2_R2_R12)
14131                 {
14132                   bfd_put_32 (input_bfd,
14133                               LIS_R2 + PPC_HA (relocation),
14134                               contents + rel->r_offset);
14135                   bfd_put_32 (input_bfd,
14136                               ADDI_R2_R2 + PPC_LO (relocation),
14137                               contents + rel->r_offset + 4);
14138                 }
14139             }
14140           else
14141             {
14142               relocation -= (rel->r_offset
14143                              + input_section->output_offset
14144                              + input_section->output_section->vma);
14145               if (relocation + 0x80008000 <= 0xffffffff)
14146                 {
14147                   unsigned int insn1, insn2;
14148
14149                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14150                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14151                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14152                       && insn2 == ADD_R2_R2_R12)
14153                     {
14154                       bfd_put_32 (input_bfd,
14155                                   ADDIS_R2_R12 + PPC_HA (relocation),
14156                                   contents + rel->r_offset);
14157                       bfd_put_32 (input_bfd,
14158                                   ADDI_R2_R2 + PPC_LO (relocation),
14159                                   contents + rel->r_offset + 4);
14160                     }
14161                 }
14162             }
14163           break;
14164
14165         case R_PPC64_REL16_HA:
14166           /* If we are generating a non-PIC executable, edit
14167              .  0:      addis 2,12,.TOC.-0b@ha
14168              .          addi 2,2,.TOC.-0b@l
14169              used by ELFv2 global entry points to set up r2, to
14170              .          lis 2,.TOC.@ha
14171              .          addi 2,2,.TOC.@l
14172              if .TOC. is in range.  */
14173           if (!bfd_link_pic (info)
14174               && !info->traditional_format
14175               && !htab->opd_abi
14176               && rel->r_addend == d_offset
14177               && h != NULL && &h->elf == htab->elf.hgot
14178               && rel + 1 < relend
14179               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14180               && rel[1].r_offset == rel->r_offset + 4
14181               && rel[1].r_addend == rel->r_addend + 4
14182               && relocation + 0x80008000 <= 0xffffffff)
14183             {
14184               unsigned int insn1, insn2;
14185               bfd_vma offset = rel->r_offset - d_offset;
14186               insn1 = bfd_get_32 (input_bfd, contents + offset);
14187               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14188               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14189                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14190                 {
14191                   r_type = R_PPC64_ADDR16_HA;
14192                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14193                   rel->r_addend -= d_offset;
14194                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14195                   rel[1].r_addend -= d_offset + 4;
14196                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14197                 }
14198             }
14199           break;
14200         }
14201
14202       /* Handle other relocations that tweak non-addend part of insn.  */
14203       insn = 0;
14204       max_br_offset = 1 << 25;
14205       addend = rel->r_addend;
14206       reloc_dest = DEST_NORMAL;
14207       switch (r_type)
14208         {
14209         default:
14210           break;
14211
14212         case R_PPC64_TOCSAVE:
14213           if (relocation + addend == (rel->r_offset
14214                                       + input_section->output_offset
14215                                       + input_section->output_section->vma)
14216               && tocsave_find (htab, NO_INSERT,
14217                                &local_syms, rel, input_bfd))
14218             {
14219               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14220               if (insn == NOP
14221                   || insn == CROR_151515 || insn == CROR_313131)
14222                 bfd_put_32 (input_bfd,
14223                             STD_R2_0R1 + STK_TOC (htab),
14224                             contents + rel->r_offset);
14225             }
14226           break;
14227
14228           /* Branch taken prediction relocations.  */
14229         case R_PPC64_ADDR14_BRTAKEN:
14230         case R_PPC64_REL14_BRTAKEN:
14231           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14232           /* Fall through.  */
14233
14234           /* Branch not taken prediction relocations.  */
14235         case R_PPC64_ADDR14_BRNTAKEN:
14236         case R_PPC64_REL14_BRNTAKEN:
14237           insn |= bfd_get_32 (input_bfd,
14238                               contents + rel->r_offset) & ~(0x01 << 21);
14239           /* Fall through.  */
14240
14241         case R_PPC64_REL14:
14242           max_br_offset = 1 << 15;
14243           /* Fall through.  */
14244
14245         case R_PPC64_REL24:
14246           /* Calls to functions with a different TOC, such as calls to
14247              shared objects, need to alter the TOC pointer.  This is
14248              done using a linkage stub.  A REL24 branching to these
14249              linkage stubs needs to be followed by a nop, as the nop
14250              will be replaced with an instruction to restore the TOC
14251              base pointer.  */
14252           fdh = h;
14253           if (h != NULL
14254               && h->oh != NULL
14255               && h->oh->is_func_descriptor)
14256             fdh = ppc_follow_link (h->oh);
14257           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14258                                            htab);
14259           if (stub_entry != NULL
14260               && (stub_entry->stub_type == ppc_stub_plt_call
14261                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14262                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14263                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14264             {
14265               bfd_boolean can_plt_call = FALSE;
14266
14267               if (stub_entry->stub_type == ppc_stub_plt_call
14268                   && !htab->opd_abi
14269                   && htab->params->plt_localentry0 != 0
14270                   && is_elfv2_localentry0 (&h->elf))
14271                 {
14272                   /* The function doesn't use or change r2.  */
14273                   can_plt_call = TRUE;
14274                 }
14275
14276               /* All of these stubs may modify r2, so there must be a
14277                  branch and link followed by a nop.  The nop is
14278                  replaced by an insn to restore r2.  */
14279               else if (rel->r_offset + 8 <= input_section->size)
14280                 {
14281                   unsigned long br;
14282
14283                   br = bfd_get_32 (input_bfd,
14284                                    contents + rel->r_offset);
14285                   if ((br & 1) != 0)
14286                     {
14287                       unsigned long nop;
14288
14289                       nop = bfd_get_32 (input_bfd,
14290                                         contents + rel->r_offset + 4);
14291                       if (nop == NOP
14292                           || nop == CROR_151515 || nop == CROR_313131)
14293                         {
14294                           if (h != NULL
14295                               && (h == htab->tls_get_addr_fd
14296                                   || h == htab->tls_get_addr)
14297                               && htab->params->tls_get_addr_opt)
14298                             {
14299                               /* Special stub used, leave nop alone.  */
14300                             }
14301                           else
14302                             bfd_put_32 (input_bfd,
14303                                         LD_R2_0R1 + STK_TOC (htab),
14304                                         contents + rel->r_offset + 4);
14305                           can_plt_call = TRUE;
14306                         }
14307                     }
14308                 }
14309
14310               if (!can_plt_call && h != NULL)
14311                 {
14312                   const char *name = h->elf.root.root.string;
14313
14314                   if (*name == '.')
14315                     ++name;
14316
14317                   if (strncmp (name, "__libc_start_main", 17) == 0
14318                       && (name[17] == 0 || name[17] == '@'))
14319                     {
14320                       /* Allow crt1 branch to go via a toc adjusting
14321                          stub.  Other calls that never return could do
14322                          the same, if we could detect such.  */
14323                       can_plt_call = TRUE;
14324                     }
14325                 }
14326
14327               if (!can_plt_call)
14328                 {
14329                   /* g++ as of 20130507 emits self-calls without a
14330                      following nop.  This is arguably wrong since we
14331                      have conflicting information.  On the one hand a
14332                      global symbol and on the other a local call
14333                      sequence, but don't error for this special case.
14334                      It isn't possible to cheaply verify we have
14335                      exactly such a call.  Allow all calls to the same
14336                      section.  */
14337                   asection *code_sec = sec;
14338
14339                   if (get_opd_info (sec) != NULL)
14340                     {
14341                       bfd_vma off = (relocation + addend
14342                                      - sec->output_section->vma
14343                                      - sec->output_offset);
14344
14345                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14346                     }
14347                   if (code_sec == input_section)
14348                     can_plt_call = TRUE;
14349                 }
14350
14351               if (!can_plt_call)
14352                 {
14353                   if (stub_entry->stub_type == ppc_stub_plt_call
14354                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14355                     info->callbacks->einfo
14356                       /* xgettext:c-format */
14357                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14358                          "recompile with -fPIC\n"),
14359                        input_bfd, input_section, rel->r_offset, sym_name);
14360                   else
14361                     info->callbacks->einfo
14362                       /* xgettext:c-format */
14363                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14364                          "(-mcmodel=small toc adjust stub)\n"),
14365                        input_bfd, input_section, rel->r_offset, sym_name);
14366
14367                   bfd_set_error (bfd_error_bad_value);
14368                   ret = FALSE;
14369                 }
14370
14371               if (can_plt_call
14372                   && (stub_entry->stub_type == ppc_stub_plt_call
14373                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14374                 unresolved_reloc = FALSE;
14375             }
14376
14377           if ((stub_entry == NULL
14378                || stub_entry->stub_type == ppc_stub_long_branch
14379                || stub_entry->stub_type == ppc_stub_plt_branch)
14380               && get_opd_info (sec) != NULL)
14381             {
14382               /* The branch destination is the value of the opd entry. */
14383               bfd_vma off = (relocation + addend
14384                              - sec->output_section->vma
14385                              - sec->output_offset);
14386               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14387               if (dest != (bfd_vma) -1)
14388                 {
14389                   relocation = dest;
14390                   addend = 0;
14391                   reloc_dest = DEST_OPD;
14392                 }
14393             }
14394
14395           /* If the branch is out of reach we ought to have a long
14396              branch stub.  */
14397           from = (rel->r_offset
14398                   + input_section->output_offset
14399                   + input_section->output_section->vma);
14400
14401           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14402                                                   ? fdh->elf.other
14403                                                   : sym->st_other);
14404
14405           if (stub_entry != NULL
14406               && (stub_entry->stub_type == ppc_stub_long_branch
14407                   || stub_entry->stub_type == ppc_stub_plt_branch)
14408               && (r_type == R_PPC64_ADDR14_BRTAKEN
14409                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14410                   || (relocation + addend - from + max_br_offset
14411                       < 2 * max_br_offset)))
14412             /* Don't use the stub if this branch is in range.  */
14413             stub_entry = NULL;
14414
14415           if (stub_entry != NULL)
14416             {
14417               /* Munge up the value and addend so that we call the stub
14418                  rather than the procedure directly.  */
14419               asection *stub_sec = stub_entry->group->stub_sec;
14420
14421               if (stub_entry->stub_type == ppc_stub_save_res)
14422                 relocation += (stub_sec->output_offset
14423                                + stub_sec->output_section->vma
14424                                + stub_sec->size - htab->sfpr->size
14425                                - htab->sfpr->output_offset
14426                                - htab->sfpr->output_section->vma);
14427               else
14428                 relocation = (stub_entry->stub_offset
14429                               + stub_sec->output_offset
14430                               + stub_sec->output_section->vma);
14431               addend = 0;
14432               reloc_dest = DEST_STUB;
14433
14434               if ((stub_entry->stub_type == ppc_stub_plt_call
14435                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14436                   && (ALWAYS_EMIT_R2SAVE
14437                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14438                   && rel + 1 < relend
14439                   && rel[1].r_offset == rel->r_offset + 4
14440                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14441                 relocation += 4;
14442             }
14443
14444           if (insn != 0)
14445             {
14446               if (is_isa_v2)
14447                 {
14448                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14449                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14450                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14451                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14452                     insn |= 0x02 << 21;
14453                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14454                     insn |= 0x08 << 21;
14455                   else
14456                     break;
14457                 }
14458               else
14459                 {
14460                   /* Invert 'y' bit if not the default.  */
14461                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14462                     insn ^= 0x01 << 21;
14463                 }
14464
14465               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14466             }
14467
14468           /* NOP out calls to undefined weak functions.
14469              We can thus call a weak function without first
14470              checking whether the function is defined.  */
14471           else if (h != NULL
14472                    && h->elf.root.type == bfd_link_hash_undefweak
14473                    && h->elf.dynindx == -1
14474                    && r_type == R_PPC64_REL24
14475                    && relocation == 0
14476                    && addend == 0)
14477             {
14478               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14479               goto copy_reloc;
14480             }
14481           break;
14482         }
14483
14484       /* Set `addend'.  */
14485       tls_type = 0;
14486       switch (r_type)
14487         {
14488         default:
14489           info->callbacks->einfo
14490             /* xgettext:c-format */
14491             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14492              input_bfd, (int) r_type, sym_name);
14493
14494           bfd_set_error (bfd_error_bad_value);
14495           ret = FALSE;
14496           goto copy_reloc;
14497
14498         case R_PPC64_NONE:
14499         case R_PPC64_TLS:
14500         case R_PPC64_TLSGD:
14501         case R_PPC64_TLSLD:
14502         case R_PPC64_TOCSAVE:
14503         case R_PPC64_GNU_VTINHERIT:
14504         case R_PPC64_GNU_VTENTRY:
14505         case R_PPC64_ENTRY:
14506           goto copy_reloc;
14507
14508           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14509              address in the GOT as relocation value instead of the
14510              symbol's value itself.  Also, create a GOT entry for the
14511              symbol and put the symbol value there.  */
14512         case R_PPC64_GOT_TLSGD16:
14513         case R_PPC64_GOT_TLSGD16_LO:
14514         case R_PPC64_GOT_TLSGD16_HI:
14515         case R_PPC64_GOT_TLSGD16_HA:
14516           tls_type = TLS_TLS | TLS_GD;
14517           goto dogot;
14518
14519         case R_PPC64_GOT_TLSLD16:
14520         case R_PPC64_GOT_TLSLD16_LO:
14521         case R_PPC64_GOT_TLSLD16_HI:
14522         case R_PPC64_GOT_TLSLD16_HA:
14523           tls_type = TLS_TLS | TLS_LD;
14524           goto dogot;
14525
14526         case R_PPC64_GOT_TPREL16_DS:
14527         case R_PPC64_GOT_TPREL16_LO_DS:
14528         case R_PPC64_GOT_TPREL16_HI:
14529         case R_PPC64_GOT_TPREL16_HA:
14530           tls_type = TLS_TLS | TLS_TPREL;
14531           goto dogot;
14532
14533         case R_PPC64_GOT_DTPREL16_DS:
14534         case R_PPC64_GOT_DTPREL16_LO_DS:
14535         case R_PPC64_GOT_DTPREL16_HI:
14536         case R_PPC64_GOT_DTPREL16_HA:
14537           tls_type = TLS_TLS | TLS_DTPREL;
14538           goto dogot;
14539
14540         case R_PPC64_GOT16:
14541         case R_PPC64_GOT16_LO:
14542         case R_PPC64_GOT16_HI:
14543         case R_PPC64_GOT16_HA:
14544         case R_PPC64_GOT16_DS:
14545         case R_PPC64_GOT16_LO_DS:
14546         dogot:
14547           {
14548             /* Relocation is to the entry for this symbol in the global
14549                offset table.  */
14550             asection *got;
14551             bfd_vma *offp;
14552             bfd_vma off;
14553             unsigned long indx = 0;
14554             struct got_entry *ent;
14555
14556             if (tls_type == (TLS_TLS | TLS_LD)
14557                 && (h == NULL
14558                     || !h->elf.def_dynamic))
14559               ent = ppc64_tlsld_got (input_bfd);
14560             else
14561               {
14562                 if (h != NULL)
14563                   {
14564                     if (!htab->elf.dynamic_sections_created
14565                         || h->elf.dynindx == -1
14566                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14567                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14568                       /* This is actually a static link, or it is a
14569                          -Bsymbolic link and the symbol is defined
14570                          locally, or the symbol was forced to be local
14571                          because of a version file.  */
14572                       ;
14573                     else
14574                       {
14575                         indx = h->elf.dynindx;
14576                         unresolved_reloc = FALSE;
14577                       }
14578                     ent = h->elf.got.glist;
14579                   }
14580                 else
14581                   {
14582                     if (local_got_ents == NULL)
14583                       abort ();
14584                     ent = local_got_ents[r_symndx];
14585                   }
14586
14587                 for (; ent != NULL; ent = ent->next)
14588                   if (ent->addend == orig_rel.r_addend
14589                       && ent->owner == input_bfd
14590                       && ent->tls_type == tls_type)
14591                     break;
14592               }
14593
14594             if (ent == NULL)
14595               abort ();
14596             if (ent->is_indirect)
14597               ent = ent->got.ent;
14598             offp = &ent->got.offset;
14599             got = ppc64_elf_tdata (ent->owner)->got;
14600             if (got == NULL)
14601               abort ();
14602
14603             /* The offset must always be a multiple of 8.  We use the
14604                least significant bit to record whether we have already
14605                processed this entry.  */
14606             off = *offp;
14607             if ((off & 1) != 0)
14608               off &= ~1;
14609             else
14610               {
14611                 /* Generate relocs for the dynamic linker, except in
14612                    the case of TLSLD where we'll use one entry per
14613                    module.  */
14614                 asection *relgot;
14615                 bfd_boolean ifunc;
14616
14617                 *offp = off | 1;
14618                 relgot = NULL;
14619                 ifunc = (h != NULL
14620                          ? h->elf.type == STT_GNU_IFUNC
14621                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14622                 if (ifunc)
14623                   {
14624                     relgot = htab->elf.irelplt;
14625                     if (indx == 0)
14626                       htab->local_ifunc_resolver = 1;
14627                     else if (is_static_defined (&h->elf))
14628                       htab->maybe_local_ifunc_resolver = 1;
14629                   }
14630                 else if (indx != 0
14631                          || (bfd_link_pic (info)
14632                              && (h == NULL
14633                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14634                                  || (tls_type == (TLS_TLS | TLS_LD)
14635                                      && !h->elf.def_dynamic))))
14636                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14637                 if (relgot != NULL)
14638                   {
14639                     outrel.r_offset = (got->output_section->vma
14640                                        + got->output_offset
14641                                        + off);
14642                     outrel.r_addend = addend;
14643                     if (tls_type & (TLS_LD | TLS_GD))
14644                       {
14645                         outrel.r_addend = 0;
14646                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14647                         if (tls_type == (TLS_TLS | TLS_GD))
14648                           {
14649                             loc = relgot->contents;
14650                             loc += (relgot->reloc_count++
14651                                     * sizeof (Elf64_External_Rela));
14652                             bfd_elf64_swap_reloca_out (output_bfd,
14653                                                        &outrel, loc);
14654                             outrel.r_offset += 8;
14655                             outrel.r_addend = addend;
14656                             outrel.r_info
14657                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14658                           }
14659                       }
14660                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14661                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14662                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14663                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14664                     else if (indx != 0)
14665                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14666                     else
14667                       {
14668                         if (ifunc)
14669                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14670                         else
14671                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14672
14673                         /* Write the .got section contents for the sake
14674                            of prelink.  */
14675                         loc = got->contents + off;
14676                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14677                                     loc);
14678                       }
14679
14680                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14681                       {
14682                         outrel.r_addend += relocation;
14683                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14684                           {
14685                             if (htab->elf.tls_sec == NULL)
14686                               outrel.r_addend = 0;
14687                             else
14688                               outrel.r_addend -= htab->elf.tls_sec->vma;
14689                           }
14690                       }
14691                     loc = relgot->contents;
14692                     loc += (relgot->reloc_count++
14693                             * sizeof (Elf64_External_Rela));
14694                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14695                   }
14696
14697                 /* Init the .got section contents here if we're not
14698                    emitting a reloc.  */
14699                 else
14700                   {
14701                     relocation += addend;
14702                     if (tls_type != 0)
14703                       {
14704                         if (htab->elf.tls_sec == NULL)
14705                           relocation = 0;
14706                         else
14707                           {
14708                             if (tls_type & TLS_LD)
14709                               relocation = 0;
14710                             else
14711                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14712                             if (tls_type & TLS_TPREL)
14713                               relocation += DTP_OFFSET - TP_OFFSET;
14714                           }
14715
14716                         if (tls_type & (TLS_GD | TLS_LD))
14717                           {
14718                             bfd_put_64 (output_bfd, relocation,
14719                                         got->contents + off + 8);
14720                             relocation = 1;
14721                           }
14722                       }
14723                     bfd_put_64 (output_bfd, relocation,
14724                                 got->contents + off);
14725                   }
14726               }
14727
14728             if (off >= (bfd_vma) -2)
14729               abort ();
14730
14731             relocation = got->output_section->vma + got->output_offset + off;
14732             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14733           }
14734           break;
14735
14736         case R_PPC64_PLT16_HA:
14737         case R_PPC64_PLT16_HI:
14738         case R_PPC64_PLT16_LO:
14739         case R_PPC64_PLT32:
14740         case R_PPC64_PLT64:
14741           /* Relocation is to the entry for this symbol in the
14742              procedure linkage table.  */
14743           {
14744             struct plt_entry **plt_list = NULL;
14745             if (h != NULL)
14746               plt_list = &h->elf.plt.plist;
14747             else if (local_got_ents != NULL)
14748               {
14749                 struct plt_entry **local_plt = (struct plt_entry **)
14750                   (local_got_ents + symtab_hdr->sh_info);
14751                 unsigned char *local_got_tls_masks = (unsigned char *)
14752                   (local_plt + symtab_hdr->sh_info);
14753                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14754                   plt_list = local_plt + r_symndx;
14755               }
14756             if (plt_list)
14757               {
14758                 struct plt_entry *ent;
14759
14760                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14761                   if (ent->plt.offset != (bfd_vma) -1
14762                       && ent->addend == orig_rel.r_addend)
14763                     {
14764                       asection *plt;
14765
14766                       plt = htab->elf.splt;
14767                       if (!htab->elf.dynamic_sections_created
14768                           || h == NULL
14769                           || h->elf.dynindx == -1)
14770                         plt = htab->elf.iplt;
14771                       relocation = (plt->output_section->vma
14772                                     + plt->output_offset
14773                                     + ent->plt.offset);
14774                       addend = 0;
14775                       unresolved_reloc = FALSE;
14776                       break;
14777                     }
14778               }
14779           }
14780           break;
14781
14782         case R_PPC64_TOC:
14783           /* Relocation value is TOC base.  */
14784           relocation = TOCstart;
14785           if (r_symndx == STN_UNDEF)
14786             relocation += htab->sec_info[input_section->id].toc_off;
14787           else if (unresolved_reloc)
14788             ;
14789           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14790             relocation += htab->sec_info[sec->id].toc_off;
14791           else
14792             unresolved_reloc = TRUE;
14793           goto dodyn;
14794
14795           /* TOC16 relocs.  We want the offset relative to the TOC base,
14796              which is the address of the start of the TOC plus 0x8000.
14797              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14798              in this order.  */
14799         case R_PPC64_TOC16:
14800         case R_PPC64_TOC16_LO:
14801         case R_PPC64_TOC16_HI:
14802         case R_PPC64_TOC16_DS:
14803         case R_PPC64_TOC16_LO_DS:
14804         case R_PPC64_TOC16_HA:
14805           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14806           break;
14807
14808           /* Relocate against the beginning of the section.  */
14809         case R_PPC64_SECTOFF:
14810         case R_PPC64_SECTOFF_LO:
14811         case R_PPC64_SECTOFF_HI:
14812         case R_PPC64_SECTOFF_DS:
14813         case R_PPC64_SECTOFF_LO_DS:
14814         case R_PPC64_SECTOFF_HA:
14815           if (sec != NULL)
14816             addend -= sec->output_section->vma;
14817           break;
14818
14819         case R_PPC64_REL16:
14820         case R_PPC64_REL16_LO:
14821         case R_PPC64_REL16_HI:
14822         case R_PPC64_REL16_HA:
14823         case R_PPC64_REL16DX_HA:
14824           break;
14825
14826         case R_PPC64_REL14:
14827         case R_PPC64_REL14_BRNTAKEN:
14828         case R_PPC64_REL14_BRTAKEN:
14829         case R_PPC64_REL24:
14830           break;
14831
14832         case R_PPC64_TPREL16:
14833         case R_PPC64_TPREL16_LO:
14834         case R_PPC64_TPREL16_HI:
14835         case R_PPC64_TPREL16_HA:
14836         case R_PPC64_TPREL16_DS:
14837         case R_PPC64_TPREL16_LO_DS:
14838         case R_PPC64_TPREL16_HIGH:
14839         case R_PPC64_TPREL16_HIGHA:
14840         case R_PPC64_TPREL16_HIGHER:
14841         case R_PPC64_TPREL16_HIGHERA:
14842         case R_PPC64_TPREL16_HIGHEST:
14843         case R_PPC64_TPREL16_HIGHESTA:
14844           if (h != NULL
14845               && h->elf.root.type == bfd_link_hash_undefweak
14846               && h->elf.dynindx == -1)
14847             {
14848               /* Make this relocation against an undefined weak symbol
14849                  resolve to zero.  This is really just a tweak, since
14850                  code using weak externs ought to check that they are
14851                  defined before using them.  */
14852               bfd_byte *p = contents + rel->r_offset - d_offset;
14853
14854               insn = bfd_get_32 (input_bfd, p);
14855               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14856               if (insn != 0)
14857                 bfd_put_32 (input_bfd, insn, p);
14858               break;
14859             }
14860           if (htab->elf.tls_sec != NULL)
14861             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14862           if (bfd_link_pic (info))
14863             /* The TPREL16 relocs shouldn't really be used in shared
14864                libs as they will result in DT_TEXTREL being set, but
14865                support them anyway.  */
14866             goto dodyn;
14867           break;
14868
14869         case R_PPC64_DTPREL16:
14870         case R_PPC64_DTPREL16_LO:
14871         case R_PPC64_DTPREL16_HI:
14872         case R_PPC64_DTPREL16_HA:
14873         case R_PPC64_DTPREL16_DS:
14874         case R_PPC64_DTPREL16_LO_DS:
14875         case R_PPC64_DTPREL16_HIGH:
14876         case R_PPC64_DTPREL16_HIGHA:
14877         case R_PPC64_DTPREL16_HIGHER:
14878         case R_PPC64_DTPREL16_HIGHERA:
14879         case R_PPC64_DTPREL16_HIGHEST:
14880         case R_PPC64_DTPREL16_HIGHESTA:
14881           if (htab->elf.tls_sec != NULL)
14882             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14883           break;
14884
14885         case R_PPC64_ADDR64_LOCAL:
14886           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14887                                               ? h->elf.other
14888                                               : sym->st_other);
14889           break;
14890
14891         case R_PPC64_DTPMOD64:
14892           relocation = 1;
14893           addend = 0;
14894           goto dodyn;
14895
14896         case R_PPC64_TPREL64:
14897           if (htab->elf.tls_sec != NULL)
14898             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14899           goto dodyn;
14900
14901         case R_PPC64_DTPREL64:
14902           if (htab->elf.tls_sec != NULL)
14903             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14904           /* Fall through.  */
14905
14906           /* Relocations that may need to be propagated if this is a
14907              dynamic object.  */
14908         case R_PPC64_REL30:
14909         case R_PPC64_REL32:
14910         case R_PPC64_REL64:
14911         case R_PPC64_ADDR14:
14912         case R_PPC64_ADDR14_BRNTAKEN:
14913         case R_PPC64_ADDR14_BRTAKEN:
14914         case R_PPC64_ADDR16:
14915         case R_PPC64_ADDR16_DS:
14916         case R_PPC64_ADDR16_HA:
14917         case R_PPC64_ADDR16_HI:
14918         case R_PPC64_ADDR16_HIGH:
14919         case R_PPC64_ADDR16_HIGHA:
14920         case R_PPC64_ADDR16_HIGHER:
14921         case R_PPC64_ADDR16_HIGHERA:
14922         case R_PPC64_ADDR16_HIGHEST:
14923         case R_PPC64_ADDR16_HIGHESTA:
14924         case R_PPC64_ADDR16_LO:
14925         case R_PPC64_ADDR16_LO_DS:
14926         case R_PPC64_ADDR24:
14927         case R_PPC64_ADDR32:
14928         case R_PPC64_ADDR64:
14929         case R_PPC64_UADDR16:
14930         case R_PPC64_UADDR32:
14931         case R_PPC64_UADDR64:
14932         dodyn:
14933           if ((input_section->flags & SEC_ALLOC) == 0)
14934             break;
14935
14936           if (NO_OPD_RELOCS && is_opd)
14937             break;
14938
14939           if (bfd_link_pic (info)
14940               ? ((h == NULL
14941                   || h->dyn_relocs != NULL)
14942                  && ((h != NULL && pc_dynrelocs (h))
14943                      || must_be_dyn_reloc (info, r_type)))
14944               : (h != NULL
14945                  ? h->dyn_relocs != NULL
14946                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14947             {
14948               bfd_boolean skip, relocate;
14949               asection *sreloc;
14950               bfd_vma out_off;
14951               long indx = 0;
14952
14953               /* When generating a dynamic object, these relocations
14954                  are copied into the output file to be resolved at run
14955                  time.  */
14956
14957               skip = FALSE;
14958               relocate = FALSE;
14959
14960               out_off = _bfd_elf_section_offset (output_bfd, info,
14961                                                  input_section, rel->r_offset);
14962               if (out_off == (bfd_vma) -1)
14963                 skip = TRUE;
14964               else if (out_off == (bfd_vma) -2)
14965                 skip = TRUE, relocate = TRUE;
14966               out_off += (input_section->output_section->vma
14967                           + input_section->output_offset);
14968               outrel.r_offset = out_off;
14969               outrel.r_addend = rel->r_addend;
14970
14971               /* Optimize unaligned reloc use.  */
14972               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14973                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14974                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14975               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14976                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14977                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14978               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14979                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14980                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14981
14982               if (skip)
14983                 memset (&outrel, 0, sizeof outrel);
14984               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14985                        && !is_opd
14986                        && r_type != R_PPC64_TOC)
14987                 {
14988                   indx = h->elf.dynindx;
14989                   BFD_ASSERT (indx != -1);
14990                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14991                 }
14992               else
14993                 {
14994                   /* This symbol is local, or marked to become local,
14995                      or this is an opd section reloc which must point
14996                      at a local function.  */
14997                   outrel.r_addend += relocation;
14998                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14999                     {
15000                       if (is_opd && h != NULL)
15001                         {
15002                           /* Lie about opd entries.  This case occurs
15003                              when building shared libraries and we
15004                              reference a function in another shared
15005                              lib.  The same thing happens for a weak
15006                              definition in an application that's
15007                              overridden by a strong definition in a
15008                              shared lib.  (I believe this is a generic
15009                              bug in binutils handling of weak syms.)
15010                              In these cases we won't use the opd
15011                              entry in this lib.  */
15012                           unresolved_reloc = FALSE;
15013                         }
15014                       if (!is_opd
15015                           && r_type == R_PPC64_ADDR64
15016                           && (h != NULL
15017                               ? h->elf.type == STT_GNU_IFUNC
15018                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15019                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15020                       else
15021                         {
15022                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15023
15024                           /* We need to relocate .opd contents for ld.so.
15025                              Prelink also wants simple and consistent rules
15026                              for relocs.  This make all RELATIVE relocs have
15027                              *r_offset equal to r_addend.  */
15028                           relocate = TRUE;
15029                         }
15030                     }
15031                   else
15032                     {
15033                       if (h != NULL
15034                           ? h->elf.type == STT_GNU_IFUNC
15035                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15036                         {
15037                           info->callbacks->einfo
15038                             /* xgettext:c-format */
15039                             (_("%H: %s for indirect "
15040                                "function `%T' unsupported\n"),
15041                              input_bfd, input_section, rel->r_offset,
15042                              ppc64_elf_howto_table[r_type]->name,
15043                              sym_name);
15044                           ret = FALSE;
15045                         }
15046                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15047                         ;
15048                       else if (sec == NULL || sec->owner == NULL)
15049                         {
15050                           bfd_set_error (bfd_error_bad_value);
15051                           return FALSE;
15052                         }
15053                       else
15054                         {
15055                           asection *osec;
15056
15057                           osec = sec->output_section;
15058                           indx = elf_section_data (osec)->dynindx;
15059
15060                           if (indx == 0)
15061                             {
15062                               if ((osec->flags & SEC_READONLY) == 0
15063                                   && htab->elf.data_index_section != NULL)
15064                                 osec = htab->elf.data_index_section;
15065                               else
15066                                 osec = htab->elf.text_index_section;
15067                               indx = elf_section_data (osec)->dynindx;
15068                             }
15069                           BFD_ASSERT (indx != 0);
15070
15071                           /* We are turning this relocation into one
15072                              against a section symbol, so subtract out
15073                              the output section's address but not the
15074                              offset of the input section in the output
15075                              section.  */
15076                           outrel.r_addend -= osec->vma;
15077                         }
15078
15079                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15080                     }
15081                 }
15082
15083               sreloc = elf_section_data (input_section)->sreloc;
15084               if (h != NULL
15085                   ? h->elf.type == STT_GNU_IFUNC
15086                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15087                 {
15088                   sreloc = htab->elf.irelplt;
15089                   if (indx == 0)
15090                     htab->local_ifunc_resolver = 1;
15091                   else if (is_static_defined (&h->elf))
15092                     htab->maybe_local_ifunc_resolver = 1;
15093                 }
15094               if (sreloc == NULL)
15095                 abort ();
15096
15097               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15098                   >= sreloc->size)
15099                 abort ();
15100               loc = sreloc->contents;
15101               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15102               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15103
15104               /* If this reloc is against an external symbol, it will
15105                  be computed at runtime, so there's no need to do
15106                  anything now.  However, for the sake of prelink ensure
15107                  that the section contents are a known value.  */
15108               if (! relocate)
15109                 {
15110                   unresolved_reloc = FALSE;
15111                   /* The value chosen here is quite arbitrary as ld.so
15112                      ignores section contents except for the special
15113                      case of .opd where the contents might be accessed
15114                      before relocation.  Choose zero, as that won't
15115                      cause reloc overflow.  */
15116                   relocation = 0;
15117                   addend = 0;
15118                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15119                      to improve backward compatibility with older
15120                      versions of ld.  */
15121                   if (r_type == R_PPC64_ADDR64)
15122                     addend = outrel.r_addend;
15123                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15124                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15125                     addend = outrel.r_offset;
15126                 }
15127             }
15128           break;
15129
15130         case R_PPC64_COPY:
15131         case R_PPC64_GLOB_DAT:
15132         case R_PPC64_JMP_SLOT:
15133         case R_PPC64_JMP_IREL:
15134         case R_PPC64_RELATIVE:
15135           /* We shouldn't ever see these dynamic relocs in relocatable
15136              files.  */
15137           /* Fall through.  */
15138
15139         case R_PPC64_PLTGOT16:
15140         case R_PPC64_PLTGOT16_DS:
15141         case R_PPC64_PLTGOT16_HA:
15142         case R_PPC64_PLTGOT16_HI:
15143         case R_PPC64_PLTGOT16_LO:
15144         case R_PPC64_PLTGOT16_LO_DS:
15145         case R_PPC64_PLTREL32:
15146         case R_PPC64_PLTREL64:
15147           /* These ones haven't been implemented yet.  */
15148
15149           info->callbacks->einfo
15150             /* xgettext:c-format */
15151             (_("%P: %B: %s is not supported for `%T'\n"),
15152              input_bfd,
15153              ppc64_elf_howto_table[r_type]->name, sym_name);
15154
15155           bfd_set_error (bfd_error_invalid_operation);
15156           ret = FALSE;
15157           goto copy_reloc;
15158         }
15159
15160       /* Multi-instruction sequences that access the TOC can be
15161          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15162          to             nop;           addi rb,r2,x;  */
15163       switch (r_type)
15164         {
15165         default:
15166           break;
15167
15168         case R_PPC64_GOT_TLSLD16_HI:
15169         case R_PPC64_GOT_TLSGD16_HI:
15170         case R_PPC64_GOT_TPREL16_HI:
15171         case R_PPC64_GOT_DTPREL16_HI:
15172         case R_PPC64_GOT16_HI:
15173         case R_PPC64_TOC16_HI:
15174           /* These relocs would only be useful if building up an
15175              offset to later add to r2, perhaps in an indexed
15176              addressing mode instruction.  Don't try to optimize.
15177              Unfortunately, the possibility of someone building up an
15178              offset like this or even with the HA relocs, means that
15179              we need to check the high insn when optimizing the low
15180              insn.  */
15181           break;
15182
15183         case R_PPC64_GOT_TLSLD16_HA:
15184         case R_PPC64_GOT_TLSGD16_HA:
15185         case R_PPC64_GOT_TPREL16_HA:
15186         case R_PPC64_GOT_DTPREL16_HA:
15187         case R_PPC64_GOT16_HA:
15188         case R_PPC64_TOC16_HA:
15189           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15190               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15191             {
15192               bfd_byte *p = contents + (rel->r_offset & ~3);
15193               bfd_put_32 (input_bfd, NOP, p);
15194             }
15195           break;
15196
15197         case R_PPC64_GOT_TLSLD16_LO:
15198         case R_PPC64_GOT_TLSGD16_LO:
15199         case R_PPC64_GOT_TPREL16_LO_DS:
15200         case R_PPC64_GOT_DTPREL16_LO_DS:
15201         case R_PPC64_GOT16_LO:
15202         case R_PPC64_GOT16_LO_DS:
15203         case R_PPC64_TOC16_LO:
15204         case R_PPC64_TOC16_LO_DS:
15205           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15206               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15207             {
15208               bfd_byte *p = contents + (rel->r_offset & ~3);
15209               insn = bfd_get_32 (input_bfd, p);
15210               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15211                 {
15212                   /* Transform addic to addi when we change reg.  */
15213                   insn &= ~((0x3f << 26) | (0x1f << 16));
15214                   insn |= (14u << 26) | (2 << 16);
15215                 }
15216               else
15217                 {
15218                   insn &= ~(0x1f << 16);
15219                   insn |= 2 << 16;
15220                 }
15221               bfd_put_32 (input_bfd, insn, p);
15222             }
15223           break;
15224         }
15225
15226       /* Do any further special processing.  */
15227       howto = ppc64_elf_howto_table[(int) r_type];
15228       switch (r_type)
15229         {
15230         default:
15231           break;
15232
15233         case R_PPC64_REL16_HA:
15234         case R_PPC64_REL16DX_HA:
15235         case R_PPC64_ADDR16_HA:
15236         case R_PPC64_ADDR16_HIGHA:
15237         case R_PPC64_ADDR16_HIGHERA:
15238         case R_PPC64_ADDR16_HIGHESTA:
15239         case R_PPC64_TOC16_HA:
15240         case R_PPC64_SECTOFF_HA:
15241         case R_PPC64_TPREL16_HA:
15242         case R_PPC64_TPREL16_HIGHA:
15243         case R_PPC64_TPREL16_HIGHERA:
15244         case R_PPC64_TPREL16_HIGHESTA:
15245         case R_PPC64_DTPREL16_HA:
15246         case R_PPC64_DTPREL16_HIGHA:
15247         case R_PPC64_DTPREL16_HIGHERA:
15248         case R_PPC64_DTPREL16_HIGHESTA:
15249           /* It's just possible that this symbol is a weak symbol
15250              that's not actually defined anywhere. In that case,
15251              'sec' would be NULL, and we should leave the symbol
15252              alone (it will be set to zero elsewhere in the link).  */
15253           if (sec == NULL)
15254             break;
15255           /* Fall through.  */
15256
15257         case R_PPC64_GOT16_HA:
15258         case R_PPC64_PLTGOT16_HA:
15259         case R_PPC64_PLT16_HA:
15260         case R_PPC64_GOT_TLSGD16_HA:
15261         case R_PPC64_GOT_TLSLD16_HA:
15262         case R_PPC64_GOT_TPREL16_HA:
15263         case R_PPC64_GOT_DTPREL16_HA:
15264           /* Add 0x10000 if sign bit in 0:15 is set.
15265              Bits 0:15 are not used.  */
15266           addend += 0x8000;
15267           break;
15268
15269         case R_PPC64_ADDR16_DS:
15270         case R_PPC64_ADDR16_LO_DS:
15271         case R_PPC64_GOT16_DS:
15272         case R_PPC64_GOT16_LO_DS:
15273         case R_PPC64_PLT16_LO_DS:
15274         case R_PPC64_SECTOFF_DS:
15275         case R_PPC64_SECTOFF_LO_DS:
15276         case R_PPC64_TOC16_DS:
15277         case R_PPC64_TOC16_LO_DS:
15278         case R_PPC64_PLTGOT16_DS:
15279         case R_PPC64_PLTGOT16_LO_DS:
15280         case R_PPC64_GOT_TPREL16_DS:
15281         case R_PPC64_GOT_TPREL16_LO_DS:
15282         case R_PPC64_GOT_DTPREL16_DS:
15283         case R_PPC64_GOT_DTPREL16_LO_DS:
15284         case R_PPC64_TPREL16_DS:
15285         case R_PPC64_TPREL16_LO_DS:
15286         case R_PPC64_DTPREL16_DS:
15287         case R_PPC64_DTPREL16_LO_DS:
15288           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15289           mask = 3;
15290           /* If this reloc is against an lq, lxv, or stxv insn, then
15291              the value must be a multiple of 16.  This is somewhat of
15292              a hack, but the "correct" way to do this by defining _DQ
15293              forms of all the _DS relocs bloats all reloc switches in
15294              this file.  It doesn't make much sense to use these
15295              relocs in data, so testing the insn should be safe.  */
15296           if ((insn & (0x3f << 26)) == (56u << 26)
15297               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15298             mask = 15;
15299           relocation += addend;
15300           addend = insn & (mask ^ 3);
15301           if ((relocation & mask) != 0)
15302             {
15303               relocation ^= relocation & mask;
15304               info->callbacks->einfo
15305                 /* xgettext:c-format */
15306                 (_("%H: error: %s not a multiple of %u\n"),
15307                  input_bfd, input_section, rel->r_offset,
15308                  howto->name,
15309                  mask + 1);
15310               bfd_set_error (bfd_error_bad_value);
15311               ret = FALSE;
15312               goto copy_reloc;
15313             }
15314           break;
15315         }
15316
15317       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15318          because such sections are not SEC_ALLOC and thus ld.so will
15319          not process them.  */
15320       if (unresolved_reloc
15321           && !((input_section->flags & SEC_DEBUGGING) != 0
15322                && h->elf.def_dynamic)
15323           && _bfd_elf_section_offset (output_bfd, info, input_section,
15324                                       rel->r_offset) != (bfd_vma) -1)
15325         {
15326           info->callbacks->einfo
15327             /* xgettext:c-format */
15328             (_("%H: unresolvable %s against `%T'\n"),
15329              input_bfd, input_section, rel->r_offset,
15330              howto->name,
15331              h->elf.root.root.string);
15332           ret = FALSE;
15333         }
15334
15335       /* 16-bit fields in insns mostly have signed values, but a
15336          few insns have 16-bit unsigned values.  Really, we should
15337          have different reloc types.  */
15338       if (howto->complain_on_overflow != complain_overflow_dont
15339           && howto->dst_mask == 0xffff
15340           && (input_section->flags & SEC_CODE) != 0)
15341         {
15342           enum complain_overflow complain = complain_overflow_signed;
15343
15344           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15345           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15346             complain = complain_overflow_bitfield;
15347           else if (howto->rightshift == 0
15348                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15349                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15350                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15351                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15352                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15353                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15354             complain = complain_overflow_unsigned;
15355           if (howto->complain_on_overflow != complain)
15356             {
15357               alt_howto = *howto;
15358               alt_howto.complain_on_overflow = complain;
15359               howto = &alt_howto;
15360             }
15361         }
15362
15363       if (r_type == R_PPC64_REL16DX_HA)
15364         {
15365           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15366           if (rel->r_offset + 4 > input_section->size)
15367             r = bfd_reloc_outofrange;
15368           else
15369             {
15370               relocation += addend;
15371               relocation -= (rel->r_offset
15372                              + input_section->output_offset
15373                              + input_section->output_section->vma);
15374               relocation = (bfd_signed_vma) relocation >> 16;
15375               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15376               insn &= ~0x1fffc1;
15377               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15378               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15379               r = bfd_reloc_ok;
15380               if (relocation + 0x8000 > 0xffff)
15381                 r = bfd_reloc_overflow;
15382             }
15383         }
15384       else
15385         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15386                                       rel->r_offset, relocation, addend);
15387
15388       if (r != bfd_reloc_ok)
15389         {
15390           char *more_info = NULL;
15391           const char *reloc_name = howto->name;
15392
15393           if (reloc_dest != DEST_NORMAL)
15394             {
15395               more_info = bfd_malloc (strlen (reloc_name) + 8);
15396               if (more_info != NULL)
15397                 {
15398                   strcpy (more_info, reloc_name);
15399                   strcat (more_info, (reloc_dest == DEST_OPD
15400                                       ? " (OPD)" : " (stub)"));
15401                   reloc_name = more_info;
15402                 }
15403             }
15404
15405           if (r == bfd_reloc_overflow)
15406             {
15407               /* On code like "if (foo) foo();" don't report overflow
15408                  on a branch to zero when foo is undefined.  */
15409               if (!warned
15410                   && (reloc_dest == DEST_STUB
15411                       || !(h != NULL
15412                            && (h->elf.root.type == bfd_link_hash_undefweak
15413                                || h->elf.root.type == bfd_link_hash_undefined)
15414                            && is_branch_reloc (r_type))))
15415                 info->callbacks->reloc_overflow (info, &h->elf.root,
15416                                                  sym_name, reloc_name,
15417                                                  orig_rel.r_addend,
15418                                                  input_bfd, input_section,
15419                                                  rel->r_offset);
15420             }
15421           else
15422             {
15423               info->callbacks->einfo
15424                 /* xgettext:c-format */
15425                 (_("%H: %s against `%T': error %d\n"),
15426                  input_bfd, input_section, rel->r_offset,
15427                  reloc_name, sym_name, (int) r);
15428               ret = FALSE;
15429             }
15430           if (more_info != NULL)
15431             free (more_info);
15432         }
15433     copy_reloc:
15434       if (wrel != rel)
15435         *wrel = *rel;
15436     }
15437
15438   if (wrel != rel)
15439     {
15440       Elf_Internal_Shdr *rel_hdr;
15441       size_t deleted = rel - wrel;
15442
15443       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15444       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15445       if (rel_hdr->sh_size == 0)
15446         {
15447           /* It is too late to remove an empty reloc section.  Leave
15448              one NONE reloc.
15449              ??? What is wrong with an empty section???  */
15450           rel_hdr->sh_size = rel_hdr->sh_entsize;
15451           deleted -= 1;
15452         }
15453       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15454       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15455       input_section->reloc_count -= deleted;
15456     }
15457
15458   /* If we're emitting relocations, then shortly after this function
15459      returns, reloc offsets and addends for this section will be
15460      adjusted.  Worse, reloc symbol indices will be for the output
15461      file rather than the input.  Save a copy of the relocs for
15462      opd_entry_value.  */
15463   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15464     {
15465       bfd_size_type amt;
15466       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15467       rel = bfd_alloc (input_bfd, amt);
15468       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15469       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15470       if (rel == NULL)
15471         return FALSE;
15472       memcpy (rel, relocs, amt);
15473     }
15474   return ret;
15475 }
15476
15477 /* Adjust the value of any local symbols in opd sections.  */
15478
15479 static int
15480 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15481                               const char *name ATTRIBUTE_UNUSED,
15482                               Elf_Internal_Sym *elfsym,
15483                               asection *input_sec,
15484                               struct elf_link_hash_entry *h)
15485 {
15486   struct _opd_sec_data *opd;
15487   long adjust;
15488   bfd_vma value;
15489
15490   if (h != NULL)
15491     return 1;
15492
15493   opd = get_opd_info (input_sec);
15494   if (opd == NULL || opd->adjust == NULL)
15495     return 1;
15496
15497   value = elfsym->st_value - input_sec->output_offset;
15498   if (!bfd_link_relocatable (info))
15499     value -= input_sec->output_section->vma;
15500
15501   adjust = opd->adjust[OPD_NDX (value)];
15502   if (adjust == -1)
15503     return 2;
15504
15505   elfsym->st_value += adjust;
15506   return 1;
15507 }
15508
15509 /* Finish up dynamic symbol handling.  We set the contents of various
15510    dynamic sections here.  */
15511
15512 static bfd_boolean
15513 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15514                                  struct bfd_link_info *info,
15515                                  struct elf_link_hash_entry *h,
15516                                  Elf_Internal_Sym *sym)
15517 {
15518   struct ppc_link_hash_table *htab;
15519   struct plt_entry *ent;
15520   Elf_Internal_Rela rela;
15521   bfd_byte *loc;
15522
15523   htab = ppc_hash_table (info);
15524   if (htab == NULL)
15525     return FALSE;
15526
15527   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15528     if (ent->plt.offset != (bfd_vma) -1)
15529       {
15530         /* This symbol has an entry in the procedure linkage
15531            table.  Set it up.  */
15532         if (!htab->elf.dynamic_sections_created
15533             || h->dynindx == -1)
15534           {
15535             BFD_ASSERT (h->type == STT_GNU_IFUNC
15536                         && h->def_regular
15537                         && (h->root.type == bfd_link_hash_defined
15538                             || h->root.type == bfd_link_hash_defweak));
15539             rela.r_offset = (htab->elf.iplt->output_section->vma
15540                              + htab->elf.iplt->output_offset
15541                              + ent->plt.offset);
15542             if (htab->opd_abi)
15543               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15544             else
15545               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15546             rela.r_addend = (h->root.u.def.value
15547                              + h->root.u.def.section->output_offset
15548                              + h->root.u.def.section->output_section->vma
15549                              + ent->addend);
15550             loc = (htab->elf.irelplt->contents
15551                    + (htab->elf.irelplt->reloc_count++
15552                       * sizeof (Elf64_External_Rela)));
15553             htab->local_ifunc_resolver = 1;
15554           }
15555         else
15556           {
15557             rela.r_offset = (htab->elf.splt->output_section->vma
15558                              + htab->elf.splt->output_offset
15559                              + ent->plt.offset);
15560             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15561             rela.r_addend = ent->addend;
15562             loc = (htab->elf.srelplt->contents
15563                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15564                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15565             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15566               htab->maybe_local_ifunc_resolver = 1;
15567           }
15568         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15569
15570         if (!htab->opd_abi)
15571           {
15572             if (!h->def_regular)
15573               {
15574                 /* Mark the symbol as undefined, rather than as
15575                    defined in glink.  Leave the value if there were
15576                    any relocations where pointer equality matters
15577                    (this is a clue for the dynamic linker, to make
15578                    function pointer comparisons work between an
15579                    application and shared library), otherwise set it
15580                    to zero.  */
15581                 sym->st_shndx = SHN_UNDEF;
15582                 if (!h->pointer_equality_needed)
15583                   sym->st_value = 0;
15584                 else if (!h->ref_regular_nonweak)
15585                   {
15586                     /* This breaks function pointer comparisons, but
15587                        that is better than breaking tests for a NULL
15588                        function pointer.  */
15589                     sym->st_value = 0;
15590                   }
15591               }
15592           }
15593       }
15594
15595   if (h->needs_copy)
15596     {
15597       /* This symbol needs a copy reloc.  Set it up.  */
15598       asection *srel;
15599
15600       if (h->dynindx == -1
15601           || (h->root.type != bfd_link_hash_defined
15602               && h->root.type != bfd_link_hash_defweak)
15603           || htab->elf.srelbss == NULL
15604           || htab->elf.sreldynrelro == NULL)
15605         abort ();
15606
15607       rela.r_offset = (h->root.u.def.value
15608                        + h->root.u.def.section->output_section->vma
15609                        + h->root.u.def.section->output_offset);
15610       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15611       rela.r_addend = 0;
15612       if (h->root.u.def.section == htab->elf.sdynrelro)
15613         srel = htab->elf.sreldynrelro;
15614       else
15615         srel = htab->elf.srelbss;
15616       loc = srel->contents;
15617       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15618       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15619     }
15620
15621   return TRUE;
15622 }
15623
15624 /* Used to decide how to sort relocs in an optimal manner for the
15625    dynamic linker, before writing them out.  */
15626
15627 static enum elf_reloc_type_class
15628 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15629                             const asection *rel_sec,
15630                             const Elf_Internal_Rela *rela)
15631 {
15632   enum elf_ppc64_reloc_type r_type;
15633   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15634
15635   if (rel_sec == htab->elf.irelplt)
15636     return reloc_class_ifunc;
15637
15638   r_type = ELF64_R_TYPE (rela->r_info);
15639   switch (r_type)
15640     {
15641     case R_PPC64_RELATIVE:
15642       return reloc_class_relative;
15643     case R_PPC64_JMP_SLOT:
15644       return reloc_class_plt;
15645     case R_PPC64_COPY:
15646       return reloc_class_copy;
15647     default:
15648       return reloc_class_normal;
15649     }
15650 }
15651
15652 /* Finish up the dynamic sections.  */
15653
15654 static bfd_boolean
15655 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15656                                    struct bfd_link_info *info)
15657 {
15658   struct ppc_link_hash_table *htab;
15659   bfd *dynobj;
15660   asection *sdyn;
15661
15662   htab = ppc_hash_table (info);
15663   if (htab == NULL)
15664     return FALSE;
15665
15666   dynobj = htab->elf.dynobj;
15667   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15668
15669   if (htab->elf.dynamic_sections_created)
15670     {
15671       Elf64_External_Dyn *dyncon, *dynconend;
15672
15673       if (sdyn == NULL || htab->elf.sgot == NULL)
15674         abort ();
15675
15676       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15677       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15678       for (; dyncon < dynconend; dyncon++)
15679         {
15680           Elf_Internal_Dyn dyn;
15681           asection *s;
15682
15683           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15684
15685           switch (dyn.d_tag)
15686             {
15687             default:
15688               continue;
15689
15690             case DT_PPC64_GLINK:
15691               s = htab->glink;
15692               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15693               /* We stupidly defined DT_PPC64_GLINK to be the start
15694                  of glink rather than the first entry point, which is
15695                  what ld.so needs, and now have a bigger stub to
15696                  support automatic multiple TOCs.  */
15697               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15698               break;
15699
15700             case DT_PPC64_OPD:
15701               s = bfd_get_section_by_name (output_bfd, ".opd");
15702               if (s == NULL)
15703                 continue;
15704               dyn.d_un.d_ptr = s->vma;
15705               break;
15706
15707             case DT_PPC64_OPT:
15708               if (htab->do_multi_toc && htab->multi_toc_needed)
15709                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15710               if (htab->has_plt_localentry0)
15711                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15712               break;
15713
15714             case DT_PPC64_OPDSZ:
15715               s = bfd_get_section_by_name (output_bfd, ".opd");
15716               if (s == NULL)
15717                 continue;
15718               dyn.d_un.d_val = s->size;
15719               break;
15720
15721             case DT_PLTGOT:
15722               s = htab->elf.splt;
15723               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15724               break;
15725
15726             case DT_JMPREL:
15727               s = htab->elf.srelplt;
15728               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15729               break;
15730
15731             case DT_PLTRELSZ:
15732               dyn.d_un.d_val = htab->elf.srelplt->size;
15733               break;
15734
15735             case DT_TEXTREL:
15736               if (htab->local_ifunc_resolver)
15737                 info->callbacks->einfo
15738                   (_("%X%P: text relocations and GNU indirect "
15739                      "functions will result in a segfault at runtime\n"));
15740               else if (htab->maybe_local_ifunc_resolver)
15741                 info->callbacks->einfo
15742                   (_("%P: warning: text relocations and GNU indirect "
15743                      "functions may result in a segfault at runtime\n"));
15744               continue;
15745             }
15746
15747           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15748         }
15749     }
15750
15751   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15752       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15753     {
15754       /* Fill in the first entry in the global offset table.
15755          We use it to hold the link-time TOCbase.  */
15756       bfd_put_64 (output_bfd,
15757                   elf_gp (output_bfd) + TOC_BASE_OFF,
15758                   htab->elf.sgot->contents);
15759
15760       /* Set .got entry size.  */
15761       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15762     }
15763
15764   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15765       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15766     {
15767       /* Set .plt entry size.  */
15768       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15769         = PLT_ENTRY_SIZE (htab);
15770     }
15771
15772   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15773      brlt ourselves if emitrelocations.  */
15774   if (htab->brlt != NULL
15775       && htab->brlt->reloc_count != 0
15776       && !_bfd_elf_link_output_relocs (output_bfd,
15777                                        htab->brlt,
15778                                        elf_section_data (htab->brlt)->rela.hdr,
15779                                        elf_section_data (htab->brlt)->relocs,
15780                                        NULL))
15781     return FALSE;
15782
15783   if (htab->glink != NULL
15784       && htab->glink->reloc_count != 0
15785       && !_bfd_elf_link_output_relocs (output_bfd,
15786                                        htab->glink,
15787                                        elf_section_data (htab->glink)->rela.hdr,
15788                                        elf_section_data (htab->glink)->relocs,
15789                                        NULL))
15790     return FALSE;
15791
15792   if (htab->glink_eh_frame != NULL
15793       && htab->glink_eh_frame->size != 0)
15794     {
15795       bfd_vma val;
15796       bfd_byte *p;
15797       struct map_stub *group;
15798       size_t align = 4;
15799
15800       p = htab->glink_eh_frame->contents;
15801       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15802
15803       for (group = htab->group; group != NULL; group = group->next)
15804         if (group->stub_sec != NULL)
15805           {
15806             /* Offset to stub section.  */
15807             val = (group->stub_sec->output_section->vma
15808                    + group->stub_sec->output_offset);
15809             val -= (htab->glink_eh_frame->output_section->vma
15810                     + htab->glink_eh_frame->output_offset
15811                     + (p + 8 - htab->glink_eh_frame->contents));
15812             if (val + 0x80000000 > 0xffffffff)
15813               {
15814                 info->callbacks->einfo
15815                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15816                    group->stub_sec->name);
15817                 return FALSE;
15818               }
15819             bfd_put_32 (dynobj, val, p + 8);
15820             p += stub_eh_frame_size (group, align);
15821           }
15822       if (htab->glink != NULL && htab->glink->size != 0)
15823         {
15824           /* Offset to .glink.  */
15825           val = (htab->glink->output_section->vma
15826                  + htab->glink->output_offset
15827                  + 8);
15828           val -= (htab->glink_eh_frame->output_section->vma
15829                   + htab->glink_eh_frame->output_offset
15830                   + (p + 8 - htab->glink_eh_frame->contents));
15831           if (val + 0x80000000 > 0xffffffff)
15832             {
15833               info->callbacks->einfo
15834                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15835                  htab->glink->name);
15836               return FALSE;
15837             }
15838           bfd_put_32 (dynobj, val, p + 8);
15839           p += (24 + align - 1) & -align;
15840         }
15841
15842       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15843           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15844                                                htab->glink_eh_frame,
15845                                                htab->glink_eh_frame->contents))
15846         return FALSE;
15847     }
15848
15849   /* We need to handle writing out multiple GOT sections ourselves,
15850      since we didn't add them to DYNOBJ.  We know dynobj is the first
15851      bfd.  */
15852   while ((dynobj = dynobj->link.next) != NULL)
15853     {
15854       asection *s;
15855
15856       if (!is_ppc64_elf (dynobj))
15857         continue;
15858
15859       s = ppc64_elf_tdata (dynobj)->got;
15860       if (s != NULL
15861           && s->size != 0
15862           && s->output_section != bfd_abs_section_ptr
15863           && !bfd_set_section_contents (output_bfd, s->output_section,
15864                                         s->contents, s->output_offset,
15865                                         s->size))
15866         return FALSE;
15867       s = ppc64_elf_tdata (dynobj)->relgot;
15868       if (s != NULL
15869           && s->size != 0
15870           && s->output_section != bfd_abs_section_ptr
15871           && !bfd_set_section_contents (output_bfd, s->output_section,
15872                                         s->contents, s->output_offset,
15873                                         s->size))
15874         return FALSE;
15875     }
15876
15877   return TRUE;
15878 }
15879
15880 #include "elf64-target.h"
15881
15882 /* FreeBSD support */
15883
15884 #undef  TARGET_LITTLE_SYM
15885 #undef  TARGET_LITTLE_NAME
15886
15887 #undef  TARGET_BIG_SYM
15888 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15889 #undef  TARGET_BIG_NAME
15890 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15891
15892 #undef  ELF_OSABI
15893 #define ELF_OSABI       ELFOSABI_FREEBSD
15894
15895 #undef  elf64_bed
15896 #define elf64_bed       elf64_powerpc_fbsd_bed
15897
15898 #include "elf64-target.h"