bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2018 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_relocs_compatible         _bfd_elf_relocs_compatible
 105 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 106 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 107 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_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_PLTresolve stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 192   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 193                                         /* 0:                           */
 194                                         /*  .quad plt0-1f               */
 195                                         /* __glink:                     */
 196 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 197 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 198                                         /* 1:                           */
 199 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 200                                         /*  ld %2,(0b-1b)(%11)          */
 201 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 202 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 203                                         /*  ld %12,0(%11)               */
 204                                         /*  ld %2,8(%11)                */
 205                                         /*  mtctr %12                   */
 206                                         /*  ld %11,16(%11)              */
 207                                         /*  bctr                        */
 208 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 209 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 210 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 211 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 212 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 213
 214 /* Pad with this.  */
 215 #define NOP             0x60000000
 216
 217 /* Some other nops.  */
 218 #define CROR_151515     0x4def7b82
 219 #define CROR_313131     0x4ffffb82
 220
 221 /* .glink entries for the first 32k functions are two instructions.  */
 222 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 223 #define B_DOT           0x48000000      /* b     .              */
 224
 225 /* After that, we need two instructions to load the index, followed by
 226    a branch.  */
 227 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 228 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 229
 230 /* Instructions used by the save and restore reg functions.  */
 231 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 232 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 233 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 234 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 235 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 236 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 237 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 238 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 239 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 240 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 241 #define BLR             0x4e800020      /* blr                  */
 242
 243 /* Since .opd is an array of descriptors and each entry will end up
 244    with identical R_PPC64_RELATIVE relocs, there is really no need to
 245    propagate .opd relocs;  The dynamic linker should be taught to
 246    relocate .opd without reloc entries.  */
 247 #ifndef NO_OPD_RELOCS
 248 #define NO_OPD_RELOCS 0
 249 #endif
 250
 251 #ifndef ARRAY_SIZE
 252 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 253 #endif
 254
 255 static inline int
 256 abiversion (bfd *abfd)
 257 {
 258   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 259 }
 260
 261 static inline void
 262 set_abiversion (bfd *abfd, int ver)
 263 {
 264   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 265   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 266 }
 267 \f
 268 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 269
 270 /* Relocation HOWTO's.  */
 271 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 272
 273 static reloc_howto_type ppc64_elf_howto_raw[] =
 274 {
 275   /* This reloc does nothing.  */
 276   HOWTO (R_PPC64_NONE,          /* type */
 277          0,                     /* rightshift */
 278          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          0,                     /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_dont, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_PPC64_NONE",        /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0,                     /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* A standard 32 bit relocation.  */
 291   HOWTO (R_PPC64_ADDR32,        /* type */
 292          0,                     /* rightshift */
 293          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 294          32,                    /* bitsize */
 295          FALSE,                 /* pc_relative */
 296          0,                     /* bitpos */
 297          complain_overflow_bitfield, /* complain_on_overflow */
 298          bfd_elf_generic_reloc, /* special_function */
 299          "R_PPC64_ADDR32",      /* name */
 300          FALSE,                 /* partial_inplace */
 301          0,                     /* src_mask */
 302          0xffffffff,            /* dst_mask */
 303          FALSE),                /* pcrel_offset */
 304
 305   /* An absolute 26 bit branch; the lower two bits must be zero.
 306      FIXME: we don't check that, we just clear them.  */
 307   HOWTO (R_PPC64_ADDR24,        /* type */
 308          0,                     /* rightshift */
 309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          26,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_bitfield, /* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_PPC64_ADDR24",      /* name */
 316          FALSE,                 /* partial_inplace */
 317          0,                     /* src_mask */
 318          0x03fffffc,            /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* A standard 16 bit relocation.  */
 322   HOWTO (R_PPC64_ADDR16,        /* type */
 323          0,                     /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_bitfield, /* complain_on_overflow */
 329          bfd_elf_generic_reloc, /* special_function */
 330          "R_PPC64_ADDR16",      /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* A 16 bit relocation without overflow.  */
 337   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 338          0,                     /* rightshift */
 339          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          16,                    /* bitsize */
 341          FALSE,                 /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_dont,/* complain_on_overflow */
 344          bfd_elf_generic_reloc, /* special_function */
 345          "R_PPC64_ADDR16_LO",   /* name */
 346          FALSE,                 /* partial_inplace */
 347          0,                     /* src_mask */
 348          0xffff,                /* dst_mask */
 349          FALSE),                /* pcrel_offset */
 350
 351   /* Bits 16-31 of an address.  */
 352   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 353          16,                    /* rightshift */
 354          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          16,                    /* bitsize */
 356          FALSE,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_signed, /* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* special_function */
 360          "R_PPC64_ADDR16_HI",   /* name */
 361          FALSE,                 /* partial_inplace */
 362          0,                     /* src_mask */
 363          0xffff,                /* dst_mask */
 364          FALSE),                /* pcrel_offset */
 365
 366   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 367      bits, treated as a signed number, is negative.  */
 368   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 369          16,                    /* rightshift */
 370          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 371          16,                    /* bitsize */
 372          FALSE,                 /* pc_relative */
 373          0,                     /* bitpos */
 374          complain_overflow_signed, /* complain_on_overflow */
 375          ppc64_elf_ha_reloc,    /* special_function */
 376          "R_PPC64_ADDR16_HA",   /* name */
 377          FALSE,                 /* partial_inplace */
 378          0,                     /* src_mask */
 379          0xffff,                /* dst_mask */
 380          FALSE),                /* pcrel_offset */
 381
 382   /* An absolute 16 bit branch; the lower two bits must be zero.
 383      FIXME: we don't check that, we just clear them.  */
 384   HOWTO (R_PPC64_ADDR14,        /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          16,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_signed, /* complain_on_overflow */
 391          ppc64_elf_branch_reloc, /* special_function */
 392          "R_PPC64_ADDR14",      /* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0x0000fffc,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   /* An absolute 16 bit branch, for which bit 10 should be set to
 399      indicate that the branch is expected to be taken.  The lower two
 400      bits must be zero.  */
 401   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_signed, /* complain_on_overflow */
 408          ppc64_elf_brtaken_reloc, /* special_function */
 409          "R_PPC64_ADDR14_BRTAKEN",/* name */
 410          FALSE,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0x0000fffc,            /* dst_mask */
 413          FALSE),                /* pcrel_offset */
 414
 415   /* An absolute 16 bit branch, for which bit 10 should be set to
 416      indicate that the branch is not expected to be taken.  The lower
 417      two bits must be zero.  */
 418   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          16,                    /* bitsize */
 422          FALSE,                 /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          ppc64_elf_brtaken_reloc, /* special_function */
 426          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 427          FALSE,                 /* partial_inplace */
 428          0,                     /* src_mask */
 429          0x0000fffc,            /* dst_mask */
 430          FALSE),                /* pcrel_offset */
 431
 432   /* A relative 26 bit branch; the lower two bits must be zero.  */
 433   HOWTO (R_PPC64_REL24,         /* type */
 434          0,                     /* rightshift */
 435          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 436          26,                    /* bitsize */
 437          TRUE,                  /* pc_relative */
 438          0,                     /* bitpos */
 439          complain_overflow_signed, /* complain_on_overflow */
 440          ppc64_elf_branch_reloc, /* special_function */
 441          "R_PPC64_REL24",       /* name */
 442          FALSE,                 /* partial_inplace */
 443          0,                     /* src_mask */
 444          0x03fffffc,            /* dst_mask */
 445          TRUE),                 /* pcrel_offset */
 446
 447   /* A relative 16 bit branch; the lower two bits must be zero.  */
 448   HOWTO (R_PPC64_REL14,         /* type */
 449          0,                     /* rightshift */
 450          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 451          16,                    /* bitsize */
 452          TRUE,                  /* pc_relative */
 453          0,                     /* bitpos */
 454          complain_overflow_signed, /* complain_on_overflow */
 455          ppc64_elf_branch_reloc, /* special_function */
 456          "R_PPC64_REL14",       /* name */
 457          FALSE,                 /* partial_inplace */
 458          0,                     /* src_mask */
 459          0x0000fffc,            /* dst_mask */
 460          TRUE),                 /* pcrel_offset */
 461
 462   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 463      the branch is expected to be taken.  The lower two bits must be
 464      zero.  */
 465   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 466          0,                     /* rightshift */
 467          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 468          16,                    /* bitsize */
 469          TRUE,                  /* pc_relative */
 470          0,                     /* bitpos */
 471          complain_overflow_signed, /* complain_on_overflow */
 472          ppc64_elf_brtaken_reloc, /* special_function */
 473          "R_PPC64_REL14_BRTAKEN", /* name */
 474          FALSE,                 /* partial_inplace */
 475          0,                     /* src_mask */
 476          0x0000fffc,            /* dst_mask */
 477          TRUE),                 /* pcrel_offset */
 478
 479   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 480      the branch is not expected to be taken.  The lower two bits must
 481      be zero.  */
 482   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 483          0,                     /* rightshift */
 484          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 485          16,                    /* bitsize */
 486          TRUE,                  /* pc_relative */
 487          0,                     /* bitpos */
 488          complain_overflow_signed, /* complain_on_overflow */
 489          ppc64_elf_brtaken_reloc, /* special_function */
 490          "R_PPC64_REL14_BRNTAKEN",/* name */
 491          FALSE,                 /* partial_inplace */
 492          0,                     /* src_mask */
 493          0x0000fffc,            /* dst_mask */
 494          TRUE),                 /* pcrel_offset */
 495
 496   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 497      symbol.  */
 498   HOWTO (R_PPC64_GOT16,         /* type */
 499          0,                     /* rightshift */
 500          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 501          16,                    /* bitsize */
 502          FALSE,                 /* pc_relative */
 503          0,                     /* bitpos */
 504          complain_overflow_signed, /* complain_on_overflow */
 505          ppc64_elf_unhandled_reloc, /* special_function */
 506          "R_PPC64_GOT16",       /* name */
 507          FALSE,                 /* partial_inplace */
 508          0,                     /* src_mask */
 509          0xffff,                /* dst_mask */
 510          FALSE),                /* pcrel_offset */
 511
 512   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 513      the symbol.  */
 514   HOWTO (R_PPC64_GOT16_LO,      /* type */
 515          0,                     /* rightshift */
 516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 517          16,                    /* bitsize */
 518          FALSE,                 /* pc_relative */
 519          0,                     /* bitpos */
 520          complain_overflow_dont, /* complain_on_overflow */
 521          ppc64_elf_unhandled_reloc, /* special_function */
 522          "R_PPC64_GOT16_LO",    /* name */
 523          FALSE,                 /* partial_inplace */
 524          0,                     /* src_mask */
 525          0xffff,                /* dst_mask */
 526          FALSE),                /* pcrel_offset */
 527
 528   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 529      the symbol.  */
 530   HOWTO (R_PPC64_GOT16_HI,      /* type */
 531          16,                    /* rightshift */
 532          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 533          16,                    /* bitsize */
 534          FALSE,                 /* pc_relative */
 535          0,                     /* bitpos */
 536          complain_overflow_signed,/* complain_on_overflow */
 537          ppc64_elf_unhandled_reloc, /* special_function */
 538          "R_PPC64_GOT16_HI",    /* name */
 539          FALSE,                 /* partial_inplace */
 540          0,                     /* src_mask */
 541          0xffff,                /* dst_mask */
 542          FALSE),                /* pcrel_offset */
 543
 544   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 545      the symbol.  */
 546   HOWTO (R_PPC64_GOT16_HA,      /* type */
 547          16,                    /* rightshift */
 548          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 549          16,                    /* bitsize */
 550          FALSE,                 /* pc_relative */
 551          0,                     /* bitpos */
 552          complain_overflow_signed,/* complain_on_overflow */
 553          ppc64_elf_unhandled_reloc, /* special_function */
 554          "R_PPC64_GOT16_HA",    /* name */
 555          FALSE,                 /* partial_inplace */
 556          0,                     /* src_mask */
 557          0xffff,                /* dst_mask */
 558          FALSE),                /* pcrel_offset */
 559
 560   /* This is used only by the dynamic linker.  The symbol should exist
 561      both in the object being run and in some shared library.  The
 562      dynamic linker copies the data addressed by the symbol from the
 563      shared library into the object, because the object being
 564      run has to have the data at some particular address.  */
 565   HOWTO (R_PPC64_COPY,          /* type */
 566          0,                     /* rightshift */
 567          0,                     /* this one is variable size */
 568          0,                     /* bitsize */
 569          FALSE,                 /* pc_relative */
 570          0,                     /* bitpos */
 571          complain_overflow_dont, /* complain_on_overflow */
 572          ppc64_elf_unhandled_reloc, /* special_function */
 573          "R_PPC64_COPY",        /* name */
 574          FALSE,                 /* partial_inplace */
 575          0,                     /* src_mask */
 576          0,                     /* dst_mask */
 577          FALSE),                /* pcrel_offset */
 578
 579   /* Like R_PPC64_ADDR64, but used when setting global offset table
 580      entries.  */
 581   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 582          0,                     /* rightshift */
 583          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 584          64,                    /* bitsize */
 585          FALSE,                 /* pc_relative */
 586          0,                     /* bitpos */
 587          complain_overflow_dont, /* complain_on_overflow */
 588          ppc64_elf_unhandled_reloc,  /* special_function */
 589          "R_PPC64_GLOB_DAT",    /* name */
 590          FALSE,                 /* partial_inplace */
 591          0,                     /* src_mask */
 592          ONES (64),             /* dst_mask */
 593          FALSE),                /* pcrel_offset */
 594
 595   /* Created by the link editor.  Marks a procedure linkage table
 596      entry for a symbol.  */
 597   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 598          0,                     /* rightshift */
 599          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 600          0,                     /* bitsize */
 601          FALSE,                 /* pc_relative */
 602          0,                     /* bitpos */
 603          complain_overflow_dont, /* complain_on_overflow */
 604          ppc64_elf_unhandled_reloc, /* special_function */
 605          "R_PPC64_JMP_SLOT",    /* name */
 606          FALSE,                 /* partial_inplace */
 607          0,                     /* src_mask */
 608          0,                     /* dst_mask */
 609          FALSE),                /* pcrel_offset */
 610
 611   /* Used only by the dynamic linker.  When the object is run, this
 612      doubleword64 is set to the load address of the object, plus the
 613      addend.  */
 614   HOWTO (R_PPC64_RELATIVE,      /* type */
 615          0,                     /* rightshift */
 616          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 617          64,                    /* bitsize */
 618          FALSE,                 /* pc_relative */
 619          0,                     /* bitpos */
 620          complain_overflow_dont, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_RELATIVE",    /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          ONES (64),             /* dst_mask */
 626          FALSE),                /* pcrel_offset */
 627
 628   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 629   HOWTO (R_PPC64_UADDR32,       /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          FALSE,                 /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_bitfield, /* complain_on_overflow */
 636          bfd_elf_generic_reloc, /* special_function */
 637          "R_PPC64_UADDR32",     /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          FALSE),                /* pcrel_offset */
 642
 643   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 644   HOWTO (R_PPC64_UADDR16,       /* type */
 645          0,                     /* rightshift */
 646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          16,                    /* bitsize */
 648          FALSE,                 /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_bitfield, /* complain_on_overflow */
 651          bfd_elf_generic_reloc, /* special_function */
 652          "R_PPC64_UADDR16",     /* name */
 653          FALSE,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffff,                /* dst_mask */
 656          FALSE),                /* pcrel_offset */
 657
 658   /* 32-bit PC relative.  */
 659   HOWTO (R_PPC64_REL32,         /* type */
 660          0,                     /* rightshift */
 661          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 662          32,                    /* bitsize */
 663          TRUE,                  /* pc_relative */
 664          0,                     /* bitpos */
 665          complain_overflow_signed, /* complain_on_overflow */
 666          bfd_elf_generic_reloc, /* special_function */
 667          "R_PPC64_REL32",       /* name */
 668          FALSE,                 /* partial_inplace */
 669          0,                     /* src_mask */
 670          0xffffffff,            /* dst_mask */
 671          TRUE),                 /* pcrel_offset */
 672
 673   /* 32-bit relocation to the symbol's procedure linkage table.  */
 674   HOWTO (R_PPC64_PLT32,         /* type */
 675          0,                     /* rightshift */
 676          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 677          32,                    /* bitsize */
 678          FALSE,                 /* pc_relative */
 679          0,                     /* bitpos */
 680          complain_overflow_bitfield, /* complain_on_overflow */
 681          ppc64_elf_unhandled_reloc, /* special_function */
 682          "R_PPC64_PLT32",       /* name */
 683          FALSE,                 /* partial_inplace */
 684          0,                     /* src_mask */
 685          0xffffffff,            /* dst_mask */
 686          FALSE),                /* pcrel_offset */
 687
 688   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 689      FIXME: R_PPC64_PLTREL32 not supported.  */
 690   HOWTO (R_PPC64_PLTREL32,      /* type */
 691          0,                     /* rightshift */
 692          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 693          32,                    /* bitsize */
 694          TRUE,                  /* pc_relative */
 695          0,                     /* bitpos */
 696          complain_overflow_signed, /* complain_on_overflow */
 697          ppc64_elf_unhandled_reloc, /* special_function */
 698          "R_PPC64_PLTREL32",    /* name */
 699          FALSE,                 /* partial_inplace */
 700          0,                     /* src_mask */
 701          0xffffffff,            /* dst_mask */
 702          TRUE),                 /* pcrel_offset */
 703
 704   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 705      the symbol.  */
 706   HOWTO (R_PPC64_PLT16_LO,      /* type */
 707          0,                     /* rightshift */
 708          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 709          16,                    /* bitsize */
 710          FALSE,                 /* pc_relative */
 711          0,                     /* bitpos */
 712          complain_overflow_dont, /* complain_on_overflow */
 713          ppc64_elf_unhandled_reloc, /* special_function */
 714          "R_PPC64_PLT16_LO",    /* name */
 715          FALSE,                 /* partial_inplace */
 716          0,                     /* src_mask */
 717          0xffff,                /* dst_mask */
 718          FALSE),                /* pcrel_offset */
 719
 720   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 721      the symbol.  */
 722   HOWTO (R_PPC64_PLT16_HI,      /* type */
 723          16,                    /* rightshift */
 724          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 725          16,                    /* bitsize */
 726          FALSE,                 /* pc_relative */
 727          0,                     /* bitpos */
 728          complain_overflow_signed, /* complain_on_overflow */
 729          ppc64_elf_unhandled_reloc, /* special_function */
 730          "R_PPC64_PLT16_HI",    /* name */
 731          FALSE,                 /* partial_inplace */
 732          0,                     /* src_mask */
 733          0xffff,                /* dst_mask */
 734          FALSE),                /* pcrel_offset */
 735
 736   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 737      the symbol.  */
 738   HOWTO (R_PPC64_PLT16_HA,      /* type */
 739          16,                    /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_signed, /* complain_on_overflow */
 745          ppc64_elf_unhandled_reloc, /* special_function */
 746          "R_PPC64_PLT16_HA",    /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF,       /* type */
 754          0,                     /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_signed, /* complain_on_overflow */
 760          ppc64_elf_sectoff_reloc, /* special_function */
 761          "R_PPC64_SECTOFF",     /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 768   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 769          0,                     /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont, /* complain_on_overflow */
 775          ppc64_elf_sectoff_reloc, /* special_function */
 776          "R_PPC64_SECTOFF_LO",  /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* 16-bit upper half section relative relocation.  */
 783   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 784          16,                    /* rightshift */
 785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          16,                    /* bitsize */
 787          FALSE,                 /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_signed, /* complain_on_overflow */
 790          ppc64_elf_sectoff_reloc, /* special_function */
 791          "R_PPC64_SECTOFF_HI",  /* name */
 792          FALSE,                 /* partial_inplace */
 793          0,                     /* src_mask */
 794          0xffff,                /* dst_mask */
 795          FALSE),                /* pcrel_offset */
 796
 797   /* 16-bit upper half adjusted section relative relocation.  */
 798   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 799          16,                    /* rightshift */
 800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 801          16,                    /* bitsize */
 802          FALSE,                 /* pc_relative */
 803          0,                     /* bitpos */
 804          complain_overflow_signed, /* complain_on_overflow */
 805          ppc64_elf_sectoff_ha_reloc, /* special_function */
 806          "R_PPC64_SECTOFF_HA",  /* name */
 807          FALSE,                 /* partial_inplace */
 808          0,                     /* src_mask */
 809          0xffff,                /* dst_mask */
 810          FALSE),                /* pcrel_offset */
 811
 812   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 813   HOWTO (R_PPC64_REL30,         /* type */
 814          2,                     /* rightshift */
 815          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 816          30,                    /* bitsize */
 817          TRUE,                  /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_dont, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_PPC64_REL30",       /* name */
 822          FALSE,                 /* partial_inplace */
 823          0,                     /* src_mask */
 824          0xfffffffc,            /* dst_mask */
 825          TRUE),                 /* pcrel_offset */
 826
 827   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 828
 829   /* A standard 64-bit relocation.  */
 830   HOWTO (R_PPC64_ADDR64,        /* type */
 831          0,                     /* rightshift */
 832          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 833          64,                    /* bitsize */
 834          FALSE,                 /* pc_relative */
 835          0,                     /* bitpos */
 836          complain_overflow_dont, /* complain_on_overflow */
 837          bfd_elf_generic_reloc, /* special_function */
 838          "R_PPC64_ADDR64",      /* name */
 839          FALSE,                 /* partial_inplace */
 840          0,                     /* src_mask */
 841          ONES (64),             /* dst_mask */
 842          FALSE),                /* pcrel_offset */
 843
 844   /* The bits 32-47 of an address.  */
 845   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 846          32,                    /* rightshift */
 847          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 848          16,                    /* bitsize */
 849          FALSE,                 /* pc_relative */
 850          0,                     /* bitpos */
 851          complain_overflow_dont, /* complain_on_overflow */
 852          bfd_elf_generic_reloc, /* special_function */
 853          "R_PPC64_ADDR16_HIGHER", /* name */
 854          FALSE,                 /* partial_inplace */
 855          0,                     /* src_mask */
 856          0xffff,                /* dst_mask */
 857          FALSE),                /* pcrel_offset */
 858
 859   /* The bits 32-47 of an address, plus 1 if the contents of the low
 860      16 bits, treated as a signed number, is negative.  */
 861   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 862          32,                    /* rightshift */
 863          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 864          16,                    /* bitsize */
 865          FALSE,                 /* pc_relative */
 866          0,                     /* bitpos */
 867          complain_overflow_dont, /* complain_on_overflow */
 868          ppc64_elf_ha_reloc,    /* special_function */
 869          "R_PPC64_ADDR16_HIGHERA", /* name */
 870          FALSE,                 /* partial_inplace */
 871          0,                     /* src_mask */
 872          0xffff,                /* dst_mask */
 873          FALSE),                /* pcrel_offset */
 874
 875   /* The bits 48-63 of an address.  */
 876   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 877          48,                    /* rightshift */
 878          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 879          16,                    /* bitsize */
 880          FALSE,                 /* pc_relative */
 881          0,                     /* bitpos */
 882          complain_overflow_dont, /* complain_on_overflow */
 883          bfd_elf_generic_reloc, /* special_function */
 884          "R_PPC64_ADDR16_HIGHEST", /* name */
 885          FALSE,                 /* partial_inplace */
 886          0,                     /* src_mask */
 887          0xffff,                /* dst_mask */
 888          FALSE),                /* pcrel_offset */
 889
 890   /* The bits 48-63 of an address, plus 1 if the contents of the low
 891      16 bits, treated as a signed number, is negative.  */
 892   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 893          48,                    /* rightshift */
 894          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 895          16,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          ppc64_elf_ha_reloc,    /* special_function */
 900          "R_PPC64_ADDR16_HIGHESTA", /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          0xffff,                /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   /* Like ADDR64, but may be unaligned.  */
 907   HOWTO (R_PPC64_UADDR64,       /* type */
 908          0,                     /* rightshift */
 909          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 910          64,                    /* bitsize */
 911          FALSE,                 /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont, /* complain_on_overflow */
 914          bfd_elf_generic_reloc, /* special_function */
 915          "R_PPC64_UADDR64",     /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          ONES (64),             /* dst_mask */
 919          FALSE),                /* pcrel_offset */
 920
 921   /* 64-bit relative relocation.  */
 922   HOWTO (R_PPC64_REL64,         /* type */
 923          0,                     /* rightshift */
 924          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 925          64,                    /* bitsize */
 926          TRUE,                  /* pc_relative */
 927          0,                     /* bitpos */
 928          complain_overflow_dont, /* complain_on_overflow */
 929          bfd_elf_generic_reloc, /* special_function */
 930          "R_PPC64_REL64",       /* name */
 931          FALSE,                 /* partial_inplace */
 932          0,                     /* src_mask */
 933          ONES (64),             /* dst_mask */
 934          TRUE),                 /* pcrel_offset */
 935
 936   /* 64-bit relocation to the symbol's procedure linkage table.  */
 937   HOWTO (R_PPC64_PLT64,         /* type */
 938          0,                     /* rightshift */
 939          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 940          64,                    /* bitsize */
 941          FALSE,                 /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          ppc64_elf_unhandled_reloc, /* special_function */
 945          "R_PPC64_PLT64",       /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          ONES (64),             /* dst_mask */
 949          FALSE),                /* pcrel_offset */
 950
 951   /* 64-bit PC relative relocation to the symbol's procedure linkage
 952      table.  */
 953   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 954   HOWTO (R_PPC64_PLTREL64,      /* type */
 955          0,                     /* rightshift */
 956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 957          64,                    /* bitsize */
 958          TRUE,                  /* pc_relative */
 959          0,                     /* bitpos */
 960          complain_overflow_dont, /* complain_on_overflow */
 961          ppc64_elf_unhandled_reloc, /* special_function */
 962          "R_PPC64_PLTREL64",    /* name */
 963          FALSE,                 /* partial_inplace */
 964          0,                     /* src_mask */
 965          ONES (64),             /* dst_mask */
 966          TRUE),                 /* pcrel_offset */
 967
 968   /* 16 bit TOC-relative relocation.  */
 969
 970   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 971   HOWTO (R_PPC64_TOC16,         /* type */
 972          0,                     /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_signed, /* complain_on_overflow */
 978          ppc64_elf_toc_reloc,   /* special_function */
 979          "R_PPC64_TOC16",       /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 16 bit TOC-relative relocation without overflow.  */
 986
 987   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 988   HOWTO (R_PPC64_TOC16_LO,      /* type */
 989          0,                     /* rightshift */
 990          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 991          16,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_dont, /* complain_on_overflow */
 995          ppc64_elf_toc_reloc,   /* special_function */
 996          "R_PPC64_TOC16_LO",    /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          0xffff,                /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* 16 bit TOC-relative relocation, high 16 bits.  */
1003
1004   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1005   HOWTO (R_PPC64_TOC16_HI,      /* type */
1006          16,                    /* rightshift */
1007          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1008          16,                    /* bitsize */
1009          FALSE,                 /* pc_relative */
1010          0,                     /* bitpos */
1011          complain_overflow_signed, /* complain_on_overflow */
1012          ppc64_elf_toc_reloc,   /* special_function */
1013          "R_PPC64_TOC16_HI",    /* name */
1014          FALSE,                 /* partial_inplace */
1015          0,                     /* src_mask */
1016          0xffff,                /* dst_mask */
1017          FALSE),                /* pcrel_offset */
1018
1019   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1020      contents of the low 16 bits, treated as a signed number, is
1021      negative.  */
1022
1023   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1024   HOWTO (R_PPC64_TOC16_HA,      /* type */
1025          16,                    /* rightshift */
1026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1027          16,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_signed, /* complain_on_overflow */
1031          ppc64_elf_toc_ha_reloc, /* special_function */
1032          "R_PPC64_TOC16_HA",    /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          0xffff,                /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1039
1040   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1041   HOWTO (R_PPC64_TOC,           /* type */
1042          0,                     /* rightshift */
1043          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1044          64,                    /* bitsize */
1045          FALSE,                 /* pc_relative */
1046          0,                     /* bitpos */
1047          complain_overflow_dont, /* complain_on_overflow */
1048          ppc64_elf_toc64_reloc, /* special_function */
1049          "R_PPC64_TOC",         /* name */
1050          FALSE,                 /* partial_inplace */
1051          0,                     /* src_mask */
1052          ONES (64),             /* dst_mask */
1053          FALSE),                /* pcrel_offset */
1054
1055   /* Like R_PPC64_GOT16, but also informs the link editor that the
1056      value to relocate may (!) refer to a PLT entry which the link
1057      editor (a) may replace with the symbol value.  If the link editor
1058      is unable to fully resolve the symbol, it may (b) create a PLT
1059      entry and store the address to the new PLT entry in the GOT.
1060      This permits lazy resolution of function symbols at run time.
1061      The link editor may also skip all of this and just (c) emit a
1062      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1063   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1064     HOWTO (R_PPC64_PLTGOT16,    /* type */
1065          0,                     /* rightshift */
1066          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1067          16,                    /* bitsize */
1068          FALSE,                 /* pc_relative */
1069          0,                     /* bitpos */
1070          complain_overflow_signed, /* complain_on_overflow */
1071          ppc64_elf_unhandled_reloc, /* special_function */
1072          "R_PPC64_PLTGOT16",    /* name */
1073          FALSE,                 /* partial_inplace */
1074          0,                     /* src_mask */
1075          0xffff,                /* dst_mask */
1076          FALSE),                /* pcrel_offset */
1077
1078   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1079   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1080   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1081          0,                     /* rightshift */
1082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1083          16,                    /* bitsize */
1084          FALSE,                 /* pc_relative */
1085          0,                     /* bitpos */
1086          complain_overflow_dont, /* complain_on_overflow */
1087          ppc64_elf_unhandled_reloc, /* special_function */
1088          "R_PPC64_PLTGOT16_LO", /* name */
1089          FALSE,                 /* partial_inplace */
1090          0,                     /* src_mask */
1091          0xffff,                /* dst_mask */
1092          FALSE),                /* pcrel_offset */
1093
1094   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1095   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1096   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1097          16,                    /* rightshift */
1098          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1099          16,                    /* bitsize */
1100          FALSE,                 /* pc_relative */
1101          0,                     /* bitpos */
1102          complain_overflow_signed, /* complain_on_overflow */
1103          ppc64_elf_unhandled_reloc, /* special_function */
1104          "R_PPC64_PLTGOT16_HI", /* name */
1105          FALSE,                 /* partial_inplace */
1106          0,                     /* src_mask */
1107          0xffff,                /* dst_mask */
1108          FALSE),                /* pcrel_offset */
1109
1110   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1111      1 if the contents of the low 16 bits, treated as a signed number,
1112      is negative.  */
1113   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1114   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1115          16,                    /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_signed, /* complain_on_overflow */
1121          ppc64_elf_unhandled_reloc, /* special_function */
1122          "R_PPC64_PLTGOT16_HA", /* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xffff,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_signed, /* complain_on_overflow */
1136          bfd_elf_generic_reloc, /* special_function */
1137          "R_PPC64_ADDR16_DS",   /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont,/* complain_on_overflow */
1151          bfd_elf_generic_reloc, /* special_function */
1152          "R_PPC64_ADDR16_LO_DS",/* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_GOT16_DS,      /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_signed, /* complain_on_overflow */
1166          ppc64_elf_unhandled_reloc, /* special_function */
1167          "R_PPC64_GOT16_DS",    /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_dont, /* complain_on_overflow */
1181          ppc64_elf_unhandled_reloc, /* special_function */
1182          "R_PPC64_GOT16_LO_DS", /* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont, /* complain_on_overflow */
1196          ppc64_elf_unhandled_reloc, /* special_function */
1197          "R_PPC64_PLT16_LO_DS", /* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_signed, /* complain_on_overflow */
1211          ppc64_elf_sectoff_reloc, /* special_function */
1212          "R_PPC64_SECTOFF_DS",  /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1219   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1220          0,                     /* rightshift */
1221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          16,                    /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont, /* complain_on_overflow */
1226          ppc64_elf_sectoff_reloc, /* special_function */
1227          "R_PPC64_SECTOFF_LO_DS",/* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0xfffc,                /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1234   HOWTO (R_PPC64_TOC16_DS,      /* type */
1235          0,                     /* rightshift */
1236          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1237          16,                    /* bitsize */
1238          FALSE,                 /* pc_relative */
1239          0,                     /* bitpos */
1240          complain_overflow_signed, /* complain_on_overflow */
1241          ppc64_elf_toc_reloc,   /* special_function */
1242          "R_PPC64_TOC16_DS",    /* name */
1243          FALSE,                 /* partial_inplace */
1244          0,                     /* src_mask */
1245          0xfffc,                /* dst_mask */
1246          FALSE),                /* pcrel_offset */
1247
1248   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1249   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1250          0,                     /* rightshift */
1251          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1252          16,                    /* bitsize */
1253          FALSE,                 /* pc_relative */
1254          0,                     /* bitpos */
1255          complain_overflow_dont, /* complain_on_overflow */
1256          ppc64_elf_toc_reloc,   /* special_function */
1257          "R_PPC64_TOC16_LO_DS", /* name */
1258          FALSE,                 /* partial_inplace */
1259          0,                     /* src_mask */
1260          0xfffc,                /* dst_mask */
1261          FALSE),                /* pcrel_offset */
1262
1263   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1264   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1265   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1266          0,                     /* rightshift */
1267          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1268          16,                    /* bitsize */
1269          FALSE,                 /* pc_relative */
1270          0,                     /* bitpos */
1271          complain_overflow_signed, /* complain_on_overflow */
1272          ppc64_elf_unhandled_reloc, /* special_function */
1273          "R_PPC64_PLTGOT16_DS", /* name */
1274          FALSE,                 /* partial_inplace */
1275          0,                     /* src_mask */
1276          0xfffc,                /* dst_mask */
1277          FALSE),                /* pcrel_offset */
1278
1279   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1280   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1281   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1282          0,                     /* rightshift */
1283          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1284          16,                    /* bitsize */
1285          FALSE,                 /* pc_relative */
1286          0,                     /* bitpos */
1287          complain_overflow_dont, /* complain_on_overflow */
1288          ppc64_elf_unhandled_reloc, /* special_function */
1289          "R_PPC64_PLTGOT16_LO_DS",/* name */
1290          FALSE,                 /* partial_inplace */
1291          0,                     /* src_mask */
1292          0xfffc,                /* dst_mask */
1293          FALSE),                /* pcrel_offset */
1294
1295   /* Marker relocs for TLS.  */
1296   HOWTO (R_PPC64_TLS,
1297          0,                     /* rightshift */
1298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1299          32,                    /* bitsize */
1300          FALSE,                 /* pc_relative */
1301          0,                     /* bitpos */
1302          complain_overflow_dont, /* complain_on_overflow */
1303          bfd_elf_generic_reloc, /* special_function */
1304          "R_PPC64_TLS",         /* name */
1305          FALSE,                 /* partial_inplace */
1306          0,                     /* src_mask */
1307          0,                     /* dst_mask */
1308          FALSE),                /* pcrel_offset */
1309
1310   HOWTO (R_PPC64_TLSGD,
1311          0,                     /* rightshift */
1312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1313          32,                    /* bitsize */
1314          FALSE,                 /* pc_relative */
1315          0,                     /* bitpos */
1316          complain_overflow_dont, /* complain_on_overflow */
1317          bfd_elf_generic_reloc, /* special_function */
1318          "R_PPC64_TLSGD",       /* name */
1319          FALSE,                 /* partial_inplace */
1320          0,                     /* src_mask */
1321          0,                     /* dst_mask */
1322          FALSE),                /* pcrel_offset */
1323
1324   HOWTO (R_PPC64_TLSLD,
1325          0,                     /* rightshift */
1326          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1327          32,                    /* bitsize */
1328          FALSE,                 /* pc_relative */
1329          0,                     /* bitpos */
1330          complain_overflow_dont, /* complain_on_overflow */
1331          bfd_elf_generic_reloc, /* special_function */
1332          "R_PPC64_TLSLD",       /* name */
1333          FALSE,                 /* partial_inplace */
1334          0,                     /* src_mask */
1335          0,                     /* dst_mask */
1336          FALSE),                /* pcrel_offset */
1337
1338   HOWTO (R_PPC64_TOCSAVE,
1339          0,                     /* rightshift */
1340          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1341          32,                    /* bitsize */
1342          FALSE,                 /* pc_relative */
1343          0,                     /* bitpos */
1344          complain_overflow_dont, /* complain_on_overflow */
1345          bfd_elf_generic_reloc, /* special_function */
1346          "R_PPC64_TOCSAVE",     /* name */
1347          FALSE,                 /* partial_inplace */
1348          0,                     /* src_mask */
1349          0,                     /* dst_mask */
1350          FALSE),                /* pcrel_offset */
1351
1352   /* Computes the load module index of the load module that contains the
1353      definition of its TLS sym.  */
1354   HOWTO (R_PPC64_DTPMOD64,
1355          0,                     /* rightshift */
1356          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1357          64,                    /* bitsize */
1358          FALSE,                 /* pc_relative */
1359          0,                     /* bitpos */
1360          complain_overflow_dont, /* complain_on_overflow */
1361          ppc64_elf_unhandled_reloc, /* special_function */
1362          "R_PPC64_DTPMOD64",    /* name */
1363          FALSE,                 /* partial_inplace */
1364          0,                     /* src_mask */
1365          ONES (64),             /* dst_mask */
1366          FALSE),                /* pcrel_offset */
1367
1368   /* Computes a dtv-relative displacement, the difference between the value
1369      of sym+add and the base address of the thread-local storage block that
1370      contains the definition of sym, minus 0x8000.  */
1371   HOWTO (R_PPC64_DTPREL64,
1372          0,                     /* rightshift */
1373          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          64,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL64",    /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          ONES (64),             /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* A 16 bit dtprel reloc.  */
1386   HOWTO (R_PPC64_DTPREL16,
1387          0,                     /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_signed, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16",    /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16, but no overflow.  */
1401   HOWTO (R_PPC64_DTPREL16_LO,
1402          0,                     /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_dont, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_LO", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HI,
1417          16,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_signed, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HI", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HA,
1432          16,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_signed, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HA", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHER,
1447          32,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHER", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1461   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1462          32,                    /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_dont, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_HIGHERA", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xffff,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1476   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1477          48,                    /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_dont, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_HIGHEST", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xffff,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1491   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1492          48,                    /* rightshift */
1493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          16,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_dont, /* complain_on_overflow */
1498          ppc64_elf_unhandled_reloc, /* special_function */
1499          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1500          FALSE,                 /* partial_inplace */
1501          0,                     /* src_mask */
1502          0xffff,                /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   /* Like DTPREL16, but for insns with a DS field.  */
1506   HOWTO (R_PPC64_DTPREL16_DS,
1507          0,                     /* rightshift */
1508          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1509          16,                    /* bitsize */
1510          FALSE,                 /* pc_relative */
1511          0,                     /* bitpos */
1512          complain_overflow_signed, /* complain_on_overflow */
1513          ppc64_elf_unhandled_reloc, /* special_function */
1514          "R_PPC64_DTPREL16_DS", /* name */
1515          FALSE,                 /* partial_inplace */
1516          0,                     /* src_mask */
1517          0xfffc,                /* dst_mask */
1518          FALSE),                /* pcrel_offset */
1519
1520   /* Like DTPREL16_DS, but no overflow.  */
1521   HOWTO (R_PPC64_DTPREL16_LO_DS,
1522          0,                     /* rightshift */
1523          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1524          16,                    /* bitsize */
1525          FALSE,                 /* pc_relative */
1526          0,                     /* bitpos */
1527          complain_overflow_dont, /* complain_on_overflow */
1528          ppc64_elf_unhandled_reloc, /* special_function */
1529          "R_PPC64_DTPREL16_LO_DS", /* name */
1530          FALSE,                 /* partial_inplace */
1531          0,                     /* src_mask */
1532          0xfffc,                /* dst_mask */
1533          FALSE),                /* pcrel_offset */
1534
1535   /* Computes a tp-relative displacement, the difference between the value of
1536      sym+add and the value of the thread pointer (r13).  */
1537   HOWTO (R_PPC64_TPREL64,
1538          0,                     /* rightshift */
1539          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          64,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL64",     /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          ONES (64),             /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* A 16 bit tprel reloc.  */
1552   HOWTO (R_PPC64_TPREL16,
1553          0,                     /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_signed, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16",     /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16, but no overflow.  */
1567   HOWTO (R_PPC64_TPREL16_LO,
1568          0,                     /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_dont, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_LO",  /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HI,
1583          16,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_signed, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HI",  /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HA,
1598          16,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_signed, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HA",  /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHER,
1613          32,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHER",      /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1627   HOWTO (R_PPC64_TPREL16_HIGHERA,
1628          32,                    /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_dont, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_HIGHERA", /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xffff,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1642   HOWTO (R_PPC64_TPREL16_HIGHEST,
1643          48,                    /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_dont, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_HIGHEST", /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xffff,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1657   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1658          48,                    /* rightshift */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1660          16,                    /* bitsize */
1661          FALSE,                 /* pc_relative */
1662          0,                     /* bitpos */
1663          complain_overflow_dont, /* complain_on_overflow */
1664          ppc64_elf_unhandled_reloc, /* special_function */
1665          "R_PPC64_TPREL16_HIGHESTA", /* name */
1666          FALSE,                 /* partial_inplace */
1667          0,                     /* src_mask */
1668          0xffff,                /* dst_mask */
1669          FALSE),                /* pcrel_offset */
1670
1671   /* Like TPREL16, but for insns with a DS field.  */
1672   HOWTO (R_PPC64_TPREL16_DS,
1673          0,                     /* rightshift */
1674          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1675          16,                    /* bitsize */
1676          FALSE,                 /* pc_relative */
1677          0,                     /* bitpos */
1678          complain_overflow_signed, /* complain_on_overflow */
1679          ppc64_elf_unhandled_reloc, /* special_function */
1680          "R_PPC64_TPREL16_DS",  /* name */
1681          FALSE,                 /* partial_inplace */
1682          0,                     /* src_mask */
1683          0xfffc,                /* dst_mask */
1684          FALSE),                /* pcrel_offset */
1685
1686   /* Like TPREL16_DS, but no overflow.  */
1687   HOWTO (R_PPC64_TPREL16_LO_DS,
1688          0,                     /* rightshift */
1689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1690          16,                    /* bitsize */
1691          FALSE,                 /* pc_relative */
1692          0,                     /* bitpos */
1693          complain_overflow_dont, /* complain_on_overflow */
1694          ppc64_elf_unhandled_reloc, /* special_function */
1695          "R_PPC64_TPREL16_LO_DS", /* name */
1696          FALSE,                 /* partial_inplace */
1697          0,                     /* src_mask */
1698          0xfffc,                /* dst_mask */
1699          FALSE),                /* pcrel_offset */
1700
1701   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1702      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1703      to the first entry relative to the TOC base (r2).  */
1704   HOWTO (R_PPC64_GOT_TLSGD16,
1705          0,                     /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_signed, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like GOT_TLSGD16, but no overflow.  */
1719   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1720          0,                     /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          FALSE,                 /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_dont, /* complain_on_overflow */
1726          ppc64_elf_unhandled_reloc, /* special_function */
1727          "R_PPC64_GOT_TLSGD16_LO", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1734   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1735          16,                    /* rightshift */
1736          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1737          16,                    /* bitsize */
1738          FALSE,                 /* pc_relative */
1739          0,                     /* bitpos */
1740          complain_overflow_signed, /* complain_on_overflow */
1741          ppc64_elf_unhandled_reloc, /* special_function */
1742          "R_PPC64_GOT_TLSGD16_HI", /* name */
1743          FALSE,                 /* partial_inplace */
1744          0,                     /* src_mask */
1745          0xffff,                /* dst_mask */
1746          FALSE),                /* pcrel_offset */
1747
1748   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1749   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1750          16,                    /* rightshift */
1751          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1752          16,                    /* bitsize */
1753          FALSE,                 /* pc_relative */
1754          0,                     /* bitpos */
1755          complain_overflow_signed, /* complain_on_overflow */
1756          ppc64_elf_unhandled_reloc, /* special_function */
1757          "R_PPC64_GOT_TLSGD16_HA", /* name */
1758          FALSE,                 /* partial_inplace */
1759          0,                     /* src_mask */
1760          0xffff,                /* dst_mask */
1761          FALSE),                /* pcrel_offset */
1762
1763   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1764      with values (sym+add)@dtpmod and zero, and computes the offset to the
1765      first entry relative to the TOC base (r2).  */
1766   HOWTO (R_PPC64_GOT_TLSLD16,
1767          0,                     /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_signed, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSLD16, but no overflow.  */
1781   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1782          0,                     /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_dont, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSLD16_LO", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1796   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1797          16,                    /* rightshift */
1798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1799          16,                    /* bitsize */
1800          FALSE,                 /* pc_relative */
1801          0,                     /* bitpos */
1802          complain_overflow_signed, /* complain_on_overflow */
1803          ppc64_elf_unhandled_reloc, /* special_function */
1804          "R_PPC64_GOT_TLSLD16_HI", /* name */
1805          FALSE,                 /* partial_inplace */
1806          0,                     /* src_mask */
1807          0xffff,                /* dst_mask */
1808          FALSE),                /* pcrel_offset */
1809
1810   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1811   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1812          16,                    /* rightshift */
1813          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1814          16,                    /* bitsize */
1815          FALSE,                 /* pc_relative */
1816          0,                     /* bitpos */
1817          complain_overflow_signed, /* complain_on_overflow */
1818          ppc64_elf_unhandled_reloc, /* special_function */
1819          "R_PPC64_GOT_TLSLD16_HA", /* name */
1820          FALSE,                 /* partial_inplace */
1821          0,                     /* src_mask */
1822          0xffff,                /* dst_mask */
1823          FALSE),                /* pcrel_offset */
1824
1825   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1826      the offset to the entry relative to the TOC base (r2).  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1828          0,                     /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_signed, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_DS", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xfffc,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Like GOT_DTPREL16_DS, but no overflow.  */
1842   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1843          0,                     /* rightshift */
1844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1845          16,                    /* bitsize */
1846          FALSE,                 /* pc_relative */
1847          0,                     /* bitpos */
1848          complain_overflow_dont, /* complain_on_overflow */
1849          ppc64_elf_unhandled_reloc, /* special_function */
1850          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1851          FALSE,                 /* partial_inplace */
1852          0,                     /* src_mask */
1853          0xfffc,                /* dst_mask */
1854          FALSE),                /* pcrel_offset */
1855
1856   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1857   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1858          16,                    /* rightshift */
1859          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1860          16,                    /* bitsize */
1861          FALSE,                 /* pc_relative */
1862          0,                     /* bitpos */
1863          complain_overflow_signed, /* complain_on_overflow */
1864          ppc64_elf_unhandled_reloc, /* special_function */
1865          "R_PPC64_GOT_DTPREL16_HI", /* name */
1866          FALSE,                 /* partial_inplace */
1867          0,                     /* src_mask */
1868          0xffff,                /* dst_mask */
1869          FALSE),                /* pcrel_offset */
1870
1871   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1872   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1873          16,                    /* rightshift */
1874          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1875          16,                    /* bitsize */
1876          FALSE,                 /* pc_relative */
1877          0,                     /* bitpos */
1878          complain_overflow_signed, /* complain_on_overflow */
1879          ppc64_elf_unhandled_reloc, /* special_function */
1880          "R_PPC64_GOT_DTPREL16_HA", /* name */
1881          FALSE,                 /* partial_inplace */
1882          0,                     /* src_mask */
1883          0xffff,                /* dst_mask */
1884          FALSE),                /* pcrel_offset */
1885
1886   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1887      offset to the entry relative to the TOC base (r2).  */
1888   HOWTO (R_PPC64_GOT_TPREL16_DS,
1889          0,                     /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_signed, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_DS", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xfffc,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   /* Like GOT_TPREL16_DS, but no overflow.  */
1903   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1904          0,                     /* rightshift */
1905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1906          16,                    /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_dont, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0xfffc,                /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1918   HOWTO (R_PPC64_GOT_TPREL16_HI,
1919          16,                    /* rightshift */
1920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1921          16,                    /* bitsize */
1922          FALSE,                 /* pc_relative */
1923          0,                     /* bitpos */
1924          complain_overflow_signed, /* complain_on_overflow */
1925          ppc64_elf_unhandled_reloc, /* special_function */
1926          "R_PPC64_GOT_TPREL16_HI", /* name */
1927          FALSE,                 /* partial_inplace */
1928          0,                     /* src_mask */
1929          0xffff,                /* dst_mask */
1930          FALSE),                /* pcrel_offset */
1931
1932   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1933   HOWTO (R_PPC64_GOT_TPREL16_HA,
1934          16,                    /* rightshift */
1935          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1936          16,                    /* bitsize */
1937          FALSE,                 /* pc_relative */
1938          0,                     /* bitpos */
1939          complain_overflow_signed, /* complain_on_overflow */
1940          ppc64_elf_unhandled_reloc, /* special_function */
1941          "R_PPC64_GOT_TPREL16_HA", /* name */
1942          FALSE,                 /* partial_inplace */
1943          0,                     /* src_mask */
1944          0xffff,                /* dst_mask */
1945          FALSE),                /* pcrel_offset */
1946
1947   HOWTO (R_PPC64_JMP_IREL,      /* type */
1948          0,                     /* rightshift */
1949          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1950          0,                     /* bitsize */
1951          FALSE,                 /* pc_relative */
1952          0,                     /* bitpos */
1953          complain_overflow_dont, /* complain_on_overflow */
1954          ppc64_elf_unhandled_reloc, /* special_function */
1955          "R_PPC64_JMP_IREL",    /* name */
1956          FALSE,                 /* partial_inplace */
1957          0,                     /* src_mask */
1958          0,                     /* dst_mask */
1959          FALSE),                /* pcrel_offset */
1960
1961   HOWTO (R_PPC64_IRELATIVE,     /* type */
1962          0,                     /* rightshift */
1963          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1964          64,                    /* bitsize */
1965          FALSE,                 /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont, /* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_IRELATIVE",   /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          ONES (64),             /* dst_mask */
1973          FALSE),                /* pcrel_offset */
1974
1975   /* A 16 bit relative relocation.  */
1976   HOWTO (R_PPC64_REL16,         /* type */
1977          0,                     /* rightshift */
1978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1979          16,                    /* bitsize */
1980          TRUE,                  /* pc_relative */
1981          0,                     /* bitpos */
1982          complain_overflow_signed, /* complain_on_overflow */
1983          bfd_elf_generic_reloc, /* special_function */
1984          "R_PPC64_REL16",       /* name */
1985          FALSE,                 /* partial_inplace */
1986          0,                     /* src_mask */
1987          0xffff,                /* dst_mask */
1988          TRUE),                 /* pcrel_offset */
1989
1990   /* A 16 bit relative relocation without overflow.  */
1991   HOWTO (R_PPC64_REL16_LO,      /* type */
1992          0,                     /* rightshift */
1993          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1994          16,                    /* bitsize */
1995          TRUE,                  /* pc_relative */
1996          0,                     /* bitpos */
1997          complain_overflow_dont,/* complain_on_overflow */
1998          bfd_elf_generic_reloc, /* special_function */
1999          "R_PPC64_REL16_LO",    /* name */
2000          FALSE,                 /* partial_inplace */
2001          0,                     /* src_mask */
2002          0xffff,                /* dst_mask */
2003          TRUE),                 /* pcrel_offset */
2004
2005   /* The high order 16 bits of a relative address.  */
2006   HOWTO (R_PPC64_REL16_HI,      /* type */
2007          16,                    /* rightshift */
2008          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2009          16,                    /* bitsize */
2010          TRUE,                  /* pc_relative */
2011          0,                     /* bitpos */
2012          complain_overflow_signed, /* complain_on_overflow */
2013          bfd_elf_generic_reloc, /* special_function */
2014          "R_PPC64_REL16_HI",    /* name */
2015          FALSE,                 /* partial_inplace */
2016          0,                     /* src_mask */
2017          0xffff,                /* dst_mask */
2018          TRUE),                 /* pcrel_offset */
2019
2020   /* The high order 16 bits of a relative address, plus 1 if the contents of
2021      the low 16 bits, treated as a signed number, is negative.  */
2022   HOWTO (R_PPC64_REL16_HA,      /* type */
2023          16,                    /* rightshift */
2024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2025          16,                    /* bitsize */
2026          TRUE,                  /* pc_relative */
2027          0,                     /* bitpos */
2028          complain_overflow_signed, /* complain_on_overflow */
2029          ppc64_elf_ha_reloc,    /* special_function */
2030          "R_PPC64_REL16_HA",    /* name */
2031          FALSE,                 /* partial_inplace */
2032          0,                     /* src_mask */
2033          0xffff,                /* dst_mask */
2034          TRUE),                 /* pcrel_offset */
2035
2036   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2037   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2038          16,                    /* rightshift */
2039          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2040          16,                    /* bitsize */
2041          TRUE,                  /* pc_relative */
2042          0,                     /* bitpos */
2043          complain_overflow_signed, /* complain_on_overflow */
2044          ppc64_elf_ha_reloc,    /* special_function */
2045          "R_PPC64_REL16DX_HA",  /* name */
2046          FALSE,                 /* partial_inplace */
2047          0,                     /* src_mask */
2048          0x1fffc1,              /* dst_mask */
2049          TRUE),                 /* pcrel_offset */
2050
2051   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2052   HOWTO (R_PPC64_16DX_HA,       /* type */
2053          16,                    /* rightshift */
2054          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2055          16,                    /* bitsize */
2056          FALSE,                 /* pc_relative */
2057          0,                     /* bitpos */
2058          complain_overflow_signed, /* complain_on_overflow */
2059          ppc64_elf_ha_reloc,    /* special_function */
2060          "R_PPC64_16DX_HA",     /* name */
2061          FALSE,                 /* partial_inplace */
2062          0,                     /* src_mask */
2063          0x1fffc1,              /* dst_mask */
2064          FALSE),                /* pcrel_offset */
2065
2066   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2067   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2068          16,                    /* rightshift */
2069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2070          16,                    /* bitsize */
2071          FALSE,                 /* pc_relative */
2072          0,                     /* bitpos */
2073          complain_overflow_dont, /* complain_on_overflow */
2074          bfd_elf_generic_reloc, /* special_function */
2075          "R_PPC64_ADDR16_HIGH", /* name */
2076          FALSE,                 /* partial_inplace */
2077          0,                     /* src_mask */
2078          0xffff,                /* dst_mask */
2079          FALSE),                /* pcrel_offset */
2080
2081   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2082   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2083          16,                    /* rightshift */
2084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2085          16,                    /* bitsize */
2086          FALSE,                 /* pc_relative */
2087          0,                     /* bitpos */
2088          complain_overflow_dont, /* complain_on_overflow */
2089          ppc64_elf_ha_reloc,    /* special_function */
2090          "R_PPC64_ADDR16_HIGHA",        /* name */
2091          FALSE,                 /* partial_inplace */
2092          0,                     /* src_mask */
2093          0xffff,                /* dst_mask */
2094          FALSE),                /* pcrel_offset */
2095
2096   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2097   HOWTO (R_PPC64_DTPREL16_HIGH,
2098          16,                    /* rightshift */
2099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2100          16,                    /* bitsize */
2101          FALSE,                 /* pc_relative */
2102          0,                     /* bitpos */
2103          complain_overflow_dont, /* complain_on_overflow */
2104          ppc64_elf_unhandled_reloc, /* special_function */
2105          "R_PPC64_DTPREL16_HIGH", /* name */
2106          FALSE,                 /* partial_inplace */
2107          0,                     /* src_mask */
2108          0xffff,                /* dst_mask */
2109          FALSE),                /* pcrel_offset */
2110
2111   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2112   HOWTO (R_PPC64_DTPREL16_HIGHA,
2113          16,                    /* rightshift */
2114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2115          16,                    /* bitsize */
2116          FALSE,                 /* pc_relative */
2117          0,                     /* bitpos */
2118          complain_overflow_dont, /* complain_on_overflow */
2119          ppc64_elf_unhandled_reloc, /* special_function */
2120          "R_PPC64_DTPREL16_HIGHA", /* name */
2121          FALSE,                 /* partial_inplace */
2122          0,                     /* src_mask */
2123          0xffff,                /* dst_mask */
2124          FALSE),                /* pcrel_offset */
2125
2126   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2127   HOWTO (R_PPC64_TPREL16_HIGH,
2128          16,                    /* rightshift */
2129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2130          16,                    /* bitsize */
2131          FALSE,                 /* pc_relative */
2132          0,                     /* bitpos */
2133          complain_overflow_dont, /* complain_on_overflow */
2134          ppc64_elf_unhandled_reloc, /* special_function */
2135          "R_PPC64_TPREL16_HIGH",        /* name */
2136          FALSE,                 /* partial_inplace */
2137          0,                     /* src_mask */
2138          0xffff,                /* dst_mask */
2139          FALSE),                /* pcrel_offset */
2140
2141   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2142   HOWTO (R_PPC64_TPREL16_HIGHA,
2143          16,                    /* rightshift */
2144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2145          16,                    /* bitsize */
2146          FALSE,                 /* pc_relative */
2147          0,                     /* bitpos */
2148          complain_overflow_dont, /* complain_on_overflow */
2149          ppc64_elf_unhandled_reloc, /* special_function */
2150          "R_PPC64_TPREL16_HIGHA",       /* name */
2151          FALSE,                 /* partial_inplace */
2152          0,                     /* src_mask */
2153          0xffff,                /* dst_mask */
2154          FALSE),                /* pcrel_offset */
2155
2156   /* Marker reloc on ELFv2 large-model function entry.  */
2157   HOWTO (R_PPC64_ENTRY,
2158          0,                     /* rightshift */
2159          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2160          32,                    /* bitsize */
2161          FALSE,                 /* pc_relative */
2162          0,                     /* bitpos */
2163          complain_overflow_dont, /* complain_on_overflow */
2164          bfd_elf_generic_reloc, /* special_function */
2165          "R_PPC64_ENTRY",       /* name */
2166          FALSE,                 /* partial_inplace */
2167          0,                     /* src_mask */
2168          0,                     /* dst_mask */
2169          FALSE),                /* pcrel_offset */
2170
2171   /* Like ADDR64, but use local entry point of function.  */
2172   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2173          0,                     /* rightshift */
2174          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2175          64,                    /* bitsize */
2176          FALSE,                 /* pc_relative */
2177          0,                     /* bitpos */
2178          complain_overflow_dont, /* complain_on_overflow */
2179          bfd_elf_generic_reloc, /* special_function */
2180          "R_PPC64_ADDR64_LOCAL", /* name */
2181          FALSE,                 /* partial_inplace */
2182          0,                     /* src_mask */
2183          ONES (64),             /* dst_mask */
2184          FALSE),                /* pcrel_offset */
2185
2186   /* GNU extension to record C++ vtable hierarchy.  */
2187   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2188          0,                     /* rightshift */
2189          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2190          0,                     /* bitsize */
2191          FALSE,                 /* pc_relative */
2192          0,                     /* bitpos */
2193          complain_overflow_dont, /* complain_on_overflow */
2194          NULL,                  /* special_function */
2195          "R_PPC64_GNU_VTINHERIT", /* name */
2196          FALSE,                 /* partial_inplace */
2197          0,                     /* src_mask */
2198          0,                     /* dst_mask */
2199          FALSE),                /* pcrel_offset */
2200
2201   /* GNU extension to record C++ vtable member usage.  */
2202   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2203          0,                     /* rightshift */
2204          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2205          0,                     /* bitsize */
2206          FALSE,                 /* pc_relative */
2207          0,                     /* bitpos */
2208          complain_overflow_dont, /* complain_on_overflow */
2209          NULL,                  /* special_function */
2210          "R_PPC64_GNU_VTENTRY", /* name */
2211          FALSE,                 /* partial_inplace */
2212          0,                     /* src_mask */
2213          0,                     /* dst_mask */
2214          FALSE),                /* pcrel_offset */
2215 };
2216
2217 \f
2218 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2219    be done.  */
2220
2221 static void
2222 ppc_howto_init (void)
2223 {
2224   unsigned int i, type;
2225
2226   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2227     {
2228       type = ppc64_elf_howto_raw[i].type;
2229       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2230       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2231     }
2232 }
2233
2234 static reloc_howto_type *
2235 ppc64_elf_reloc_type_lookup (bfd *abfd,
2236                              bfd_reloc_code_real_type code)
2237 {
2238   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2239
2240   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2241     /* Initialize howto table if needed.  */
2242     ppc_howto_init ();
2243
2244   switch (code)
2245     {
2246     default:
2247       /* xgettext:c-format */
2248       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2249       bfd_set_error (bfd_error_bad_value);
2250       return NULL;
2251
2252     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2253       break;
2254     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2255       break;
2256     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2257       break;
2258     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2259       break;
2260     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2261       break;
2262     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2263       break;
2264     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2265       break;
2266     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2267       break;
2268     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2269       break;
2270     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2271       break;
2272     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2273       break;
2274     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2275       break;
2276     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2277       break;
2278     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2279       break;
2280     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2281       break;
2282     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2283       break;
2284     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2285       break;
2286     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2287       break;
2288     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2289       break;
2290     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2291       break;
2292     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2293       break;
2294     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2295       break;
2296     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2297       break;
2298     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2299       break;
2300     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2301       break;
2302     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2303       break;
2304     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2305       break;
2306     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2307       break;
2308     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2309       break;
2310     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2311       break;
2312     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2313       break;
2314     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2315       break;
2316     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2317       break;
2318     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2319       break;
2320     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2321       break;
2322     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2323       break;
2324     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2325       break;
2326     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2327       break;
2328     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2329       break;
2330     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2331       break;
2332     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2333       break;
2334     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2335       break;
2336     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2337       break;
2338     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2339       break;
2340     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2341       break;
2342     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2343       break;
2344     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2345       break;
2346     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2347       break;
2348     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2349       break;
2350     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2351       break;
2352     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2353       break;
2354     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2355       break;
2356     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2357       break;
2358     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2359       break;
2360     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2361       break;
2362     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2363       break;
2364     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2365       break;
2366     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2367       break;
2368     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2371       break;
2372     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2373       break;
2374     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2375       break;
2376     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2377       break;
2378     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2379       break;
2380     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2381       break;
2382     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2383       break;
2384     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2385       break;
2386     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2387       break;
2388     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2389       break;
2390     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2391       break;
2392     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2393       break;
2394     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2395       break;
2396     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2397       break;
2398     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2399       break;
2400     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2401       break;
2402     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2403       break;
2404     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2405       break;
2406     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2407       break;
2408     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2409       break;
2410     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2411       break;
2412     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2413       break;
2414     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2415       break;
2416     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2417       break;
2418     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2419       break;
2420     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2421       break;
2422     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2423       break;
2424     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2425       break;
2426     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2427       break;
2428     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2429       break;
2430     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2431       break;
2432     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2433       break;
2434     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2435       break;
2436     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2437       break;
2438     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2439       break;
2440     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2441       break;
2442     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2443       break;
2444     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2445       break;
2446     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2447       break;
2448     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2449       break;
2450     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2451       break;
2452     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2453       break;
2454     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2455       break;
2456     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2457       break;
2458     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2459       break;
2460     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2461       break;
2462     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2463       break;
2464     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2465       break;
2466     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2467       break;
2468     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2469       break;
2470     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2471       break;
2472     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2473       break;
2474     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2475       break;
2476     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2477       break;
2478     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2479       break;
2480     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2481       break;
2482     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2483       break;
2484     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2485       break;
2486     }
2487
2488   return ppc64_elf_howto_table[r];
2489 };
2490
2491 static reloc_howto_type *
2492 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2493                              const char *r_name)
2494 {
2495   unsigned int i;
2496
2497   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2498     if (ppc64_elf_howto_raw[i].name != NULL
2499         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2500       return &ppc64_elf_howto_raw[i];
2501
2502
2503   return NULL;
2504 }
2505
2506 /* Set the howto pointer for a PowerPC ELF reloc.  */
2507
2508 static bfd_boolean
2509 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2510                          Elf_Internal_Rela *dst)
2511 {
2512   unsigned int type;
2513
2514   /* Initialize howto table if needed.  */
2515   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2516     ppc_howto_init ();
2517
2518   type = ELF64_R_TYPE (dst->r_info);
2519   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2520     {
2521       /* xgettext:c-format */
2522       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2523                           abfd, type);
2524       bfd_set_error (bfd_error_bad_value);
2525       return FALSE;
2526     }
2527   cache_ptr->howto = ppc64_elf_howto_table[type];
2528   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2529     {
2530       /* xgettext:c-format */
2531       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2532                           abfd, type);
2533       bfd_set_error (bfd_error_bad_value);
2534       return FALSE;
2535     }
2536
2537   return TRUE;
2538 }
2539
2540 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2541
2542 static bfd_reloc_status_type
2543 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544                     void *data, asection *input_section,
2545                     bfd *output_bfd, char **error_message)
2546 {
2547   enum elf_ppc64_reloc_type r_type;
2548   long insn;
2549   bfd_size_type octets;
2550   bfd_vma value;
2551
2552   /* If this is a relocatable link (output_bfd test tells us), just
2553      call the generic function.  Any adjustment will be done at final
2554      link time.  */
2555   if (output_bfd != NULL)
2556     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2557                                   input_section, output_bfd, error_message);
2558
2559   /* Adjust the addend for sign extension of the low 16 bits.
2560      We won't actually be using the low 16 bits, so trashing them
2561      doesn't matter.  */
2562   reloc_entry->addend += 0x8000;
2563   r_type = reloc_entry->howto->type;
2564   if (r_type != R_PPC64_REL16DX_HA)
2565     return bfd_reloc_continue;
2566
2567   value = 0;
2568   if (!bfd_is_com_section (symbol->section))
2569     value = symbol->value;
2570   value += (reloc_entry->addend
2571             + symbol->section->output_offset
2572             + symbol->section->output_section->vma);
2573   value -= (reloc_entry->address
2574             + input_section->output_offset
2575             + input_section->output_section->vma);
2576   value = (bfd_signed_vma) value >> 16;
2577
2578   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2579   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2580   insn &= ~0x1fffc1;
2581   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2582   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2583   if (value + 0x8000 > 0xffff)
2584     return bfd_reloc_overflow;
2585   return bfd_reloc_ok;
2586 }
2587
2588 static bfd_reloc_status_type
2589 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2590                         void *data, asection *input_section,
2591                         bfd *output_bfd, char **error_message)
2592 {
2593   if (output_bfd != NULL)
2594     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2595                                   input_section, output_bfd, error_message);
2596
2597   if (strcmp (symbol->section->name, ".opd") == 0
2598       && (symbol->section->owner->flags & DYNAMIC) == 0)
2599     {
2600       bfd_vma dest = opd_entry_value (symbol->section,
2601                                       symbol->value + reloc_entry->addend,
2602                                       NULL, NULL, FALSE);
2603       if (dest != (bfd_vma) -1)
2604         reloc_entry->addend = dest - (symbol->value
2605                                       + symbol->section->output_section->vma
2606                                       + symbol->section->output_offset);
2607     }
2608   else
2609     {
2610       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2611
2612       if (symbol->section->owner != abfd
2613           && symbol->section->owner != NULL
2614           && abiversion (symbol->section->owner) >= 2)
2615         {
2616           unsigned int i;
2617
2618           for (i = 0; i < symbol->section->owner->symcount; ++i)
2619             {
2620               asymbol *symdef = symbol->section->owner->outsymbols[i];
2621
2622               if (strcmp (symdef->name, symbol->name) == 0)
2623                 {
2624                   elfsym = (elf_symbol_type *) symdef;
2625                   break;
2626                 }
2627             }
2628         }
2629       reloc_entry->addend
2630         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2631     }
2632   return bfd_reloc_continue;
2633 }
2634
2635 static bfd_reloc_status_type
2636 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2637                          void *data, asection *input_section,
2638                          bfd *output_bfd, char **error_message)
2639 {
2640   long insn;
2641   enum elf_ppc64_reloc_type r_type;
2642   bfd_size_type octets;
2643   /* Assume 'at' branch hints.  */
2644   bfd_boolean is_isa_v2 = TRUE;
2645
2646   /* If this is a relocatable link (output_bfd test tells us), just
2647      call the generic function.  Any adjustment will be done at final
2648      link time.  */
2649   if (output_bfd != NULL)
2650     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2651                                   input_section, output_bfd, error_message);
2652
2653   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2654   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2655   insn &= ~(0x01 << 21);
2656   r_type = reloc_entry->howto->type;
2657   if (r_type == R_PPC64_ADDR14_BRTAKEN
2658       || r_type == R_PPC64_REL14_BRTAKEN)
2659     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2660
2661   if (is_isa_v2)
2662     {
2663       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2664          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2665          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2666       if ((insn & (0x14 << 21)) == (0x04 << 21))
2667         insn |= 0x02 << 21;
2668       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2669         insn |= 0x08 << 21;
2670       else
2671         goto out;
2672     }
2673   else
2674     {
2675       bfd_vma target = 0;
2676       bfd_vma from;
2677
2678       if (!bfd_is_com_section (symbol->section))
2679         target = symbol->value;
2680       target += symbol->section->output_section->vma;
2681       target += symbol->section->output_offset;
2682       target += reloc_entry->addend;
2683
2684       from = (reloc_entry->address
2685               + input_section->output_offset
2686               + input_section->output_section->vma);
2687
2688       /* Invert 'y' bit if not the default.  */
2689       if ((bfd_signed_vma) (target - from) < 0)
2690         insn ^= 0x01 << 21;
2691     }
2692   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2693  out:
2694   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2695                                  input_section, output_bfd, error_message);
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_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   return bfd_reloc_continue;
2713 }
2714
2715 static bfd_reloc_status_type
2716 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2717                             void *data, asection *input_section,
2718                             bfd *output_bfd, char **error_message)
2719 {
2720   /* If this is a relocatable link (output_bfd test tells us), just
2721      call the generic function.  Any adjustment will be done at final
2722      link time.  */
2723   if (output_bfd != NULL)
2724     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2725                                   input_section, output_bfd, error_message);
2726
2727   /* Subtract the symbol section base address.  */
2728   reloc_entry->addend -= symbol->section->output_section->vma;
2729
2730   /* Adjust the addend for sign extension of the low 16 bits.  */
2731   reloc_entry->addend += 0x8000;
2732   return bfd_reloc_continue;
2733 }
2734
2735 static bfd_reloc_status_type
2736 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2737                      void *data, asection *input_section,
2738                      bfd *output_bfd, char **error_message)
2739 {
2740   bfd_vma TOCstart;
2741
2742   /* If this is a relocatable link (output_bfd test tells us), just
2743      call the generic function.  Any adjustment will be done at final
2744      link time.  */
2745   if (output_bfd != NULL)
2746     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2747                                   input_section, output_bfd, error_message);
2748
2749   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2750   if (TOCstart == 0)
2751     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2752
2753   /* Subtract the TOC base address.  */
2754   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2755   return bfd_reloc_continue;
2756 }
2757
2758 static bfd_reloc_status_type
2759 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2760                         void *data, asection *input_section,
2761                         bfd *output_bfd, char **error_message)
2762 {
2763   bfd_vma TOCstart;
2764
2765   /* If this is a relocatable link (output_bfd test tells us), just
2766      call the generic function.  Any adjustment will be done at final
2767      link time.  */
2768   if (output_bfd != NULL)
2769     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2770                                   input_section, output_bfd, error_message);
2771
2772   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2773   if (TOCstart == 0)
2774     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2775
2776   /* Subtract the TOC base address.  */
2777   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2778
2779   /* Adjust the addend for sign extension of the low 16 bits.  */
2780   reloc_entry->addend += 0x8000;
2781   return bfd_reloc_continue;
2782 }
2783
2784 static bfd_reloc_status_type
2785 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2786                        void *data, asection *input_section,
2787                        bfd *output_bfd, char **error_message)
2788 {
2789   bfd_vma TOCstart;
2790   bfd_size_type octets;
2791
2792   /* If this is a relocatable link (output_bfd test tells us), just
2793      call the generic function.  Any adjustment will be done at final
2794      link time.  */
2795   if (output_bfd != NULL)
2796     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2797                                   input_section, output_bfd, error_message);
2798
2799   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2800   if (TOCstart == 0)
2801     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2802
2803   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2804   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2805   return bfd_reloc_ok;
2806 }
2807
2808 static bfd_reloc_status_type
2809 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2810                            void *data, asection *input_section,
2811                            bfd *output_bfd, char **error_message)
2812 {
2813   /* If this is a relocatable link (output_bfd test tells us), just
2814      call the generic function.  Any adjustment will be done at final
2815      link time.  */
2816   if (output_bfd != NULL)
2817     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2818                                   input_section, output_bfd, error_message);
2819
2820   if (error_message != NULL)
2821     {
2822       static char buf[60];
2823       sprintf (buf, "generic linker can't handle %s",
2824                reloc_entry->howto->name);
2825       *error_message = buf;
2826     }
2827   return bfd_reloc_dangerous;
2828 }
2829
2830 /* Track GOT entries needed for a given symbol.  We might need more
2831    than one got entry per symbol.  */
2832 struct got_entry
2833 {
2834   struct got_entry *next;
2835
2836   /* The symbol addend that we'll be placing in the GOT.  */
2837   bfd_vma addend;
2838
2839   /* Unlike other ELF targets, we use separate GOT entries for the same
2840      symbol referenced from different input files.  This is to support
2841      automatic multiple TOC/GOT sections, where the TOC base can vary
2842      from one input file to another.  After partitioning into TOC groups
2843      we merge entries within the group.
2844
2845      Point to the BFD owning this GOT entry.  */
2846   bfd *owner;
2847
2848   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2849      TLS_TPREL or TLS_DTPREL for tls entries.  */
2850   unsigned char tls_type;
2851
2852   /* Non-zero if got.ent points to real entry.  */
2853   unsigned char is_indirect;
2854
2855   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2856   union
2857     {
2858       bfd_signed_vma refcount;
2859       bfd_vma offset;
2860       struct got_entry *ent;
2861     } got;
2862 };
2863
2864 /* The same for PLT.  */
2865 struct plt_entry
2866 {
2867   struct plt_entry *next;
2868
2869   bfd_vma addend;
2870
2871   union
2872     {
2873       bfd_signed_vma refcount;
2874       bfd_vma offset;
2875     } plt;
2876 };
2877
2878 struct ppc64_elf_obj_tdata
2879 {
2880   struct elf_obj_tdata elf;
2881
2882   /* Shortcuts to dynamic linker sections.  */
2883   asection *got;
2884   asection *relgot;
2885
2886   /* Used during garbage collection.  We attach global symbols defined
2887      on removed .opd entries to this section so that the sym is removed.  */
2888   asection *deleted_section;
2889
2890   /* TLS local dynamic got entry handling.  Support for multiple GOT
2891      sections means we potentially need one of these for each input bfd.  */
2892   struct got_entry tlsld_got;
2893
2894   union {
2895     /* A copy of relocs before they are modified for --emit-relocs.  */
2896     Elf_Internal_Rela *relocs;
2897
2898     /* Section contents.  */
2899     bfd_byte *contents;
2900   } opd;
2901
2902   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2903      the reloc to be in the range -32768 to 32767.  */
2904   unsigned int has_small_toc_reloc : 1;
2905
2906   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2907      instruction not one we handle.  */
2908   unsigned int unexpected_toc_insn : 1;
2909 };
2910
2911 #define ppc64_elf_tdata(bfd) \
2912   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2913
2914 #define ppc64_tlsld_got(bfd) \
2915   (&ppc64_elf_tdata (bfd)->tlsld_got)
2916
2917 #define is_ppc64_elf(bfd) \
2918   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2919    && elf_object_id (bfd) == PPC64_ELF_DATA)
2920
2921 /* Override the generic function because we store some extras.  */
2922
2923 static bfd_boolean
2924 ppc64_elf_mkobject (bfd *abfd)
2925 {
2926   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2927                                   PPC64_ELF_DATA);
2928 }
2929
2930 /* Fix bad default arch selected for a 64 bit input bfd when the
2931    default is 32 bit.  Also select arch based on apuinfo.  */
2932
2933 static bfd_boolean
2934 ppc64_elf_object_p (bfd *abfd)
2935 {
2936   if (!abfd->arch_info->the_default)
2937     return TRUE;
2938
2939   if (abfd->arch_info->bits_per_word == 32)
2940     {
2941       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2942
2943       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2944         {
2945           /* Relies on arch after 32 bit default being 64 bit default.  */
2946           abfd->arch_info = abfd->arch_info->next;
2947           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2948         }
2949     }
2950   return _bfd_elf_ppc_set_arch (abfd);
2951 }
2952
2953 /* Support for core dump NOTE sections.  */
2954
2955 static bfd_boolean
2956 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2957 {
2958   size_t offset, size;
2959
2960   if (note->descsz != 504)
2961     return FALSE;
2962
2963   /* pr_cursig */
2964   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2965
2966   /* pr_pid */
2967   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2968
2969   /* pr_reg */
2970   offset = 112;
2971   size = 384;
2972
2973   /* Make a ".reg/999" section.  */
2974   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2975                                           size, note->descpos + offset);
2976 }
2977
2978 static bfd_boolean
2979 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2980 {
2981   if (note->descsz != 136)
2982     return FALSE;
2983
2984   elf_tdata (abfd)->core->pid
2985     = bfd_get_32 (abfd, note->descdata + 24);
2986   elf_tdata (abfd)->core->program
2987     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2988   elf_tdata (abfd)->core->command
2989     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2990
2991   return TRUE;
2992 }
2993
2994 static char *
2995 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2996                            ...)
2997 {
2998   switch (note_type)
2999     {
3000     default:
3001       return NULL;
3002
3003     case NT_PRPSINFO:
3004       {
3005         char data[136];
3006         va_list ap;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, sizeof (data));
3010         strncpy (data + 40, va_arg (ap, const char *), 16);
3011         strncpy (data + 56, va_arg (ap, const char *), 80);
3012         va_end (ap);
3013         return elfcore_write_note (abfd, buf, bufsiz,
3014                                    "CORE", note_type, data, sizeof (data));
3015       }
3016
3017     case NT_PRSTATUS:
3018       {
3019         char data[504];
3020         va_list ap;
3021         long pid;
3022         int cursig;
3023         const void *greg;
3024
3025         va_start (ap, note_type);
3026         memset (data, 0, 112);
3027         pid = va_arg (ap, long);
3028         bfd_put_32 (abfd, pid, data + 32);
3029         cursig = va_arg (ap, int);
3030         bfd_put_16 (abfd, cursig, data + 12);
3031         greg = va_arg (ap, const void *);
3032         memcpy (data + 112, greg, 384);
3033         memset (data + 496, 0, 8);
3034         va_end (ap);
3035         return elfcore_write_note (abfd, buf, bufsiz,
3036                                    "CORE", note_type, data, sizeof (data));
3037       }
3038     }
3039 }
3040
3041 /* Add extra PPC sections.  */
3042
3043 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3044 {
3045   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3046   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3047   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3048   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3049   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3050   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3051   { NULL,                     0,  0, 0,            0 }
3052 };
3053
3054 enum _ppc64_sec_type {
3055   sec_normal = 0,
3056   sec_opd = 1,
3057   sec_toc = 2
3058 };
3059
3060 struct _ppc64_elf_section_data
3061 {
3062   struct bfd_elf_section_data elf;
3063
3064   union
3065   {
3066     /* An array with one entry for each opd function descriptor,
3067        and some spares since opd entries may be either 16 or 24 bytes.  */
3068 #define OPD_NDX(OFF) ((OFF) >> 4)
3069     struct _opd_sec_data
3070     {
3071       /* Points to the function code section for local opd entries.  */
3072       asection **func_sec;
3073
3074       /* After editing .opd, adjust references to opd local syms.  */
3075       long *adjust;
3076     } opd;
3077
3078     /* An array for toc sections, indexed by offset/8.  */
3079     struct _toc_sec_data
3080     {
3081       /* Specifies the relocation symbol index used at a given toc offset.  */
3082       unsigned *symndx;
3083
3084       /* And the relocation addend.  */
3085       bfd_vma *add;
3086     } toc;
3087   } u;
3088
3089   enum _ppc64_sec_type sec_type:2;
3090
3091   /* Flag set when small branches are detected.  Used to
3092      select suitable defaults for the stub group size.  */
3093   unsigned int has_14bit_branch:1;
3094 };
3095
3096 #define ppc64_elf_section_data(sec) \
3097   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3098
3099 static bfd_boolean
3100 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3101 {
3102   if (!sec->used_by_bfd)
3103     {
3104       struct _ppc64_elf_section_data *sdata;
3105       bfd_size_type amt = sizeof (*sdata);
3106
3107       sdata = bfd_zalloc (abfd, amt);
3108       if (sdata == NULL)
3109         return FALSE;
3110       sec->used_by_bfd = sdata;
3111     }
3112
3113   return _bfd_elf_new_section_hook (abfd, sec);
3114 }
3115
3116 static struct _opd_sec_data *
3117 get_opd_info (asection * sec)
3118 {
3119   if (sec != NULL
3120       && ppc64_elf_section_data (sec) != NULL
3121       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3122     return &ppc64_elf_section_data (sec)->u.opd;
3123   return NULL;
3124 }
3125 \f
3126 /* Parameters for the qsort hook.  */
3127 static bfd_boolean synthetic_relocatable;
3128 static asection *synthetic_opd;
3129
3130 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3131
3132 static int
3133 compare_symbols (const void *ap, const void *bp)
3134 {
3135   const asymbol *a = * (const asymbol **) ap;
3136   const asymbol *b = * (const asymbol **) bp;
3137
3138   /* Section symbols first.  */
3139   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3140     return -1;
3141   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3142     return 1;
3143
3144   /* then .opd symbols.  */
3145   if (synthetic_opd != NULL)
3146     {
3147       if (strcmp (a->section->name, ".opd") == 0
3148           && strcmp (b->section->name, ".opd") != 0)
3149         return -1;
3150       if (strcmp (a->section->name, ".opd") != 0
3151           && strcmp (b->section->name, ".opd") == 0)
3152         return 1;
3153     }
3154
3155   /* then other code symbols.  */
3156   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3157       == (SEC_CODE | SEC_ALLOC)
3158       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3159          != (SEC_CODE | SEC_ALLOC))
3160     return -1;
3161
3162   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3163       != (SEC_CODE | SEC_ALLOC)
3164       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3165          == (SEC_CODE | SEC_ALLOC))
3166     return 1;
3167
3168   if (synthetic_relocatable)
3169     {
3170       if (a->section->id < b->section->id)
3171         return -1;
3172
3173       if (a->section->id > b->section->id)
3174         return 1;
3175     }
3176
3177   if (a->value + a->section->vma < b->value + b->section->vma)
3178     return -1;
3179
3180   if (a->value + a->section->vma > b->value + b->section->vma)
3181     return 1;
3182
3183   /* For syms with the same value, prefer strong dynamic global function
3184      syms over other syms.  */
3185   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3186     return -1;
3187
3188   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3189     return 1;
3190
3191   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3192     return -1;
3193
3194   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3195     return 1;
3196
3197   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3198     return -1;
3199
3200   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3201     return 1;
3202
3203   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3204     return -1;
3205
3206   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3207     return 1;
3208
3209   return a > b;
3210 }
3211
3212 /* Search SYMS for a symbol of the given VALUE.  */
3213
3214 static asymbol *
3215 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3216 {
3217   long mid;
3218
3219   if (id == (unsigned) -1)
3220     {
3221       while (lo < hi)
3222         {
3223           mid = (lo + hi) >> 1;
3224           if (syms[mid]->value + syms[mid]->section->vma < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value + syms[mid]->section->vma > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   else
3233     {
3234       while (lo < hi)
3235         {
3236           mid = (lo + hi) >> 1;
3237           if (syms[mid]->section->id < id)
3238             lo = mid + 1;
3239           else if (syms[mid]->section->id > id)
3240             hi = mid;
3241           else if (syms[mid]->value < value)
3242             lo = mid + 1;
3243           else if (syms[mid]->value > value)
3244             hi = mid;
3245           else
3246             return syms[mid];
3247         }
3248     }
3249   return NULL;
3250 }
3251
3252 static bfd_boolean
3253 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3254 {
3255   bfd_vma vma = *(bfd_vma *) ptr;
3256   return ((section->flags & SEC_ALLOC) != 0
3257           && section->vma <= vma
3258           && vma < section->vma + section->size);
3259 }
3260
3261 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3262    entry syms.  Also generate @plt symbols for the glink branch table.
3263    Returns count of synthetic symbols in RET or -1 on error.  */
3264
3265 static long
3266 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3267                                 long static_count, asymbol **static_syms,
3268                                 long dyn_count, asymbol **dyn_syms,
3269                                 asymbol **ret)
3270 {
3271   asymbol *s;
3272   size_t i, j, count;
3273   char *names;
3274   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3275   asection *opd = NULL;
3276   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3277   asymbol **syms;
3278   int abi = abiversion (abfd);
3279
3280   *ret = NULL;
3281
3282   if (abi < 2)
3283     {
3284       opd = bfd_get_section_by_name (abfd, ".opd");
3285       if (opd == NULL && abi == 1)
3286         return 0;
3287     }
3288
3289   syms = NULL;
3290   codesecsym = 0;
3291   codesecsymend = 0;
3292   secsymend = 0;
3293   opdsymend = 0;
3294   symcount = 0;
3295   if (opd != NULL)
3296     {
3297       symcount = static_count;
3298       if (!relocatable)
3299         symcount += dyn_count;
3300       if (symcount == 0)
3301         return 0;
3302
3303       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3304       if (syms == NULL)
3305         return -1;
3306
3307       if (!relocatable && static_count != 0 && dyn_count != 0)
3308         {
3309           /* Use both symbol tables.  */
3310           memcpy (syms, static_syms, static_count * sizeof (*syms));
3311           memcpy (syms + static_count, dyn_syms,
3312                   (dyn_count + 1) * sizeof (*syms));
3313         }
3314       else if (!relocatable && static_count == 0)
3315         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3316       else
3317         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3318
3319       /* Trim uninteresting symbols.  Interesting symbols are section,
3320          function, and notype symbols.  */
3321       for (i = 0, j = 0; i < symcount; ++i)
3322         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3323                                | BSF_RELC | BSF_SRELC)) == 0)
3324           syms[j++] = syms[i];
3325       symcount = j;
3326
3327       synthetic_relocatable = relocatable;
3328       synthetic_opd = opd;
3329       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3330
3331       if (!relocatable && symcount > 1)
3332         {
3333           /* Trim duplicate syms, since we may have merged the normal and
3334              dynamic symbols.  Actually, we only care about syms that have
3335              different values, so trim any with the same value.  */
3336           for (i = 1, j = 1; i < symcount; ++i)
3337             if (syms[i - 1]->value + syms[i - 1]->section->vma
3338                 != syms[i]->value + syms[i]->section->vma)
3339               syms[j++] = syms[i];
3340           symcount = j;
3341         }
3342
3343       i = 0;
3344       /* Note that here and in compare_symbols we can't compare opd and
3345          sym->section directly.  With separate debug info files, the
3346          symbols will be extracted from the debug file while abfd passed
3347          to this function is the real binary.  */
3348       if (strcmp (syms[i]->section->name, ".opd") == 0)
3349         ++i;
3350       codesecsym = i;
3351
3352       for (; i < symcount; ++i)
3353         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3354                                          | SEC_THREAD_LOCAL))
3355              != (SEC_CODE | SEC_ALLOC))
3356             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3357           break;
3358       codesecsymend = i;
3359
3360       for (; i < symcount; ++i)
3361         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3362           break;
3363       secsymend = i;
3364
3365       for (; i < symcount; ++i)
3366         if (strcmp (syms[i]->section->name, ".opd") != 0)
3367           break;
3368       opdsymend = i;
3369
3370       for (; i < symcount; ++i)
3371         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3372             != (SEC_CODE | SEC_ALLOC))
3373           break;
3374       symcount = i;
3375     }
3376   count = 0;
3377
3378   if (relocatable)
3379     {
3380       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3381       arelent *r;
3382       size_t size;
3383       size_t relcount;
3384
3385       if (opdsymend == secsymend)
3386         goto done;
3387
3388       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3389       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3390       if (relcount == 0)
3391         goto done;
3392
3393       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3394         {
3395           count = -1;
3396           goto done;
3397         }
3398
3399       size = 0;
3400       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3401         {
3402           asymbol *sym;
3403
3404           while (r < opd->relocation + relcount
3405                  && r->address < syms[i]->value + opd->vma)
3406             ++r;
3407
3408           if (r == opd->relocation + relcount)
3409             break;
3410
3411           if (r->address != syms[i]->value + opd->vma)
3412             continue;
3413
3414           if (r->howto->type != R_PPC64_ADDR64)
3415             continue;
3416
3417           sym = *r->sym_ptr_ptr;
3418           if (!sym_exists_at (syms, opdsymend, symcount,
3419                               sym->section->id, sym->value + r->addend))
3420             {
3421               ++count;
3422               size += sizeof (asymbol);
3423               size += strlen (syms[i]->name) + 2;
3424             }
3425         }
3426
3427       if (size == 0)
3428         goto done;
3429       s = *ret = bfd_malloc (size);
3430       if (s == NULL)
3431         {
3432           count = -1;
3433           goto done;
3434         }
3435
3436       names = (char *) (s + count);
3437
3438       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3439         {
3440           asymbol *sym;
3441
3442           while (r < opd->relocation + relcount
3443                  && r->address < syms[i]->value + opd->vma)
3444             ++r;
3445
3446           if (r == opd->relocation + relcount)
3447             break;
3448
3449           if (r->address != syms[i]->value + opd->vma)
3450             continue;
3451
3452           if (r->howto->type != R_PPC64_ADDR64)
3453             continue;
3454
3455           sym = *r->sym_ptr_ptr;
3456           if (!sym_exists_at (syms, opdsymend, symcount,
3457                               sym->section->id, sym->value + r->addend))
3458             {
3459               size_t len;
3460
3461               *s = *syms[i];
3462               s->flags |= BSF_SYNTHETIC;
3463               s->section = sym->section;
3464               s->value = sym->value + r->addend;
3465               s->name = names;
3466               *names++ = '.';
3467               len = strlen (syms[i]->name);
3468               memcpy (names, syms[i]->name, len + 1);
3469               names += len + 1;
3470               /* Have udata.p point back to the original symbol this
3471                  synthetic symbol was derived from.  */
3472               s->udata.p = syms[i];
3473               s++;
3474             }
3475         }
3476     }
3477   else
3478     {
3479       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3480       bfd_byte *contents = NULL;
3481       size_t size;
3482       size_t plt_count = 0;
3483       bfd_vma glink_vma = 0, resolv_vma = 0;
3484       asection *dynamic, *glink = NULL, *relplt = NULL;
3485       arelent *p;
3486
3487       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3488         {
3489         free_contents_and_exit_err:
3490           count = -1;
3491         free_contents_and_exit:
3492           if (contents)
3493             free (contents);
3494           goto done;
3495         }
3496
3497       size = 0;
3498       for (i = secsymend; i < opdsymend; ++i)
3499         {
3500           bfd_vma ent;
3501
3502           /* Ignore bogus symbols.  */
3503           if (syms[i]->value > opd->size - 8)
3504             continue;
3505
3506           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3507           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3508             {
3509               ++count;
3510               size += sizeof (asymbol);
3511               size += strlen (syms[i]->name) + 2;
3512             }
3513         }
3514
3515       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3516       if (dyn_count != 0
3517           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3518         {
3519           bfd_byte *dynbuf, *extdyn, *extdynend;
3520           size_t extdynsize;
3521           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3522
3523           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3524             goto free_contents_and_exit_err;
3525
3526           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3527           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3528
3529           extdyn = dynbuf;
3530           extdynend = extdyn + dynamic->size;
3531           for (; extdyn < extdynend; extdyn += extdynsize)
3532             {
3533               Elf_Internal_Dyn dyn;
3534               (*swap_dyn_in) (abfd, extdyn, &dyn);
3535
3536               if (dyn.d_tag == DT_NULL)
3537                 break;
3538
3539               if (dyn.d_tag == DT_PPC64_GLINK)
3540                 {
3541                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3542                      See comment in ppc64_elf_finish_dynamic_sections. */
3543                   glink_vma = dyn.d_un.d_val + 8 * 4;
3544                   /* The .glink section usually does not survive the final
3545                      link; search for the section (usually .text) where the
3546                      glink stubs now reside.  */
3547                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3548                                                 &glink_vma);
3549                   break;
3550                 }
3551             }
3552
3553           free (dynbuf);
3554         }
3555
3556       if (glink != NULL)
3557         {
3558           /* Determine __glink trampoline by reading the relative branch
3559              from the first glink stub.  */
3560           bfd_byte buf[4];
3561           unsigned int off = 0;
3562
3563           while (bfd_get_section_contents (abfd, glink, buf,
3564                                            glink_vma + off - glink->vma, 4))
3565             {
3566               unsigned int insn = bfd_get_32 (abfd, buf);
3567               insn ^= B_DOT;
3568               if ((insn & ~0x3fffffc) == 0)
3569                 {
3570                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3571                   break;
3572                 }
3573               off += 4;
3574               if (off > 4)
3575                 break;
3576             }
3577
3578           if (resolv_vma)
3579             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3580
3581           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3582           if (relplt != NULL)
3583             {
3584               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3585               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3586                 goto free_contents_and_exit_err;
3587
3588               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3589               size += plt_count * sizeof (asymbol);
3590
3591               p = relplt->relocation;
3592               for (i = 0; i < plt_count; i++, p++)
3593                 {
3594                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3595                   if (p->addend != 0)
3596                     size += sizeof ("+0x") - 1 + 16;
3597                 }
3598             }
3599         }
3600
3601       if (size == 0)
3602         goto free_contents_and_exit;
3603       s = *ret = bfd_malloc (size);
3604       if (s == NULL)
3605         goto free_contents_and_exit_err;
3606
3607       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3608
3609       for (i = secsymend; i < opdsymend; ++i)
3610         {
3611           bfd_vma ent;
3612
3613           if (syms[i]->value > opd->size - 8)
3614             continue;
3615
3616           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3617           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3618             {
3619               size_t lo, hi;
3620               size_t len;
3621               asection *sec = abfd->sections;
3622
3623               *s = *syms[i];
3624               lo = codesecsym;
3625               hi = codesecsymend;
3626               while (lo < hi)
3627                 {
3628                   size_t mid = (lo + hi) >> 1;
3629                   if (syms[mid]->section->vma < ent)
3630                     lo = mid + 1;
3631                   else if (syms[mid]->section->vma > ent)
3632                     hi = mid;
3633                   else
3634                     {
3635                       sec = syms[mid]->section;
3636                       break;
3637                     }
3638                 }
3639
3640               if (lo >= hi && lo > codesecsym)
3641                 sec = syms[lo - 1]->section;
3642
3643               for (; sec != NULL; sec = sec->next)
3644                 {
3645                   if (sec->vma > ent)
3646                     break;
3647                   /* SEC_LOAD may not be set if SEC is from a separate debug
3648                      info file.  */
3649                   if ((sec->flags & SEC_ALLOC) == 0)
3650                     break;
3651                   if ((sec->flags & SEC_CODE) != 0)
3652                     s->section = sec;
3653                 }
3654               s->flags |= BSF_SYNTHETIC;
3655               s->value = ent - s->section->vma;
3656               s->name = names;
3657               *names++ = '.';
3658               len = strlen (syms[i]->name);
3659               memcpy (names, syms[i]->name, len + 1);
3660               names += len + 1;
3661               /* Have udata.p point back to the original symbol this
3662                  synthetic symbol was derived from.  */
3663               s->udata.p = syms[i];
3664               s++;
3665             }
3666         }
3667       free (contents);
3668
3669       if (glink != NULL && relplt != NULL)
3670         {
3671           if (resolv_vma)
3672             {
3673               /* Add a symbol for the main glink trampoline.  */
3674               memset (s, 0, sizeof *s);
3675               s->the_bfd = abfd;
3676               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3677               s->section = glink;
3678               s->value = resolv_vma - glink->vma;
3679               s->name = names;
3680               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3681               names += sizeof ("__glink_PLTresolve");
3682               s++;
3683               count++;
3684             }
3685
3686           /* FIXME: It would be very much nicer to put sym@plt on the
3687              stub rather than on the glink branch table entry.  The
3688              objdump disassembler would then use a sensible symbol
3689              name on plt calls.  The difficulty in doing so is
3690              a) finding the stubs, and,
3691              b) matching stubs against plt entries, and,
3692              c) there can be multiple stubs for a given plt entry.
3693
3694              Solving (a) could be done by code scanning, but older
3695              ppc64 binaries used different stubs to current code.
3696              (b) is the tricky one since you need to known the toc
3697              pointer for at least one function that uses a pic stub to
3698              be able to calculate the plt address referenced.
3699              (c) means gdb would need to set multiple breakpoints (or
3700              find the glink branch itself) when setting breakpoints
3701              for pending shared library loads.  */
3702           p = relplt->relocation;
3703           for (i = 0; i < plt_count; i++, p++)
3704             {
3705               size_t len;
3706
3707               *s = **p->sym_ptr_ptr;
3708               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3709                  we are defining a symbol, ensure one of them is set.  */
3710               if ((s->flags & BSF_LOCAL) == 0)
3711                 s->flags |= BSF_GLOBAL;
3712               s->flags |= BSF_SYNTHETIC;
3713               s->section = glink;
3714               s->value = glink_vma - glink->vma;
3715               s->name = names;
3716               s->udata.p = NULL;
3717               len = strlen ((*p->sym_ptr_ptr)->name);
3718               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3719               names += len;
3720               if (p->addend != 0)
3721                 {
3722                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3723                   names += sizeof ("+0x") - 1;
3724                   bfd_sprintf_vma (abfd, names, p->addend);
3725                   names += strlen (names);
3726                 }
3727               memcpy (names, "@plt", sizeof ("@plt"));
3728               names += sizeof ("@plt");
3729               s++;
3730               if (abi < 2)
3731                 {
3732                   glink_vma += 8;
3733                   if (i >= 0x8000)
3734                     glink_vma += 4;
3735                 }
3736               else
3737                 glink_vma += 4;
3738             }
3739           count += plt_count;
3740         }
3741     }
3742
3743  done:
3744   free (syms);
3745   return count;
3746 }
3747 \f
3748 /* The following functions are specific to the ELF linker, while
3749    functions above are used generally.  Those named ppc64_elf_* are
3750    called by the main ELF linker code.  They appear in this file more
3751    or less in the order in which they are called.  eg.
3752    ppc64_elf_check_relocs is called early in the link process,
3753    ppc64_elf_finish_dynamic_sections is one of the last functions
3754    called.
3755
3756    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3757    functions have both a function code symbol and a function descriptor
3758    symbol.  A call to foo in a relocatable object file looks like:
3759
3760    .            .text
3761    .    x:
3762    .            bl      .foo
3763    .            nop
3764
3765    The function definition in another object file might be:
3766
3767    .            .section .opd
3768    .    foo:    .quad   .foo
3769    .            .quad   .TOC.@tocbase
3770    .            .quad   0
3771    .
3772    .            .text
3773    .    .foo:   blr
3774
3775    When the linker resolves the call during a static link, the branch
3776    unsurprisingly just goes to .foo and the .opd information is unused.
3777    If the function definition is in a shared library, things are a little
3778    different:  The call goes via a plt call stub, the opd information gets
3779    copied to the plt, and the linker patches the nop.
3780
3781    .    x:
3782    .            bl      .foo_stub
3783    .            ld      2,40(1)
3784    .
3785    .
3786    .    .foo_stub:
3787    .            std     2,40(1)                 # in practice, the call stub
3788    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3789    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3790    .            ld      12,0(11)
3791    .            ld      2,8(11)
3792    .            mtctr   12
3793    .            ld      11,16(11)
3794    .            bctr
3795    .
3796    .            .section .plt
3797    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3798
3799    The "reloc ()" notation is supposed to indicate that the linker emits
3800    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3801    copying.
3802
3803    What are the difficulties here?  Well, firstly, the relocations
3804    examined by the linker in check_relocs are against the function code
3805    sym .foo, while the dynamic relocation in the plt is emitted against
3806    the function descriptor symbol, foo.  Somewhere along the line, we need
3807    to carefully copy dynamic link information from one symbol to the other.
3808    Secondly, the generic part of the elf linker will make .foo a dynamic
3809    symbol as is normal for most other backends.  We need foo dynamic
3810    instead, at least for an application final link.  However, when
3811    creating a shared library containing foo, we need to have both symbols
3812    dynamic so that references to .foo are satisfied during the early
3813    stages of linking.  Otherwise the linker might decide to pull in a
3814    definition from some other object, eg. a static library.
3815
3816    Update: As of August 2004, we support a new convention.  Function
3817    calls may use the function descriptor symbol, ie. "bl foo".  This
3818    behaves exactly as "bl .foo".  */
3819
3820 /* Of those relocs that might be copied as dynamic relocs, this
3821    function selects those that must be copied when linking a shared
3822    library or PIE, even when the symbol is local.  */
3823
3824 static int
3825 must_be_dyn_reloc (struct bfd_link_info *info,
3826                    enum elf_ppc64_reloc_type r_type)
3827 {
3828   switch (r_type)
3829     {
3830     default:
3831       /* Only relative relocs can be resolved when the object load
3832          address isn't fixed.  DTPREL64 is excluded because the
3833          dynamic linker needs to differentiate global dynamic from
3834          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3835       return 1;
3836
3837     case R_PPC64_REL32:
3838     case R_PPC64_REL64:
3839     case R_PPC64_REL30:
3840       return 0;
3841
3842     case R_PPC64_TPREL16:
3843     case R_PPC64_TPREL16_LO:
3844     case R_PPC64_TPREL16_HI:
3845     case R_PPC64_TPREL16_HA:
3846     case R_PPC64_TPREL16_DS:
3847     case R_PPC64_TPREL16_LO_DS:
3848     case R_PPC64_TPREL16_HIGH:
3849     case R_PPC64_TPREL16_HIGHA:
3850     case R_PPC64_TPREL16_HIGHER:
3851     case R_PPC64_TPREL16_HIGHERA:
3852     case R_PPC64_TPREL16_HIGHEST:
3853     case R_PPC64_TPREL16_HIGHESTA:
3854     case R_PPC64_TPREL64:
3855       /* These relocations are relative but in a shared library the
3856          linker doesn't know the thread pointer base.  */
3857       return bfd_link_dll (info);
3858     }
3859 }
3860
3861 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3862    copying dynamic variables from a shared lib into an app's dynbss
3863    section, and instead use a dynamic relocation to point into the
3864    shared lib.  With code that gcc generates, it's vital that this be
3865    enabled;  In the PowerPC64 ABI, the address of a function is actually
3866    the address of a function descriptor, which resides in the .opd
3867    section.  gcc uses the descriptor directly rather than going via the
3868    GOT as some other ABI's do, which means that initialized function
3869    pointers must reference the descriptor.  Thus, a function pointer
3870    initialized to the address of a function in a shared library will
3871    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3872    redefines the function descriptor symbol to point to the copy.  This
3873    presents a problem as a plt entry for that function is also
3874    initialized from the function descriptor symbol and the copy reloc
3875    may not be initialized first.  */
3876 #define ELIMINATE_COPY_RELOCS 1
3877
3878 /* Section name for stubs is the associated section name plus this
3879    string.  */
3880 #define STUB_SUFFIX ".stub"
3881
3882 /* Linker stubs.
3883    ppc_stub_long_branch:
3884    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3885    destination, but a 24 bit branch in a stub section will reach.
3886    .    b       dest
3887
3888    ppc_stub_plt_branch:
3889    Similar to the above, but a 24 bit branch in the stub section won't
3890    reach its destination.
3891    .    addis   %r11,%r2,xxx@toc@ha
3892    .    ld      %r12,xxx@toc@l(%r11)
3893    .    mtctr   %r12
3894    .    bctr
3895
3896    ppc_stub_plt_call:
3897    Used to call a function in a shared library.  If it so happens that
3898    the plt entry referenced crosses a 64k boundary, then an extra
3899    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3900    .    std     %r2,40(%r1)
3901    .    addis   %r11,%r2,xxx@toc@ha
3902    .    ld      %r12,xxx+0@toc@l(%r11)
3903    .    mtctr   %r12
3904    .    ld      %r2,xxx+8@toc@l(%r11)
3905    .    ld      %r11,xxx+16@toc@l(%r11)
3906    .    bctr
3907
3908    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3909    code to adjust the value and save r2 to support multiple toc sections.
3910    A ppc_stub_long_branch with an r2 offset looks like:
3911    .    std     %r2,40(%r1)
3912    .    addis   %r2,%r2,off@ha
3913    .    addi    %r2,%r2,off@l
3914    .    b       dest
3915
3916    A ppc_stub_plt_branch with an r2 offset looks like:
3917    .    std     %r2,40(%r1)
3918    .    addis   %r11,%r2,xxx@toc@ha
3919    .    ld      %r12,xxx@toc@l(%r11)
3920    .    addis   %r2,%r2,off@ha
3921    .    addi    %r2,%r2,off@l
3922    .    mtctr   %r12
3923    .    bctr
3924
3925    In cases where the "addis" instruction would add zero, the "addis" is
3926    omitted and following instructions modified slightly in some cases.
3927 */
3928
3929 enum ppc_stub_type {
3930   ppc_stub_none,
3931   ppc_stub_long_branch,
3932   ppc_stub_long_branch_r2off,
3933   ppc_stub_plt_branch,
3934   ppc_stub_plt_branch_r2off,
3935   ppc_stub_plt_call,
3936   ppc_stub_plt_call_r2save,
3937   ppc_stub_global_entry,
3938   ppc_stub_save_res
3939 };
3940
3941 /* Information on stub grouping.  */
3942 struct map_stub
3943 {
3944   /* The stub section.  */
3945   asection *stub_sec;
3946   /* This is the section to which stubs in the group will be attached.  */
3947   asection *link_sec;
3948   /* Next group.  */
3949   struct map_stub *next;
3950   /* Whether to emit a copy of register save/restore functions in this
3951      group.  */
3952   int needs_save_res;
3953   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3954      or -1u if no such stub with bctrl exists.  */
3955   unsigned int tls_get_addr_opt_bctrl;
3956 };
3957
3958 struct ppc_stub_hash_entry {
3959
3960   /* Base hash table entry structure.  */
3961   struct bfd_hash_entry root;
3962
3963   enum ppc_stub_type stub_type;
3964
3965   /* Group information.  */
3966   struct map_stub *group;
3967
3968   /* Offset within stub_sec of the beginning of this stub.  */
3969   bfd_vma stub_offset;
3970
3971   /* Given the symbol's value and its section we can determine its final
3972      value when building the stubs (so the stub knows where to jump.  */
3973   bfd_vma target_value;
3974   asection *target_section;
3975
3976   /* The symbol table entry, if any, that this was derived from.  */
3977   struct ppc_link_hash_entry *h;
3978   struct plt_entry *plt_ent;
3979
3980   /* Symbol st_other.  */
3981   unsigned char other;
3982 };
3983
3984 struct ppc_branch_hash_entry {
3985
3986   /* Base hash table entry structure.  */
3987   struct bfd_hash_entry root;
3988
3989   /* Offset within branch lookup table.  */
3990   unsigned int offset;
3991
3992   /* Generation marker.  */
3993   unsigned int iter;
3994 };
3995
3996 /* Used to track dynamic relocations for local symbols.  */
3997 struct ppc_dyn_relocs
3998 {
3999   struct ppc_dyn_relocs *next;
4000
4001   /* The input section of the reloc.  */
4002   asection *sec;
4003
4004   /* Total number of relocs copied for the input section.  */
4005   unsigned int count : 31;
4006
4007   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4008   unsigned int ifunc : 1;
4009 };
4010
4011 struct ppc_link_hash_entry
4012 {
4013   struct elf_link_hash_entry elf;
4014
4015   union {
4016     /* A pointer to the most recently used stub hash entry against this
4017        symbol.  */
4018     struct ppc_stub_hash_entry *stub_cache;
4019
4020     /* A pointer to the next symbol starting with a '.'  */
4021     struct ppc_link_hash_entry *next_dot_sym;
4022   } u;
4023
4024   /* Track dynamic relocs copied for this symbol.  */
4025   struct elf_dyn_relocs *dyn_relocs;
4026
4027   /* Link between function code and descriptor symbols.  */
4028   struct ppc_link_hash_entry *oh;
4029
4030   /* Flag function code and descriptor symbols.  */
4031   unsigned int is_func:1;
4032   unsigned int is_func_descriptor:1;
4033   unsigned int fake:1;
4034
4035   /* Whether global opd/toc sym has been adjusted or not.
4036      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4037      should be set for all globals defined in any opd/toc section.  */
4038   unsigned int adjust_done:1;
4039
4040   /* Set if this is an out-of-line register save/restore function,
4041      with non-standard calling convention.  */
4042   unsigned int save_res:1;
4043
4044   /* Set if a duplicate symbol with non-zero localentry is detected,
4045      even when the duplicate symbol does not provide a definition.  */
4046   unsigned int non_zero_localentry:1;
4047
4048   /* Contexts in which symbol is used in the GOT (or TOC).
4049      Bits are or'd into the mask as the corresponding relocs are
4050      encountered during check_relocs, with TLS_TLS being set when any
4051      of the other TLS bits are set.  tls_optimize clears bits when
4052      optimizing to indicate the corresponding GOT entry type is not
4053      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4054      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4055      separate flag rather than setting TPREL just for convenience in
4056      distinguishing the two cases.
4057      These flags are also kept for local symbols.  */
4058 #define TLS_TLS          1      /* Any TLS reloc.  */
4059 #define TLS_GD           2      /* GD reloc. */
4060 #define TLS_LD           4      /* LD reloc. */
4061 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4062 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4063 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4064 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4065 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4066   unsigned char tls_mask;
4067
4068   /* The above field is also used to mark function symbols.  In which
4069      case TLS_TLS will be 0.  */
4070 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4071 #define NON_GOT        256      /* local symbol plt, not stored.  */
4072 };
4073
4074 /* ppc64 ELF linker hash table.  */
4075
4076 struct ppc_link_hash_table
4077 {
4078   struct elf_link_hash_table elf;
4079
4080   /* The stub hash table.  */
4081   struct bfd_hash_table stub_hash_table;
4082
4083   /* Another hash table for plt_branch stubs.  */
4084   struct bfd_hash_table branch_hash_table;
4085
4086   /* Hash table for function prologue tocsave.  */
4087   htab_t tocsave_htab;
4088
4089   /* Various options and other info passed from the linker.  */
4090   struct ppc64_elf_params *params;
4091
4092   /* The size of sec_info below.  */
4093   unsigned int sec_info_arr_size;
4094
4095   /* Per-section array of extra section info.  Done this way rather
4096      than as part of ppc64_elf_section_data so we have the info for
4097      non-ppc64 sections.  */
4098   struct
4099   {
4100     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4101     bfd_vma toc_off;
4102
4103     union
4104     {
4105       /* The section group that this section belongs to.  */
4106       struct map_stub *group;
4107       /* A temp section list pointer.  */
4108       asection *list;
4109     } u;
4110   } *sec_info;
4111
4112   /* Linked list of groups.  */
4113   struct map_stub *group;
4114
4115   /* Temp used when calculating TOC pointers.  */
4116   bfd_vma toc_curr;
4117   bfd *toc_bfd;
4118   asection *toc_first_sec;
4119
4120   /* Used when adding symbols.  */
4121   struct ppc_link_hash_entry *dot_syms;
4122
4123   /* Shortcuts to get to dynamic linker sections.  */
4124   asection *glink;
4125   asection *global_entry;
4126   asection *sfpr;
4127   asection *brlt;
4128   asection *relbrlt;
4129   asection *glink_eh_frame;
4130
4131   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4132   struct ppc_link_hash_entry *tls_get_addr;
4133   struct ppc_link_hash_entry *tls_get_addr_fd;
4134
4135   /* The size of reliplt used by got entry relocs.  */
4136   bfd_size_type got_reli_size;
4137
4138   /* Statistics.  */
4139   unsigned long stub_count[ppc_stub_global_entry];
4140
4141   /* Number of stubs against global syms.  */
4142   unsigned long stub_globals;
4143
4144   /* Set if we're linking code with function descriptors.  */
4145   unsigned int opd_abi:1;
4146
4147   /* Support for multiple toc sections.  */
4148   unsigned int do_multi_toc:1;
4149   unsigned int multi_toc_needed:1;
4150   unsigned int second_toc_pass:1;
4151   unsigned int do_toc_opt:1;
4152
4153   /* Set if tls optimization is enabled.  */
4154   unsigned int do_tls_opt:1;
4155
4156   /* Set on error.  */
4157   unsigned int stub_error:1;
4158
4159   /* Whether func_desc_adjust needs to be run over symbols.  */
4160   unsigned int need_func_desc_adj:1;
4161
4162   /* Whether there exist local gnu indirect function resolvers,
4163      referenced by dynamic relocations.  */
4164   unsigned int local_ifunc_resolver:1;
4165   unsigned int maybe_local_ifunc_resolver:1;
4166
4167   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4168   unsigned int has_plt_localentry0:1;
4169
4170   /* Incremented every time we size stubs.  */
4171   unsigned int stub_iteration;
4172
4173   /* Small local sym cache.  */
4174   struct sym_cache sym_cache;
4175 };
4176
4177 /* Rename some of the generic section flags to better document how they
4178    are used here.  */
4179
4180 /* Nonzero if this section has TLS related relocations.  */
4181 #define has_tls_reloc sec_flg0
4182
4183 /* Nonzero if this section has a call to __tls_get_addr.  */
4184 #define has_tls_get_addr_call sec_flg1
4185
4186 /* Nonzero if this section has any toc or got relocs.  */
4187 #define has_toc_reloc sec_flg2
4188
4189 /* Nonzero if this section has a call to another section that uses
4190    the toc or got.  */
4191 #define makes_toc_func_call sec_flg3
4192
4193 /* Recursion protection when determining above flag.  */
4194 #define call_check_in_progress sec_flg4
4195 #define call_check_done sec_flg5
4196
4197 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4198
4199 #define ppc_hash_table(p) \
4200   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4201   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4202
4203 #define ppc_stub_hash_lookup(table, string, create, copy) \
4204   ((struct ppc_stub_hash_entry *) \
4205    bfd_hash_lookup ((table), (string), (create), (copy)))
4206
4207 #define ppc_branch_hash_lookup(table, string, create, copy) \
4208   ((struct ppc_branch_hash_entry *) \
4209    bfd_hash_lookup ((table), (string), (create), (copy)))
4210
4211 /* Create an entry in the stub hash table.  */
4212
4213 static struct bfd_hash_entry *
4214 stub_hash_newfunc (struct bfd_hash_entry *entry,
4215                    struct bfd_hash_table *table,
4216                    const char *string)
4217 {
4218   /* Allocate the structure if it has not already been allocated by a
4219      subclass.  */
4220   if (entry == NULL)
4221     {
4222       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4223       if (entry == NULL)
4224         return entry;
4225     }
4226
4227   /* Call the allocation method of the superclass.  */
4228   entry = bfd_hash_newfunc (entry, table, string);
4229   if (entry != NULL)
4230     {
4231       struct ppc_stub_hash_entry *eh;
4232
4233       /* Initialize the local fields.  */
4234       eh = (struct ppc_stub_hash_entry *) entry;
4235       eh->stub_type = ppc_stub_none;
4236       eh->group = NULL;
4237       eh->stub_offset = 0;
4238       eh->target_value = 0;
4239       eh->target_section = NULL;
4240       eh->h = NULL;
4241       eh->plt_ent = NULL;
4242       eh->other = 0;
4243     }
4244
4245   return entry;
4246 }
4247
4248 /* Create an entry in the branch hash table.  */
4249
4250 static struct bfd_hash_entry *
4251 branch_hash_newfunc (struct bfd_hash_entry *entry,
4252                      struct bfd_hash_table *table,
4253                      const char *string)
4254 {
4255   /* Allocate the structure if it has not already been allocated by a
4256      subclass.  */
4257   if (entry == NULL)
4258     {
4259       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4260       if (entry == NULL)
4261         return entry;
4262     }
4263
4264   /* Call the allocation method of the superclass.  */
4265   entry = bfd_hash_newfunc (entry, table, string);
4266   if (entry != NULL)
4267     {
4268       struct ppc_branch_hash_entry *eh;
4269
4270       /* Initialize the local fields.  */
4271       eh = (struct ppc_branch_hash_entry *) entry;
4272       eh->offset = 0;
4273       eh->iter = 0;
4274     }
4275
4276   return entry;
4277 }
4278
4279 /* Create an entry in a ppc64 ELF linker hash table.  */
4280
4281 static struct bfd_hash_entry *
4282 link_hash_newfunc (struct bfd_hash_entry *entry,
4283                    struct bfd_hash_table *table,
4284                    const char *string)
4285 {
4286   /* Allocate the structure if it has not already been allocated by a
4287      subclass.  */
4288   if (entry == NULL)
4289     {
4290       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4291       if (entry == NULL)
4292         return entry;
4293     }
4294
4295   /* Call the allocation method of the superclass.  */
4296   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4297   if (entry != NULL)
4298     {
4299       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4300
4301       memset (&eh->u.stub_cache, 0,
4302               (sizeof (struct ppc_link_hash_entry)
4303                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4304
4305       /* When making function calls, old ABI code references function entry
4306          points (dot symbols), while new ABI code references the function
4307          descriptor symbol.  We need to make any combination of reference and
4308          definition work together, without breaking archive linking.
4309
4310          For a defined function "foo" and an undefined call to "bar":
4311          An old object defines "foo" and ".foo", references ".bar" (possibly
4312          "bar" too).
4313          A new object defines "foo" and references "bar".
4314
4315          A new object thus has no problem with its undefined symbols being
4316          satisfied by definitions in an old object.  On the other hand, the
4317          old object won't have ".bar" satisfied by a new object.
4318
4319          Keep a list of newly added dot-symbols.  */
4320
4321       if (string[0] == '.')
4322         {
4323           struct ppc_link_hash_table *htab;
4324
4325           htab = (struct ppc_link_hash_table *) table;
4326           eh->u.next_dot_sym = htab->dot_syms;
4327           htab->dot_syms = eh;
4328         }
4329     }
4330
4331   return entry;
4332 }
4333
4334 struct tocsave_entry {
4335   asection *sec;
4336   bfd_vma offset;
4337 };
4338
4339 static hashval_t
4340 tocsave_htab_hash (const void *p)
4341 {
4342   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4343   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4344 }
4345
4346 static int
4347 tocsave_htab_eq (const void *p1, const void *p2)
4348 {
4349   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4350   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4351   return e1->sec == e2->sec && e1->offset == e2->offset;
4352 }
4353
4354 /* Destroy a ppc64 ELF linker hash table.  */
4355
4356 static void
4357 ppc64_elf_link_hash_table_free (bfd *obfd)
4358 {
4359   struct ppc_link_hash_table *htab;
4360
4361   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4362   if (htab->tocsave_htab)
4363     htab_delete (htab->tocsave_htab);
4364   bfd_hash_table_free (&htab->branch_hash_table);
4365   bfd_hash_table_free (&htab->stub_hash_table);
4366   _bfd_elf_link_hash_table_free (obfd);
4367 }
4368
4369 /* Create a ppc64 ELF linker hash table.  */
4370
4371 static struct bfd_link_hash_table *
4372 ppc64_elf_link_hash_table_create (bfd *abfd)
4373 {
4374   struct ppc_link_hash_table *htab;
4375   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4376
4377   htab = bfd_zmalloc (amt);
4378   if (htab == NULL)
4379     return NULL;
4380
4381   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4382                                       sizeof (struct ppc_link_hash_entry),
4383                                       PPC64_ELF_DATA))
4384     {
4385       free (htab);
4386       return NULL;
4387     }
4388
4389   /* Init the stub hash table too.  */
4390   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4391                             sizeof (struct ppc_stub_hash_entry)))
4392     {
4393       _bfd_elf_link_hash_table_free (abfd);
4394       return NULL;
4395     }
4396
4397   /* And the branch hash table.  */
4398   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4399                             sizeof (struct ppc_branch_hash_entry)))
4400     {
4401       bfd_hash_table_free (&htab->stub_hash_table);
4402       _bfd_elf_link_hash_table_free (abfd);
4403       return NULL;
4404     }
4405
4406   htab->tocsave_htab = htab_try_create (1024,
4407                                         tocsave_htab_hash,
4408                                         tocsave_htab_eq,
4409                                         NULL);
4410   if (htab->tocsave_htab == NULL)
4411     {
4412       ppc64_elf_link_hash_table_free (abfd);
4413       return NULL;
4414     }
4415   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4416
4417   /* Initializing two fields of the union is just cosmetic.  We really
4418      only care about glist, but when compiled on a 32-bit host the
4419      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4420      debugger inspection of these fields look nicer.  */
4421   htab->elf.init_got_refcount.refcount = 0;
4422   htab->elf.init_got_refcount.glist = NULL;
4423   htab->elf.init_plt_refcount.refcount = 0;
4424   htab->elf.init_plt_refcount.glist = NULL;
4425   htab->elf.init_got_offset.offset = 0;
4426   htab->elf.init_got_offset.glist = NULL;
4427   htab->elf.init_plt_offset.offset = 0;
4428   htab->elf.init_plt_offset.glist = NULL;
4429
4430   return &htab->elf.root;
4431 }
4432
4433 /* Create sections for linker generated code.  */
4434
4435 static bfd_boolean
4436 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4437 {
4438   struct ppc_link_hash_table *htab;
4439   flagword flags;
4440
4441   htab = ppc_hash_table (info);
4442
4443   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4444            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4445   if (htab->params->save_restore_funcs)
4446     {
4447       /* Create .sfpr for code to save and restore fp regs.  */
4448       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4449                                                        flags);
4450       if (htab->sfpr == NULL
4451           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4452         return FALSE;
4453     }
4454
4455   if (bfd_link_relocatable (info))
4456     return TRUE;
4457
4458   /* Create .glink for lazy dynamic linking support.  */
4459   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4460                                                     flags);
4461   if (htab->glink == NULL
4462       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4463     return FALSE;
4464
4465   /* The part of .glink used by global entry stubs, separate so that
4466      it can be aligned appropriately without affecting htab->glink.  */
4467   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4468                                                            flags);
4469   if (htab->global_entry == NULL
4470       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4471     return FALSE;
4472
4473   if (!info->no_ld_generated_unwind_info)
4474     {
4475       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4476                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4477       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4478                                                                  ".eh_frame",
4479                                                                  flags);
4480       if (htab->glink_eh_frame == NULL
4481           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4482         return FALSE;
4483     }
4484
4485   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4486   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4487   if (htab->elf.iplt == NULL
4488       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4489     return FALSE;
4490
4491   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4492            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4493   htab->elf.irelplt
4494     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4495   if (htab->elf.irelplt == NULL
4496       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4497     return FALSE;
4498
4499   /* Create branch lookup table for plt_branch stubs.  */
4500   flags = (SEC_ALLOC | SEC_LOAD
4501            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4502   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4503                                                    flags);
4504   if (htab->brlt == NULL
4505       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4506     return FALSE;
4507
4508   if (!bfd_link_pic (info))
4509     return TRUE;
4510
4511   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4512            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4513   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4514                                                       ".rela.branch_lt",
4515                                                       flags);
4516   if (htab->relbrlt == NULL
4517       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4518     return FALSE;
4519
4520   return TRUE;
4521 }
4522
4523 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4524
4525 bfd_boolean
4526 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4527                          struct ppc64_elf_params *params)
4528 {
4529   struct ppc_link_hash_table *htab;
4530
4531   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4532
4533 /* Always hook our dynamic sections into the first bfd, which is the
4534    linker created stub bfd.  This ensures that the GOT header is at
4535    the start of the output TOC section.  */
4536   htab = ppc_hash_table (info);
4537   htab->elf.dynobj = params->stub_bfd;
4538   htab->params = params;
4539
4540   return create_linkage_sections (htab->elf.dynobj, info);
4541 }
4542
4543 /* Build a name for an entry in the stub hash table.  */
4544
4545 static char *
4546 ppc_stub_name (const asection *input_section,
4547                const asection *sym_sec,
4548                const struct ppc_link_hash_entry *h,
4549                const Elf_Internal_Rela *rel)
4550 {
4551   char *stub_name;
4552   ssize_t len;
4553
4554   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4555      offsets from a sym as a branch target?  In fact, we could
4556      probably assume the addend is always zero.  */
4557   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4558
4559   if (h)
4560     {
4561       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4562       stub_name = bfd_malloc (len);
4563       if (stub_name == NULL)
4564         return stub_name;
4565
4566       len = sprintf (stub_name, "%08x.%s+%x",
4567                      input_section->id & 0xffffffff,
4568                      h->elf.root.root.string,
4569                      (int) rel->r_addend & 0xffffffff);
4570     }
4571   else
4572     {
4573       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4574       stub_name = bfd_malloc (len);
4575       if (stub_name == NULL)
4576         return stub_name;
4577
4578       len = sprintf (stub_name, "%08x.%x:%x+%x",
4579                      input_section->id & 0xffffffff,
4580                      sym_sec->id & 0xffffffff,
4581                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4582                      (int) rel->r_addend & 0xffffffff);
4583     }
4584   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4585     stub_name[len - 2] = 0;
4586   return stub_name;
4587 }
4588
4589 /* Look up an entry in the stub hash.  Stub entries are cached because
4590    creating the stub name takes a bit of time.  */
4591
4592 static struct ppc_stub_hash_entry *
4593 ppc_get_stub_entry (const asection *input_section,
4594                     const asection *sym_sec,
4595                     struct ppc_link_hash_entry *h,
4596                     const Elf_Internal_Rela *rel,
4597                     struct ppc_link_hash_table *htab)
4598 {
4599   struct ppc_stub_hash_entry *stub_entry;
4600   struct map_stub *group;
4601
4602   /* If this input section is part of a group of sections sharing one
4603      stub section, then use the id of the first section in the group.
4604      Stub names need to include a section id, as there may well be
4605      more than one stub used to reach say, printf, and we need to
4606      distinguish between them.  */
4607   group = htab->sec_info[input_section->id].u.group;
4608   if (group == NULL)
4609     return NULL;
4610
4611   if (h != NULL && h->u.stub_cache != NULL
4612       && h->u.stub_cache->h == h
4613       && h->u.stub_cache->group == group)
4614     {
4615       stub_entry = h->u.stub_cache;
4616     }
4617   else
4618     {
4619       char *stub_name;
4620
4621       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4622       if (stub_name == NULL)
4623         return NULL;
4624
4625       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4626                                          stub_name, FALSE, FALSE);
4627       if (h != NULL)
4628         h->u.stub_cache = stub_entry;
4629
4630       free (stub_name);
4631     }
4632
4633   return stub_entry;
4634 }
4635
4636 /* Add a new stub entry to the stub hash.  Not all fields of the new
4637    stub entry are initialised.  */
4638
4639 static struct ppc_stub_hash_entry *
4640 ppc_add_stub (const char *stub_name,
4641               asection *section,
4642               struct bfd_link_info *info)
4643 {
4644   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4645   struct map_stub *group;
4646   asection *link_sec;
4647   asection *stub_sec;
4648   struct ppc_stub_hash_entry *stub_entry;
4649
4650   group = htab->sec_info[section->id].u.group;
4651   link_sec = group->link_sec;
4652   stub_sec = group->stub_sec;
4653   if (stub_sec == NULL)
4654     {
4655       size_t namelen;
4656       bfd_size_type len;
4657       char *s_name;
4658
4659       namelen = strlen (link_sec->name);
4660       len = namelen + sizeof (STUB_SUFFIX);
4661       s_name = bfd_alloc (htab->params->stub_bfd, len);
4662       if (s_name == NULL)
4663         return NULL;
4664
4665       memcpy (s_name, link_sec->name, namelen);
4666       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4667       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4668       if (stub_sec == NULL)
4669         return NULL;
4670       group->stub_sec = stub_sec;
4671     }
4672
4673   /* Enter this entry into the linker stub hash table.  */
4674   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4675                                      TRUE, FALSE);
4676   if (stub_entry == NULL)
4677     {
4678       /* xgettext:c-format */
4679       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4680                           section->owner, stub_name);
4681       return NULL;
4682     }
4683
4684   stub_entry->group = group;
4685   stub_entry->stub_offset = 0;
4686   return stub_entry;
4687 }
4688
4689 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4690    not already done.  */
4691
4692 static bfd_boolean
4693 create_got_section (bfd *abfd, struct bfd_link_info *info)
4694 {
4695   asection *got, *relgot;
4696   flagword flags;
4697   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4698
4699   if (!is_ppc64_elf (abfd))
4700     return FALSE;
4701   if (htab == NULL)
4702     return FALSE;
4703
4704   if (!htab->elf.sgot
4705       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4706     return FALSE;
4707
4708   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4709            | SEC_LINKER_CREATED);
4710
4711   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4712   if (!got
4713       || !bfd_set_section_alignment (abfd, got, 3))
4714     return FALSE;
4715
4716   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4717                                                flags | SEC_READONLY);
4718   if (!relgot
4719       || ! bfd_set_section_alignment (abfd, relgot, 3))
4720     return FALSE;
4721
4722   ppc64_elf_tdata (abfd)->got = got;
4723   ppc64_elf_tdata (abfd)->relgot = relgot;
4724   return TRUE;
4725 }
4726
4727 /* Follow indirect and warning symbol links.  */
4728
4729 static inline struct bfd_link_hash_entry *
4730 follow_link (struct bfd_link_hash_entry *h)
4731 {
4732   while (h->type == bfd_link_hash_indirect
4733          || h->type == bfd_link_hash_warning)
4734     h = h->u.i.link;
4735   return h;
4736 }
4737
4738 static inline struct elf_link_hash_entry *
4739 elf_follow_link (struct elf_link_hash_entry *h)
4740 {
4741   return (struct elf_link_hash_entry *) follow_link (&h->root);
4742 }
4743
4744 static inline struct ppc_link_hash_entry *
4745 ppc_follow_link (struct ppc_link_hash_entry *h)
4746 {
4747   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4748 }
4749
4750 /* Merge PLT info on FROM with that on TO.  */
4751
4752 static void
4753 move_plt_plist (struct ppc_link_hash_entry *from,
4754                 struct ppc_link_hash_entry *to)
4755 {
4756   if (from->elf.plt.plist != NULL)
4757     {
4758       if (to->elf.plt.plist != NULL)
4759         {
4760           struct plt_entry **entp;
4761           struct plt_entry *ent;
4762
4763           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4764             {
4765               struct plt_entry *dent;
4766
4767               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4768                 if (dent->addend == ent->addend)
4769                   {
4770                     dent->plt.refcount += ent->plt.refcount;
4771                     *entp = ent->next;
4772                     break;
4773                   }
4774               if (dent == NULL)
4775                 entp = &ent->next;
4776             }
4777           *entp = to->elf.plt.plist;
4778         }
4779
4780       to->elf.plt.plist = from->elf.plt.plist;
4781       from->elf.plt.plist = NULL;
4782     }
4783 }
4784
4785 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4786
4787 static void
4788 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4789                                 struct elf_link_hash_entry *dir,
4790                                 struct elf_link_hash_entry *ind)
4791 {
4792   struct ppc_link_hash_entry *edir, *eind;
4793
4794   edir = (struct ppc_link_hash_entry *) dir;
4795   eind = (struct ppc_link_hash_entry *) ind;
4796
4797   edir->is_func |= eind->is_func;
4798   edir->is_func_descriptor |= eind->is_func_descriptor;
4799   edir->tls_mask |= eind->tls_mask;
4800   if (eind->oh != NULL)
4801     edir->oh = ppc_follow_link (eind->oh);
4802
4803   if (edir->elf.versioned != versioned_hidden)
4804     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4805   edir->elf.ref_regular |= eind->elf.ref_regular;
4806   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4807   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4808   edir->elf.needs_plt |= eind->elf.needs_plt;
4809   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4810
4811   /* If we were called to copy over info for a weak sym, don't copy
4812      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4813      in order to simplify readonly_dynrelocs and save a field in the
4814      symbol hash entry, but that means dyn_relocs can't be used in any
4815      tests about a specific symbol, or affect other symbol flags which
4816      are then tested.  */
4817   if (eind->elf.root.type != bfd_link_hash_indirect)
4818     return;
4819
4820   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4821   if (eind->dyn_relocs != NULL)
4822     {
4823       if (edir->dyn_relocs != NULL)
4824         {
4825           struct elf_dyn_relocs **pp;
4826           struct elf_dyn_relocs *p;
4827
4828           /* Add reloc counts against the indirect sym to the direct sym
4829              list.  Merge any entries against the same section.  */
4830           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4831             {
4832               struct elf_dyn_relocs *q;
4833
4834               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4835                 if (q->sec == p->sec)
4836                   {
4837                     q->pc_count += p->pc_count;
4838                     q->count += p->count;
4839                     *pp = p->next;
4840                     break;
4841                   }
4842               if (q == NULL)
4843                 pp = &p->next;
4844             }
4845           *pp = edir->dyn_relocs;
4846         }
4847
4848       edir->dyn_relocs = eind->dyn_relocs;
4849       eind->dyn_relocs = NULL;
4850     }
4851
4852   /* Copy over got entries that we may have already seen to the
4853      symbol which just became indirect.  */
4854   if (eind->elf.got.glist != NULL)
4855     {
4856       if (edir->elf.got.glist != NULL)
4857         {
4858           struct got_entry **entp;
4859           struct got_entry *ent;
4860
4861           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4862             {
4863               struct got_entry *dent;
4864
4865               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4866                 if (dent->addend == ent->addend
4867                     && dent->owner == ent->owner
4868                     && dent->tls_type == ent->tls_type)
4869                   {
4870                     dent->got.refcount += ent->got.refcount;
4871                     *entp = ent->next;
4872                     break;
4873                   }
4874               if (dent == NULL)
4875                 entp = &ent->next;
4876             }
4877           *entp = edir->elf.got.glist;
4878         }
4879
4880       edir->elf.got.glist = eind->elf.got.glist;
4881       eind->elf.got.glist = NULL;
4882     }
4883
4884   /* And plt entries.  */
4885   move_plt_plist (eind, edir);
4886
4887   if (eind->elf.dynindx != -1)
4888     {
4889       if (edir->elf.dynindx != -1)
4890         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4891                                 edir->elf.dynstr_index);
4892       edir->elf.dynindx = eind->elf.dynindx;
4893       edir->elf.dynstr_index = eind->elf.dynstr_index;
4894       eind->elf.dynindx = -1;
4895       eind->elf.dynstr_index = 0;
4896     }
4897 }
4898
4899 /* Find the function descriptor hash entry from the given function code
4900    hash entry FH.  Link the entries via their OH fields.  */
4901
4902 static struct ppc_link_hash_entry *
4903 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4904 {
4905   struct ppc_link_hash_entry *fdh = fh->oh;
4906
4907   if (fdh == NULL)
4908     {
4909       const char *fd_name = fh->elf.root.root.string + 1;
4910
4911       fdh = (struct ppc_link_hash_entry *)
4912         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4913       if (fdh == NULL)
4914         return fdh;
4915
4916       fdh->is_func_descriptor = 1;
4917       fdh->oh = fh;
4918       fh->is_func = 1;
4919       fh->oh = fdh;
4920     }
4921
4922   fdh = ppc_follow_link (fdh);
4923   fdh->is_func_descriptor = 1;
4924   fdh->oh = fh;
4925   return fdh;
4926 }
4927
4928 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4929
4930 static struct ppc_link_hash_entry *
4931 make_fdh (struct bfd_link_info *info,
4932           struct ppc_link_hash_entry *fh)
4933 {
4934   bfd *abfd = fh->elf.root.u.undef.abfd;
4935   struct bfd_link_hash_entry *bh = NULL;
4936   struct ppc_link_hash_entry *fdh;
4937   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4938                     ? BSF_WEAK
4939                     : BSF_GLOBAL);
4940
4941   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4942                                          fh->elf.root.root.string + 1,
4943                                          flags, bfd_und_section_ptr, 0,
4944                                          NULL, FALSE, FALSE, &bh))
4945     return NULL;
4946
4947   fdh = (struct ppc_link_hash_entry *) bh;
4948   fdh->elf.non_elf = 0;
4949   fdh->fake = 1;
4950   fdh->is_func_descriptor = 1;
4951   fdh->oh = fh;
4952   fh->is_func = 1;
4953   fh->oh = fdh;
4954   return fdh;
4955 }
4956
4957 /* Fix function descriptor symbols defined in .opd sections to be
4958    function type.  */
4959
4960 static bfd_boolean
4961 ppc64_elf_add_symbol_hook (bfd *ibfd,
4962                            struct bfd_link_info *info,
4963                            Elf_Internal_Sym *isym,
4964                            const char **name,
4965                            flagword *flags ATTRIBUTE_UNUSED,
4966                            asection **sec,
4967                            bfd_vma *value)
4968 {
4969   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4970       && (ibfd->flags & DYNAMIC) == 0
4971       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4972     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4973
4974   if (*sec != NULL
4975       && strcmp ((*sec)->name, ".opd") == 0)
4976     {
4977       asection *code_sec;
4978
4979       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4980             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4981         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4982
4983       /* If the symbol is a function defined in .opd, and the function
4984          code is in a discarded group, let it appear to be undefined.  */
4985       if (!bfd_link_relocatable (info)
4986           && (*sec)->reloc_count != 0
4987           && opd_entry_value (*sec, *value, &code_sec, NULL,
4988                               FALSE) != (bfd_vma) -1
4989           && discarded_section (code_sec))
4990         {
4991           *sec = bfd_und_section_ptr;
4992           isym->st_shndx = SHN_UNDEF;
4993         }
4994     }
4995   else if (*sec != NULL
4996            && strcmp ((*sec)->name, ".toc") == 0
4997            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4998     {
4999       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5000       if (htab != NULL)
5001         htab->params->object_in_toc = 1;
5002     }
5003
5004   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5005     {
5006       if (abiversion (ibfd) == 0)
5007         set_abiversion (ibfd, 2);
5008       else if (abiversion (ibfd) == 1)
5009         {
5010           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5011                                 " for ABI version 1"), *name);
5012           bfd_set_error (bfd_error_bad_value);
5013           return FALSE;
5014         }
5015     }
5016
5017   return TRUE;
5018 }
5019
5020 /* Merge non-visibility st_other attributes: local entry point.  */
5021
5022 static void
5023 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5024                                   const Elf_Internal_Sym *isym,
5025                                   bfd_boolean definition,
5026                                   bfd_boolean dynamic)
5027 {
5028   if (definition && (!dynamic || !h->def_regular))
5029     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5030                 | ELF_ST_VISIBILITY (h->other));
5031 }
5032
5033 /* Hook called on merging a symbol.  We use this to clear "fake" since
5034    we now have a real symbol.  */
5035
5036 static bfd_boolean
5037 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5038                         const Elf_Internal_Sym *isym,
5039                         asection **psec ATTRIBUTE_UNUSED,
5040                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5041                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5042                         bfd *oldbfd ATTRIBUTE_UNUSED,
5043                         const asection *oldsec ATTRIBUTE_UNUSED)
5044 {
5045   ((struct ppc_link_hash_entry *) h)->fake = 0;
5046   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5047     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5048   return TRUE;
5049 }
5050
5051 /* This function makes an old ABI object reference to ".bar" cause the
5052    inclusion of a new ABI object archive that defines "bar".
5053    NAME is a symbol defined in an archive.  Return a symbol in the hash
5054    table that might be satisfied by the archive symbols.  */
5055
5056 static struct elf_link_hash_entry *
5057 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5058                                  struct bfd_link_info *info,
5059                                  const char *name)
5060 {
5061   struct elf_link_hash_entry *h;
5062   char *dot_name;
5063   size_t len;
5064
5065   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5066   if (h != NULL
5067       /* Don't return this sym if it is a fake function descriptor
5068          created by add_symbol_adjust.  */
5069       && !((struct ppc_link_hash_entry *) h)->fake)
5070     return h;
5071
5072   if (name[0] == '.')
5073     return h;
5074
5075   len = strlen (name);
5076   dot_name = bfd_alloc (abfd, len + 2);
5077   if (dot_name == NULL)
5078     return (struct elf_link_hash_entry *) -1;
5079   dot_name[0] = '.';
5080   memcpy (dot_name + 1, name, len + 1);
5081   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5082   bfd_release (abfd, dot_name);
5083   return h;
5084 }
5085
5086 /* This function satisfies all old ABI object references to ".bar" if a
5087    new ABI object defines "bar".  Well, at least, undefined dot symbols
5088    are made weak.  This stops later archive searches from including an
5089    object if we already have a function descriptor definition.  It also
5090    prevents the linker complaining about undefined symbols.
5091    We also check and correct mismatched symbol visibility here.  The
5092    most restrictive visibility of the function descriptor and the
5093    function entry symbol is used.  */
5094
5095 static bfd_boolean
5096 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5097 {
5098   struct ppc_link_hash_table *htab;
5099   struct ppc_link_hash_entry *fdh;
5100
5101   if (eh->elf.root.type == bfd_link_hash_warning)
5102     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5103
5104   if (eh->elf.root.type == bfd_link_hash_indirect)
5105     return TRUE;
5106
5107   if (eh->elf.root.root.string[0] != '.')
5108     abort ();
5109
5110   htab = ppc_hash_table (info);
5111   if (htab == NULL)
5112     return FALSE;
5113
5114   fdh = lookup_fdh (eh, htab);
5115   if (fdh == NULL
5116       && !bfd_link_relocatable (info)
5117       && (eh->elf.root.type == bfd_link_hash_undefined
5118           || eh->elf.root.type == bfd_link_hash_undefweak)
5119       && eh->elf.ref_regular)
5120     {
5121       /* Make an undefined function descriptor sym, in order to
5122          pull in an --as-needed shared lib.  Archives are handled
5123          elsewhere.  */
5124       fdh = make_fdh (info, eh);
5125       if (fdh == NULL)
5126         return FALSE;
5127     }
5128
5129   if (fdh != NULL)
5130     {
5131       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5132       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5133
5134       /* Make both descriptor and entry symbol have the most
5135          constraining visibility of either symbol.  */
5136       if (entry_vis < descr_vis)
5137         fdh->elf.other += entry_vis - descr_vis;
5138       else if (entry_vis > descr_vis)
5139         eh->elf.other += descr_vis - entry_vis;
5140
5141       /* Propagate reference flags from entry symbol to function
5142          descriptor symbol.  */
5143       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5144       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5145       fdh->elf.ref_regular |= eh->elf.ref_regular;
5146       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5147
5148       if (!fdh->elf.forced_local
5149           && fdh->elf.dynindx == -1
5150           && fdh->elf.versioned != versioned_hidden
5151           && (bfd_link_dll (info)
5152               || fdh->elf.def_dynamic
5153               || fdh->elf.ref_dynamic)
5154           && (eh->elf.ref_regular
5155               || eh->elf.def_regular))
5156         {
5157           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5158             return FALSE;
5159         }
5160     }
5161
5162   return TRUE;
5163 }
5164
5165 /* Set up opd section info and abiversion for IBFD, and process list
5166    of dot-symbols we made in link_hash_newfunc.  */
5167
5168 static bfd_boolean
5169 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5170 {
5171   struct ppc_link_hash_table *htab;
5172   struct ppc_link_hash_entry **p, *eh;
5173   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5174
5175   if (opd != NULL && opd->size != 0)
5176     {
5177       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5178       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5179
5180       if (abiversion (ibfd) == 0)
5181         set_abiversion (ibfd, 1);
5182       else if (abiversion (ibfd) >= 2)
5183         {
5184           /* xgettext:c-format */
5185           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5186                               ibfd, abiversion (ibfd));
5187           bfd_set_error (bfd_error_bad_value);
5188           return FALSE;
5189         }
5190     }
5191
5192   if (is_ppc64_elf (info->output_bfd))
5193     {
5194       /* For input files without an explicit abiversion in e_flags
5195          we should have flagged any with symbol st_other bits set
5196          as ELFv1 and above flagged those with .opd as ELFv2.
5197          Set the output abiversion if not yet set, and for any input
5198          still ambiguous, take its abiversion from the output.
5199          Differences in ABI are reported later.  */
5200       if (abiversion (info->output_bfd) == 0)
5201         set_abiversion (info->output_bfd, abiversion (ibfd));
5202       else if (abiversion (ibfd) == 0)
5203         set_abiversion (ibfd, abiversion (info->output_bfd));
5204     }
5205
5206   htab = ppc_hash_table (info);
5207   if (htab == NULL)
5208     return TRUE;
5209
5210   if (opd != NULL && opd->size != 0
5211       && (ibfd->flags & DYNAMIC) == 0
5212       && (opd->flags & SEC_RELOC) != 0
5213       && opd->reloc_count != 0
5214       && !bfd_is_abs_section (opd->output_section)
5215       && info->gc_sections)
5216     {
5217       /* Garbage collection needs some extra help with .opd sections.
5218          We don't want to necessarily keep everything referenced by
5219          relocs in .opd, as that would keep all functions.  Instead,
5220          if we reference an .opd symbol (a function descriptor), we
5221          want to keep the function code symbol's section.  This is
5222          easy for global symbols, but for local syms we need to keep
5223          information about the associated function section.  */
5224       bfd_size_type amt;
5225       asection **opd_sym_map;
5226       Elf_Internal_Shdr *symtab_hdr;
5227       Elf_Internal_Rela *relocs, *rel_end, *rel;
5228
5229       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5230       opd_sym_map = bfd_zalloc (ibfd, amt);
5231       if (opd_sym_map == NULL)
5232         return FALSE;
5233       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5234       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5235                                           info->keep_memory);
5236       if (relocs == NULL)
5237         return FALSE;
5238       symtab_hdr = &elf_symtab_hdr (ibfd);
5239       rel_end = relocs + opd->reloc_count - 1;
5240       for (rel = relocs; rel < rel_end; rel++)
5241         {
5242           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5243           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5244
5245           if (r_type == R_PPC64_ADDR64
5246               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5247               && r_symndx < symtab_hdr->sh_info)
5248             {
5249               Elf_Internal_Sym *isym;
5250               asection *s;
5251
5252               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5253               if (isym == NULL)
5254                 {
5255                   if (elf_section_data (opd)->relocs != relocs)
5256                     free (relocs);
5257                   return FALSE;
5258                 }
5259
5260               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5261               if (s != NULL && s != opd)
5262                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5263             }
5264         }
5265       if (elf_section_data (opd)->relocs != relocs)
5266         free (relocs);
5267     }
5268
5269   p = &htab->dot_syms;
5270   while ((eh = *p) != NULL)
5271     {
5272       *p = NULL;
5273       if (&eh->elf == htab->elf.hgot)
5274         ;
5275       else if (htab->elf.hgot == NULL
5276                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5277         htab->elf.hgot = &eh->elf;
5278       else if (abiversion (ibfd) <= 1)
5279         {
5280           htab->need_func_desc_adj = 1;
5281           if (!add_symbol_adjust (eh, info))
5282             return FALSE;
5283         }
5284       p = &eh->u.next_dot_sym;
5285     }
5286   return TRUE;
5287 }
5288
5289 /* Undo hash table changes when an --as-needed input file is determined
5290    not to be needed.  */
5291
5292 static bfd_boolean
5293 ppc64_elf_notice_as_needed (bfd *ibfd,
5294                             struct bfd_link_info *info,
5295                             enum notice_asneeded_action act)
5296 {
5297   if (act == notice_not_needed)
5298     {
5299       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5300
5301       if (htab == NULL)
5302         return FALSE;
5303
5304       htab->dot_syms = NULL;
5305     }
5306   return _bfd_elf_notice_as_needed (ibfd, info, act);
5307 }
5308
5309 /* If --just-symbols against a final linked binary, then assume we need
5310    toc adjusting stubs when calling functions defined there.  */
5311
5312 static void
5313 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5314 {
5315   if ((sec->flags & SEC_CODE) != 0
5316       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5317       && is_ppc64_elf (sec->owner))
5318     {
5319       if (abiversion (sec->owner) >= 2
5320           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5321         sec->has_toc_reloc = 1;
5322     }
5323   _bfd_elf_link_just_syms (sec, info);
5324 }
5325
5326 static struct plt_entry **
5327 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5328                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5329 {
5330   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5331   struct plt_entry **local_plt;
5332   unsigned char *local_got_tls_masks;
5333
5334   if (local_got_ents == NULL)
5335     {
5336       bfd_size_type size = symtab_hdr->sh_info;
5337
5338       size *= (sizeof (*local_got_ents)
5339                + sizeof (*local_plt)
5340                + sizeof (*local_got_tls_masks));
5341       local_got_ents = bfd_zalloc (abfd, size);
5342       if (local_got_ents == NULL)
5343         return NULL;
5344       elf_local_got_ents (abfd) = local_got_ents;
5345     }
5346
5347   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5348     {
5349       struct got_entry *ent;
5350
5351       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5352         if (ent->addend == r_addend
5353             && ent->owner == abfd
5354             && ent->tls_type == tls_type)
5355           break;
5356       if (ent == NULL)
5357         {
5358           bfd_size_type amt = sizeof (*ent);
5359           ent = bfd_alloc (abfd, amt);
5360           if (ent == NULL)
5361             return FALSE;
5362           ent->next = local_got_ents[r_symndx];
5363           ent->addend = r_addend;
5364           ent->owner = abfd;
5365           ent->tls_type = tls_type;
5366           ent->is_indirect = FALSE;
5367           ent->got.refcount = 0;
5368           local_got_ents[r_symndx] = ent;
5369         }
5370       ent->got.refcount += 1;
5371     }
5372
5373   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5374   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5375   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5376
5377   return local_plt + r_symndx;
5378 }
5379
5380 static bfd_boolean
5381 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5382 {
5383   struct plt_entry *ent;
5384
5385   for (ent = *plist; ent != NULL; ent = ent->next)
5386     if (ent->addend == addend)
5387       break;
5388   if (ent == NULL)
5389     {
5390       bfd_size_type amt = sizeof (*ent);
5391       ent = bfd_alloc (abfd, amt);
5392       if (ent == NULL)
5393         return FALSE;
5394       ent->next = *plist;
5395       ent->addend = addend;
5396       ent->plt.refcount = 0;
5397       *plist = ent;
5398     }
5399   ent->plt.refcount += 1;
5400   return TRUE;
5401 }
5402
5403 static bfd_boolean
5404 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5405 {
5406   return (r_type == R_PPC64_REL24
5407           || r_type == R_PPC64_REL14
5408           || r_type == R_PPC64_REL14_BRTAKEN
5409           || r_type == R_PPC64_REL14_BRNTAKEN
5410           || r_type == R_PPC64_ADDR24
5411           || r_type == R_PPC64_ADDR14
5412           || r_type == R_PPC64_ADDR14_BRTAKEN
5413           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5414 }
5415
5416 /* Look through the relocs for a section during the first phase, and
5417    calculate needed space in the global offset table, procedure
5418    linkage table, and dynamic reloc sections.  */
5419
5420 static bfd_boolean
5421 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5422                         asection *sec, const Elf_Internal_Rela *relocs)
5423 {
5424   struct ppc_link_hash_table *htab;
5425   Elf_Internal_Shdr *symtab_hdr;
5426   struct elf_link_hash_entry **sym_hashes;
5427   const Elf_Internal_Rela *rel;
5428   const Elf_Internal_Rela *rel_end;
5429   asection *sreloc;
5430   struct elf_link_hash_entry *tga, *dottga;
5431   bfd_boolean is_opd;
5432
5433   if (bfd_link_relocatable (info))
5434     return TRUE;
5435
5436   /* Don't do anything special with non-loaded, non-alloced sections.
5437      In particular, any relocs in such sections should not affect GOT
5438      and PLT reference counting (ie. we don't allow them to create GOT
5439      or PLT entries), there's no possibility or desire to optimize TLS
5440      relocs, and there's not much point in propagating relocs to shared
5441      libs that the dynamic linker won't relocate.  */
5442   if ((sec->flags & SEC_ALLOC) == 0)
5443     return TRUE;
5444
5445   BFD_ASSERT (is_ppc64_elf (abfd));
5446
5447   htab = ppc_hash_table (info);
5448   if (htab == NULL)
5449     return FALSE;
5450
5451   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5452                               FALSE, FALSE, TRUE);
5453   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5454                                  FALSE, FALSE, TRUE);
5455   symtab_hdr = &elf_symtab_hdr (abfd);
5456   sym_hashes = elf_sym_hashes (abfd);
5457   sreloc = NULL;
5458   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5459   rel_end = relocs + sec->reloc_count;
5460   for (rel = relocs; rel < rel_end; rel++)
5461     {
5462       unsigned long r_symndx;
5463       struct elf_link_hash_entry *h;
5464       enum elf_ppc64_reloc_type r_type;
5465       int tls_type;
5466       struct _ppc64_elf_section_data *ppc64_sec;
5467       struct plt_entry **ifunc, **plt_list;
5468
5469       r_symndx = ELF64_R_SYM (rel->r_info);
5470       if (r_symndx < symtab_hdr->sh_info)
5471         h = NULL;
5472       else
5473         {
5474           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5475           h = elf_follow_link (h);
5476
5477           if (h == htab->elf.hgot)
5478             sec->has_toc_reloc = 1;
5479         }
5480
5481       tls_type = 0;
5482       ifunc = NULL;
5483       if (h != NULL)
5484         {
5485           if (h->type == STT_GNU_IFUNC)
5486             {
5487               h->needs_plt = 1;
5488               ifunc = &h->plt.plist;
5489             }
5490         }
5491       else
5492         {
5493           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5494                                                           abfd, r_symndx);
5495           if (isym == NULL)
5496             return FALSE;
5497
5498           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5499             {
5500               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5501                                              rel->r_addend,
5502                                              NON_GOT | PLT_IFUNC);
5503               if (ifunc == NULL)
5504                 return FALSE;
5505             }
5506         }
5507
5508       r_type = ELF64_R_TYPE (rel->r_info);
5509       switch (r_type)
5510         {
5511         case R_PPC64_TLSGD:
5512         case R_PPC64_TLSLD:
5513           /* These special tls relocs tie a call to __tls_get_addr with
5514              its parameter symbol.  */
5515           if (h != NULL)
5516             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5517           else
5518             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5519                                         rel->r_addend,
5520                                         NON_GOT | TLS_TLS | TLS_MARK))
5521               return FALSE;
5522           sec->has_tls_reloc = 1;
5523           break;
5524
5525         case R_PPC64_GOT_TLSLD16:
5526         case R_PPC64_GOT_TLSLD16_LO:
5527         case R_PPC64_GOT_TLSLD16_HI:
5528         case R_PPC64_GOT_TLSLD16_HA:
5529           tls_type = TLS_TLS | TLS_LD;
5530           goto dogottls;
5531
5532         case R_PPC64_GOT_TLSGD16:
5533         case R_PPC64_GOT_TLSGD16_LO:
5534         case R_PPC64_GOT_TLSGD16_HI:
5535         case R_PPC64_GOT_TLSGD16_HA:
5536           tls_type = TLS_TLS | TLS_GD;
5537           goto dogottls;
5538
5539         case R_PPC64_GOT_TPREL16_DS:
5540         case R_PPC64_GOT_TPREL16_LO_DS:
5541         case R_PPC64_GOT_TPREL16_HI:
5542         case R_PPC64_GOT_TPREL16_HA:
5543           if (bfd_link_dll (info))
5544             info->flags |= DF_STATIC_TLS;
5545           tls_type = TLS_TLS | TLS_TPREL;
5546           goto dogottls;
5547
5548         case R_PPC64_GOT_DTPREL16_DS:
5549         case R_PPC64_GOT_DTPREL16_LO_DS:
5550         case R_PPC64_GOT_DTPREL16_HI:
5551         case R_PPC64_GOT_DTPREL16_HA:
5552           tls_type = TLS_TLS | TLS_DTPREL;
5553         dogottls:
5554           sec->has_tls_reloc = 1;
5555           /* Fall through */
5556
5557         case R_PPC64_GOT16:
5558         case R_PPC64_GOT16_DS:
5559         case R_PPC64_GOT16_HA:
5560         case R_PPC64_GOT16_HI:
5561         case R_PPC64_GOT16_LO:
5562         case R_PPC64_GOT16_LO_DS:
5563           /* This symbol requires a global offset table entry.  */
5564           sec->has_toc_reloc = 1;
5565           if (r_type == R_PPC64_GOT_TLSLD16
5566               || r_type == R_PPC64_GOT_TLSGD16
5567               || r_type == R_PPC64_GOT_TPREL16_DS
5568               || r_type == R_PPC64_GOT_DTPREL16_DS
5569               || r_type == R_PPC64_GOT16
5570               || r_type == R_PPC64_GOT16_DS)
5571             {
5572               htab->do_multi_toc = 1;
5573               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5574             }
5575
5576           if (ppc64_elf_tdata (abfd)->got == NULL
5577               && !create_got_section (abfd, info))
5578             return FALSE;
5579
5580           if (h != NULL)
5581             {
5582               struct ppc_link_hash_entry *eh;
5583               struct got_entry *ent;
5584
5585               eh = (struct ppc_link_hash_entry *) h;
5586               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5587                 if (ent->addend == rel->r_addend
5588                     && ent->owner == abfd
5589                     && ent->tls_type == tls_type)
5590                   break;
5591               if (ent == NULL)
5592                 {
5593                   bfd_size_type amt = sizeof (*ent);
5594                   ent = bfd_alloc (abfd, amt);
5595                   if (ent == NULL)
5596                     return FALSE;
5597                   ent->next = eh->elf.got.glist;
5598                   ent->addend = rel->r_addend;
5599                   ent->owner = abfd;
5600                   ent->tls_type = tls_type;
5601                   ent->is_indirect = FALSE;
5602                   ent->got.refcount = 0;
5603                   eh->elf.got.glist = ent;
5604                 }
5605               ent->got.refcount += 1;
5606               eh->tls_mask |= tls_type;
5607             }
5608           else
5609             /* This is a global offset table entry for a local symbol.  */
5610             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5611                                         rel->r_addend, tls_type))
5612               return FALSE;
5613
5614           /* We may also need a plt entry if the symbol turns out to be
5615              an ifunc.  */
5616           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5617             {
5618               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5619                 return FALSE;
5620             }
5621           break;
5622
5623         case R_PPC64_PLT16_HA:
5624         case R_PPC64_PLT16_HI:
5625         case R_PPC64_PLT16_LO:
5626         case R_PPC64_PLT16_LO_DS:
5627         case R_PPC64_PLT32:
5628         case R_PPC64_PLT64:
5629           /* This symbol requires a procedure linkage table entry.  */
5630           plt_list = ifunc;
5631           if (h != NULL)
5632             {
5633               h->needs_plt = 1;
5634               if (h->root.root.string[0] == '.'
5635                   && h->root.root.string[1] != '\0')
5636                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5637               plt_list = &h->plt.plist;
5638             }
5639           if (plt_list == NULL)
5640             {
5641               /* It does not make sense to have a procedure linkage
5642                  table entry for a non-ifunc local symbol.  */
5643               info->callbacks->einfo
5644                 /* xgettext:c-format */
5645                 (_("%H: %s reloc against local symbol\n"),
5646                  abfd, sec, rel->r_offset,
5647                  ppc64_elf_howto_table[r_type]->name);
5648               bfd_set_error (bfd_error_bad_value);
5649               return FALSE;
5650             }
5651           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5652             return FALSE;
5653           break;
5654
5655           /* The following relocations don't need to propagate the
5656              relocation if linking a shared object since they are
5657              section relative.  */
5658         case R_PPC64_SECTOFF:
5659         case R_PPC64_SECTOFF_LO:
5660         case R_PPC64_SECTOFF_HI:
5661         case R_PPC64_SECTOFF_HA:
5662         case R_PPC64_SECTOFF_DS:
5663         case R_PPC64_SECTOFF_LO_DS:
5664         case R_PPC64_DTPREL16:
5665         case R_PPC64_DTPREL16_LO:
5666         case R_PPC64_DTPREL16_HI:
5667         case R_PPC64_DTPREL16_HA:
5668         case R_PPC64_DTPREL16_DS:
5669         case R_PPC64_DTPREL16_LO_DS:
5670         case R_PPC64_DTPREL16_HIGH:
5671         case R_PPC64_DTPREL16_HIGHA:
5672         case R_PPC64_DTPREL16_HIGHER:
5673         case R_PPC64_DTPREL16_HIGHERA:
5674         case R_PPC64_DTPREL16_HIGHEST:
5675         case R_PPC64_DTPREL16_HIGHESTA:
5676           break;
5677
5678           /* Nor do these.  */
5679         case R_PPC64_REL16:
5680         case R_PPC64_REL16_LO:
5681         case R_PPC64_REL16_HI:
5682         case R_PPC64_REL16_HA:
5683         case R_PPC64_REL16DX_HA:
5684           break;
5685
5686           /* Not supported as a dynamic relocation.  */
5687         case R_PPC64_ADDR64_LOCAL:
5688           if (bfd_link_pic (info))
5689             {
5690               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5691                 ppc_howto_init ();
5692               /* xgettext:c-format */
5693               info->callbacks->einfo (_("%H: %s reloc unsupported "
5694                                         "in shared libraries and PIEs\n"),
5695                                       abfd, sec, rel->r_offset,
5696                                       ppc64_elf_howto_table[r_type]->name);
5697               bfd_set_error (bfd_error_bad_value);
5698               return FALSE;
5699             }
5700           break;
5701
5702         case R_PPC64_TOC16:
5703         case R_PPC64_TOC16_DS:
5704           htab->do_multi_toc = 1;
5705           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5706           /* Fall through.  */
5707         case R_PPC64_TOC16_LO:
5708         case R_PPC64_TOC16_HI:
5709         case R_PPC64_TOC16_HA:
5710         case R_PPC64_TOC16_LO_DS:
5711           sec->has_toc_reloc = 1;
5712           break;
5713
5714           /* Marker reloc.  */
5715         case R_PPC64_ENTRY:
5716           break;
5717
5718           /* This relocation describes the C++ object vtable hierarchy.
5719              Reconstruct it for later use during GC.  */
5720         case R_PPC64_GNU_VTINHERIT:
5721           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5722             return FALSE;
5723           break;
5724
5725           /* This relocation describes which C++ vtable entries are actually
5726              used.  Record for later use during GC.  */
5727         case R_PPC64_GNU_VTENTRY:
5728           BFD_ASSERT (h != NULL);
5729           if (h != NULL
5730               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5731             return FALSE;
5732           break;
5733
5734         case R_PPC64_REL14:
5735         case R_PPC64_REL14_BRTAKEN:
5736         case R_PPC64_REL14_BRNTAKEN:
5737           {
5738             asection *dest = NULL;
5739
5740             /* Heuristic: If jumping outside our section, chances are
5741                we are going to need a stub.  */
5742             if (h != NULL)
5743               {
5744                 /* If the sym is weak it may be overridden later, so
5745                    don't assume we know where a weak sym lives.  */
5746                 if (h->root.type == bfd_link_hash_defined)
5747                   dest = h->root.u.def.section;
5748               }
5749             else
5750               {
5751                 Elf_Internal_Sym *isym;
5752
5753                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5754                                               abfd, r_symndx);
5755                 if (isym == NULL)
5756                   return FALSE;
5757
5758                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5759               }
5760
5761             if (dest != sec)
5762               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5763           }
5764           /* Fall through.  */
5765
5766         case R_PPC64_REL24:
5767           plt_list = ifunc;
5768           if (h != NULL)
5769             {
5770               h->needs_plt = 1;
5771               if (h->root.root.string[0] == '.'
5772                   && h->root.root.string[1] != '\0')
5773                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5774
5775               if (h == tga || h == dottga)
5776                 {
5777                   sec->has_tls_reloc = 1;
5778                   if (rel != relocs
5779                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5780                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5781                     /* We have a new-style __tls_get_addr call with
5782                        a marker reloc.  */
5783                     ;
5784                   else
5785                     /* Mark this section as having an old-style call.  */
5786                     sec->has_tls_get_addr_call = 1;
5787                 }
5788               plt_list = &h->plt.plist;
5789             }
5790
5791           /* We may need a .plt entry if the function this reloc
5792              refers to is in a shared lib.  */
5793           if (plt_list
5794               && !update_plt_info (abfd, plt_list, rel->r_addend))
5795             return FALSE;
5796           break;
5797
5798         case R_PPC64_ADDR14:
5799         case R_PPC64_ADDR14_BRNTAKEN:
5800         case R_PPC64_ADDR14_BRTAKEN:
5801         case R_PPC64_ADDR24:
5802           goto dodyn;
5803
5804         case R_PPC64_TPREL64:
5805           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5806           if (bfd_link_dll (info))
5807             info->flags |= DF_STATIC_TLS;
5808           goto dotlstoc;
5809
5810         case R_PPC64_DTPMOD64:
5811           if (rel + 1 < rel_end
5812               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5813               && rel[1].r_offset == rel->r_offset + 8)
5814             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5815           else
5816             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5817           goto dotlstoc;
5818
5819         case R_PPC64_DTPREL64:
5820           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5821           if (rel != relocs
5822               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5823               && rel[-1].r_offset == rel->r_offset - 8)
5824             /* This is the second reloc of a dtpmod, dtprel pair.
5825                Don't mark with TLS_DTPREL.  */
5826             goto dodyn;
5827
5828         dotlstoc:
5829           sec->has_tls_reloc = 1;
5830           if (h != NULL)
5831             {
5832               struct ppc_link_hash_entry *eh;
5833               eh = (struct ppc_link_hash_entry *) h;
5834               eh->tls_mask |= tls_type;
5835             }
5836           else
5837             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5838                                         rel->r_addend, tls_type))
5839               return FALSE;
5840
5841           ppc64_sec = ppc64_elf_section_data (sec);
5842           if (ppc64_sec->sec_type != sec_toc)
5843             {
5844               bfd_size_type amt;
5845
5846               /* One extra to simplify get_tls_mask.  */
5847               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5848               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5849               if (ppc64_sec->u.toc.symndx == NULL)
5850                 return FALSE;
5851               amt = sec->size * sizeof (bfd_vma) / 8;
5852               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5853               if (ppc64_sec->u.toc.add == NULL)
5854                 return FALSE;
5855               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5856               ppc64_sec->sec_type = sec_toc;
5857             }
5858           BFD_ASSERT (rel->r_offset % 8 == 0);
5859           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5860           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5861
5862           /* Mark the second slot of a GD or LD entry.
5863              -1 to indicate GD and -2 to indicate LD.  */
5864           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5865             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5866           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5867             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5868           goto dodyn;
5869
5870         case R_PPC64_TPREL16:
5871         case R_PPC64_TPREL16_LO:
5872         case R_PPC64_TPREL16_HI:
5873         case R_PPC64_TPREL16_HA:
5874         case R_PPC64_TPREL16_DS:
5875         case R_PPC64_TPREL16_LO_DS:
5876         case R_PPC64_TPREL16_HIGH:
5877         case R_PPC64_TPREL16_HIGHA:
5878         case R_PPC64_TPREL16_HIGHER:
5879         case R_PPC64_TPREL16_HIGHERA:
5880         case R_PPC64_TPREL16_HIGHEST:
5881         case R_PPC64_TPREL16_HIGHESTA:
5882           if (bfd_link_dll (info))
5883             info->flags |= DF_STATIC_TLS;
5884           goto dodyn;
5885
5886         case R_PPC64_ADDR64:
5887           if (is_opd
5888               && rel + 1 < rel_end
5889               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5890             {
5891               if (h != NULL)
5892                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5893             }
5894           /* Fall through.  */
5895
5896         case R_PPC64_ADDR16:
5897         case R_PPC64_ADDR16_DS:
5898         case R_PPC64_ADDR16_HA:
5899         case R_PPC64_ADDR16_HI:
5900         case R_PPC64_ADDR16_HIGH:
5901         case R_PPC64_ADDR16_HIGHA:
5902         case R_PPC64_ADDR16_HIGHER:
5903         case R_PPC64_ADDR16_HIGHERA:
5904         case R_PPC64_ADDR16_HIGHEST:
5905         case R_PPC64_ADDR16_HIGHESTA:
5906         case R_PPC64_ADDR16_LO:
5907         case R_PPC64_ADDR16_LO_DS:
5908           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5909               && rel->r_addend == 0)
5910             {
5911               /* We may need a .plt entry if this reloc refers to a
5912                  function in a shared lib.  */
5913               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5914                 return FALSE;
5915               h->pointer_equality_needed = 1;
5916             }
5917           /* Fall through.  */
5918
5919         case R_PPC64_REL30:
5920         case R_PPC64_REL32:
5921         case R_PPC64_REL64:
5922         case R_PPC64_ADDR32:
5923         case R_PPC64_UADDR16:
5924         case R_PPC64_UADDR32:
5925         case R_PPC64_UADDR64:
5926         case R_PPC64_TOC:
5927           if (h != NULL && !bfd_link_pic (info))
5928             /* We may need a copy reloc.  */
5929             h->non_got_ref = 1;
5930
5931           /* Don't propagate .opd relocs.  */
5932           if (NO_OPD_RELOCS && is_opd)
5933             break;
5934
5935           /* If we are creating a shared library, and this is a reloc
5936              against a global symbol, or a non PC relative reloc
5937              against a local symbol, then we need to copy the reloc
5938              into the shared library.  However, if we are linking with
5939              -Bsymbolic, we do not need to copy a reloc against a
5940              global symbol which is defined in an object we are
5941              including in the link (i.e., DEF_REGULAR is set).  At
5942              this point we have not seen all the input files, so it is
5943              possible that DEF_REGULAR is not set now but will be set
5944              later (it is never cleared).  In case of a weak definition,
5945              DEF_REGULAR may be cleared later by a strong definition in
5946              a shared library.  We account for that possibility below by
5947              storing information in the dyn_relocs field of the hash
5948              table entry.  A similar situation occurs when creating
5949              shared libraries and symbol visibility changes render the
5950              symbol local.
5951
5952              If on the other hand, we are creating an executable, we
5953              may need to keep relocations for symbols satisfied by a
5954              dynamic library if we manage to avoid copy relocs for the
5955              symbol.  */
5956         dodyn:
5957           if ((bfd_link_pic (info)
5958                && (must_be_dyn_reloc (info, r_type)
5959                    || (h != NULL
5960                        && (!SYMBOLIC_BIND (info, h)
5961                            || h->root.type == bfd_link_hash_defweak
5962                            || !h->def_regular))))
5963               || (ELIMINATE_COPY_RELOCS
5964                   && !bfd_link_pic (info)
5965                   && h != NULL
5966                   && (h->root.type == bfd_link_hash_defweak
5967                       || !h->def_regular))
5968               || (!bfd_link_pic (info)
5969                   && ifunc != NULL))
5970             {
5971               /* We must copy these reloc types into the output file.
5972                  Create a reloc section in dynobj and make room for
5973                  this reloc.  */
5974               if (sreloc == NULL)
5975                 {
5976                   sreloc = _bfd_elf_make_dynamic_reloc_section
5977                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5978
5979                   if (sreloc == NULL)
5980                     return FALSE;
5981                 }
5982
5983               /* If this is a global symbol, we count the number of
5984                  relocations we need for this symbol.  */
5985               if (h != NULL)
5986                 {
5987                   struct elf_dyn_relocs *p;
5988                   struct elf_dyn_relocs **head;
5989
5990                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5991                   p = *head;
5992                   if (p == NULL || p->sec != sec)
5993                     {
5994                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5995                       if (p == NULL)
5996                         return FALSE;
5997                       p->next = *head;
5998                       *head = p;
5999                       p->sec = sec;
6000                       p->count = 0;
6001                       p->pc_count = 0;
6002                     }
6003                   p->count += 1;
6004                   if (!must_be_dyn_reloc (info, r_type))
6005                     p->pc_count += 1;
6006                 }
6007               else
6008                 {
6009                   /* Track dynamic relocs needed for local syms too.
6010                      We really need local syms available to do this
6011                      easily.  Oh well.  */
6012                   struct ppc_dyn_relocs *p;
6013                   struct ppc_dyn_relocs **head;
6014                   bfd_boolean is_ifunc;
6015                   asection *s;
6016                   void *vpp;
6017                   Elf_Internal_Sym *isym;
6018
6019                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6020                                                 abfd, r_symndx);
6021                   if (isym == NULL)
6022                     return FALSE;
6023
6024                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6025                   if (s == NULL)
6026                     s = sec;
6027
6028                   vpp = &elf_section_data (s)->local_dynrel;
6029                   head = (struct ppc_dyn_relocs **) vpp;
6030                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6031                   p = *head;
6032                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6033                     p = p->next;
6034                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6035                     {
6036                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6037                       if (p == NULL)
6038                         return FALSE;
6039                       p->next = *head;
6040                       *head = p;
6041                       p->sec = sec;
6042                       p->ifunc = is_ifunc;
6043                       p->count = 0;
6044                     }
6045                   p->count += 1;
6046                 }
6047             }
6048           break;
6049
6050         default:
6051           break;
6052         }
6053     }
6054
6055   return TRUE;
6056 }
6057
6058 /* Merge backend specific data from an object file to the output
6059    object file when linking.  */
6060
6061 static bfd_boolean
6062 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6063 {
6064   bfd *obfd = info->output_bfd;
6065   unsigned long iflags, oflags;
6066
6067   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6068     return TRUE;
6069
6070   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6071     return TRUE;
6072
6073   if (!_bfd_generic_verify_endian_match (ibfd, info))
6074     return FALSE;
6075
6076   iflags = elf_elfheader (ibfd)->e_flags;
6077   oflags = elf_elfheader (obfd)->e_flags;
6078
6079   if (iflags & ~EF_PPC64_ABI)
6080     {
6081       _bfd_error_handler
6082         /* xgettext:c-format */
6083         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6084       bfd_set_error (bfd_error_bad_value);
6085       return FALSE;
6086     }
6087   else if (iflags != oflags && iflags != 0)
6088     {
6089       _bfd_error_handler
6090         /* xgettext:c-format */
6091         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6092          ibfd, iflags, oflags);
6093       bfd_set_error (bfd_error_bad_value);
6094       return FALSE;
6095     }
6096
6097   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6098
6099   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6100   _bfd_elf_merge_object_attributes (ibfd, info);
6101
6102   return TRUE;
6103 }
6104
6105 static bfd_boolean
6106 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6107 {
6108   /* Print normal ELF private data.  */
6109   _bfd_elf_print_private_bfd_data (abfd, ptr);
6110
6111   if (elf_elfheader (abfd)->e_flags != 0)
6112     {
6113       FILE *file = ptr;
6114
6115       fprintf (file, _("private flags = 0x%lx:"),
6116                elf_elfheader (abfd)->e_flags);
6117
6118       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6119         fprintf (file, _(" [abiv%ld]"),
6120                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6121       fputc ('\n', file);
6122     }
6123
6124   return TRUE;
6125 }
6126
6127 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6128    of the code entry point, and its section, which must be in the same
6129    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6130
6131 static bfd_vma
6132 opd_entry_value (asection *opd_sec,
6133                  bfd_vma offset,
6134                  asection **code_sec,
6135                  bfd_vma *code_off,
6136                  bfd_boolean in_code_sec)
6137 {
6138   bfd *opd_bfd = opd_sec->owner;
6139   Elf_Internal_Rela *relocs;
6140   Elf_Internal_Rela *lo, *hi, *look;
6141   bfd_vma val;
6142
6143   /* No relocs implies we are linking a --just-symbols object, or looking
6144      at a final linked executable with addr2line or somesuch.  */
6145   if (opd_sec->reloc_count == 0)
6146     {
6147       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6148
6149       if (contents == NULL)
6150         {
6151           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6152             return (bfd_vma) -1;
6153           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6154         }
6155
6156       /* PR 17512: file: 64b9dfbb.  */
6157       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6158         return (bfd_vma) -1;
6159
6160       val = bfd_get_64 (opd_bfd, contents + offset);
6161       if (code_sec != NULL)
6162         {
6163           asection *sec, *likely = NULL;
6164
6165           if (in_code_sec)
6166             {
6167               sec = *code_sec;
6168               if (sec->vma <= val
6169                   && val < sec->vma + sec->size)
6170                 likely = sec;
6171               else
6172                 val = -1;
6173             }
6174           else
6175             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6176               if (sec->vma <= val
6177                   && (sec->flags & SEC_LOAD) != 0
6178                   && (sec->flags & SEC_ALLOC) != 0)
6179                 likely = sec;
6180           if (likely != NULL)
6181             {
6182               *code_sec = likely;
6183               if (code_off != NULL)
6184                 *code_off = val - likely->vma;
6185             }
6186         }
6187       return val;
6188     }
6189
6190   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6191
6192   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6193   if (relocs == NULL)
6194     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6195   /* PR 17512: file: df8e1fd6.  */
6196   if (relocs == NULL)
6197     return (bfd_vma) -1;
6198
6199   /* Go find the opd reloc at the sym address.  */
6200   lo = relocs;
6201   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6202   val = (bfd_vma) -1;
6203   while (lo < hi)
6204     {
6205       look = lo + (hi - lo) / 2;
6206       if (look->r_offset < offset)
6207         lo = look + 1;
6208       else if (look->r_offset > offset)
6209         hi = look;
6210       else
6211         {
6212           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6213
6214           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6215               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6216             {
6217               unsigned long symndx = ELF64_R_SYM (look->r_info);
6218               asection *sec = NULL;
6219
6220               if (symndx >= symtab_hdr->sh_info
6221                   && elf_sym_hashes (opd_bfd) != NULL)
6222                 {
6223                   struct elf_link_hash_entry **sym_hashes;
6224                   struct elf_link_hash_entry *rh;
6225
6226                   sym_hashes = elf_sym_hashes (opd_bfd);
6227                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6228                   if (rh != NULL)
6229                     {
6230                       rh = elf_follow_link (rh);
6231                       if (rh->root.type != bfd_link_hash_defined
6232                           && rh->root.type != bfd_link_hash_defweak)
6233                         break;
6234                       if (rh->root.u.def.section->owner == opd_bfd)
6235                         {
6236                           val = rh->root.u.def.value;
6237                           sec = rh->root.u.def.section;
6238                         }
6239                     }
6240                 }
6241
6242               if (sec == NULL)
6243                 {
6244                   Elf_Internal_Sym *sym;
6245
6246                   if (symndx < symtab_hdr->sh_info)
6247                     {
6248                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6249                       if (sym == NULL)
6250                         {
6251                           size_t symcnt = symtab_hdr->sh_info;
6252                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6253                                                       symcnt, 0,
6254                                                       NULL, NULL, NULL);
6255                           if (sym == NULL)
6256                             break;
6257                           symtab_hdr->contents = (bfd_byte *) sym;
6258                         }
6259                       sym += symndx;
6260                     }
6261                   else
6262                     {
6263                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6264                                                   1, symndx,
6265                                                   NULL, NULL, NULL);
6266                       if (sym == NULL)
6267                         break;
6268                     }
6269                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6270                   if (sec == NULL)
6271                     break;
6272                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6273                   val = sym->st_value;
6274                 }
6275
6276               val += look->r_addend;
6277               if (code_off != NULL)
6278                 *code_off = val;
6279               if (code_sec != NULL)
6280                 {
6281                   if (in_code_sec && *code_sec != sec)
6282                     return -1;
6283                   else
6284                     *code_sec = sec;
6285                 }
6286               if (sec->output_section != NULL)
6287                 val += sec->output_section->vma + sec->output_offset;
6288             }
6289           break;
6290         }
6291     }
6292
6293   return val;
6294 }
6295
6296 /* If the ELF symbol SYM might be a function in SEC, return the
6297    function size and set *CODE_OFF to the function's entry point,
6298    otherwise return zero.  */
6299
6300 static bfd_size_type
6301 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6302                               bfd_vma *code_off)
6303 {
6304   bfd_size_type size;
6305
6306   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6307                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6308     return 0;
6309
6310   size = 0;
6311   if (!(sym->flags & BSF_SYNTHETIC))
6312     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6313
6314   if (strcmp (sym->section->name, ".opd") == 0)
6315     {
6316       struct _opd_sec_data *opd = get_opd_info (sym->section);
6317       bfd_vma symval = sym->value;
6318
6319       if (opd != NULL
6320           && opd->adjust != NULL
6321           && elf_section_data (sym->section)->relocs != NULL)
6322         {
6323           /* opd_entry_value will use cached relocs that have been
6324              adjusted, but with raw symbols.  That means both local
6325              and global symbols need adjusting.  */
6326           long adjust = opd->adjust[OPD_NDX (symval)];
6327           if (adjust == -1)
6328             return 0;
6329           symval += adjust;
6330         }
6331
6332       if (opd_entry_value (sym->section, symval,
6333                            &sec, code_off, TRUE) == (bfd_vma) -1)
6334         return 0;
6335       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6336          symbol.  This size has nothing to do with the code size of the
6337          function, which is what we're supposed to return, but the
6338          code size isn't available without looking up the dot-sym.
6339          However, doing that would be a waste of time particularly
6340          since elf_find_function will look at the dot-sym anyway.
6341          Now, elf_find_function will keep the largest size of any
6342          function sym found at the code address of interest, so return
6343          1 here to avoid it incorrectly caching a larger function size
6344          for a small function.  This does mean we return the wrong
6345          size for a new-ABI function of size 24, but all that does is
6346          disable caching for such functions.  */
6347       if (size == 24)
6348         size = 1;
6349     }
6350   else
6351     {
6352       if (sym->section != sec)
6353         return 0;
6354       *code_off = sym->value;
6355     }
6356   if (size == 0)
6357     size = 1;
6358   return size;
6359 }
6360
6361 /* Return true if symbol is a strong function defined in an ELFv2
6362    object with st_other localentry bits of zero, ie. its local entry
6363    point coincides with its global entry point.  */
6364
6365 static bfd_boolean
6366 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6367 {
6368   return (h != NULL
6369           && h->type == STT_FUNC
6370           && h->root.type == bfd_link_hash_defined
6371           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6372           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6373           && is_ppc64_elf (h->root.u.def.section->owner)
6374           && abiversion (h->root.u.def.section->owner) >= 2);
6375 }
6376
6377 /* Return true if symbol is defined in a regular object file.  */
6378
6379 static bfd_boolean
6380 is_static_defined (struct elf_link_hash_entry *h)
6381 {
6382   return ((h->root.type == bfd_link_hash_defined
6383            || h->root.type == bfd_link_hash_defweak)
6384           && h->root.u.def.section != NULL
6385           && h->root.u.def.section->output_section != NULL);
6386 }
6387
6388 /* If FDH is a function descriptor symbol, return the associated code
6389    entry symbol if it is defined.  Return NULL otherwise.  */
6390
6391 static struct ppc_link_hash_entry *
6392 defined_code_entry (struct ppc_link_hash_entry *fdh)
6393 {
6394   if (fdh->is_func_descriptor)
6395     {
6396       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6397       if (fh->elf.root.type == bfd_link_hash_defined
6398           || fh->elf.root.type == bfd_link_hash_defweak)
6399         return fh;
6400     }
6401   return NULL;
6402 }
6403
6404 /* If FH is a function code entry symbol, return the associated
6405    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6406
6407 static struct ppc_link_hash_entry *
6408 defined_func_desc (struct ppc_link_hash_entry *fh)
6409 {
6410   if (fh->oh != NULL
6411       && fh->oh->is_func_descriptor)
6412     {
6413       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6414       if (fdh->elf.root.type == bfd_link_hash_defined
6415           || fdh->elf.root.type == bfd_link_hash_defweak)
6416         return fdh;
6417     }
6418   return NULL;
6419 }
6420
6421 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6422
6423 /* Garbage collect sections, after first dealing with dot-symbols.  */
6424
6425 static bfd_boolean
6426 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6427 {
6428   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6429
6430   if (htab != NULL && htab->need_func_desc_adj)
6431     {
6432       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6433       htab->need_func_desc_adj = 0;
6434     }
6435   return bfd_elf_gc_sections (abfd, info);
6436 }
6437
6438 /* Mark all our entry sym sections, both opd and code section.  */
6439
6440 static void
6441 ppc64_elf_gc_keep (struct bfd_link_info *info)
6442 {
6443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6444   struct bfd_sym_chain *sym;
6445
6446   if (htab == NULL)
6447     return;
6448
6449   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6450     {
6451       struct ppc_link_hash_entry *eh, *fh;
6452       asection *sec;
6453
6454       eh = (struct ppc_link_hash_entry *)
6455         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6456       if (eh == NULL)
6457         continue;
6458       if (eh->elf.root.type != bfd_link_hash_defined
6459           && eh->elf.root.type != bfd_link_hash_defweak)
6460         continue;
6461
6462       fh = defined_code_entry (eh);
6463       if (fh != NULL)
6464         {
6465           sec = fh->elf.root.u.def.section;
6466           sec->flags |= SEC_KEEP;
6467         }
6468       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6469                && opd_entry_value (eh->elf.root.u.def.section,
6470                                    eh->elf.root.u.def.value,
6471                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6472         sec->flags |= SEC_KEEP;
6473
6474       sec = eh->elf.root.u.def.section;
6475       sec->flags |= SEC_KEEP;
6476     }
6477 }
6478
6479 /* Mark sections containing dynamically referenced symbols.  When
6480    building shared libraries, we must assume that any visible symbol is
6481    referenced.  */
6482
6483 static bfd_boolean
6484 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6485 {
6486   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6487   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6488   struct ppc_link_hash_entry *fdh;
6489   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6490
6491   /* Dynamic linking info is on the func descriptor sym.  */
6492   fdh = defined_func_desc (eh);
6493   if (fdh != NULL)
6494     eh = fdh;
6495
6496   if ((eh->elf.root.type == bfd_link_hash_defined
6497        || eh->elf.root.type == bfd_link_hash_defweak)
6498       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6499           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6500               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6501               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6502               && (!bfd_link_executable (info)
6503                   || info->gc_keep_exported
6504                   || info->export_dynamic
6505                   || (eh->elf.dynamic
6506                       && d != NULL
6507                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6508               && (eh->elf.versioned >= versioned
6509                   || !bfd_hide_sym_by_version (info->version_info,
6510                                                eh->elf.root.root.string)))))
6511     {
6512       asection *code_sec;
6513       struct ppc_link_hash_entry *fh;
6514
6515       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6516
6517       /* Function descriptor syms cause the associated
6518          function code sym section to be marked.  */
6519       fh = defined_code_entry (eh);
6520       if (fh != NULL)
6521         {
6522           code_sec = fh->elf.root.u.def.section;
6523           code_sec->flags |= SEC_KEEP;
6524         }
6525       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6526                && opd_entry_value (eh->elf.root.u.def.section,
6527                                    eh->elf.root.u.def.value,
6528                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6529         code_sec->flags |= SEC_KEEP;
6530     }
6531
6532   return TRUE;
6533 }
6534
6535 /* Return the section that should be marked against GC for a given
6536    relocation.  */
6537
6538 static asection *
6539 ppc64_elf_gc_mark_hook (asection *sec,
6540                         struct bfd_link_info *info,
6541                         Elf_Internal_Rela *rel,
6542                         struct elf_link_hash_entry *h,
6543                         Elf_Internal_Sym *sym)
6544 {
6545   asection *rsec;
6546
6547   /* Syms return NULL if we're marking .opd, so we avoid marking all
6548      function sections, as all functions are referenced in .opd.  */
6549   rsec = NULL;
6550   if (get_opd_info (sec) != NULL)
6551     return rsec;
6552
6553   if (h != NULL)
6554     {
6555       enum elf_ppc64_reloc_type r_type;
6556       struct ppc_link_hash_entry *eh, *fh, *fdh;
6557
6558       r_type = ELF64_R_TYPE (rel->r_info);
6559       switch (r_type)
6560         {
6561         case R_PPC64_GNU_VTINHERIT:
6562         case R_PPC64_GNU_VTENTRY:
6563           break;
6564
6565         default:
6566           switch (h->root.type)
6567             {
6568             case bfd_link_hash_defined:
6569             case bfd_link_hash_defweak:
6570               eh = (struct ppc_link_hash_entry *) h;
6571               fdh = defined_func_desc (eh);
6572               if (fdh != NULL)
6573                 {
6574                   /* -mcall-aixdesc code references the dot-symbol on
6575                      a call reloc.  Mark the function descriptor too
6576                      against garbage collection.  */
6577                   fdh->elf.mark = 1;
6578                   if (fdh->elf.is_weakalias)
6579                     weakdef (&fdh->elf)->mark = 1;
6580                   eh = fdh;
6581                 }
6582
6583               /* Function descriptor syms cause the associated
6584                  function code sym section to be marked.  */
6585               fh = defined_code_entry (eh);
6586               if (fh != NULL)
6587                 {
6588                   /* They also mark their opd section.  */
6589                   eh->elf.root.u.def.section->gc_mark = 1;
6590
6591                   rsec = fh->elf.root.u.def.section;
6592                 }
6593               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6594                        && opd_entry_value (eh->elf.root.u.def.section,
6595                                            eh->elf.root.u.def.value,
6596                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6597                 eh->elf.root.u.def.section->gc_mark = 1;
6598               else
6599                 rsec = h->root.u.def.section;
6600               break;
6601
6602             case bfd_link_hash_common:
6603               rsec = h->root.u.c.p->section;
6604               break;
6605
6606             default:
6607               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6608             }
6609         }
6610     }
6611   else
6612     {
6613       struct _opd_sec_data *opd;
6614
6615       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6616       opd = get_opd_info (rsec);
6617       if (opd != NULL && opd->func_sec != NULL)
6618         {
6619           rsec->gc_mark = 1;
6620
6621           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6622         }
6623     }
6624
6625   return rsec;
6626 }
6627
6628 /* The maximum size of .sfpr.  */
6629 #define SFPR_MAX (218*4)
6630
6631 struct sfpr_def_parms
6632 {
6633   const char name[12];
6634   unsigned char lo, hi;
6635   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6636   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6637 };
6638
6639 /* Auto-generate _save*, _rest* functions in .sfpr.
6640    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6641    instead.  */
6642
6643 static bfd_boolean
6644 sfpr_define (struct bfd_link_info *info,
6645              const struct sfpr_def_parms *parm,
6646              asection *stub_sec)
6647 {
6648   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6649   unsigned int i;
6650   size_t len = strlen (parm->name);
6651   bfd_boolean writing = FALSE;
6652   char sym[16];
6653
6654   if (htab == NULL)
6655     return FALSE;
6656
6657   memcpy (sym, parm->name, len);
6658   sym[len + 2] = 0;
6659
6660   for (i = parm->lo; i <= parm->hi; i++)
6661     {
6662       struct ppc_link_hash_entry *h;
6663
6664       sym[len + 0] = i / 10 + '0';
6665       sym[len + 1] = i % 10 + '0';
6666       h = (struct ppc_link_hash_entry *)
6667         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6668       if (stub_sec != NULL)
6669         {
6670           if (h != NULL
6671               && h->elf.root.type == bfd_link_hash_defined
6672               && h->elf.root.u.def.section == htab->sfpr)
6673             {
6674               struct elf_link_hash_entry *s;
6675               char buf[32];
6676               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6677               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6678               if (s == NULL)
6679                 return FALSE;
6680               if (s->root.type == bfd_link_hash_new
6681                   || (s->root.type = bfd_link_hash_defined
6682                       && s->root.u.def.section == stub_sec))
6683                 {
6684                   s->root.type = bfd_link_hash_defined;
6685                   s->root.u.def.section = stub_sec;
6686                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6687                                          + h->elf.root.u.def.value);
6688                   s->ref_regular = 1;
6689                   s->def_regular = 1;
6690                   s->ref_regular_nonweak = 1;
6691                   s->forced_local = 1;
6692                   s->non_elf = 0;
6693                   s->root.linker_def = 1;
6694                 }
6695             }
6696           continue;
6697         }
6698       if (h != NULL)
6699         {
6700           h->save_res = 1;
6701           if (!h->elf.def_regular)
6702             {
6703               h->elf.root.type = bfd_link_hash_defined;
6704               h->elf.root.u.def.section = htab->sfpr;
6705               h->elf.root.u.def.value = htab->sfpr->size;
6706               h->elf.type = STT_FUNC;
6707               h->elf.def_regular = 1;
6708               h->elf.non_elf = 0;
6709               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6710               writing = TRUE;
6711               if (htab->sfpr->contents == NULL)
6712                 {
6713                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6714                   if (htab->sfpr->contents == NULL)
6715                     return FALSE;
6716                 }
6717             }
6718         }
6719       if (writing)
6720         {
6721           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6722           if (i != parm->hi)
6723             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6724           else
6725             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6726           htab->sfpr->size = p - htab->sfpr->contents;
6727         }
6728     }
6729
6730   return TRUE;
6731 }
6732
6733 static bfd_byte *
6734 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6735 {
6736   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6737   return p + 4;
6738 }
6739
6740 static bfd_byte *
6741 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6742 {
6743   p = savegpr0 (abfd, p, r);
6744   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6745   p = p + 4;
6746   bfd_put_32 (abfd, BLR, p);
6747   return p + 4;
6748 }
6749
6750 static bfd_byte *
6751 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6752 {
6753   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6754   return p + 4;
6755 }
6756
6757 static bfd_byte *
6758 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6759 {
6760   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6761   p = p + 4;
6762   p = restgpr0 (abfd, p, r);
6763   bfd_put_32 (abfd, MTLR_R0, p);
6764   p = p + 4;
6765   if (r == 29)
6766     {
6767       p = restgpr0 (abfd, p, 30);
6768       p = restgpr0 (abfd, p, 31);
6769     }
6770   bfd_put_32 (abfd, BLR, p);
6771   return p + 4;
6772 }
6773
6774 static bfd_byte *
6775 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6776 {
6777   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6778   return p + 4;
6779 }
6780
6781 static bfd_byte *
6782 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6783 {
6784   p = savegpr1 (abfd, p, r);
6785   bfd_put_32 (abfd, BLR, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6793   return p + 4;
6794 }
6795
6796 static bfd_byte *
6797 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6798 {
6799   p = restgpr1 (abfd, p, r);
6800   bfd_put_32 (abfd, BLR, p);
6801   return p + 4;
6802 }
6803
6804 static bfd_byte *
6805 savefpr (bfd *abfd, bfd_byte *p, int r)
6806 {
6807   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6808   return p + 4;
6809 }
6810
6811 static bfd_byte *
6812 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6813 {
6814   p = savefpr (abfd, p, r);
6815   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6816   p = p + 4;
6817   bfd_put_32 (abfd, BLR, p);
6818   return p + 4;
6819 }
6820
6821 static bfd_byte *
6822 restfpr (bfd *abfd, bfd_byte *p, int r)
6823 {
6824   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6825   return p + 4;
6826 }
6827
6828 static bfd_byte *
6829 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6830 {
6831   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6832   p = p + 4;
6833   p = restfpr (abfd, p, r);
6834   bfd_put_32 (abfd, MTLR_R0, p);
6835   p = p + 4;
6836   if (r == 29)
6837     {
6838       p = restfpr (abfd, p, 30);
6839       p = restfpr (abfd, p, 31);
6840     }
6841   bfd_put_32 (abfd, BLR, p);
6842   return p + 4;
6843 }
6844
6845 static bfd_byte *
6846 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6847 {
6848   p = savefpr (abfd, p, r);
6849   bfd_put_32 (abfd, BLR, p);
6850   return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6855 {
6856   p = restfpr (abfd, p, r);
6857   bfd_put_32 (abfd, BLR, p);
6858   return p + 4;
6859 }
6860
6861 static bfd_byte *
6862 savevr (bfd *abfd, bfd_byte *p, int r)
6863 {
6864   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6865   p = p + 4;
6866   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   p = savevr (abfd, p, r);
6874   bfd_put_32 (abfd, BLR, p);
6875   return p + 4;
6876 }
6877
6878 static bfd_byte *
6879 restvr (bfd *abfd, bfd_byte *p, int r)
6880 {
6881   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6882   p = p + 4;
6883   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6884   return p + 4;
6885 }
6886
6887 static bfd_byte *
6888 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6889 {
6890   p = restvr (abfd, p, r);
6891   bfd_put_32 (abfd, BLR, p);
6892   return p + 4;
6893 }
6894
6895 /* Called via elf_link_hash_traverse to transfer dynamic linking
6896    information on function code symbol entries to their corresponding
6897    function descriptor symbol entries.  */
6898
6899 static bfd_boolean
6900 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6901 {
6902   struct bfd_link_info *info;
6903   struct ppc_link_hash_table *htab;
6904   struct ppc_link_hash_entry *fh;
6905   struct ppc_link_hash_entry *fdh;
6906   bfd_boolean force_local;
6907
6908   fh = (struct ppc_link_hash_entry *) h;
6909   if (fh->elf.root.type == bfd_link_hash_indirect)
6910     return TRUE;
6911
6912   if (!fh->is_func)
6913     return TRUE;
6914
6915   if (fh->elf.root.root.string[0] != '.'
6916       || fh->elf.root.root.string[1] == '\0')
6917     return TRUE;
6918
6919   info = inf;
6920   htab = ppc_hash_table (info);
6921   if (htab == NULL)
6922     return FALSE;
6923
6924   /* Find the corresponding function descriptor symbol.  */
6925   fdh = lookup_fdh (fh, htab);
6926
6927   /* Resolve undefined references to dot-symbols as the value
6928      in the function descriptor, if we have one in a regular object.
6929      This is to satisfy cases like ".quad .foo".  Calls to functions
6930      in dynamic objects are handled elsewhere.  */
6931   if ((fh->elf.root.type == bfd_link_hash_undefined
6932        || fh->elf.root.type == bfd_link_hash_undefweak)
6933       && (fdh->elf.root.type == bfd_link_hash_defined
6934           || fdh->elf.root.type == bfd_link_hash_defweak)
6935       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6936       && opd_entry_value (fdh->elf.root.u.def.section,
6937                           fdh->elf.root.u.def.value,
6938                           &fh->elf.root.u.def.section,
6939                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6940     {
6941       fh->elf.root.type = fdh->elf.root.type;
6942       fh->elf.forced_local = 1;
6943       fh->elf.def_regular = fdh->elf.def_regular;
6944       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6945     }
6946
6947   if (!fh->elf.dynamic)
6948     {
6949       struct plt_entry *ent;
6950
6951       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6952         if (ent->plt.refcount > 0)
6953           break;
6954       if (ent == NULL)
6955         return TRUE;
6956     }
6957
6958   /* Create a descriptor as undefined if necessary.  */
6959   if (fdh == NULL
6960       && !bfd_link_executable (info)
6961       && (fh->elf.root.type == bfd_link_hash_undefined
6962           || fh->elf.root.type == bfd_link_hash_undefweak))
6963     {
6964       fdh = make_fdh (info, fh);
6965       if (fdh == NULL)
6966         return FALSE;
6967     }
6968
6969   /* We can't support overriding of symbols on a fake descriptor.  */
6970   if (fdh != NULL
6971       && fdh->fake
6972       && (fh->elf.root.type == bfd_link_hash_defined
6973           || fh->elf.root.type == bfd_link_hash_defweak))
6974     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6975
6976   /* Transfer dynamic linking information to the function descriptor.  */
6977   if (fdh != NULL)
6978     {
6979       fdh->elf.ref_regular |= fh->elf.ref_regular;
6980       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6981       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6982       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6983       fdh->elf.dynamic |= fh->elf.dynamic;
6984       fdh->elf.needs_plt |= (fh->elf.needs_plt
6985                              || fh->elf.type == STT_FUNC
6986                              || fh->elf.type == STT_GNU_IFUNC);
6987       move_plt_plist (fh, fdh);
6988
6989       if (!fdh->elf.forced_local
6990           && fh->elf.dynindx != -1)
6991         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6992           return FALSE;
6993     }
6994
6995   /* Now that the info is on the function descriptor, clear the
6996      function code sym info.  Any function code syms for which we
6997      don't have a definition in a regular file, we force local.
6998      This prevents a shared library from exporting syms that have
6999      been imported from another library.  Function code syms that
7000      are really in the library we must leave global to prevent the
7001      linker dragging in a definition from a static library.  */
7002   force_local = (!fh->elf.def_regular
7003                  || fdh == NULL
7004                  || !fdh->elf.def_regular
7005                  || fdh->elf.forced_local);
7006   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7007
7008   return TRUE;
7009 }
7010
7011 static const struct sfpr_def_parms save_res_funcs[] =
7012   {
7013     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7014     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7015     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7016     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7017     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7018     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7019     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7020     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7021     { "._savef", 14, 31, savefpr, savefpr1_tail },
7022     { "._restf", 14, 31, restfpr, restfpr1_tail },
7023     { "_savevr_", 20, 31, savevr, savevr_tail },
7024     { "_restvr_", 20, 31, restvr, restvr_tail }
7025   };
7026
7027 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7028    this hook to a) provide some gcc support functions, and b) transfer
7029    dynamic linking information gathered so far on function code symbol
7030    entries, to their corresponding function descriptor symbol entries.  */
7031
7032 static bfd_boolean
7033 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7034                             struct bfd_link_info *info)
7035 {
7036   struct ppc_link_hash_table *htab;
7037
7038   htab = ppc_hash_table (info);
7039   if (htab == NULL)
7040     return FALSE;
7041
7042   /* Provide any missing _save* and _rest* functions.  */
7043   if (htab->sfpr != NULL)
7044     {
7045       unsigned int i;
7046
7047       htab->sfpr->size = 0;
7048       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7049         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7050           return FALSE;
7051       if (htab->sfpr->size == 0)
7052         htab->sfpr->flags |= SEC_EXCLUDE;
7053     }
7054
7055   if (bfd_link_relocatable (info))
7056     return TRUE;
7057
7058   if (htab->elf.hgot != NULL)
7059     {
7060       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7061       /* Make .TOC. defined so as to prevent it being made dynamic.
7062          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7063       if (!htab->elf.hgot->def_regular
7064           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7065         {
7066           htab->elf.hgot->root.type = bfd_link_hash_defined;
7067           htab->elf.hgot->root.u.def.value = 0;
7068           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7069           htab->elf.hgot->def_regular = 1;
7070           htab->elf.hgot->root.linker_def = 1;
7071         }
7072       htab->elf.hgot->type = STT_OBJECT;
7073       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7074                                | STV_HIDDEN);
7075     }
7076
7077   if (htab->need_func_desc_adj)
7078     {
7079       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7080       htab->need_func_desc_adj = 0;
7081     }
7082
7083   return TRUE;
7084 }
7085
7086 /* Find dynamic relocs for H that apply to read-only sections.  */
7087
7088 static asection *
7089 readonly_dynrelocs (struct elf_link_hash_entry *h)
7090 {
7091   struct ppc_link_hash_entry *eh;
7092   struct elf_dyn_relocs *p;
7093
7094   eh = (struct ppc_link_hash_entry *) h;
7095   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7096     {
7097       asection *s = p->sec->output_section;
7098
7099       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7100         return p->sec;
7101     }
7102   return NULL;
7103 }
7104
7105 /* Return true if we have dynamic relocs against H or any of its weak
7106    aliases, that apply to read-only sections.  Cannot be used after
7107    size_dynamic_sections.  */
7108
7109 static bfd_boolean
7110 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7111 {
7112   struct ppc_link_hash_entry *eh;
7113
7114   eh = (struct ppc_link_hash_entry *) h;
7115   do
7116     {
7117       if (readonly_dynrelocs (&eh->elf))
7118         return TRUE;
7119       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7120     } while (eh != NULL && &eh->elf != h);
7121
7122   return FALSE;
7123 }
7124
7125 /* Return whether EH has pc-relative dynamic relocs.  */
7126
7127 static bfd_boolean
7128 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7129 {
7130   struct elf_dyn_relocs *p;
7131
7132   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7133     if (p->pc_count != 0)
7134       return TRUE;
7135   return FALSE;
7136 }
7137
7138 /* Return true if a global entry stub will be created for H.  Valid
7139    for ELFv2 before plt entries have been allocated.  */
7140
7141 static bfd_boolean
7142 global_entry_stub (struct elf_link_hash_entry *h)
7143 {
7144   struct plt_entry *pent;
7145
7146   if (!h->pointer_equality_needed
7147       || h->def_regular)
7148     return FALSE;
7149
7150   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7151     if (pent->plt.refcount > 0
7152         && pent->addend == 0)
7153       return TRUE;
7154
7155   return FALSE;
7156 }
7157
7158 /* Adjust a symbol defined by a dynamic object and referenced by a
7159    regular object.  The current definition is in some section of the
7160    dynamic object, but we're not including those sections.  We have to
7161    change the definition to something the rest of the link can
7162    understand.  */
7163
7164 static bfd_boolean
7165 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7166                                  struct elf_link_hash_entry *h)
7167 {
7168   struct ppc_link_hash_table *htab;
7169   asection *s, *srel;
7170
7171   htab = ppc_hash_table (info);
7172   if (htab == NULL)
7173     return FALSE;
7174
7175   /* Deal with function syms.  */
7176   if (h->type == STT_FUNC
7177       || h->type == STT_GNU_IFUNC
7178       || h->needs_plt)
7179     {
7180       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7181                            || SYMBOL_CALLS_LOCAL (info, h)
7182                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7183       /* Discard dyn_relocs when non-pic if we've decided that a
7184          function symbol is local and not an ifunc.  We keep dynamic
7185          relocs for ifuncs when local rather than always emitting a
7186          plt call stub for them and defining the symbol on the call
7187          stub.  We can't do that for ELFv1 anyway (a function symbol
7188          is defined on a descriptor, not code) and it can be faster at
7189          run-time due to not needing to bounce through a stub.  The
7190          dyn_relocs for ifuncs will be applied even in a static
7191          executable.  */
7192       if (!bfd_link_pic (info)
7193           && h->type != STT_GNU_IFUNC
7194           && local)
7195         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7196
7197       /* Clear procedure linkage table information for any symbol that
7198          won't need a .plt entry.  */
7199       struct plt_entry *ent;
7200       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7201         if (ent->plt.refcount > 0)
7202           break;
7203       if (ent == NULL
7204           || (h->type != STT_GNU_IFUNC && local))
7205         {
7206           h->plt.plist = NULL;
7207           h->needs_plt = 0;
7208           h->pointer_equality_needed = 0;
7209         }
7210       else if (abiversion (info->output_bfd) >= 2)
7211         {
7212           /* Taking a function's address in a read/write section
7213              doesn't require us to define the function symbol in the
7214              executable on a global entry stub.  A dynamic reloc can
7215              be used instead.  The reason we prefer a few more dynamic
7216              relocs is that calling via a global entry stub costs a
7217              few more instructions, and pointer_equality_needed causes
7218              extra work in ld.so when resolving these symbols.  */
7219           if (global_entry_stub (h))
7220             {
7221               if (!readonly_dynrelocs (h))
7222                 {
7223                   h->pointer_equality_needed = 0;
7224                   /* If we haven't seen a branch reloc then we don't need
7225                      a plt entry.  */
7226                   if (!h->needs_plt)
7227                     h->plt.plist = NULL;
7228                 }
7229               else if (!bfd_link_pic (info))
7230                 /* We are going to be defining the function symbol on the
7231                    plt stub, so no dyn_relocs needed when non-pic.  */
7232                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7233             }
7234
7235           /* ELFv2 function symbols can't have copy relocs.  */
7236           return TRUE;
7237         }
7238       else if (!h->needs_plt
7239                && !readonly_dynrelocs (h))
7240         {
7241           /* If we haven't seen a branch reloc then we don't need a
7242              plt entry.  */
7243           h->plt.plist = NULL;
7244           h->pointer_equality_needed = 0;
7245           return TRUE;
7246         }
7247     }
7248   else
7249     h->plt.plist = NULL;
7250
7251   /* If this is a weak symbol, and there is a real definition, the
7252      processor independent code will have arranged for us to see the
7253      real definition first, and we can just use the same value.  */
7254   if (h->is_weakalias)
7255     {
7256       struct elf_link_hash_entry *def = weakdef (h);
7257       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7258       h->root.u.def.section = def->root.u.def.section;
7259       h->root.u.def.value = def->root.u.def.value;
7260       if (def->root.u.def.section == htab->elf.sdynbss
7261           || def->root.u.def.section == htab->elf.sdynrelro)
7262         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7263       return TRUE;
7264     }
7265
7266   /* If we are creating a shared library, we must presume that the
7267      only references to the symbol are via the global offset table.
7268      For such cases we need not do anything here; the relocations will
7269      be handled correctly by relocate_section.  */
7270   if (bfd_link_pic (info))
7271     return TRUE;
7272
7273   /* If there are no references to this symbol that do not use the
7274      GOT, we don't need to generate a copy reloc.  */
7275   if (!h->non_got_ref)
7276     return TRUE;
7277
7278   /* Don't generate a copy reloc for symbols defined in the executable.  */
7279   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7280
7281       /* If -z nocopyreloc was given, don't generate them either.  */
7282       || info->nocopyreloc
7283
7284       /* If we don't find any dynamic relocs in read-only sections, then
7285          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7286       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7287
7288       /* Protected variables do not work with .dynbss.  The copy in
7289          .dynbss won't be used by the shared library with the protected
7290          definition for the variable.  Text relocations are preferable
7291          to an incorrect program.  */
7292       || h->protected_def)
7293     return TRUE;
7294
7295   if (h->plt.plist != NULL)
7296     {
7297       /* We should never get here, but unfortunately there are versions
7298          of gcc out there that improperly (for this ABI) put initialized
7299          function pointers, vtable refs and suchlike in read-only
7300          sections.  Allow them to proceed, but warn that this might
7301          break at runtime.  */
7302       info->callbacks->einfo
7303         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7304            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7305          h->root.root.string);
7306     }
7307
7308   /* This is a reference to a symbol defined by a dynamic object which
7309      is not a function.  */
7310
7311   /* We must allocate the symbol in our .dynbss section, which will
7312      become part of the .bss section of the executable.  There will be
7313      an entry for this symbol in the .dynsym section.  The dynamic
7314      object will contain position independent code, so all references
7315      from the dynamic object to this symbol will go through the global
7316      offset table.  The dynamic linker will use the .dynsym entry to
7317      determine the address it must put in the global offset table, so
7318      both the dynamic object and the regular object will refer to the
7319      same memory location for the variable.  */
7320   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7321     {
7322       s = htab->elf.sdynrelro;
7323       srel = htab->elf.sreldynrelro;
7324     }
7325   else
7326     {
7327       s = htab->elf.sdynbss;
7328       srel = htab->elf.srelbss;
7329     }
7330   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7331     {
7332       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7333          linker to copy the initial value out of the dynamic object
7334          and into the runtime process image.  */
7335       srel->size += sizeof (Elf64_External_Rela);
7336       h->needs_copy = 1;
7337     }
7338
7339   /* We no longer want dyn_relocs.  */
7340   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7341   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7342 }
7343
7344 /* If given a function descriptor symbol, hide both the function code
7345    sym and the descriptor.  */
7346 static void
7347 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7348                        struct elf_link_hash_entry *h,
7349                        bfd_boolean force_local)
7350 {
7351   struct ppc_link_hash_entry *eh;
7352   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7353
7354   eh = (struct ppc_link_hash_entry *) h;
7355   if (eh->is_func_descriptor)
7356     {
7357       struct ppc_link_hash_entry *fh = eh->oh;
7358
7359       if (fh == NULL)
7360         {
7361           const char *p, *q;
7362           struct elf_link_hash_table *htab = elf_hash_table (info);
7363           char save;
7364
7365           /* We aren't supposed to use alloca in BFD because on
7366              systems which do not have alloca the version in libiberty
7367              calls xmalloc, which might cause the program to crash
7368              when it runs out of memory.  This function doesn't have a
7369              return status, so there's no way to gracefully return an
7370              error.  So cheat.  We know that string[-1] can be safely
7371              accessed;  It's either a string in an ELF string table,
7372              or allocated in an objalloc structure.  */
7373
7374           p = eh->elf.root.root.string - 1;
7375           save = *p;
7376           *(char *) p = '.';
7377           fh = (struct ppc_link_hash_entry *)
7378             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7379           *(char *) p = save;
7380
7381           /* Unfortunately, if it so happens that the string we were
7382              looking for was allocated immediately before this string,
7383              then we overwrote the string terminator.  That's the only
7384              reason the lookup should fail.  */
7385           if (fh == NULL)
7386             {
7387               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7388               while (q >= eh->elf.root.root.string && *q == *p)
7389                 --q, --p;
7390               if (q < eh->elf.root.root.string && *p == '.')
7391                 fh = (struct ppc_link_hash_entry *)
7392                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7393             }
7394           if (fh != NULL)
7395             {
7396               eh->oh = fh;
7397               fh->oh = eh;
7398             }
7399         }
7400       if (fh != NULL)
7401         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7402     }
7403 }
7404
7405 static bfd_boolean
7406 get_sym_h (struct elf_link_hash_entry **hp,
7407            Elf_Internal_Sym **symp,
7408            asection **symsecp,
7409            unsigned char **tls_maskp,
7410            Elf_Internal_Sym **locsymsp,
7411            unsigned long r_symndx,
7412            bfd *ibfd)
7413 {
7414   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7415
7416   if (r_symndx >= symtab_hdr->sh_info)
7417     {
7418       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7419       struct elf_link_hash_entry *h;
7420
7421       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7422       h = elf_follow_link (h);
7423
7424       if (hp != NULL)
7425         *hp = h;
7426
7427       if (symp != NULL)
7428         *symp = NULL;
7429
7430       if (symsecp != NULL)
7431         {
7432           asection *symsec = NULL;
7433           if (h->root.type == bfd_link_hash_defined
7434               || h->root.type == bfd_link_hash_defweak)
7435             symsec = h->root.u.def.section;
7436           *symsecp = symsec;
7437         }
7438
7439       if (tls_maskp != NULL)
7440         {
7441           struct ppc_link_hash_entry *eh;
7442
7443           eh = (struct ppc_link_hash_entry *) h;
7444           *tls_maskp = &eh->tls_mask;
7445         }
7446     }
7447   else
7448     {
7449       Elf_Internal_Sym *sym;
7450       Elf_Internal_Sym *locsyms = *locsymsp;
7451
7452       if (locsyms == NULL)
7453         {
7454           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7455           if (locsyms == NULL)
7456             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7457                                             symtab_hdr->sh_info,
7458                                             0, NULL, NULL, NULL);
7459           if (locsyms == NULL)
7460             return FALSE;
7461           *locsymsp = locsyms;
7462         }
7463       sym = locsyms + r_symndx;
7464
7465       if (hp != NULL)
7466         *hp = NULL;
7467
7468       if (symp != NULL)
7469         *symp = sym;
7470
7471       if (symsecp != NULL)
7472         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7473
7474       if (tls_maskp != NULL)
7475         {
7476           struct got_entry **lgot_ents;
7477           unsigned char *tls_mask;
7478
7479           tls_mask = NULL;
7480           lgot_ents = elf_local_got_ents (ibfd);
7481           if (lgot_ents != NULL)
7482             {
7483               struct plt_entry **local_plt = (struct plt_entry **)
7484                 (lgot_ents + symtab_hdr->sh_info);
7485               unsigned char *lgot_masks = (unsigned char *)
7486                 (local_plt + symtab_hdr->sh_info);
7487               tls_mask = &lgot_masks[r_symndx];
7488             }
7489           *tls_maskp = tls_mask;
7490         }
7491     }
7492   return TRUE;
7493 }
7494
7495 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7496    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7497    type suitable for optimization, and 1 otherwise.  */
7498
7499 static int
7500 get_tls_mask (unsigned char **tls_maskp,
7501               unsigned long *toc_symndx,
7502               bfd_vma *toc_addend,
7503               Elf_Internal_Sym **locsymsp,
7504               const Elf_Internal_Rela *rel,
7505               bfd *ibfd)
7506 {
7507   unsigned long r_symndx;
7508   int next_r;
7509   struct elf_link_hash_entry *h;
7510   Elf_Internal_Sym *sym;
7511   asection *sec;
7512   bfd_vma off;
7513
7514   r_symndx = ELF64_R_SYM (rel->r_info);
7515   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7516     return 0;
7517
7518   if ((*tls_maskp != NULL
7519        && (**tls_maskp & TLS_TLS) != 0
7520        && **tls_maskp != (TLS_TLS | TLS_MARK))
7521       || sec == NULL
7522       || ppc64_elf_section_data (sec) == NULL
7523       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7524     return 1;
7525
7526   /* Look inside a TOC section too.  */
7527   if (h != NULL)
7528     {
7529       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7530       off = h->root.u.def.value;
7531     }
7532   else
7533     off = sym->st_value;
7534   off += rel->r_addend;
7535   BFD_ASSERT (off % 8 == 0);
7536   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7537   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7538   if (toc_symndx != NULL)
7539     *toc_symndx = r_symndx;
7540   if (toc_addend != NULL)
7541     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7542   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7543     return 0;
7544   if ((h == NULL || is_static_defined (h))
7545       && (next_r == -1 || next_r == -2))
7546     return 1 - next_r;
7547   return 1;
7548 }
7549
7550 /* Find (or create) an entry in the tocsave hash table.  */
7551
7552 static struct tocsave_entry *
7553 tocsave_find (struct ppc_link_hash_table *htab,
7554               enum insert_option insert,
7555               Elf_Internal_Sym **local_syms,
7556               const Elf_Internal_Rela *irela,
7557               bfd *ibfd)
7558 {
7559   unsigned long r_indx;
7560   struct elf_link_hash_entry *h;
7561   Elf_Internal_Sym *sym;
7562   struct tocsave_entry ent, *p;
7563   hashval_t hash;
7564   struct tocsave_entry **slot;
7565
7566   r_indx = ELF64_R_SYM (irela->r_info);
7567   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7568     return NULL;
7569   if (ent.sec == NULL || ent.sec->output_section == NULL)
7570     {
7571       _bfd_error_handler
7572         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7573       return NULL;
7574     }
7575
7576   if (h != NULL)
7577     ent.offset = h->root.u.def.value;
7578   else
7579     ent.offset = sym->st_value;
7580   ent.offset += irela->r_addend;
7581
7582   hash = tocsave_htab_hash (&ent);
7583   slot = ((struct tocsave_entry **)
7584           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7585   if (slot == NULL)
7586     return NULL;
7587
7588   if (*slot == NULL)
7589     {
7590       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7591       if (p == NULL)
7592         return NULL;
7593       *p = ent;
7594       *slot = p;
7595     }
7596   return *slot;
7597 }
7598
7599 /* Adjust all global syms defined in opd sections.  In gcc generated
7600    code for the old ABI, these will already have been done.  */
7601
7602 static bfd_boolean
7603 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7604 {
7605   struct ppc_link_hash_entry *eh;
7606   asection *sym_sec;
7607   struct _opd_sec_data *opd;
7608
7609   if (h->root.type == bfd_link_hash_indirect)
7610     return TRUE;
7611
7612   if (h->root.type != bfd_link_hash_defined
7613       && h->root.type != bfd_link_hash_defweak)
7614     return TRUE;
7615
7616   eh = (struct ppc_link_hash_entry *) h;
7617   if (eh->adjust_done)
7618     return TRUE;
7619
7620   sym_sec = eh->elf.root.u.def.section;
7621   opd = get_opd_info (sym_sec);
7622   if (opd != NULL && opd->adjust != NULL)
7623     {
7624       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7625       if (adjust == -1)
7626         {
7627           /* This entry has been deleted.  */
7628           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7629           if (dsec == NULL)
7630             {
7631               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7632                 if (discarded_section (dsec))
7633                   {
7634                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7635                     break;
7636                   }
7637             }
7638           eh->elf.root.u.def.value = 0;
7639           eh->elf.root.u.def.section = dsec;
7640         }
7641       else
7642         eh->elf.root.u.def.value += adjust;
7643       eh->adjust_done = 1;
7644     }
7645   return TRUE;
7646 }
7647
7648 /* Handles decrementing dynamic reloc counts for the reloc specified by
7649    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7650    have already been determined.  */
7651
7652 static bfd_boolean
7653 dec_dynrel_count (bfd_vma r_info,
7654                   asection *sec,
7655                   struct bfd_link_info *info,
7656                   Elf_Internal_Sym **local_syms,
7657                   struct elf_link_hash_entry *h,
7658                   Elf_Internal_Sym *sym)
7659 {
7660   enum elf_ppc64_reloc_type r_type;
7661   asection *sym_sec = NULL;
7662
7663   /* Can this reloc be dynamic?  This switch, and later tests here
7664      should be kept in sync with the code in check_relocs.  */
7665   r_type = ELF64_R_TYPE (r_info);
7666   switch (r_type)
7667     {
7668     default:
7669       return TRUE;
7670
7671     case R_PPC64_TPREL16:
7672     case R_PPC64_TPREL16_LO:
7673     case R_PPC64_TPREL16_HI:
7674     case R_PPC64_TPREL16_HA:
7675     case R_PPC64_TPREL16_DS:
7676     case R_PPC64_TPREL16_LO_DS:
7677     case R_PPC64_TPREL16_HIGH:
7678     case R_PPC64_TPREL16_HIGHA:
7679     case R_PPC64_TPREL16_HIGHER:
7680     case R_PPC64_TPREL16_HIGHERA:
7681     case R_PPC64_TPREL16_HIGHEST:
7682     case R_PPC64_TPREL16_HIGHESTA:
7683     case R_PPC64_TPREL64:
7684     case R_PPC64_DTPMOD64:
7685     case R_PPC64_DTPREL64:
7686     case R_PPC64_ADDR64:
7687     case R_PPC64_REL30:
7688     case R_PPC64_REL32:
7689     case R_PPC64_REL64:
7690     case R_PPC64_ADDR14:
7691     case R_PPC64_ADDR14_BRNTAKEN:
7692     case R_PPC64_ADDR14_BRTAKEN:
7693     case R_PPC64_ADDR16:
7694     case R_PPC64_ADDR16_DS:
7695     case R_PPC64_ADDR16_HA:
7696     case R_PPC64_ADDR16_HI:
7697     case R_PPC64_ADDR16_HIGH:
7698     case R_PPC64_ADDR16_HIGHA:
7699     case R_PPC64_ADDR16_HIGHER:
7700     case R_PPC64_ADDR16_HIGHERA:
7701     case R_PPC64_ADDR16_HIGHEST:
7702     case R_PPC64_ADDR16_HIGHESTA:
7703     case R_PPC64_ADDR16_LO:
7704     case R_PPC64_ADDR16_LO_DS:
7705     case R_PPC64_ADDR24:
7706     case R_PPC64_ADDR32:
7707     case R_PPC64_UADDR16:
7708     case R_PPC64_UADDR32:
7709     case R_PPC64_UADDR64:
7710     case R_PPC64_TOC:
7711       break;
7712     }
7713
7714   if (local_syms != NULL)
7715     {
7716       unsigned long r_symndx;
7717       bfd *ibfd = sec->owner;
7718
7719       r_symndx = ELF64_R_SYM (r_info);
7720       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7721         return FALSE;
7722     }
7723
7724   if ((bfd_link_pic (info)
7725        && (must_be_dyn_reloc (info, r_type)
7726            || (h != NULL
7727                && (!SYMBOLIC_BIND (info, h)
7728                    || h->root.type == bfd_link_hash_defweak
7729                    || !h->def_regular))))
7730       || (ELIMINATE_COPY_RELOCS
7731           && !bfd_link_pic (info)
7732           && h != NULL
7733           && (h->root.type == bfd_link_hash_defweak
7734               || !h->def_regular)))
7735     ;
7736   else
7737     return TRUE;
7738
7739   if (h != NULL)
7740     {
7741       struct elf_dyn_relocs *p;
7742       struct elf_dyn_relocs **pp;
7743       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7744
7745       /* elf_gc_sweep may have already removed all dyn relocs associated
7746          with local syms for a given section.  Also, symbol flags are
7747          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7748          report a dynreloc miscount.  */
7749       if (*pp == NULL && info->gc_sections)
7750         return TRUE;
7751
7752       while ((p = *pp) != NULL)
7753         {
7754           if (p->sec == sec)
7755             {
7756               if (!must_be_dyn_reloc (info, r_type))
7757                 p->pc_count -= 1;
7758               p->count -= 1;
7759               if (p->count == 0)
7760                 *pp = p->next;
7761               return TRUE;
7762             }
7763           pp = &p->next;
7764         }
7765     }
7766   else
7767     {
7768       struct ppc_dyn_relocs *p;
7769       struct ppc_dyn_relocs **pp;
7770       void *vpp;
7771       bfd_boolean is_ifunc;
7772
7773       if (local_syms == NULL)
7774         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7775       if (sym_sec == NULL)
7776         sym_sec = sec;
7777
7778       vpp = &elf_section_data (sym_sec)->local_dynrel;
7779       pp = (struct ppc_dyn_relocs **) vpp;
7780
7781       if (*pp == NULL && info->gc_sections)
7782         return TRUE;
7783
7784       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7785       while ((p = *pp) != NULL)
7786         {
7787           if (p->sec == sec && p->ifunc == is_ifunc)
7788             {
7789               p->count -= 1;
7790               if (p->count == 0)
7791                 *pp = p->next;
7792               return TRUE;
7793             }
7794           pp = &p->next;
7795         }
7796     }
7797
7798   /* xgettext:c-format */
7799   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7800                       sec->owner, sec);
7801   bfd_set_error (bfd_error_bad_value);
7802   return FALSE;
7803 }
7804
7805 /* Remove unused Official Procedure Descriptor entries.  Currently we
7806    only remove those associated with functions in discarded link-once
7807    sections, or weakly defined functions that have been overridden.  It
7808    would be possible to remove many more entries for statically linked
7809    applications.  */
7810
7811 bfd_boolean
7812 ppc64_elf_edit_opd (struct bfd_link_info *info)
7813 {
7814   bfd *ibfd;
7815   bfd_boolean some_edited = FALSE;
7816   asection *need_pad = NULL;
7817   struct ppc_link_hash_table *htab;
7818
7819   htab = ppc_hash_table (info);
7820   if (htab == NULL)
7821     return FALSE;
7822
7823   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7824     {
7825       asection *sec;
7826       Elf_Internal_Rela *relstart, *rel, *relend;
7827       Elf_Internal_Shdr *symtab_hdr;
7828       Elf_Internal_Sym *local_syms;
7829       struct _opd_sec_data *opd;
7830       bfd_boolean need_edit, add_aux_fields, broken;
7831       bfd_size_type cnt_16b = 0;
7832
7833       if (!is_ppc64_elf (ibfd))
7834         continue;
7835
7836       sec = bfd_get_section_by_name (ibfd, ".opd");
7837       if (sec == NULL || sec->size == 0)
7838         continue;
7839
7840       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7841         continue;
7842
7843       if (sec->output_section == bfd_abs_section_ptr)
7844         continue;
7845
7846       /* Look through the section relocs.  */
7847       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7848         continue;
7849
7850       local_syms = NULL;
7851       symtab_hdr = &elf_symtab_hdr (ibfd);
7852
7853       /* Read the relocations.  */
7854       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7855                                             info->keep_memory);
7856       if (relstart == NULL)
7857         return FALSE;
7858
7859       /* First run through the relocs to check they are sane, and to
7860          determine whether we need to edit this opd section.  */
7861       need_edit = FALSE;
7862       broken = FALSE;
7863       need_pad = sec;
7864       relend = relstart + sec->reloc_count;
7865       for (rel = relstart; rel < relend; )
7866         {
7867           enum elf_ppc64_reloc_type r_type;
7868           unsigned long r_symndx;
7869           asection *sym_sec;
7870           struct elf_link_hash_entry *h;
7871           Elf_Internal_Sym *sym;
7872           bfd_vma offset;
7873
7874           /* .opd contains an array of 16 or 24 byte entries.  We're
7875              only interested in the reloc pointing to a function entry
7876              point.  */
7877           offset = rel->r_offset;
7878           if (rel + 1 == relend
7879               || rel[1].r_offset != offset + 8)
7880             {
7881               /* If someone messes with .opd alignment then after a
7882                  "ld -r" we might have padding in the middle of .opd.
7883                  Also, there's nothing to prevent someone putting
7884                  something silly in .opd with the assembler.  No .opd
7885                  optimization for them!  */
7886             broken_opd:
7887               _bfd_error_handler
7888                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7889               broken = TRUE;
7890               break;
7891             }
7892
7893           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7894               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7895             {
7896               _bfd_error_handler
7897                 /* xgettext:c-format */
7898                 (_("%pB: unexpected reloc type %u in .opd section"),
7899                  ibfd, r_type);
7900               broken = TRUE;
7901               break;
7902             }
7903
7904           r_symndx = ELF64_R_SYM (rel->r_info);
7905           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7906                           r_symndx, ibfd))
7907             goto error_ret;
7908
7909           if (sym_sec == NULL || sym_sec->owner == NULL)
7910             {
7911               const char *sym_name;
7912               if (h != NULL)
7913                 sym_name = h->root.root.string;
7914               else
7915                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7916                                              sym_sec);
7917
7918               _bfd_error_handler
7919                 /* xgettext:c-format */
7920                 (_("%pB: undefined sym `%s' in .opd section"),
7921                  ibfd, sym_name);
7922               broken = TRUE;
7923               break;
7924             }
7925
7926           /* opd entries are always for functions defined in the
7927              current input bfd.  If the symbol isn't defined in the
7928              input bfd, then we won't be using the function in this
7929              bfd;  It must be defined in a linkonce section in another
7930              bfd, or is weak.  It's also possible that we are
7931              discarding the function due to a linker script /DISCARD/,
7932              which we test for via the output_section.  */
7933           if (sym_sec->owner != ibfd
7934               || sym_sec->output_section == bfd_abs_section_ptr)
7935             need_edit = TRUE;
7936
7937           rel += 2;
7938           if (rel + 1 == relend
7939               || (rel + 2 < relend
7940                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7941             ++rel;
7942
7943           if (rel == relend)
7944             {
7945               if (sec->size == offset + 24)
7946                 {
7947                   need_pad = NULL;
7948                   break;
7949                 }
7950               if (sec->size == offset + 16)
7951                 {
7952                   cnt_16b++;
7953                   break;
7954                 }
7955               goto broken_opd;
7956             }
7957           else if (rel + 1 < relend
7958                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7959                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7960             {
7961               if (rel[0].r_offset == offset + 16)
7962                 cnt_16b++;
7963               else if (rel[0].r_offset != offset + 24)
7964                 goto broken_opd;
7965             }
7966           else
7967             goto broken_opd;
7968         }
7969
7970       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7971
7972       if (!broken && (need_edit || add_aux_fields))
7973         {
7974           Elf_Internal_Rela *write_rel;
7975           Elf_Internal_Shdr *rel_hdr;
7976           bfd_byte *rptr, *wptr;
7977           bfd_byte *new_contents;
7978           bfd_size_type amt;
7979
7980           new_contents = NULL;
7981           amt = OPD_NDX (sec->size) * sizeof (long);
7982           opd = &ppc64_elf_section_data (sec)->u.opd;
7983           opd->adjust = bfd_zalloc (sec->owner, amt);
7984           if (opd->adjust == NULL)
7985             return FALSE;
7986
7987           /* This seems a waste of time as input .opd sections are all
7988              zeros as generated by gcc, but I suppose there's no reason
7989              this will always be so.  We might start putting something in
7990              the third word of .opd entries.  */
7991           if ((sec->flags & SEC_IN_MEMORY) == 0)
7992             {
7993               bfd_byte *loc;
7994               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7995                 {
7996                   if (loc != NULL)
7997                     free (loc);
7998                 error_ret:
7999                   if (local_syms != NULL
8000                       && symtab_hdr->contents != (unsigned char *) local_syms)
8001                     free (local_syms);
8002                   if (elf_section_data (sec)->relocs != relstart)
8003                     free (relstart);
8004                   return FALSE;
8005                 }
8006               sec->contents = loc;
8007               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8008             }
8009
8010           elf_section_data (sec)->relocs = relstart;
8011
8012           new_contents = sec->contents;
8013           if (add_aux_fields)
8014             {
8015               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8016               if (new_contents == NULL)
8017                 return FALSE;
8018               need_pad = NULL;
8019             }
8020           wptr = new_contents;
8021           rptr = sec->contents;
8022           write_rel = relstart;
8023           for (rel = relstart; rel < relend; )
8024             {
8025               unsigned long r_symndx;
8026               asection *sym_sec;
8027               struct elf_link_hash_entry *h;
8028               struct ppc_link_hash_entry *fdh = NULL;
8029               Elf_Internal_Sym *sym;
8030               long opd_ent_size;
8031               Elf_Internal_Rela *next_rel;
8032               bfd_boolean skip;
8033
8034               r_symndx = ELF64_R_SYM (rel->r_info);
8035               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8036                               r_symndx, ibfd))
8037                 goto error_ret;
8038
8039               next_rel = rel + 2;
8040               if (next_rel + 1 == relend
8041                   || (next_rel + 2 < relend
8042                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8043                 ++next_rel;
8044
8045               /* See if the .opd entry is full 24 byte or
8046                  16 byte (with fd_aux entry overlapped with next
8047                  fd_func).  */
8048               opd_ent_size = 24;
8049               if (next_rel == relend)
8050                 {
8051                   if (sec->size == rel->r_offset + 16)
8052                     opd_ent_size = 16;
8053                 }
8054               else if (next_rel->r_offset == rel->r_offset + 16)
8055                 opd_ent_size = 16;
8056
8057               if (h != NULL
8058                   && h->root.root.string[0] == '.')
8059                 {
8060                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8061                   if (fdh != NULL)
8062                     {
8063                       fdh = ppc_follow_link (fdh);
8064                       if (fdh->elf.root.type != bfd_link_hash_defined
8065                           && fdh->elf.root.type != bfd_link_hash_defweak)
8066                         fdh = NULL;
8067                     }
8068                 }
8069
8070               skip = (sym_sec->owner != ibfd
8071                       || sym_sec->output_section == bfd_abs_section_ptr);
8072               if (skip)
8073                 {
8074                   if (fdh != NULL && sym_sec->owner == ibfd)
8075                     {
8076                       /* Arrange for the function descriptor sym
8077                          to be dropped.  */
8078                       fdh->elf.root.u.def.value = 0;
8079                       fdh->elf.root.u.def.section = sym_sec;
8080                     }
8081                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8082
8083                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8084                     rel = next_rel;
8085                   else
8086                     while (1)
8087                       {
8088                         if (!dec_dynrel_count (rel->r_info, sec, info,
8089                                                NULL, h, sym))
8090                           goto error_ret;
8091
8092                         if (++rel == next_rel)
8093                           break;
8094
8095                         r_symndx = ELF64_R_SYM (rel->r_info);
8096                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8097                                         r_symndx, ibfd))
8098                           goto error_ret;
8099                       }
8100                 }
8101               else
8102                 {
8103                   /* We'll be keeping this opd entry.  */
8104                   long adjust;
8105
8106                   if (fdh != NULL)
8107                     {
8108                       /* Redefine the function descriptor symbol to
8109                          this location in the opd section.  It is
8110                          necessary to update the value here rather
8111                          than using an array of adjustments as we do
8112                          for local symbols, because various places
8113                          in the generic ELF code use the value
8114                          stored in u.def.value.  */
8115                       fdh->elf.root.u.def.value = wptr - new_contents;
8116                       fdh->adjust_done = 1;
8117                     }
8118
8119                   /* Local syms are a bit tricky.  We could
8120                      tweak them as they can be cached, but
8121                      we'd need to look through the local syms
8122                      for the function descriptor sym which we
8123                      don't have at the moment.  So keep an
8124                      array of adjustments.  */
8125                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8126                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8127
8128                   if (wptr != rptr)
8129                     memcpy (wptr, rptr, opd_ent_size);
8130                   wptr += opd_ent_size;
8131                   if (add_aux_fields && opd_ent_size == 16)
8132                     {
8133                       memset (wptr, '\0', 8);
8134                       wptr += 8;
8135                     }
8136
8137                   /* We need to adjust any reloc offsets to point to the
8138                      new opd entries.  */
8139                   for ( ; rel != next_rel; ++rel)
8140                     {
8141                       rel->r_offset += adjust;
8142                       if (write_rel != rel)
8143                         memcpy (write_rel, rel, sizeof (*rel));
8144                       ++write_rel;
8145                     }
8146                 }
8147
8148               rptr += opd_ent_size;
8149             }
8150
8151           sec->size = wptr - new_contents;
8152           sec->reloc_count = write_rel - relstart;
8153           if (add_aux_fields)
8154             {
8155               free (sec->contents);
8156               sec->contents = new_contents;
8157             }
8158
8159           /* Fudge the header size too, as this is used later in
8160              elf_bfd_final_link if we are emitting relocs.  */
8161           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8162           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8163           some_edited = TRUE;
8164         }
8165       else if (elf_section_data (sec)->relocs != relstart)
8166         free (relstart);
8167
8168       if (local_syms != NULL
8169           && symtab_hdr->contents != (unsigned char *) local_syms)
8170         {
8171           if (!info->keep_memory)
8172             free (local_syms);
8173           else
8174             symtab_hdr->contents = (unsigned char *) local_syms;
8175         }
8176     }
8177
8178   if (some_edited)
8179     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8180
8181   /* If we are doing a final link and the last .opd entry is just 16 byte
8182      long, add a 8 byte padding after it.  */
8183   if (need_pad != NULL && !bfd_link_relocatable (info))
8184     {
8185       bfd_byte *p;
8186
8187       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8188         {
8189           BFD_ASSERT (need_pad->size > 0);
8190
8191           p = bfd_malloc (need_pad->size + 8);
8192           if (p == NULL)
8193             return FALSE;
8194
8195           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8196                                           p, 0, need_pad->size))
8197             return FALSE;
8198
8199           need_pad->contents = p;
8200           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8201         }
8202       else
8203         {
8204           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8205           if (p == NULL)
8206             return FALSE;
8207
8208           need_pad->contents = p;
8209         }
8210
8211       memset (need_pad->contents + need_pad->size, 0, 8);
8212       need_pad->size += 8;
8213     }
8214
8215   return TRUE;
8216 }
8217
8218 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8219
8220 asection *
8221 ppc64_elf_tls_setup (struct bfd_link_info *info)
8222 {
8223   struct ppc_link_hash_table *htab;
8224
8225   htab = ppc_hash_table (info);
8226   if (htab == NULL)
8227     return NULL;
8228
8229   if (abiversion (info->output_bfd) == 1)
8230     htab->opd_abi = 1;
8231
8232   if (htab->params->no_multi_toc)
8233     htab->do_multi_toc = 0;
8234   else if (!htab->do_multi_toc)
8235     htab->params->no_multi_toc = 1;
8236
8237   /* Default to --no-plt-localentry, as this option can cause problems
8238      with symbol interposition.  For example, glibc libpthread.so and
8239      libc.so duplicate many pthread symbols, with a fallback
8240      implementation in libc.so.  In some cases the fallback does more
8241      work than the pthread implementation.  __pthread_condattr_destroy
8242      is one such symbol: the libpthread.so implementation is
8243      localentry:0 while the libc.so implementation is localentry:8.
8244      An app that "cleverly" uses dlopen to only load necessary
8245      libraries at runtime may omit loading libpthread.so when not
8246      running multi-threaded, which then results in the libc.so
8247      fallback symbols being used and ld.so complaining.  Now there
8248      are workarounds in ld (see non_zero_localentry) to detect the
8249      pthread situation, but that may not be the only case where
8250      --plt-localentry can cause trouble.  */
8251   if (htab->params->plt_localentry0 < 0)
8252     htab->params->plt_localentry0 = 0;
8253   if (htab->params->plt_localentry0
8254       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8255                                FALSE, FALSE, FALSE) == NULL)
8256     _bfd_error_handler
8257       (_("warning: --plt-localentry is especially dangerous without "
8258          "ld.so support to detect ABI violations"));
8259
8260   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8261                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8262                                               FALSE, FALSE, TRUE));
8263   /* Move dynamic linking info to the function descriptor sym.  */
8264   if (htab->tls_get_addr != NULL)
8265     func_desc_adjust (&htab->tls_get_addr->elf, info);
8266   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8267                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8268                                                  FALSE, FALSE, TRUE));
8269   if (htab->params->tls_get_addr_opt)
8270     {
8271       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8272
8273       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8274                                   FALSE, FALSE, TRUE);
8275       if (opt != NULL)
8276         func_desc_adjust (opt, info);
8277       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8278                                      FALSE, FALSE, TRUE);
8279       if (opt_fd != NULL
8280           && (opt_fd->root.type == bfd_link_hash_defined
8281               || opt_fd->root.type == bfd_link_hash_defweak))
8282         {
8283           /* If glibc supports an optimized __tls_get_addr call stub,
8284              signalled by the presence of __tls_get_addr_opt, and we'll
8285              be calling __tls_get_addr via a plt call stub, then
8286              make __tls_get_addr point to __tls_get_addr_opt.  */
8287           tga_fd = &htab->tls_get_addr_fd->elf;
8288           if (htab->elf.dynamic_sections_created
8289               && tga_fd != NULL
8290               && (tga_fd->type == STT_FUNC
8291                   || tga_fd->needs_plt)
8292               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8293                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8294             {
8295               struct plt_entry *ent;
8296
8297               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8298                 if (ent->plt.refcount > 0)
8299                   break;
8300               if (ent != NULL)
8301                 {
8302                   tga_fd->root.type = bfd_link_hash_indirect;
8303                   tga_fd->root.u.i.link = &opt_fd->root;
8304                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8305                   opt_fd->mark = 1;
8306                   if (opt_fd->dynindx != -1)
8307                     {
8308                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8309                       opt_fd->dynindx = -1;
8310                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8311                                               opt_fd->dynstr_index);
8312                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8313                         return NULL;
8314                     }
8315                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8316                   tga = &htab->tls_get_addr->elf;
8317                   if (opt != NULL && tga != NULL)
8318                     {
8319                       tga->root.type = bfd_link_hash_indirect;
8320                       tga->root.u.i.link = &opt->root;
8321                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8322                       opt->mark = 1;
8323                       _bfd_elf_link_hash_hide_symbol (info, opt,
8324                                                       tga->forced_local);
8325                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8326                     }
8327                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8328                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8329                   if (htab->tls_get_addr != NULL)
8330                     {
8331                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8332                       htab->tls_get_addr->is_func = 1;
8333                     }
8334                 }
8335             }
8336         }
8337       else if (htab->params->tls_get_addr_opt < 0)
8338         htab->params->tls_get_addr_opt = 0;
8339     }
8340   return _bfd_elf_tls_setup (info->output_bfd, info);
8341 }
8342
8343 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8344    HASH1 or HASH2.  */
8345
8346 static bfd_boolean
8347 branch_reloc_hash_match (const bfd *ibfd,
8348                          const Elf_Internal_Rela *rel,
8349                          const struct ppc_link_hash_entry *hash1,
8350                          const struct ppc_link_hash_entry *hash2)
8351 {
8352   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8353   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8354   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8355
8356   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8357     {
8358       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8359       struct elf_link_hash_entry *h;
8360
8361       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8362       h = elf_follow_link (h);
8363       if (h == &hash1->elf || h == &hash2->elf)
8364         return TRUE;
8365     }
8366   return FALSE;
8367 }
8368
8369 /* Run through all the TLS relocs looking for optimization
8370    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8371    a preliminary section layout so that we know the TLS segment
8372    offsets.  We can't optimize earlier because some optimizations need
8373    to know the tp offset, and we need to optimize before allocating
8374    dynamic relocations.  */
8375
8376 bfd_boolean
8377 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8378 {
8379   bfd *ibfd;
8380   asection *sec;
8381   struct ppc_link_hash_table *htab;
8382   unsigned char *toc_ref;
8383   int pass;
8384
8385   if (!bfd_link_executable (info))
8386     return TRUE;
8387
8388   htab = ppc_hash_table (info);
8389   if (htab == NULL)
8390     return FALSE;
8391
8392   /* Make two passes over the relocs.  On the first pass, mark toc
8393      entries involved with tls relocs, and check that tls relocs
8394      involved in setting up a tls_get_addr call are indeed followed by
8395      such a call.  If they are not, we can't do any tls optimization.
8396      On the second pass twiddle tls_mask flags to notify
8397      relocate_section that optimization can be done, and adjust got
8398      and plt refcounts.  */
8399   toc_ref = NULL;
8400   for (pass = 0; pass < 2; ++pass)
8401     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8402       {
8403         Elf_Internal_Sym *locsyms = NULL;
8404         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8405
8406         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8407           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8408             {
8409               Elf_Internal_Rela *relstart, *rel, *relend;
8410               bfd_boolean found_tls_get_addr_arg = 0;
8411
8412               /* Read the relocations.  */
8413               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8414                                                     info->keep_memory);
8415               if (relstart == NULL)
8416                 {
8417                   free (toc_ref);
8418                   return FALSE;
8419                 }
8420
8421               relend = relstart + sec->reloc_count;
8422               for (rel = relstart; rel < relend; rel++)
8423                 {
8424                   enum elf_ppc64_reloc_type r_type;
8425                   unsigned long r_symndx;
8426                   struct elf_link_hash_entry *h;
8427                   Elf_Internal_Sym *sym;
8428                   asection *sym_sec;
8429                   unsigned char *tls_mask;
8430                   unsigned char tls_set, tls_clear, tls_type = 0;
8431                   bfd_vma value;
8432                   bfd_boolean ok_tprel, is_local;
8433                   long toc_ref_index = 0;
8434                   int expecting_tls_get_addr = 0;
8435                   bfd_boolean ret = FALSE;
8436
8437                   r_symndx = ELF64_R_SYM (rel->r_info);
8438                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8439                                   r_symndx, ibfd))
8440                     {
8441                     err_free_rel:
8442                       if (elf_section_data (sec)->relocs != relstart)
8443                         free (relstart);
8444                       if (toc_ref != NULL)
8445                         free (toc_ref);
8446                       if (locsyms != NULL
8447                           && (elf_symtab_hdr (ibfd).contents
8448                               != (unsigned char *) locsyms))
8449                         free (locsyms);
8450                       return ret;
8451                     }
8452
8453                   if (h != NULL)
8454                     {
8455                       if (h->root.type == bfd_link_hash_defined
8456                           || h->root.type == bfd_link_hash_defweak)
8457                         value = h->root.u.def.value;
8458                       else if (h->root.type == bfd_link_hash_undefweak)
8459                         value = 0;
8460                       else
8461                         {
8462                           found_tls_get_addr_arg = 0;
8463                           continue;
8464                         }
8465                     }
8466                   else
8467                     /* Symbols referenced by TLS relocs must be of type
8468                        STT_TLS.  So no need for .opd local sym adjust.  */
8469                     value = sym->st_value;
8470
8471                   ok_tprel = FALSE;
8472                   is_local = FALSE;
8473                   if (h == NULL
8474                       || !h->def_dynamic)
8475                     {
8476                       is_local = TRUE;
8477                       if (h != NULL
8478                           && h->root.type == bfd_link_hash_undefweak)
8479                         ok_tprel = TRUE;
8480                       else if (sym_sec != NULL
8481                                && sym_sec->output_section != NULL)
8482                         {
8483                           value += sym_sec->output_offset;
8484                           value += sym_sec->output_section->vma;
8485                           value -= htab->elf.tls_sec->vma;
8486                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8487                                       < (bfd_vma) 1 << 32);
8488                         }
8489                     }
8490
8491                   r_type = ELF64_R_TYPE (rel->r_info);
8492                   /* If this section has old-style __tls_get_addr calls
8493                      without marker relocs, then check that each
8494                      __tls_get_addr call reloc is preceded by a reloc
8495                      that conceivably belongs to the __tls_get_addr arg
8496                      setup insn.  If we don't find matching arg setup
8497                      relocs, don't do any tls optimization.  */
8498                   if (pass == 0
8499                       && sec->has_tls_get_addr_call
8500                       && h != NULL
8501                       && (h == &htab->tls_get_addr->elf
8502                           || h == &htab->tls_get_addr_fd->elf)
8503                       && !found_tls_get_addr_arg
8504                       && is_branch_reloc (r_type))
8505                     {
8506                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8507                                                 "TLS optimization disabled\n"),
8508                                               ibfd, sec, rel->r_offset);
8509                       ret = TRUE;
8510                       goto err_free_rel;
8511                     }
8512
8513                   found_tls_get_addr_arg = 0;
8514                   switch (r_type)
8515                     {
8516                     case R_PPC64_GOT_TLSLD16:
8517                     case R_PPC64_GOT_TLSLD16_LO:
8518                       expecting_tls_get_addr = 1;
8519                       found_tls_get_addr_arg = 1;
8520                       /* Fall through.  */
8521
8522                     case R_PPC64_GOT_TLSLD16_HI:
8523                     case R_PPC64_GOT_TLSLD16_HA:
8524                       /* These relocs should never be against a symbol
8525                          defined in a shared lib.  Leave them alone if
8526                          that turns out to be the case.  */
8527                       if (!is_local)
8528                         continue;
8529
8530                       /* LD -> LE */
8531                       tls_set = 0;
8532                       tls_clear = TLS_LD;
8533                       tls_type = TLS_TLS | TLS_LD;
8534                       break;
8535
8536                     case R_PPC64_GOT_TLSGD16:
8537                     case R_PPC64_GOT_TLSGD16_LO:
8538                       expecting_tls_get_addr = 1;
8539                       found_tls_get_addr_arg = 1;
8540                       /* Fall through. */
8541
8542                     case R_PPC64_GOT_TLSGD16_HI:
8543                     case R_PPC64_GOT_TLSGD16_HA:
8544                       if (ok_tprel)
8545                         /* GD -> LE */
8546                         tls_set = 0;
8547                       else
8548                         /* GD -> IE */
8549                         tls_set = TLS_TLS | TLS_TPRELGD;
8550                       tls_clear = TLS_GD;
8551                       tls_type = TLS_TLS | TLS_GD;
8552                       break;
8553
8554                     case R_PPC64_GOT_TPREL16_DS:
8555                     case R_PPC64_GOT_TPREL16_LO_DS:
8556                     case R_PPC64_GOT_TPREL16_HI:
8557                     case R_PPC64_GOT_TPREL16_HA:
8558                       if (ok_tprel)
8559                         {
8560                           /* IE -> LE */
8561                           tls_set = 0;
8562                           tls_clear = TLS_TPREL;
8563                           tls_type = TLS_TLS | TLS_TPREL;
8564                           break;
8565                         }
8566                       continue;
8567
8568                     case R_PPC64_TLSGD:
8569                     case R_PPC64_TLSLD:
8570                       found_tls_get_addr_arg = 1;
8571                       /* Fall through.  */
8572
8573                     case R_PPC64_TLS:
8574                     case R_PPC64_TOC16:
8575                     case R_PPC64_TOC16_LO:
8576                       if (sym_sec == NULL || sym_sec != toc)
8577                         continue;
8578
8579                       /* Mark this toc entry as referenced by a TLS
8580                          code sequence.  We can do that now in the
8581                          case of R_PPC64_TLS, and after checking for
8582                          tls_get_addr for the TOC16 relocs.  */
8583                       if (toc_ref == NULL)
8584                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8585                       if (toc_ref == NULL)
8586                         goto err_free_rel;
8587
8588                       if (h != NULL)
8589                         value = h->root.u.def.value;
8590                       else
8591                         value = sym->st_value;
8592                       value += rel->r_addend;
8593                       if (value % 8 != 0)
8594                         continue;
8595                       BFD_ASSERT (value < toc->size
8596                                   && toc->output_offset % 8 == 0);
8597                       toc_ref_index = (value + toc->output_offset) / 8;
8598                       if (r_type == R_PPC64_TLS
8599                           || r_type == R_PPC64_TLSGD
8600                           || r_type == R_PPC64_TLSLD)
8601                         {
8602                           toc_ref[toc_ref_index] = 1;
8603                           continue;
8604                         }
8605
8606                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8607                         continue;
8608
8609                       tls_set = 0;
8610                       tls_clear = 0;
8611                       expecting_tls_get_addr = 2;
8612                       break;
8613
8614                     case R_PPC64_TPREL64:
8615                       if (pass == 0
8616                           || sec != toc
8617                           || toc_ref == NULL
8618                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8619                         continue;
8620                       if (ok_tprel)
8621                         {
8622                           /* IE -> LE */
8623                           tls_set = TLS_EXPLICIT;
8624                           tls_clear = TLS_TPREL;
8625                           break;
8626                         }
8627                       continue;
8628
8629                     case R_PPC64_DTPMOD64:
8630                       if (pass == 0
8631                           || sec != toc
8632                           || toc_ref == NULL
8633                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8634                         continue;
8635                       if (rel + 1 < relend
8636                           && (rel[1].r_info
8637                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8638                           && rel[1].r_offset == rel->r_offset + 8)
8639                         {
8640                           if (ok_tprel)
8641                             /* GD -> LE */
8642                             tls_set = TLS_EXPLICIT | TLS_GD;
8643                           else
8644                             /* GD -> IE */
8645                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8646                           tls_clear = TLS_GD;
8647                         }
8648                       else
8649                         {
8650                           if (!is_local)
8651                             continue;
8652
8653                           /* LD -> LE */
8654                           tls_set = TLS_EXPLICIT;
8655                           tls_clear = TLS_LD;
8656                         }
8657                       break;
8658
8659                     default:
8660                       continue;
8661                     }
8662
8663                   if (pass == 0)
8664                     {
8665                       if (!expecting_tls_get_addr
8666                           || !sec->has_tls_get_addr_call)
8667                         continue;
8668
8669                       if (rel + 1 < relend
8670                           && branch_reloc_hash_match (ibfd, rel + 1,
8671                                                       htab->tls_get_addr,
8672                                                       htab->tls_get_addr_fd))
8673                         {
8674                           if (expecting_tls_get_addr == 2)
8675                             {
8676                               /* Check for toc tls entries.  */
8677                               unsigned char *toc_tls;
8678                               int retval;
8679
8680                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8681                                                      &locsyms,
8682                                                      rel, ibfd);
8683                               if (retval == 0)
8684                                 goto err_free_rel;
8685                               if (toc_tls != NULL)
8686                                 {
8687                                   if ((*toc_tls & TLS_TLS) != 0
8688                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8689                                     found_tls_get_addr_arg = 1;
8690                                   if (retval > 1)
8691                                     toc_ref[toc_ref_index] = 1;
8692                                 }
8693                             }
8694                           continue;
8695                         }
8696
8697                       /* Uh oh, we didn't find the expected call.  We
8698                          could just mark this symbol to exclude it
8699                          from tls optimization but it's safer to skip
8700                          the entire optimization.  */
8701                       /* xgettext:c-format */
8702                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8703                                                 "TLS optimization disabled\n"),
8704                                               ibfd, sec, rel->r_offset);
8705                       ret = TRUE;
8706                       goto err_free_rel;
8707                     }
8708
8709                   /* If we don't have old-style __tls_get_addr calls
8710                      without TLSGD/TLSLD marker relocs, and we haven't
8711                      found a new-style __tls_get_addr call with a
8712                      marker for this symbol, then we either have a
8713                      broken object file or an -mlongcall style
8714                      indirect call to __tls_get_addr without a marker.
8715                      Disable optimization in this case.  */
8716                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8717                       && (tls_set & TLS_EXPLICIT) == 0
8718                       && !sec->has_tls_get_addr_call
8719                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8720                           != (TLS_TLS | TLS_MARK)))
8721                     continue;
8722
8723                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8724                     {
8725                       struct plt_entry *ent;
8726                       for (ent = htab->tls_get_addr->elf.plt.plist;
8727                            ent != NULL;
8728                            ent = ent->next)
8729                         if (ent->addend == 0)
8730                           {
8731                             if (ent->plt.refcount > 0)
8732                               {
8733                                 ent->plt.refcount -= 1;
8734                                 expecting_tls_get_addr = 0;
8735                               }
8736                             break;
8737                           }
8738                     }
8739
8740                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8741                     {
8742                       struct plt_entry *ent;
8743                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8744                            ent != NULL;
8745                            ent = ent->next)
8746                         if (ent->addend == 0)
8747                           {
8748                             if (ent->plt.refcount > 0)
8749                               ent->plt.refcount -= 1;
8750                             break;
8751                           }
8752                     }
8753
8754                   if (tls_clear == 0)
8755                     continue;
8756
8757                   if ((tls_set & TLS_EXPLICIT) == 0)
8758                     {
8759                       struct got_entry *ent;
8760
8761                       /* Adjust got entry for this reloc.  */
8762                       if (h != NULL)
8763                         ent = h->got.glist;
8764                       else
8765                         ent = elf_local_got_ents (ibfd)[r_symndx];
8766
8767                       for (; ent != NULL; ent = ent->next)
8768                         if (ent->addend == rel->r_addend
8769                             && ent->owner == ibfd
8770                             && ent->tls_type == tls_type)
8771                           break;
8772                       if (ent == NULL)
8773                         abort ();
8774
8775                       if (tls_set == 0)
8776                         {
8777                           /* We managed to get rid of a got entry.  */
8778                           if (ent->got.refcount > 0)
8779                             ent->got.refcount -= 1;
8780                         }
8781                     }
8782                   else
8783                     {
8784                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8785                          we'll lose one or two dyn relocs.  */
8786                       if (!dec_dynrel_count (rel->r_info, sec, info,
8787                                              NULL, h, sym))
8788                         return FALSE;
8789
8790                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8791                         {
8792                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8793                                                  NULL, h, sym))
8794                             return FALSE;
8795                         }
8796                     }
8797
8798                   *tls_mask |= tls_set;
8799                   *tls_mask &= ~tls_clear;
8800                 }
8801
8802               if (elf_section_data (sec)->relocs != relstart)
8803                 free (relstart);
8804             }
8805
8806         if (locsyms != NULL
8807             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8808           {
8809             if (!info->keep_memory)
8810               free (locsyms);
8811             else
8812               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8813           }
8814       }
8815
8816   if (toc_ref != NULL)
8817     free (toc_ref);
8818   htab->do_tls_opt = 1;
8819   return TRUE;
8820 }
8821
8822 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8823    the values of any global symbols in a toc section that has been
8824    edited.  Globals in toc sections should be a rarity, so this function
8825    sets a flag if any are found in toc sections other than the one just
8826    edited, so that further hash table traversals can be avoided.  */
8827
8828 struct adjust_toc_info
8829 {
8830   asection *toc;
8831   unsigned long *skip;
8832   bfd_boolean global_toc_syms;
8833 };
8834
8835 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8836
8837 static bfd_boolean
8838 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8839 {
8840   struct ppc_link_hash_entry *eh;
8841   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8842   unsigned long i;
8843
8844   if (h->root.type != bfd_link_hash_defined
8845       && h->root.type != bfd_link_hash_defweak)
8846     return TRUE;
8847
8848   eh = (struct ppc_link_hash_entry *) h;
8849   if (eh->adjust_done)
8850     return TRUE;
8851
8852   if (eh->elf.root.u.def.section == toc_inf->toc)
8853     {
8854       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8855         i = toc_inf->toc->rawsize >> 3;
8856       else
8857         i = eh->elf.root.u.def.value >> 3;
8858
8859       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8860         {
8861           _bfd_error_handler
8862             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8863           do
8864             ++i;
8865           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8866           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8867         }
8868
8869       eh->elf.root.u.def.value -= toc_inf->skip[i];
8870       eh->adjust_done = 1;
8871     }
8872   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8873     toc_inf->global_toc_syms = TRUE;
8874
8875   return TRUE;
8876 }
8877
8878 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8879    on a _LO variety toc/got reloc.  */
8880
8881 static bfd_boolean
8882 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8883 {
8884   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8885           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8886           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8887           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8888           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8889           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8890           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8891           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8892           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8893           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8894           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8895           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8896           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8897           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8898           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8899           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8900           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8901               /* Exclude lfqu by testing reloc.  If relocs are ever
8902                  defined for the reduced D field in psq_lu then those
8903                  will need testing too.  */
8904               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8905           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8906               && (insn & 1) == 0)
8907           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8908           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8909               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8910               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8911           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8912               && (insn & 1) == 0));
8913 }
8914
8915 /* Examine all relocs referencing .toc sections in order to remove
8916    unused .toc entries.  */
8917
8918 bfd_boolean
8919 ppc64_elf_edit_toc (struct bfd_link_info *info)
8920 {
8921   bfd *ibfd;
8922   struct adjust_toc_info toc_inf;
8923   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8924
8925   htab->do_toc_opt = 1;
8926   toc_inf.global_toc_syms = TRUE;
8927   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8928     {
8929       asection *toc, *sec;
8930       Elf_Internal_Shdr *symtab_hdr;
8931       Elf_Internal_Sym *local_syms;
8932       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8933       unsigned long *skip, *drop;
8934       unsigned char *used;
8935       unsigned char *keep, last, some_unused;
8936
8937       if (!is_ppc64_elf (ibfd))
8938         continue;
8939
8940       toc = bfd_get_section_by_name (ibfd, ".toc");
8941       if (toc == NULL
8942           || toc->size == 0
8943           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8944           || discarded_section (toc))
8945         continue;
8946
8947       toc_relocs = NULL;
8948       local_syms = NULL;
8949       symtab_hdr = &elf_symtab_hdr (ibfd);
8950
8951       /* Look at sections dropped from the final link.  */
8952       skip = NULL;
8953       relstart = NULL;
8954       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8955         {
8956           if (sec->reloc_count == 0
8957               || !discarded_section (sec)
8958               || get_opd_info (sec)
8959               || (sec->flags & SEC_ALLOC) == 0
8960               || (sec->flags & SEC_DEBUGGING) != 0)
8961             continue;
8962
8963           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8964           if (relstart == NULL)
8965             goto error_ret;
8966
8967           /* Run through the relocs to see which toc entries might be
8968              unused.  */
8969           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8970             {
8971               enum elf_ppc64_reloc_type r_type;
8972               unsigned long r_symndx;
8973               asection *sym_sec;
8974               struct elf_link_hash_entry *h;
8975               Elf_Internal_Sym *sym;
8976               bfd_vma val;
8977
8978               r_type = ELF64_R_TYPE (rel->r_info);
8979               switch (r_type)
8980                 {
8981                 default:
8982                   continue;
8983
8984                 case R_PPC64_TOC16:
8985                 case R_PPC64_TOC16_LO:
8986                 case R_PPC64_TOC16_HI:
8987                 case R_PPC64_TOC16_HA:
8988                 case R_PPC64_TOC16_DS:
8989                 case R_PPC64_TOC16_LO_DS:
8990                   break;
8991                 }
8992
8993               r_symndx = ELF64_R_SYM (rel->r_info);
8994               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8995                               r_symndx, ibfd))
8996                 goto error_ret;
8997
8998               if (sym_sec != toc)
8999                 continue;
9000
9001               if (h != NULL)
9002                 val = h->root.u.def.value;
9003               else
9004                 val = sym->st_value;
9005               val += rel->r_addend;
9006
9007               if (val >= toc->size)
9008                 continue;
9009
9010               /* Anything in the toc ought to be aligned to 8 bytes.
9011                  If not, don't mark as unused.  */
9012               if (val & 7)
9013                 continue;
9014
9015               if (skip == NULL)
9016                 {
9017                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9018                   if (skip == NULL)
9019                     goto error_ret;
9020                 }
9021
9022               skip[val >> 3] = ref_from_discarded;
9023             }
9024
9025           if (elf_section_data (sec)->relocs != relstart)
9026             free (relstart);
9027         }
9028
9029       /* For largetoc loads of address constants, we can convert
9030          .  addis rx,2,addr@got@ha
9031          .  ld ry,addr@got@l(rx)
9032          to
9033          .  addis rx,2,addr@toc@ha
9034          .  addi ry,rx,addr@toc@l
9035          when addr is within 2G of the toc pointer.  This then means
9036          that the word storing "addr" in the toc is no longer needed.  */
9037
9038       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9039           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9040           && toc->reloc_count != 0)
9041         {
9042           /* Read toc relocs.  */
9043           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9044                                                   info->keep_memory);
9045           if (toc_relocs == NULL)
9046             goto error_ret;
9047
9048           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9049             {
9050               enum elf_ppc64_reloc_type r_type;
9051               unsigned long r_symndx;
9052               asection *sym_sec;
9053               struct elf_link_hash_entry *h;
9054               Elf_Internal_Sym *sym;
9055               bfd_vma val, addr;
9056
9057               r_type = ELF64_R_TYPE (rel->r_info);
9058               if (r_type != R_PPC64_ADDR64)
9059                 continue;
9060
9061               r_symndx = ELF64_R_SYM (rel->r_info);
9062               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9063                               r_symndx, ibfd))
9064                 goto error_ret;
9065
9066               if (sym_sec == NULL
9067                   || sym_sec->output_section == NULL
9068                   || discarded_section (sym_sec))
9069                 continue;
9070
9071               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9072                 continue;
9073
9074               if (h != NULL)
9075                 {
9076                   if (h->type == STT_GNU_IFUNC)
9077                     continue;
9078                   val = h->root.u.def.value;
9079                 }
9080               else
9081                 {
9082                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9083                     continue;
9084                   val = sym->st_value;
9085                 }
9086               val += rel->r_addend;
9087               val += sym_sec->output_section->vma + sym_sec->output_offset;
9088
9089               /* We don't yet know the exact toc pointer value, but we
9090                  know it will be somewhere in the toc section.  Don't
9091                  optimize if the difference from any possible toc
9092                  pointer is outside [ff..f80008000, 7fff7fff].  */
9093               addr = toc->output_section->vma + TOC_BASE_OFF;
9094               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9095                 continue;
9096
9097               addr = toc->output_section->vma + toc->output_section->rawsize;
9098               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9099                 continue;
9100
9101               if (skip == NULL)
9102                 {
9103                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9104                   if (skip == NULL)
9105                     goto error_ret;
9106                 }
9107
9108               skip[rel->r_offset >> 3]
9109                 |= can_optimize | ((rel - toc_relocs) << 2);
9110             }
9111         }
9112
9113       if (skip == NULL)
9114         continue;
9115
9116       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9117       if (used == NULL)
9118         {
9119         error_ret:
9120           if (local_syms != NULL
9121               && symtab_hdr->contents != (unsigned char *) local_syms)
9122             free (local_syms);
9123           if (sec != NULL
9124               && relstart != NULL
9125               && elf_section_data (sec)->relocs != relstart)
9126             free (relstart);
9127           if (toc_relocs != NULL
9128               && elf_section_data (toc)->relocs != toc_relocs)
9129             free (toc_relocs);
9130           if (skip != NULL)
9131             free (skip);
9132           return FALSE;
9133         }
9134
9135       /* Now check all kept sections that might reference the toc.
9136          Check the toc itself last.  */
9137       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9138                   : ibfd->sections);
9139            sec != NULL;
9140            sec = (sec == toc ? NULL
9141                   : sec->next == NULL ? toc
9142                   : sec->next == toc && toc->next ? toc->next
9143                   : sec->next))
9144         {
9145           int repeat;
9146
9147           if (sec->reloc_count == 0
9148               || discarded_section (sec)
9149               || get_opd_info (sec)
9150               || (sec->flags & SEC_ALLOC) == 0
9151               || (sec->flags & SEC_DEBUGGING) != 0)
9152             continue;
9153
9154           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9155                                                 info->keep_memory);
9156           if (relstart == NULL)
9157             {
9158               free (used);
9159               goto error_ret;
9160             }
9161
9162           /* Mark toc entries referenced as used.  */
9163           do
9164             {
9165               repeat = 0;
9166               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9167                 {
9168                   enum elf_ppc64_reloc_type r_type;
9169                   unsigned long r_symndx;
9170                   asection *sym_sec;
9171                   struct elf_link_hash_entry *h;
9172                   Elf_Internal_Sym *sym;
9173                   bfd_vma val;
9174                   enum {no_check, check_lo, check_ha} insn_check;
9175
9176                   r_type = ELF64_R_TYPE (rel->r_info);
9177                   switch (r_type)
9178                     {
9179                     default:
9180                       insn_check = no_check;
9181                       break;
9182
9183                     case R_PPC64_GOT_TLSLD16_HA:
9184                     case R_PPC64_GOT_TLSGD16_HA:
9185                     case R_PPC64_GOT_TPREL16_HA:
9186                     case R_PPC64_GOT_DTPREL16_HA:
9187                     case R_PPC64_GOT16_HA:
9188                     case R_PPC64_TOC16_HA:
9189                       insn_check = check_ha;
9190                       break;
9191
9192                     case R_PPC64_GOT_TLSLD16_LO:
9193                     case R_PPC64_GOT_TLSGD16_LO:
9194                     case R_PPC64_GOT_TPREL16_LO_DS:
9195                     case R_PPC64_GOT_DTPREL16_LO_DS:
9196                     case R_PPC64_GOT16_LO:
9197                     case R_PPC64_GOT16_LO_DS:
9198                     case R_PPC64_TOC16_LO:
9199                     case R_PPC64_TOC16_LO_DS:
9200                       insn_check = check_lo;
9201                       break;
9202                     }
9203
9204                   if (insn_check != no_check)
9205                     {
9206                       bfd_vma off = rel->r_offset & ~3;
9207                       unsigned char buf[4];
9208                       unsigned int insn;
9209
9210                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9211                         {
9212                           free (used);
9213                           goto error_ret;
9214                         }
9215                       insn = bfd_get_32 (ibfd, buf);
9216                       if (insn_check == check_lo
9217                           ? !ok_lo_toc_insn (insn, r_type)
9218                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9219                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9220                         {
9221                           char str[12];
9222
9223                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9224                           sprintf (str, "%#08x", insn);
9225                           info->callbacks->einfo
9226                             /* xgettext:c-format */
9227                             (_("%H: toc optimization is not supported for"
9228                                " %s instruction\n"),
9229                              ibfd, sec, rel->r_offset & ~3, str);
9230                         }
9231                     }
9232
9233                   switch (r_type)
9234                     {
9235                     case R_PPC64_TOC16:
9236                     case R_PPC64_TOC16_LO:
9237                     case R_PPC64_TOC16_HI:
9238                     case R_PPC64_TOC16_HA:
9239                     case R_PPC64_TOC16_DS:
9240                     case R_PPC64_TOC16_LO_DS:
9241                       /* In case we're taking addresses of toc entries.  */
9242                     case R_PPC64_ADDR64:
9243                       break;
9244
9245                     default:
9246                       continue;
9247                     }
9248
9249                   r_symndx = ELF64_R_SYM (rel->r_info);
9250                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9251                                   r_symndx, ibfd))
9252                     {
9253                       free (used);
9254                       goto error_ret;
9255                     }
9256
9257                   if (sym_sec != toc)
9258                     continue;
9259
9260                   if (h != NULL)
9261                     val = h->root.u.def.value;
9262                   else
9263                     val = sym->st_value;
9264                   val += rel->r_addend;
9265
9266                   if (val >= toc->size)
9267                     continue;
9268
9269                   if ((skip[val >> 3] & can_optimize) != 0)
9270                     {
9271                       bfd_vma off;
9272                       unsigned char opc;
9273
9274                       switch (r_type)
9275                         {
9276                         case R_PPC64_TOC16_HA:
9277                           break;
9278
9279                         case R_PPC64_TOC16_LO_DS:
9280                           off = rel->r_offset;
9281                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9282                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9283                                                          off, 1))
9284                             {
9285                               free (used);
9286                               goto error_ret;
9287                             }
9288                           if ((opc & (0x3f << 2)) == (58u << 2))
9289                             break;
9290                           /* Fall through.  */
9291
9292                         default:
9293                           /* Wrong sort of reloc, or not a ld.  We may
9294                              as well clear ref_from_discarded too.  */
9295                           skip[val >> 3] = 0;
9296                         }
9297                     }
9298
9299                   if (sec != toc)
9300                     used[val >> 3] = 1;
9301                   /* For the toc section, we only mark as used if this
9302                      entry itself isn't unused.  */
9303                   else if ((used[rel->r_offset >> 3]
9304                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9305                            && !used[val >> 3])
9306                     {
9307                       /* Do all the relocs again, to catch reference
9308                          chains.  */
9309                       repeat = 1;
9310                       used[val >> 3] = 1;
9311                     }
9312                 }
9313             }
9314           while (repeat);
9315
9316           if (elf_section_data (sec)->relocs != relstart)
9317             free (relstart);
9318         }
9319
9320       /* Merge the used and skip arrays.  Assume that TOC
9321          doublewords not appearing as either used or unused belong
9322          to an entry more than one doubleword in size.  */
9323       for (drop = skip, keep = used, last = 0, some_unused = 0;
9324            drop < skip + (toc->size + 7) / 8;
9325            ++drop, ++keep)
9326         {
9327           if (*keep)
9328             {
9329               *drop &= ~ref_from_discarded;
9330               if ((*drop & can_optimize) != 0)
9331                 some_unused = 1;
9332               last = 0;
9333             }
9334           else if ((*drop & ref_from_discarded) != 0)
9335             {
9336               some_unused = 1;
9337               last = ref_from_discarded;
9338             }
9339           else
9340             *drop = last;
9341         }
9342
9343       free (used);
9344
9345       if (some_unused)
9346         {
9347           bfd_byte *contents, *src;
9348           unsigned long off;
9349           Elf_Internal_Sym *sym;
9350           bfd_boolean local_toc_syms = FALSE;
9351
9352           /* Shuffle the toc contents, and at the same time convert the
9353              skip array from booleans into offsets.  */
9354           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9355             goto error_ret;
9356
9357           elf_section_data (toc)->this_hdr.contents = contents;
9358
9359           for (src = contents, off = 0, drop = skip;
9360                src < contents + toc->size;
9361                src += 8, ++drop)
9362             {
9363               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9364                 off += 8;
9365               else if (off != 0)
9366                 {
9367                   *drop = off;
9368                   memcpy (src - off, src, 8);
9369                 }
9370             }
9371           *drop = off;
9372           toc->rawsize = toc->size;
9373           toc->size = src - contents - off;
9374
9375           /* Adjust addends for relocs against the toc section sym,
9376              and optimize any accesses we can.  */
9377           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9378             {
9379               if (sec->reloc_count == 0
9380                   || discarded_section (sec))
9381                 continue;
9382
9383               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9384                                                     info->keep_memory);
9385               if (relstart == NULL)
9386                 goto error_ret;
9387
9388               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9389                 {
9390                   enum elf_ppc64_reloc_type r_type;
9391                   unsigned long r_symndx;
9392                   asection *sym_sec;
9393                   struct elf_link_hash_entry *h;
9394                   bfd_vma val;
9395
9396                   r_type = ELF64_R_TYPE (rel->r_info);
9397                   switch (r_type)
9398                     {
9399                     default:
9400                       continue;
9401
9402                     case R_PPC64_TOC16:
9403                     case R_PPC64_TOC16_LO:
9404                     case R_PPC64_TOC16_HI:
9405                     case R_PPC64_TOC16_HA:
9406                     case R_PPC64_TOC16_DS:
9407                     case R_PPC64_TOC16_LO_DS:
9408                     case R_PPC64_ADDR64:
9409                       break;
9410                     }
9411
9412                   r_symndx = ELF64_R_SYM (rel->r_info);
9413                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9414                                   r_symndx, ibfd))
9415                     goto error_ret;
9416
9417                   if (sym_sec != toc)
9418                     continue;
9419
9420                   if (h != NULL)
9421                     val = h->root.u.def.value;
9422                   else
9423                     {
9424                       val = sym->st_value;
9425                       if (val != 0)
9426                         local_toc_syms = TRUE;
9427                     }
9428
9429                   val += rel->r_addend;
9430
9431                   if (val > toc->rawsize)
9432                     val = toc->rawsize;
9433                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9434                     continue;
9435                   else if ((skip[val >> 3] & can_optimize) != 0)
9436                     {
9437                       Elf_Internal_Rela *tocrel
9438                         = toc_relocs + (skip[val >> 3] >> 2);
9439                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9440
9441                       switch (r_type)
9442                         {
9443                         case R_PPC64_TOC16_HA:
9444                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9445                           break;
9446
9447                         case R_PPC64_TOC16_LO_DS:
9448                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9449                           break;
9450
9451                         default:
9452                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9453                             ppc_howto_init ();
9454                           info->callbacks->einfo
9455                             /* xgettext:c-format */
9456                             (_("%H: %s references "
9457                                "optimized away TOC entry\n"),
9458                              ibfd, sec, rel->r_offset,
9459                              ppc64_elf_howto_table[r_type]->name);
9460                           bfd_set_error (bfd_error_bad_value);
9461                           goto error_ret;
9462                         }
9463                       rel->r_addend = tocrel->r_addend;
9464                       elf_section_data (sec)->relocs = relstart;
9465                       continue;
9466                     }
9467
9468                   if (h != NULL || sym->st_value != 0)
9469                     continue;
9470
9471                   rel->r_addend -= skip[val >> 3];
9472                   elf_section_data (sec)->relocs = relstart;
9473                 }
9474
9475               if (elf_section_data (sec)->relocs != relstart)
9476                 free (relstart);
9477             }
9478
9479           /* We shouldn't have local or global symbols defined in the TOC,
9480              but handle them anyway.  */
9481           if (local_syms != NULL)
9482             for (sym = local_syms;
9483                  sym < local_syms + symtab_hdr->sh_info;
9484                  ++sym)
9485               if (sym->st_value != 0
9486                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9487                 {
9488                   unsigned long i;
9489
9490                   if (sym->st_value > toc->rawsize)
9491                     i = toc->rawsize >> 3;
9492                   else
9493                     i = sym->st_value >> 3;
9494
9495                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9496                     {
9497                       if (local_toc_syms)
9498                         _bfd_error_handler
9499                           (_("%s defined on removed toc entry"),
9500                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9501                       do
9502                         ++i;
9503                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9504                       sym->st_value = (bfd_vma) i << 3;
9505                     }
9506
9507                   sym->st_value -= skip[i];
9508                   symtab_hdr->contents = (unsigned char *) local_syms;
9509                 }
9510
9511           /* Adjust any global syms defined in this toc input section.  */
9512           if (toc_inf.global_toc_syms)
9513             {
9514               toc_inf.toc = toc;
9515               toc_inf.skip = skip;
9516               toc_inf.global_toc_syms = FALSE;
9517               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9518                                       &toc_inf);
9519             }
9520
9521           if (toc->reloc_count != 0)
9522             {
9523               Elf_Internal_Shdr *rel_hdr;
9524               Elf_Internal_Rela *wrel;
9525               bfd_size_type sz;
9526
9527               /* Remove unused toc relocs, and adjust those we keep.  */
9528               if (toc_relocs == NULL)
9529                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9530                                                         info->keep_memory);
9531               if (toc_relocs == NULL)
9532                 goto error_ret;
9533
9534               wrel = toc_relocs;
9535               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9536                 if ((skip[rel->r_offset >> 3]
9537                      & (ref_from_discarded | can_optimize)) == 0)
9538                   {
9539                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9540                     wrel->r_info = rel->r_info;
9541                     wrel->r_addend = rel->r_addend;
9542                     ++wrel;
9543                   }
9544                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9545                                             &local_syms, NULL, NULL))
9546                   goto error_ret;
9547
9548               elf_section_data (toc)->relocs = toc_relocs;
9549               toc->reloc_count = wrel - toc_relocs;
9550               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9551               sz = rel_hdr->sh_entsize;
9552               rel_hdr->sh_size = toc->reloc_count * sz;
9553             }
9554         }
9555       else if (toc_relocs != NULL
9556                && elf_section_data (toc)->relocs != toc_relocs)
9557         free (toc_relocs);
9558
9559       if (local_syms != NULL
9560           && symtab_hdr->contents != (unsigned char *) local_syms)
9561         {
9562           if (!info->keep_memory)
9563             free (local_syms);
9564           else
9565             symtab_hdr->contents = (unsigned char *) local_syms;
9566         }
9567       free (skip);
9568     }
9569
9570   return TRUE;
9571 }
9572
9573 /* Return true iff input section I references the TOC using
9574    instructions limited to +/-32k offsets.  */
9575
9576 bfd_boolean
9577 ppc64_elf_has_small_toc_reloc (asection *i)
9578 {
9579   return (is_ppc64_elf (i->owner)
9580           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9581 }
9582
9583 /* Allocate space for one GOT entry.  */
9584
9585 static void
9586 allocate_got (struct elf_link_hash_entry *h,
9587               struct bfd_link_info *info,
9588               struct got_entry *gent)
9589 {
9590   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9591   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9592   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9593                  ? 16 : 8);
9594   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9595                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9596   asection *got = ppc64_elf_tdata (gent->owner)->got;
9597
9598   gent->got.offset = got->size;
9599   got->size += entsize;
9600
9601   if (h->type == STT_GNU_IFUNC)
9602     {
9603       htab->elf.irelplt->size += rentsize;
9604       htab->got_reli_size += rentsize;
9605     }
9606   else if (((bfd_link_pic (info)
9607              && !((gent->tls_type & TLS_TPREL) != 0
9608                   && bfd_link_executable (info)
9609                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9610             || (htab->elf.dynamic_sections_created
9611                 && h->dynindx != -1
9612                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9613            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9614     {
9615       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9616       relgot->size += rentsize;
9617     }
9618 }
9619
9620 /* This function merges got entries in the same toc group.  */
9621
9622 static void
9623 merge_got_entries (struct got_entry **pent)
9624 {
9625   struct got_entry *ent, *ent2;
9626
9627   for (ent = *pent; ent != NULL; ent = ent->next)
9628     if (!ent->is_indirect)
9629       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9630         if (!ent2->is_indirect
9631             && ent2->addend == ent->addend
9632             && ent2->tls_type == ent->tls_type
9633             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9634           {
9635             ent2->is_indirect = TRUE;
9636             ent2->got.ent = ent;
9637           }
9638 }
9639
9640 /* If H is undefined, make it dynamic if that makes sense.  */
9641
9642 static bfd_boolean
9643 ensure_undef_dynamic (struct bfd_link_info *info,
9644                       struct elf_link_hash_entry *h)
9645 {
9646   struct elf_link_hash_table *htab = elf_hash_table (info);
9647
9648   if (htab->dynamic_sections_created
9649       && ((info->dynamic_undefined_weak != 0
9650            && h->root.type == bfd_link_hash_undefweak)
9651           || h->root.type == bfd_link_hash_undefined)
9652       && h->dynindx == -1
9653       && !h->forced_local
9654       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9655     return bfd_elf_link_record_dynamic_symbol (info, h);
9656   return TRUE;
9657 }
9658
9659 /* Allocate space in .plt, .got and associated reloc sections for
9660    dynamic relocs.  */
9661
9662 static bfd_boolean
9663 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9664 {
9665   struct bfd_link_info *info;
9666   struct ppc_link_hash_table *htab;
9667   asection *s;
9668   struct ppc_link_hash_entry *eh;
9669   struct got_entry **pgent, *gent;
9670
9671   if (h->root.type == bfd_link_hash_indirect)
9672     return TRUE;
9673
9674   info = (struct bfd_link_info *) inf;
9675   htab = ppc_hash_table (info);
9676   if (htab == NULL)
9677     return FALSE;
9678
9679   eh = (struct ppc_link_hash_entry *) h;
9680   /* Run through the TLS GD got entries first if we're changing them
9681      to TPREL.  */
9682   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9683     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9684       if (gent->got.refcount > 0
9685           && (gent->tls_type & TLS_GD) != 0)
9686         {
9687           /* This was a GD entry that has been converted to TPREL.  If
9688              there happens to be a TPREL entry we can use that one.  */
9689           struct got_entry *ent;
9690           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9691             if (ent->got.refcount > 0
9692                 && (ent->tls_type & TLS_TPREL) != 0
9693                 && ent->addend == gent->addend
9694                 && ent->owner == gent->owner)
9695               {
9696                 gent->got.refcount = 0;
9697                 break;
9698               }
9699
9700           /* If not, then we'll be using our own TPREL entry.  */
9701           if (gent->got.refcount != 0)
9702             gent->tls_type = TLS_TLS | TLS_TPREL;
9703         }
9704
9705   /* Remove any list entry that won't generate a word in the GOT before
9706      we call merge_got_entries.  Otherwise we risk merging to empty
9707      entries.  */
9708   pgent = &h->got.glist;
9709   while ((gent = *pgent) != NULL)
9710     if (gent->got.refcount > 0)
9711       {
9712         if ((gent->tls_type & TLS_LD) != 0
9713             && !h->def_dynamic)
9714           {
9715             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9716             *pgent = gent->next;
9717           }
9718         else
9719           pgent = &gent->next;
9720       }
9721     else
9722       *pgent = gent->next;
9723
9724   if (!htab->do_multi_toc)
9725     merge_got_entries (&h->got.glist);
9726
9727   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9728     if (!gent->is_indirect)
9729       {
9730         /* Make sure this symbol is output as a dynamic symbol.  */
9731         if (!ensure_undef_dynamic (info, h))
9732           return FALSE;
9733
9734         if (!is_ppc64_elf (gent->owner))
9735           abort ();
9736
9737         allocate_got (h, info, gent);
9738       }
9739
9740   /* If no dynamic sections we can't have dynamic relocs, except for
9741      IFUNCs which are handled even in static executables.  */
9742   if (!htab->elf.dynamic_sections_created
9743       && h->type != STT_GNU_IFUNC)
9744     eh->dyn_relocs = NULL;
9745
9746   /* Discard relocs on undefined symbols that must be local.  */
9747   else if (h->root.type == bfd_link_hash_undefined
9748            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9749     eh->dyn_relocs = NULL;
9750
9751   /* Also discard relocs on undefined weak syms with non-default
9752      visibility, or when dynamic_undefined_weak says so.  */
9753   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9754     eh->dyn_relocs = NULL;
9755
9756   if (eh->dyn_relocs != NULL)
9757     {
9758       struct elf_dyn_relocs *p, **pp;
9759
9760       /* In the shared -Bsymbolic case, discard space allocated for
9761          dynamic pc-relative relocs against symbols which turn out to
9762          be defined in regular objects.  For the normal shared case,
9763          discard space for relocs that have become local due to symbol
9764          visibility changes.  */
9765
9766       if (bfd_link_pic (info))
9767         {
9768           /* Relocs that use pc_count are those that appear on a call
9769              insn, or certain REL relocs (see must_be_dyn_reloc) that
9770              can be generated via assembly.  We want calls to
9771              protected symbols to resolve directly to the function
9772              rather than going via the plt.  If people want function
9773              pointer comparisons to work as expected then they should
9774              avoid writing weird assembly.  */
9775           if (SYMBOL_CALLS_LOCAL (info, h))
9776             {
9777               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9778                 {
9779                   p->count -= p->pc_count;
9780                   p->pc_count = 0;
9781                   if (p->count == 0)
9782                     *pp = p->next;
9783                   else
9784                     pp = &p->next;
9785                 }
9786             }
9787
9788           if (eh->dyn_relocs != NULL)
9789             {
9790               /* Make sure this symbol is output as a dynamic symbol.  */
9791               if (!ensure_undef_dynamic (info, h))
9792                 return FALSE;
9793             }
9794         }
9795       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9796         {
9797           /* For the non-pic case, discard space for relocs against
9798              symbols which turn out to need copy relocs or are not
9799              dynamic.  */
9800           if (h->dynamic_adjusted
9801               && !h->def_regular
9802               && !ELF_COMMON_DEF_P (h))
9803             {
9804               /* Make sure this symbol is output as a dynamic symbol.  */
9805               if (!ensure_undef_dynamic (info, h))
9806                 return FALSE;
9807
9808               if (h->dynindx == -1)
9809                 eh->dyn_relocs = NULL;
9810             }
9811           else
9812             eh->dyn_relocs = NULL;
9813         }
9814
9815       /* Finally, allocate space.  */
9816       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9817         {
9818           asection *sreloc = elf_section_data (p->sec)->sreloc;
9819           if (eh->elf.type == STT_GNU_IFUNC)
9820             sreloc = htab->elf.irelplt;
9821           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9822         }
9823     }
9824
9825   if ((htab->elf.dynamic_sections_created
9826        && h->dynindx != -1)
9827       || h->type == STT_GNU_IFUNC)
9828     {
9829       struct plt_entry *pent;
9830       bfd_boolean doneone = FALSE;
9831       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9832         if (pent->plt.refcount > 0)
9833           {
9834             if (!htab->elf.dynamic_sections_created
9835                 || h->dynindx == -1)
9836               {
9837                 s = htab->elf.iplt;
9838                 pent->plt.offset = s->size;
9839                 s->size += PLT_ENTRY_SIZE (htab);
9840                 s = htab->elf.irelplt;
9841               }
9842             else
9843               {
9844                 /* If this is the first .plt entry, make room for the special
9845                    first entry.  */
9846                 s = htab->elf.splt;
9847                 if (s->size == 0)
9848                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9849
9850                 pent->plt.offset = s->size;
9851
9852                 /* Make room for this entry.  */
9853                 s->size += PLT_ENTRY_SIZE (htab);
9854
9855                 /* Make room for the .glink code.  */
9856                 s = htab->glink;
9857                 if (s->size == 0)
9858                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
9859                 if (htab->opd_abi)
9860                   {
9861                     /* We need bigger stubs past index 32767.  */
9862                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9863                       s->size += 4;
9864                     s->size += 2*4;
9865                   }
9866                 else
9867                   s->size += 4;
9868
9869                 /* We also need to make an entry in the .rela.plt section.  */
9870                 s = htab->elf.srelplt;
9871               }
9872             s->size += sizeof (Elf64_External_Rela);
9873             doneone = TRUE;
9874           }
9875         else
9876           pent->plt.offset = (bfd_vma) -1;
9877       if (!doneone)
9878         {
9879           h->plt.plist = NULL;
9880           h->needs_plt = 0;
9881         }
9882     }
9883   else
9884     {
9885       h->plt.plist = NULL;
9886       h->needs_plt = 0;
9887     }
9888
9889   return TRUE;
9890 }
9891
9892 #define PPC_LO(v) ((v) & 0xffff)
9893 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9894 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9895
9896 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9897    to set up space for global entry stubs.  These are put in glink,
9898    after the branch table.  */
9899
9900 static bfd_boolean
9901 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9902 {
9903   struct bfd_link_info *info;
9904   struct ppc_link_hash_table *htab;
9905   struct plt_entry *pent;
9906   asection *s, *plt;
9907
9908   if (h->root.type == bfd_link_hash_indirect)
9909     return TRUE;
9910
9911   if (!h->pointer_equality_needed)
9912     return TRUE;
9913
9914   if (h->def_regular)
9915     return TRUE;
9916
9917   info = inf;
9918   htab = ppc_hash_table (info);
9919   if (htab == NULL)
9920     return FALSE;
9921
9922   s = htab->global_entry;
9923   plt = htab->elf.splt;
9924   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9925     if (pent->plt.offset != (bfd_vma) -1
9926         && pent->addend == 0)
9927       {
9928         /* For ELFv2, if this symbol is not defined in a regular file
9929            and we are not generating a shared library or pie, then we
9930            need to define the symbol in the executable on a call stub.
9931            This is to avoid text relocations.  */
9932         bfd_vma off, stub_align, stub_off, stub_size;
9933         unsigned int align_power;
9934
9935         stub_size = 16;
9936         stub_off = s->size;
9937         if (htab->params->plt_stub_align >= 0)
9938           align_power = htab->params->plt_stub_align;
9939         else
9940           align_power = -htab->params->plt_stub_align;
9941         /* Setting section alignment is delayed until we know it is
9942            non-empty.  Otherwise the .text output section will be
9943            aligned at least to plt_stub_align even when no global
9944            entry stubs are needed.  */
9945         if (s->alignment_power < align_power)
9946           s->alignment_power = align_power;
9947         stub_align = (bfd_vma) 1 << align_power;
9948         if (htab->params->plt_stub_align >= 0
9949             || ((((stub_off + stub_size - 1) & -stub_align)
9950                  - (stub_off & -stub_align))
9951                 > ((stub_size - 1) & -stub_align)))
9952           stub_off = (stub_off + stub_align - 1) & -stub_align;
9953         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9954         off -= stub_off + s->output_offset + s->output_section->vma;
9955         /* Note that for --plt-stub-align negative we have a possible
9956            dependency between stub offset and size.  Break that
9957            dependency by assuming the max stub size when calculating
9958            the stub offset.  */
9959         if (PPC_HA (off) == 0)
9960           stub_size -= 4;
9961         h->root.type = bfd_link_hash_defined;
9962         h->root.u.def.section = s;
9963         h->root.u.def.value = stub_off;
9964         s->size = stub_off + stub_size;
9965         break;
9966       }
9967   return TRUE;
9968 }
9969
9970 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9971    read-only sections.  */
9972
9973 static bfd_boolean
9974 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9975 {
9976   asection *sec;
9977
9978   if (h->root.type == bfd_link_hash_indirect)
9979     return TRUE;
9980
9981   sec = readonly_dynrelocs (h);
9982   if (sec != NULL)
9983     {
9984       struct bfd_link_info *info = (struct bfd_link_info *) inf;
9985
9986       info->flags |= DF_TEXTREL;
9987       info->callbacks->minfo
9988         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
9989          sec->owner, h->root.root.string, sec);
9990
9991       /* Not an error, just cut short the traversal.  */
9992       return FALSE;
9993     }
9994   return TRUE;
9995 }
9996
9997 /* Set the sizes of the dynamic sections.  */
9998
9999 static bfd_boolean
10000 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10001                                  struct bfd_link_info *info)
10002 {
10003   struct ppc_link_hash_table *htab;
10004   bfd *dynobj;
10005   asection *s;
10006   bfd_boolean relocs;
10007   bfd *ibfd;
10008   struct got_entry *first_tlsld;
10009
10010   htab = ppc_hash_table (info);
10011   if (htab == NULL)
10012     return FALSE;
10013
10014   dynobj = htab->elf.dynobj;
10015   if (dynobj == NULL)
10016     abort ();
10017
10018   if (htab->elf.dynamic_sections_created)
10019     {
10020       /* Set the contents of the .interp section to the interpreter.  */
10021       if (bfd_link_executable (info) && !info->nointerp)
10022         {
10023           s = bfd_get_linker_section (dynobj, ".interp");
10024           if (s == NULL)
10025             abort ();
10026           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10027           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10028         }
10029     }
10030
10031   /* Set up .got offsets for local syms, and space for local dynamic
10032      relocs.  */
10033   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10034     {
10035       struct got_entry **lgot_ents;
10036       struct got_entry **end_lgot_ents;
10037       struct plt_entry **local_plt;
10038       struct plt_entry **end_local_plt;
10039       unsigned char *lgot_masks;
10040       bfd_size_type locsymcount;
10041       Elf_Internal_Shdr *symtab_hdr;
10042
10043       if (!is_ppc64_elf (ibfd))
10044         continue;
10045
10046       for (s = ibfd->sections; s != NULL; s = s->next)
10047         {
10048           struct ppc_dyn_relocs *p;
10049
10050           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10051             {
10052               if (!bfd_is_abs_section (p->sec)
10053                   && bfd_is_abs_section (p->sec->output_section))
10054                 {
10055                   /* Input section has been discarded, either because
10056                      it is a copy of a linkonce section or due to
10057                      linker script /DISCARD/, so we'll be discarding
10058                      the relocs too.  */
10059                 }
10060               else if (p->count != 0)
10061                 {
10062                   asection *srel = elf_section_data (p->sec)->sreloc;
10063                   if (p->ifunc)
10064                     srel = htab->elf.irelplt;
10065                   srel->size += p->count * sizeof (Elf64_External_Rela);
10066                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10067                     info->flags |= DF_TEXTREL;
10068                 }
10069             }
10070         }
10071
10072       lgot_ents = elf_local_got_ents (ibfd);
10073       if (!lgot_ents)
10074         continue;
10075
10076       symtab_hdr = &elf_symtab_hdr (ibfd);
10077       locsymcount = symtab_hdr->sh_info;
10078       end_lgot_ents = lgot_ents + locsymcount;
10079       local_plt = (struct plt_entry **) end_lgot_ents;
10080       end_local_plt = local_plt + locsymcount;
10081       lgot_masks = (unsigned char *) end_local_plt;
10082       s = ppc64_elf_tdata (ibfd)->got;
10083       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10084         {
10085           struct got_entry **pent, *ent;
10086
10087           pent = lgot_ents;
10088           while ((ent = *pent) != NULL)
10089             if (ent->got.refcount > 0)
10090               {
10091                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10092                   {
10093                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10094                     *pent = ent->next;
10095                   }
10096                 else
10097                   {
10098                     unsigned int ent_size = 8;
10099                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10100
10101                     ent->got.offset = s->size;
10102                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10103                       {
10104                         ent_size *= 2;
10105                         rel_size *= 2;
10106                       }
10107                     s->size += ent_size;
10108                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10109                       {
10110                         htab->elf.irelplt->size += rel_size;
10111                         htab->got_reli_size += rel_size;
10112                       }
10113                     else if (bfd_link_pic (info)
10114                              && !((ent->tls_type & TLS_TPREL) != 0
10115                                   && bfd_link_executable (info)))
10116                       {
10117                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10118                         srel->size += rel_size;
10119                       }
10120                     pent = &ent->next;
10121                   }
10122               }
10123             else
10124               *pent = ent->next;
10125         }
10126
10127       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10128       for (; local_plt < end_local_plt; ++local_plt)
10129         {
10130           struct plt_entry *ent;
10131
10132           for (ent = *local_plt; ent != NULL; ent = ent->next)
10133             if (ent->plt.refcount > 0)
10134               {
10135                 s = htab->elf.iplt;
10136                 ent->plt.offset = s->size;
10137                 s->size += PLT_ENTRY_SIZE (htab);
10138
10139                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10140               }
10141             else
10142               ent->plt.offset = (bfd_vma) -1;
10143         }
10144     }
10145
10146   /* Allocate global sym .plt and .got entries, and space for global
10147      sym dynamic relocs.  */
10148   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10149
10150   if (!htab->opd_abi && !bfd_link_pic (info))
10151     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10152
10153   first_tlsld = NULL;
10154   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10155     {
10156       struct got_entry *ent;
10157
10158       if (!is_ppc64_elf (ibfd))
10159         continue;
10160
10161       ent = ppc64_tlsld_got (ibfd);
10162       if (ent->got.refcount > 0)
10163         {
10164           if (!htab->do_multi_toc && first_tlsld != NULL)
10165             {
10166               ent->is_indirect = TRUE;
10167               ent->got.ent = first_tlsld;
10168             }
10169           else
10170             {
10171               if (first_tlsld == NULL)
10172                 first_tlsld = ent;
10173               s = ppc64_elf_tdata (ibfd)->got;
10174               ent->got.offset = s->size;
10175               ent->owner = ibfd;
10176               s->size += 16;
10177               if (bfd_link_pic (info))
10178                 {
10179                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10180                   srel->size += sizeof (Elf64_External_Rela);
10181                 }
10182             }
10183         }
10184       else
10185         ent->got.offset = (bfd_vma) -1;
10186     }
10187
10188   /* We now have determined the sizes of the various dynamic sections.
10189      Allocate memory for them.  */
10190   relocs = FALSE;
10191   for (s = dynobj->sections; s != NULL; s = s->next)
10192     {
10193       if ((s->flags & SEC_LINKER_CREATED) == 0)
10194         continue;
10195
10196       if (s == htab->brlt || s == htab->relbrlt)
10197         /* These haven't been allocated yet;  don't strip.  */
10198         continue;
10199       else if (s == htab->elf.sgot
10200                || s == htab->elf.splt
10201                || s == htab->elf.iplt
10202                || s == htab->glink
10203                || s == htab->global_entry
10204                || s == htab->elf.sdynbss
10205                || s == htab->elf.sdynrelro)
10206         {
10207           /* Strip this section if we don't need it; see the
10208              comment below.  */
10209         }
10210       else if (s == htab->glink_eh_frame)
10211         {
10212           if (!bfd_is_abs_section (s->output_section))
10213             /* Not sized yet.  */
10214             continue;
10215         }
10216       else if (CONST_STRNEQ (s->name, ".rela"))
10217         {
10218           if (s->size != 0)
10219             {
10220               if (s != htab->elf.srelplt)
10221                 relocs = TRUE;
10222
10223               /* We use the reloc_count field as a counter if we need
10224                  to copy relocs into the output file.  */
10225               s->reloc_count = 0;
10226             }
10227         }
10228       else
10229         {
10230           /* It's not one of our sections, so don't allocate space.  */
10231           continue;
10232         }
10233
10234       if (s->size == 0)
10235         {
10236           /* If we don't need this section, strip it from the
10237              output file.  This is mostly to handle .rela.bss and
10238              .rela.plt.  We must create both sections in
10239              create_dynamic_sections, because they must be created
10240              before the linker maps input sections to output
10241              sections.  The linker does that before
10242              adjust_dynamic_symbol is called, and it is that
10243              function which decides whether anything needs to go
10244              into these sections.  */
10245           s->flags |= SEC_EXCLUDE;
10246           continue;
10247         }
10248
10249       if (bfd_is_abs_section (s->output_section))
10250         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10251                             s->name);
10252
10253       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10254         continue;
10255
10256       /* Allocate memory for the section contents.  We use bfd_zalloc
10257          here in case unused entries are not reclaimed before the
10258          section's contents are written out.  This should not happen,
10259          but this way if it does we get a R_PPC64_NONE reloc in .rela
10260          sections instead of garbage.
10261          We also rely on the section contents being zero when writing
10262          the GOT and .dynrelro.  */
10263       s->contents = bfd_zalloc (dynobj, s->size);
10264       if (s->contents == NULL)
10265         return FALSE;
10266     }
10267
10268   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10269     {
10270       if (!is_ppc64_elf (ibfd))
10271         continue;
10272
10273       s = ppc64_elf_tdata (ibfd)->got;
10274       if (s != NULL && s != htab->elf.sgot)
10275         {
10276           if (s->size == 0)
10277             s->flags |= SEC_EXCLUDE;
10278           else
10279             {
10280               s->contents = bfd_zalloc (ibfd, s->size);
10281               if (s->contents == NULL)
10282                 return FALSE;
10283             }
10284         }
10285       s = ppc64_elf_tdata (ibfd)->relgot;
10286       if (s != NULL)
10287         {
10288           if (s->size == 0)
10289             s->flags |= SEC_EXCLUDE;
10290           else
10291             {
10292               s->contents = bfd_zalloc (ibfd, s->size);
10293               if (s->contents == NULL)
10294                 return FALSE;
10295               relocs = TRUE;
10296               s->reloc_count = 0;
10297             }
10298         }
10299     }
10300
10301   if (htab->elf.dynamic_sections_created)
10302     {
10303       bfd_boolean tls_opt;
10304
10305       /* Add some entries to the .dynamic section.  We fill in the
10306          values later, in ppc64_elf_finish_dynamic_sections, but we
10307          must add the entries now so that we get the correct size for
10308          the .dynamic section.  The DT_DEBUG entry is filled in by the
10309          dynamic linker and used by the debugger.  */
10310 #define add_dynamic_entry(TAG, VAL) \
10311   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10312
10313       if (bfd_link_executable (info))
10314         {
10315           if (!add_dynamic_entry (DT_DEBUG, 0))
10316             return FALSE;
10317         }
10318
10319       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10320         {
10321           if (!add_dynamic_entry (DT_PLTGOT, 0)
10322               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10323               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10324               || !add_dynamic_entry (DT_JMPREL, 0)
10325               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10326             return FALSE;
10327         }
10328
10329       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10330         {
10331           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10332               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10333             return FALSE;
10334         }
10335
10336       tls_opt = (htab->params->tls_get_addr_opt
10337                  && htab->tls_get_addr_fd != NULL
10338                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10339       if (tls_opt || !htab->opd_abi)
10340         {
10341           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10342             return FALSE;
10343         }
10344
10345       if (relocs)
10346         {
10347           if (!add_dynamic_entry (DT_RELA, 0)
10348               || !add_dynamic_entry (DT_RELASZ, 0)
10349               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10350             return FALSE;
10351
10352           /* If any dynamic relocs apply to a read-only section,
10353              then we need a DT_TEXTREL entry.  */
10354           if ((info->flags & DF_TEXTREL) == 0)
10355             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10356
10357           if ((info->flags & DF_TEXTREL) != 0)
10358             {
10359               if (!add_dynamic_entry (DT_TEXTREL, 0))
10360                 return FALSE;
10361             }
10362         }
10363     }
10364 #undef add_dynamic_entry
10365
10366   return TRUE;
10367 }
10368
10369 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10370
10371 static bfd_boolean
10372 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10373 {
10374   if (h->plt.plist != NULL
10375       && !h->def_regular
10376       && !h->pointer_equality_needed)
10377     return FALSE;
10378
10379   return _bfd_elf_hash_symbol (h);
10380 }
10381
10382 /* Determine the type of stub needed, if any, for a call.  */
10383
10384 static inline enum ppc_stub_type
10385 ppc_type_of_stub (asection *input_sec,
10386                   const Elf_Internal_Rela *rel,
10387                   struct ppc_link_hash_entry **hash,
10388                   struct plt_entry **plt_ent,
10389                   bfd_vma destination,
10390                   unsigned long local_off)
10391 {
10392   struct ppc_link_hash_entry *h = *hash;
10393   bfd_vma location;
10394   bfd_vma branch_offset;
10395   bfd_vma max_branch_offset;
10396   enum elf_ppc64_reloc_type r_type;
10397
10398   if (h != NULL)
10399     {
10400       struct plt_entry *ent;
10401       struct ppc_link_hash_entry *fdh = h;
10402       if (h->oh != NULL
10403           && h->oh->is_func_descriptor)
10404         {
10405           fdh = ppc_follow_link (h->oh);
10406           *hash = fdh;
10407         }
10408
10409       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10410         if (ent->addend == rel->r_addend
10411             && ent->plt.offset != (bfd_vma) -1)
10412           {
10413             *plt_ent = ent;
10414             return ppc_stub_plt_call;
10415           }
10416
10417       /* Here, we know we don't have a plt entry.  If we don't have a
10418          either a defined function descriptor or a defined entry symbol
10419          in a regular object file, then it is pointless trying to make
10420          any other type of stub.  */
10421       if (!is_static_defined (&fdh->elf)
10422           && !is_static_defined (&h->elf))
10423         return ppc_stub_none;
10424     }
10425   else if (elf_local_got_ents (input_sec->owner) != NULL)
10426     {
10427       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10428       struct plt_entry **local_plt = (struct plt_entry **)
10429         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10430       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10431
10432       if (local_plt[r_symndx] != NULL)
10433         {
10434           struct plt_entry *ent;
10435
10436           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10437             if (ent->addend == rel->r_addend
10438                 && ent->plt.offset != (bfd_vma) -1)
10439               {
10440                 *plt_ent = ent;
10441                 return ppc_stub_plt_call;
10442               }
10443         }
10444     }
10445
10446   /* Determine where the call point is.  */
10447   location = (input_sec->output_offset
10448               + input_sec->output_section->vma
10449               + rel->r_offset);
10450
10451   branch_offset = destination - location;
10452   r_type = ELF64_R_TYPE (rel->r_info);
10453
10454   /* Determine if a long branch stub is needed.  */
10455   max_branch_offset = 1 << 25;
10456   if (r_type != R_PPC64_REL24)
10457     max_branch_offset = 1 << 15;
10458
10459   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10460     /* We need a stub.  Figure out whether a long_branch or plt_branch
10461        is needed later.  */
10462     return ppc_stub_long_branch;
10463
10464   return ppc_stub_none;
10465 }
10466
10467 /* With power7 weakly ordered memory model, it is possible for ld.so
10468    to update a plt entry in one thread and have another thread see a
10469    stale zero toc entry.  To avoid this we need some sort of acquire
10470    barrier in the call stub.  One solution is to make the load of the
10471    toc word seem to appear to depend on the load of the function entry
10472    word.  Another solution is to test for r2 being zero, and branch to
10473    the appropriate glink entry if so.
10474
10475    .    fake dep barrier        compare
10476    .    ld 12,xxx(2)            ld 12,xxx(2)
10477    .    mtctr 12                mtctr 12
10478    .    xor 11,12,12            ld 2,xxx+8(2)
10479    .    add 2,2,11              cmpldi 2,0
10480    .    ld 2,xxx+8(2)           bnectr+
10481    .    bctr                    b <glink_entry>
10482
10483    The solution involving the compare turns out to be faster, so
10484    that's what we use unless the branch won't reach.  */
10485
10486 #define ALWAYS_USE_FAKE_DEP 0
10487 #define ALWAYS_EMIT_R2SAVE 0
10488
10489 static inline unsigned int
10490 plt_stub_size (struct ppc_link_hash_table *htab,
10491                struct ppc_stub_hash_entry *stub_entry,
10492                bfd_vma off)
10493 {
10494   unsigned size = 12;
10495
10496   if (ALWAYS_EMIT_R2SAVE
10497       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10498     size += 4;
10499   if (PPC_HA (off) != 0)
10500     size += 4;
10501   if (htab->opd_abi)
10502     {
10503       size += 4;
10504       if (htab->params->plt_static_chain)
10505         size += 4;
10506       if (htab->params->plt_thread_safe
10507           && htab->elf.dynamic_sections_created
10508           && stub_entry->h != NULL
10509           && stub_entry->h->elf.dynindx != -1)
10510         size += 8;
10511       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10512         size += 4;
10513     }
10514   if (stub_entry->h != NULL
10515       && (stub_entry->h == htab->tls_get_addr_fd
10516           || stub_entry->h == htab->tls_get_addr)
10517       && htab->params->tls_get_addr_opt)
10518     {
10519       size += 7 * 4;
10520       if (ALWAYS_EMIT_R2SAVE
10521           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10522         size += 6 * 4;
10523     }
10524   return size;
10525 }
10526
10527 /* Depending on the sign of plt_stub_align:
10528    If positive, return the padding to align to a 2**plt_stub_align
10529    boundary.
10530    If negative, if this stub would cross fewer 2**plt_stub_align
10531    boundaries if we align, then return the padding needed to do so.  */
10532
10533 static inline unsigned int
10534 plt_stub_pad (struct ppc_link_hash_table *htab,
10535               struct ppc_stub_hash_entry *stub_entry,
10536               bfd_vma plt_off)
10537 {
10538   int stub_align;
10539   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10540   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10541
10542   if (htab->params->plt_stub_align >= 0)
10543     {
10544       stub_align = 1 << htab->params->plt_stub_align;
10545       if ((stub_off & (stub_align - 1)) != 0)
10546         return stub_align - (stub_off & (stub_align - 1));
10547       return 0;
10548     }
10549
10550   stub_align = 1 << -htab->params->plt_stub_align;
10551   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10552       > ((stub_size - 1) & -stub_align))
10553     return stub_align - (stub_off & (stub_align - 1));
10554   return 0;
10555 }
10556
10557 /* Build a .plt call stub.  */
10558
10559 static inline bfd_byte *
10560 build_plt_stub (struct ppc_link_hash_table *htab,
10561                 struct ppc_stub_hash_entry *stub_entry,
10562                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10563 {
10564   bfd *obfd = htab->params->stub_bfd;
10565   bfd_boolean plt_load_toc = htab->opd_abi;
10566   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10567   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10568                                  && htab->elf.dynamic_sections_created
10569                                  && stub_entry->h != NULL
10570                                  && stub_entry->h->elf.dynindx != -1);
10571   bfd_boolean use_fake_dep = plt_thread_safe;
10572   bfd_vma cmp_branch_off = 0;
10573
10574   if (!ALWAYS_USE_FAKE_DEP
10575       && plt_load_toc
10576       && plt_thread_safe
10577       && !((stub_entry->h == htab->tls_get_addr_fd
10578             || stub_entry->h == htab->tls_get_addr)
10579            && htab->params->tls_get_addr_opt))
10580     {
10581       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10582       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10583                           / PLT_ENTRY_SIZE (htab));
10584       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10585       bfd_vma to, from;
10586
10587       if (pltindex > 32768)
10588         glinkoff += (pltindex - 32768) * 4;
10589       to = (glinkoff
10590             + htab->glink->output_offset
10591             + htab->glink->output_section->vma);
10592       from = (p - stub_entry->group->stub_sec->contents
10593               + 4 * (ALWAYS_EMIT_R2SAVE
10594                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10595               + 4 * (PPC_HA (offset) != 0)
10596               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10597                      != PPC_HA (offset))
10598               + 4 * (plt_static_chain != 0)
10599               + 20
10600               + stub_entry->group->stub_sec->output_offset
10601               + stub_entry->group->stub_sec->output_section->vma);
10602       cmp_branch_off = to - from;
10603       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10604     }
10605
10606   if (PPC_HA (offset) != 0)
10607     {
10608       if (r != NULL)
10609         {
10610           if (ALWAYS_EMIT_R2SAVE
10611               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10612             r[0].r_offset += 4;
10613           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10614           r[1].r_offset = r[0].r_offset + 4;
10615           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10616           r[1].r_addend = r[0].r_addend;
10617           if (plt_load_toc)
10618             {
10619               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10620                 {
10621                   r[2].r_offset = r[1].r_offset + 4;
10622                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10623                   r[2].r_addend = r[0].r_addend;
10624                 }
10625               else
10626                 {
10627                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10628                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10629                   r[2].r_addend = r[0].r_addend + 8;
10630                   if (plt_static_chain)
10631                     {
10632                       r[3].r_offset = r[2].r_offset + 4;
10633                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10634                       r[3].r_addend = r[0].r_addend + 16;
10635                     }
10636                 }
10637             }
10638         }
10639       if (ALWAYS_EMIT_R2SAVE
10640           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10641         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10642       if (plt_load_toc)
10643         {
10644           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10645           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10646         }
10647       else
10648         {
10649           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10650           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10651         }
10652       if (plt_load_toc
10653           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10654         {
10655           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10656           offset = 0;
10657         }
10658       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10659       if (plt_load_toc)
10660         {
10661           if (use_fake_dep)
10662             {
10663               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10664               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10665             }
10666           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10667           if (plt_static_chain)
10668             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10669         }
10670     }
10671   else
10672     {
10673       if (r != NULL)
10674         {
10675           if (ALWAYS_EMIT_R2SAVE
10676               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10677             r[0].r_offset += 4;
10678           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10679           if (plt_load_toc)
10680             {
10681               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10682                 {
10683                   r[1].r_offset = r[0].r_offset + 4;
10684                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10685                   r[1].r_addend = r[0].r_addend;
10686                 }
10687               else
10688                 {
10689                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10690                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10691                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10692                   if (plt_static_chain)
10693                     {
10694                       r[2].r_offset = r[1].r_offset + 4;
10695                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10696                       r[2].r_addend = r[0].r_addend + 8;
10697                     }
10698                 }
10699             }
10700         }
10701       if (ALWAYS_EMIT_R2SAVE
10702           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10703         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10704       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10705       if (plt_load_toc
10706           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10707         {
10708           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10709           offset = 0;
10710         }
10711       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10712       if (plt_load_toc)
10713         {
10714           if (use_fake_dep)
10715             {
10716               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10717               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10718             }
10719           if (plt_static_chain)
10720             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10721           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10722         }
10723     }
10724   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10725     {
10726       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10727       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10728       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10729     }
10730   else
10731     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10732   return p;
10733 }
10734
10735 /* Build a special .plt call stub for __tls_get_addr.  */
10736
10737 #define LD_R11_0R3      0xe9630000
10738 #define LD_R12_0R3      0xe9830000
10739 #define MR_R0_R3        0x7c601b78
10740 #define CMPDI_R11_0     0x2c2b0000
10741 #define ADD_R3_R12_R13  0x7c6c6a14
10742 #define BEQLR           0x4d820020
10743 #define MR_R3_R0        0x7c030378
10744 #define STD_R11_0R1     0xf9610000
10745 #define BCTRL           0x4e800421
10746 #define LD_R11_0R1      0xe9610000
10747 #define MTLR_R11        0x7d6803a6
10748
10749 static inline bfd_byte *
10750 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10751                          struct ppc_stub_hash_entry *stub_entry,
10752                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10753 {
10754   bfd *obfd = htab->params->stub_bfd;
10755
10756   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10757   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10758   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10759   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10760   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10761   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10762   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10763   if (r != NULL)
10764     r[0].r_offset += 7 * 4;
10765   if (!ALWAYS_EMIT_R2SAVE
10766       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10767     return build_plt_stub (htab, stub_entry, p, offset, r);
10768
10769   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10770   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10771
10772   if (r != NULL)
10773     r[0].r_offset += 2 * 4;
10774   p = build_plt_stub (htab, stub_entry, p, offset, r);
10775   bfd_put_32 (obfd, BCTRL, p - 4);
10776
10777   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10778   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10779   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10780   bfd_put_32 (obfd, BLR, p),                    p += 4;
10781
10782   return p;
10783 }
10784
10785 static Elf_Internal_Rela *
10786 get_relocs (asection *sec, int count)
10787 {
10788   Elf_Internal_Rela *relocs;
10789   struct bfd_elf_section_data *elfsec_data;
10790
10791   elfsec_data = elf_section_data (sec);
10792   relocs = elfsec_data->relocs;
10793   if (relocs == NULL)
10794     {
10795       bfd_size_type relsize;
10796       relsize = sec->reloc_count * sizeof (*relocs);
10797       relocs = bfd_alloc (sec->owner, relsize);
10798       if (relocs == NULL)
10799         return NULL;
10800       elfsec_data->relocs = relocs;
10801       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10802                                           sizeof (Elf_Internal_Shdr));
10803       if (elfsec_data->rela.hdr == NULL)
10804         return NULL;
10805       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10806                                         * sizeof (Elf64_External_Rela));
10807       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10808       sec->reloc_count = 0;
10809     }
10810   relocs += sec->reloc_count;
10811   sec->reloc_count += count;
10812   return relocs;
10813 }
10814
10815 static bfd_vma
10816 get_r2off (struct bfd_link_info *info,
10817            struct ppc_stub_hash_entry *stub_entry)
10818 {
10819   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10820   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10821
10822   if (r2off == 0)
10823     {
10824       /* Support linking -R objects.  Get the toc pointer from the
10825          opd entry.  */
10826       char buf[8];
10827       if (!htab->opd_abi)
10828         return r2off;
10829       asection *opd = stub_entry->h->elf.root.u.def.section;
10830       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10831
10832       if (strcmp (opd->name, ".opd") != 0
10833           || opd->reloc_count != 0)
10834         {
10835           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
10836                                   stub_entry->h->elf.root.root.string);
10837           bfd_set_error (bfd_error_bad_value);
10838           return (bfd_vma) -1;
10839         }
10840       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10841         return (bfd_vma) -1;
10842       r2off = bfd_get_64 (opd->owner, buf);
10843       r2off -= elf_gp (info->output_bfd);
10844     }
10845   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10846   return r2off;
10847 }
10848
10849 static bfd_boolean
10850 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10851 {
10852   struct ppc_stub_hash_entry *stub_entry;
10853   struct ppc_branch_hash_entry *br_entry;
10854   struct bfd_link_info *info;
10855   struct ppc_link_hash_table *htab;
10856   bfd_byte *loc;
10857   bfd_byte *p;
10858   bfd_vma dest, off;
10859   Elf_Internal_Rela *r;
10860   asection *plt;
10861
10862   /* Massage our args to the form they really have.  */
10863   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10864   info = in_arg;
10865
10866   htab = ppc_hash_table (info);
10867   if (htab == NULL)
10868     return FALSE;
10869
10870   /* Make a note of the offset within the stubs for this entry.  */
10871   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10872   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10873
10874   htab->stub_count[stub_entry->stub_type - 1] += 1;
10875   switch (stub_entry->stub_type)
10876     {
10877     case ppc_stub_long_branch:
10878     case ppc_stub_long_branch_r2off:
10879       /* Branches are relative.  This is where we are going to.  */
10880       dest = (stub_entry->target_value
10881               + stub_entry->target_section->output_offset
10882               + stub_entry->target_section->output_section->vma);
10883       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10884       off = dest;
10885
10886       /* And this is where we are coming from.  */
10887       off -= (stub_entry->stub_offset
10888               + stub_entry->group->stub_sec->output_offset
10889               + stub_entry->group->stub_sec->output_section->vma);
10890
10891       p = loc;
10892       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10893         {
10894           bfd_vma r2off = get_r2off (info, stub_entry);
10895
10896           if (r2off == (bfd_vma) -1)
10897             {
10898               htab->stub_error = TRUE;
10899               return FALSE;
10900             }
10901           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
10902           p += 4;
10903           if (PPC_HA (r2off) != 0)
10904             {
10905               bfd_put_32 (htab->params->stub_bfd,
10906                           ADDIS_R2_R2 | PPC_HA (r2off), p);
10907               p += 4;
10908             }
10909           if (PPC_LO (r2off) != 0)
10910             {
10911               bfd_put_32 (htab->params->stub_bfd,
10912                           ADDI_R2_R2 | PPC_LO (r2off), p);
10913               p += 4;
10914             }
10915           off -= p - loc;
10916         }
10917       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
10918       p += 4;
10919
10920       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10921         {
10922           _bfd_error_handler
10923             (_("long branch stub `%s' offset overflow"),
10924              stub_entry->root.string);
10925           htab->stub_error = TRUE;
10926           return FALSE;
10927         }
10928
10929       if (info->emitrelocations)
10930         {
10931           r = get_relocs (stub_entry->group->stub_sec, 1);
10932           if (r == NULL)
10933             return FALSE;
10934           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
10935           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10936           r->r_addend = dest;
10937           if (stub_entry->h != NULL)
10938             {
10939               struct elf_link_hash_entry **hashes;
10940               unsigned long symndx;
10941               struct ppc_link_hash_entry *h;
10942
10943               hashes = elf_sym_hashes (htab->params->stub_bfd);
10944               if (hashes == NULL)
10945                 {
10946                   bfd_size_type hsize;
10947
10948                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10949                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10950                   if (hashes == NULL)
10951                     return FALSE;
10952                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10953                   htab->stub_globals = 1;
10954                 }
10955               symndx = htab->stub_globals++;
10956               h = stub_entry->h;
10957               hashes[symndx] = &h->elf;
10958               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10959               if (h->oh != NULL && h->oh->is_func)
10960                 h = ppc_follow_link (h->oh);
10961               if (h->elf.root.u.def.section != stub_entry->target_section)
10962                 /* H is an opd symbol.  The addend must be zero.  */
10963                 r->r_addend = 0;
10964               else
10965                 {
10966                   off = (h->elf.root.u.def.value
10967                          + h->elf.root.u.def.section->output_offset
10968                          + h->elf.root.u.def.section->output_section->vma);
10969                   r->r_addend -= off;
10970                 }
10971             }
10972         }
10973       break;
10974
10975     case ppc_stub_plt_branch:
10976     case ppc_stub_plt_branch_r2off:
10977       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10978                                          stub_entry->root.string + 9,
10979                                          FALSE, FALSE);
10980       if (br_entry == NULL)
10981         {
10982           _bfd_error_handler (_("can't find branch stub `%s'"),
10983                               stub_entry->root.string);
10984           htab->stub_error = TRUE;
10985           return FALSE;
10986         }
10987
10988       dest = (stub_entry->target_value
10989               + stub_entry->target_section->output_offset
10990               + stub_entry->target_section->output_section->vma);
10991       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10992         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10993
10994       bfd_put_64 (htab->brlt->owner, dest,
10995                   htab->brlt->contents + br_entry->offset);
10996
10997       if (br_entry->iter == htab->stub_iteration)
10998         {
10999           br_entry->iter = 0;
11000
11001           if (htab->relbrlt != NULL)
11002             {
11003               /* Create a reloc for the branch lookup table entry.  */
11004               Elf_Internal_Rela rela;
11005               bfd_byte *rl;
11006
11007               rela.r_offset = (br_entry->offset
11008                                + htab->brlt->output_offset
11009                                + htab->brlt->output_section->vma);
11010               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11011               rela.r_addend = dest;
11012
11013               rl = htab->relbrlt->contents;
11014               rl += (htab->relbrlt->reloc_count++
11015                      * sizeof (Elf64_External_Rela));
11016               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11017             }
11018           else if (info->emitrelocations)
11019             {
11020               r = get_relocs (htab->brlt, 1);
11021               if (r == NULL)
11022                 return FALSE;
11023               /* brlt, being SEC_LINKER_CREATED does not go through the
11024                  normal reloc processing.  Symbols and offsets are not
11025                  translated from input file to output file form, so
11026                  set up the offset per the output file.  */
11027               r->r_offset = (br_entry->offset
11028                              + htab->brlt->output_offset
11029                              + htab->brlt->output_section->vma);
11030               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11031               r->r_addend = dest;
11032             }
11033         }
11034
11035       dest = (br_entry->offset
11036               + htab->brlt->output_offset
11037               + htab->brlt->output_section->vma);
11038
11039       off = (dest
11040              - elf_gp (info->output_bfd)
11041              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11042
11043       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11044         {
11045           info->callbacks->einfo
11046             (_("%P: linkage table error against `%pT'\n"),
11047              stub_entry->root.string);
11048           bfd_set_error (bfd_error_bad_value);
11049           htab->stub_error = TRUE;
11050           return FALSE;
11051         }
11052
11053       if (info->emitrelocations)
11054         {
11055           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11056           if (r == NULL)
11057             return FALSE;
11058           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11059           if (bfd_big_endian (info->output_bfd))
11060             r[0].r_offset += 2;
11061           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11062             r[0].r_offset += 4;
11063           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11064           r[0].r_addend = dest;
11065           if (PPC_HA (off) != 0)
11066             {
11067               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11068               r[1].r_offset = r[0].r_offset + 4;
11069               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11070               r[1].r_addend = r[0].r_addend;
11071             }
11072         }
11073
11074       p = loc;
11075       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11076         {
11077           if (PPC_HA (off) != 0)
11078             {
11079               bfd_put_32 (htab->params->stub_bfd,
11080                           ADDIS_R12_R2 | PPC_HA (off), p);
11081               p += 4;
11082               bfd_put_32 (htab->params->stub_bfd,
11083                           LD_R12_0R12 | PPC_LO (off), p);
11084             }
11085           else
11086             bfd_put_32 (htab->params->stub_bfd,
11087                         LD_R12_0R2 | PPC_LO (off), p);
11088         }
11089       else
11090         {
11091           bfd_vma r2off = get_r2off (info, stub_entry);
11092
11093           if (r2off == (bfd_vma) -1)
11094             {
11095               htab->stub_error = TRUE;
11096               return FALSE;
11097             }
11098
11099           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11100           p += 4;
11101           if (PPC_HA (off) != 0)
11102             {
11103               bfd_put_32 (htab->params->stub_bfd,
11104                           ADDIS_R12_R2 | PPC_HA (off), p);
11105               p += 4;
11106               bfd_put_32 (htab->params->stub_bfd,
11107                           LD_R12_0R12 | PPC_LO (off), p);
11108             }
11109           else
11110             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11111
11112           if (PPC_HA (r2off) != 0)
11113             {
11114               p += 4;
11115               bfd_put_32 (htab->params->stub_bfd,
11116                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11117             }
11118           if (PPC_LO (r2off) != 0)
11119             {
11120               p += 4;
11121               bfd_put_32 (htab->params->stub_bfd,
11122                           ADDI_R2_R2 | PPC_LO (r2off), p);
11123             }
11124         }
11125       p += 4;
11126       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11127       p += 4;
11128       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11129       p += 4;
11130       break;
11131
11132     case ppc_stub_plt_call:
11133     case ppc_stub_plt_call_r2save:
11134       if (stub_entry->h != NULL
11135           && stub_entry->h->is_func_descriptor
11136           && stub_entry->h->oh != NULL)
11137         {
11138           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11139
11140           /* If the old-ABI "dot-symbol" is undefined make it weak so
11141              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11142           if (fh->elf.root.type == bfd_link_hash_undefined
11143               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11144                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11145             fh->elf.root.type = bfd_link_hash_undefweak;
11146         }
11147
11148       /* Now build the stub.  */
11149       dest = stub_entry->plt_ent->plt.offset & ~1;
11150       if (dest >= (bfd_vma) -2)
11151         abort ();
11152
11153       plt = htab->elf.splt;
11154       if (!htab->elf.dynamic_sections_created
11155           || stub_entry->h == NULL
11156           || stub_entry->h->elf.dynindx == -1)
11157         plt = htab->elf.iplt;
11158
11159       dest += plt->output_offset + plt->output_section->vma;
11160
11161       off = (dest
11162              - elf_gp (info->output_bfd)
11163              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11164
11165       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11166         {
11167           info->callbacks->einfo
11168             /* xgettext:c-format */
11169             (_("%P: linkage table error against `%pT'\n"),
11170              stub_entry->h != NULL
11171              ? stub_entry->h->elf.root.root.string
11172              : "<local sym>");
11173           bfd_set_error (bfd_error_bad_value);
11174           htab->stub_error = TRUE;
11175           return FALSE;
11176         }
11177
11178       if (htab->params->plt_stub_align != 0)
11179         {
11180           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11181
11182           stub_entry->group->stub_sec->size += pad;
11183           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11184           loc += pad;
11185         }
11186
11187       r = NULL;
11188       if (info->emitrelocations)
11189         {
11190           r = get_relocs (stub_entry->group->stub_sec,
11191                           ((PPC_HA (off) != 0)
11192                            + (htab->opd_abi
11193                               ? 2 + (htab->params->plt_static_chain
11194                                      && PPC_HA (off + 16) == PPC_HA (off))
11195                               : 1)));
11196           if (r == NULL)
11197             return FALSE;
11198           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11199           if (bfd_big_endian (info->output_bfd))
11200             r[0].r_offset += 2;
11201           r[0].r_addend = dest;
11202         }
11203       if (stub_entry->h != NULL
11204           && (stub_entry->h == htab->tls_get_addr_fd
11205               || stub_entry->h == htab->tls_get_addr)
11206           && htab->params->tls_get_addr_opt)
11207         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11208       else
11209         p = build_plt_stub (htab, stub_entry, loc, off, r);
11210       break;
11211
11212     case ppc_stub_save_res:
11213       return TRUE;
11214
11215     default:
11216       BFD_FAIL ();
11217       return FALSE;
11218     }
11219
11220   stub_entry->group->stub_sec->size += p - loc;
11221
11222   if (htab->params->emit_stub_syms)
11223     {
11224       struct elf_link_hash_entry *h;
11225       size_t len1, len2;
11226       char *name;
11227       const char *const stub_str[] = { "long_branch",
11228                                        "long_branch_r2off",
11229                                        "plt_branch",
11230                                        "plt_branch_r2off",
11231                                        "plt_call",
11232                                        "plt_call" };
11233
11234       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11235       len2 = strlen (stub_entry->root.string);
11236       name = bfd_malloc (len1 + len2 + 2);
11237       if (name == NULL)
11238         return FALSE;
11239       memcpy (name, stub_entry->root.string, 9);
11240       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11241       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11242       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11243       if (h == NULL)
11244         return FALSE;
11245       if (h->root.type == bfd_link_hash_new)
11246         {
11247           h->root.type = bfd_link_hash_defined;
11248           h->root.u.def.section = stub_entry->group->stub_sec;
11249           h->root.u.def.value = stub_entry->stub_offset;
11250           h->ref_regular = 1;
11251           h->def_regular = 1;
11252           h->ref_regular_nonweak = 1;
11253           h->forced_local = 1;
11254           h->non_elf = 0;
11255           h->root.linker_def = 1;
11256         }
11257     }
11258
11259   return TRUE;
11260 }
11261
11262 /* As above, but don't actually build the stub.  Just bump offset so
11263    we know stub section sizes, and select plt_branch stubs where
11264    long_branch stubs won't do.  */
11265
11266 static bfd_boolean
11267 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11268 {
11269   struct ppc_stub_hash_entry *stub_entry;
11270   struct bfd_link_info *info;
11271   struct ppc_link_hash_table *htab;
11272   bfd_vma off;
11273   int size;
11274
11275   /* Massage our args to the form they really have.  */
11276   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11277   info = in_arg;
11278
11279   htab = ppc_hash_table (info);
11280   if (htab == NULL)
11281     return FALSE;
11282
11283   if (stub_entry->h != NULL
11284       && stub_entry->h->save_res
11285       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11286       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11287     {
11288       /* Don't make stubs to out-of-line register save/restore
11289          functions.  Instead, emit copies of the functions.  */
11290       stub_entry->group->needs_save_res = 1;
11291       stub_entry->stub_type = ppc_stub_save_res;
11292       return TRUE;
11293     }
11294
11295   if (stub_entry->stub_type == ppc_stub_plt_call
11296       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11297     {
11298       asection *plt;
11299       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11300       if (off >= (bfd_vma) -2)
11301         abort ();
11302       plt = htab->elf.splt;
11303       if (!htab->elf.dynamic_sections_created
11304           || stub_entry->h == NULL
11305           || stub_entry->h->elf.dynindx == -1)
11306         plt = htab->elf.iplt;
11307       off += (plt->output_offset
11308               + plt->output_section->vma
11309               - elf_gp (info->output_bfd)
11310               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11311
11312       size = plt_stub_size (htab, stub_entry, off);
11313       if (stub_entry->h != NULL
11314           && (stub_entry->h == htab->tls_get_addr_fd
11315               || stub_entry->h == htab->tls_get_addr)
11316           && htab->params->tls_get_addr_opt
11317           && (ALWAYS_EMIT_R2SAVE
11318               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11319         stub_entry->group->tls_get_addr_opt_bctrl
11320           = stub_entry->group->stub_sec->size + size - 5 * 4;
11321
11322       if (htab->params->plt_stub_align)
11323         size += plt_stub_pad (htab, stub_entry, off);
11324       if (info->emitrelocations)
11325         {
11326           stub_entry->group->stub_sec->reloc_count
11327             += ((PPC_HA (off) != 0)
11328                 + (htab->opd_abi
11329                    ? 2 + (htab->params->plt_static_chain
11330                           && PPC_HA (off + 16) == PPC_HA (off))
11331                    : 1));
11332           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11333         }
11334     }
11335   else
11336     {
11337       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11338          variants.  */
11339       bfd_vma r2off = 0;
11340       bfd_vma local_off = 0;
11341
11342       off = (stub_entry->target_value
11343              + stub_entry->target_section->output_offset
11344              + stub_entry->target_section->output_section->vma);
11345       off -= (stub_entry->group->stub_sec->size
11346               + stub_entry->group->stub_sec->output_offset
11347               + stub_entry->group->stub_sec->output_section->vma);
11348
11349       /* Reset the stub type from the plt variant in case we now
11350          can reach with a shorter stub.  */
11351       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11352         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11353
11354       size = 4;
11355       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11356         {
11357           r2off = get_r2off (info, stub_entry);
11358           if (r2off == (bfd_vma) -1)
11359             {
11360               htab->stub_error = TRUE;
11361               return FALSE;
11362             }
11363           size = 8;
11364           if (PPC_HA (r2off) != 0)
11365             size += 4;
11366           if (PPC_LO (r2off) != 0)
11367             size += 4;
11368           off -= size - 4;
11369         }
11370
11371       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11372
11373       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11374          Do the same for -R objects without function descriptors.  */
11375       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11376           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11377               && r2off == 0
11378               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11379         {
11380           struct ppc_branch_hash_entry *br_entry;
11381
11382           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11383                                              stub_entry->root.string + 9,
11384                                              TRUE, FALSE);
11385           if (br_entry == NULL)
11386             {
11387               _bfd_error_handler (_("can't build branch stub `%s'"),
11388                                   stub_entry->root.string);
11389               htab->stub_error = TRUE;
11390               return FALSE;
11391             }
11392
11393           if (br_entry->iter != htab->stub_iteration)
11394             {
11395               br_entry->iter = htab->stub_iteration;
11396               br_entry->offset = htab->brlt->size;
11397               htab->brlt->size += 8;
11398
11399               if (htab->relbrlt != NULL)
11400                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11401               else if (info->emitrelocations)
11402                 {
11403                   htab->brlt->reloc_count += 1;
11404                   htab->brlt->flags |= SEC_RELOC;
11405                 }
11406             }
11407
11408           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11409           off = (br_entry->offset
11410                  + htab->brlt->output_offset
11411                  + htab->brlt->output_section->vma
11412                  - elf_gp (info->output_bfd)
11413                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11414
11415           if (info->emitrelocations)
11416             {
11417               stub_entry->group->stub_sec->reloc_count
11418                 += 1 + (PPC_HA (off) != 0);
11419               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11420             }
11421
11422           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11423             {
11424               size = 12;
11425               if (PPC_HA (off) != 0)
11426                 size = 16;
11427             }
11428           else
11429             {
11430               size = 16;
11431               if (PPC_HA (off) != 0)
11432                 size += 4;
11433
11434               if (PPC_HA (r2off) != 0)
11435                 size += 4;
11436               if (PPC_LO (r2off) != 0)
11437                 size += 4;
11438             }
11439         }
11440       else if (info->emitrelocations)
11441         {
11442           stub_entry->group->stub_sec->reloc_count += 1;
11443           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11444         }
11445     }
11446
11447   stub_entry->group->stub_sec->size += size;
11448   return TRUE;
11449 }
11450
11451 /* Set up various things so that we can make a list of input sections
11452    for each output section included in the link.  Returns -1 on error,
11453    0 when no stubs will be needed, and 1 on success.  */
11454
11455 int
11456 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11457 {
11458   unsigned int id;
11459   bfd_size_type amt;
11460   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11461
11462   if (htab == NULL)
11463     return -1;
11464
11465   htab->sec_info_arr_size = bfd_get_next_section_id ();
11466   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11467   htab->sec_info = bfd_zmalloc (amt);
11468   if (htab->sec_info == NULL)
11469     return -1;
11470
11471   /* Set toc_off for com, und, abs and ind sections.  */
11472   for (id = 0; id < 3; id++)
11473     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11474
11475   return 1;
11476 }
11477
11478 /* Set up for first pass at multitoc partitioning.  */
11479
11480 void
11481 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11482 {
11483   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11484
11485   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11486   htab->toc_bfd = NULL;
11487   htab->toc_first_sec = NULL;
11488 }
11489
11490 /* The linker repeatedly calls this function for each TOC input section
11491    and linker generated GOT section.  Group input bfds such that the toc
11492    within a group is less than 64k in size.  */
11493
11494 bfd_boolean
11495 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11496 {
11497   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11498   bfd_vma addr, off, limit;
11499
11500   if (htab == NULL)
11501     return FALSE;
11502
11503   if (!htab->second_toc_pass)
11504     {
11505       /* Keep track of the first .toc or .got section for this input bfd.  */
11506       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11507
11508       if (new_bfd)
11509         {
11510           htab->toc_bfd = isec->owner;
11511           htab->toc_first_sec = isec;
11512         }
11513
11514       addr = isec->output_offset + isec->output_section->vma;
11515       off = addr - htab->toc_curr;
11516       limit = 0x80008000;
11517       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11518         limit = 0x10000;
11519       if (off + isec->size > limit)
11520         {
11521           addr = (htab->toc_first_sec->output_offset
11522                   + htab->toc_first_sec->output_section->vma);
11523           htab->toc_curr = addr;
11524           htab->toc_curr &= -TOC_BASE_ALIGN;
11525         }
11526
11527       /* toc_curr is the base address of this toc group.  Set elf_gp
11528          for the input section to be the offset relative to the
11529          output toc base plus 0x8000.  Making the input elf_gp an
11530          offset allows us to move the toc as a whole without
11531          recalculating input elf_gp.  */
11532       off = htab->toc_curr - elf_gp (info->output_bfd);
11533       off += TOC_BASE_OFF;
11534
11535       /* Die if someone uses a linker script that doesn't keep input
11536          file .toc and .got together.  */
11537       if (new_bfd
11538           && elf_gp (isec->owner) != 0
11539           && elf_gp (isec->owner) != off)
11540         return FALSE;
11541
11542       elf_gp (isec->owner) = off;
11543       return TRUE;
11544     }
11545
11546   /* During the second pass toc_first_sec points to the start of
11547      a toc group, and toc_curr is used to track the old elf_gp.
11548      We use toc_bfd to ensure we only look at each bfd once.  */
11549   if (htab->toc_bfd == isec->owner)
11550     return TRUE;
11551   htab->toc_bfd = isec->owner;
11552
11553   if (htab->toc_first_sec == NULL
11554       || htab->toc_curr != elf_gp (isec->owner))
11555     {
11556       htab->toc_curr = elf_gp (isec->owner);
11557       htab->toc_first_sec = isec;
11558     }
11559   addr = (htab->toc_first_sec->output_offset
11560           + htab->toc_first_sec->output_section->vma);
11561   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11562   elf_gp (isec->owner) = off;
11563
11564   return TRUE;
11565 }
11566
11567 /* Called via elf_link_hash_traverse to merge GOT entries for global
11568    symbol H.  */
11569
11570 static bfd_boolean
11571 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11572 {
11573   if (h->root.type == bfd_link_hash_indirect)
11574     return TRUE;
11575
11576   merge_got_entries (&h->got.glist);
11577
11578   return TRUE;
11579 }
11580
11581 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11582    symbol H.  */
11583
11584 static bfd_boolean
11585 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11586 {
11587   struct got_entry *gent;
11588
11589   if (h->root.type == bfd_link_hash_indirect)
11590     return TRUE;
11591
11592   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11593     if (!gent->is_indirect)
11594       allocate_got (h, (struct bfd_link_info *) inf, gent);
11595   return TRUE;
11596 }
11597
11598 /* Called on the first multitoc pass after the last call to
11599    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11600    entries.  */
11601
11602 bfd_boolean
11603 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11604 {
11605   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11606   struct bfd *ibfd, *ibfd2;
11607   bfd_boolean done_something;
11608
11609   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11610
11611   if (!htab->do_multi_toc)
11612     return FALSE;
11613
11614   /* Merge global sym got entries within a toc group.  */
11615   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11616
11617   /* And tlsld_got.  */
11618   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11619     {
11620       struct got_entry *ent, *ent2;
11621
11622       if (!is_ppc64_elf (ibfd))
11623         continue;
11624
11625       ent = ppc64_tlsld_got (ibfd);
11626       if (!ent->is_indirect
11627           && ent->got.offset != (bfd_vma) -1)
11628         {
11629           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11630             {
11631               if (!is_ppc64_elf (ibfd2))
11632                 continue;
11633
11634               ent2 = ppc64_tlsld_got (ibfd2);
11635               if (!ent2->is_indirect
11636                   && ent2->got.offset != (bfd_vma) -1
11637                   && elf_gp (ibfd2) == elf_gp (ibfd))
11638                 {
11639                   ent2->is_indirect = TRUE;
11640                   ent2->got.ent = ent;
11641                 }
11642             }
11643         }
11644     }
11645
11646   /* Zap sizes of got sections.  */
11647   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11648   htab->elf.irelplt->size -= htab->got_reli_size;
11649   htab->got_reli_size = 0;
11650
11651   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11652     {
11653       asection *got, *relgot;
11654
11655       if (!is_ppc64_elf (ibfd))
11656         continue;
11657
11658       got = ppc64_elf_tdata (ibfd)->got;
11659       if (got != NULL)
11660         {
11661           got->rawsize = got->size;
11662           got->size = 0;
11663           relgot = ppc64_elf_tdata (ibfd)->relgot;
11664           relgot->rawsize = relgot->size;
11665           relgot->size = 0;
11666         }
11667     }
11668
11669   /* Now reallocate the got, local syms first.  We don't need to
11670      allocate section contents again since we never increase size.  */
11671   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11672     {
11673       struct got_entry **lgot_ents;
11674       struct got_entry **end_lgot_ents;
11675       struct plt_entry **local_plt;
11676       struct plt_entry **end_local_plt;
11677       unsigned char *lgot_masks;
11678       bfd_size_type locsymcount;
11679       Elf_Internal_Shdr *symtab_hdr;
11680       asection *s;
11681
11682       if (!is_ppc64_elf (ibfd))
11683         continue;
11684
11685       lgot_ents = elf_local_got_ents (ibfd);
11686       if (!lgot_ents)
11687         continue;
11688
11689       symtab_hdr = &elf_symtab_hdr (ibfd);
11690       locsymcount = symtab_hdr->sh_info;
11691       end_lgot_ents = lgot_ents + locsymcount;
11692       local_plt = (struct plt_entry **) end_lgot_ents;
11693       end_local_plt = local_plt + locsymcount;
11694       lgot_masks = (unsigned char *) end_local_plt;
11695       s = ppc64_elf_tdata (ibfd)->got;
11696       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11697         {
11698           struct got_entry *ent;
11699
11700           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11701             {
11702               unsigned int ent_size = 8;
11703               unsigned int rel_size = sizeof (Elf64_External_Rela);
11704
11705               ent->got.offset = s->size;
11706               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11707                 {
11708                   ent_size *= 2;
11709                   rel_size *= 2;
11710                 }
11711               s->size += ent_size;
11712               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
11713                 {
11714                   htab->elf.irelplt->size += rel_size;
11715                   htab->got_reli_size += rel_size;
11716                 }
11717               else if (bfd_link_pic (info)
11718                        && !((ent->tls_type & TLS_TPREL) != 0
11719                             && bfd_link_executable (info)))
11720                 {
11721                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11722                   srel->size += rel_size;
11723                 }
11724             }
11725         }
11726     }
11727
11728   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11729
11730   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11731     {
11732       struct got_entry *ent;
11733
11734       if (!is_ppc64_elf (ibfd))
11735         continue;
11736
11737       ent = ppc64_tlsld_got (ibfd);
11738       if (!ent->is_indirect
11739           && ent->got.offset != (bfd_vma) -1)
11740         {
11741           asection *s = ppc64_elf_tdata (ibfd)->got;
11742           ent->got.offset = s->size;
11743           s->size += 16;
11744           if (bfd_link_pic (info))
11745             {
11746               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11747               srel->size += sizeof (Elf64_External_Rela);
11748             }
11749         }
11750     }
11751
11752   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11753   if (!done_something)
11754     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11755       {
11756         asection *got;
11757
11758         if (!is_ppc64_elf (ibfd))
11759           continue;
11760
11761         got = ppc64_elf_tdata (ibfd)->got;
11762         if (got != NULL)
11763           {
11764             done_something = got->rawsize != got->size;
11765             if (done_something)
11766               break;
11767           }
11768       }
11769
11770   if (done_something)
11771     (*htab->params->layout_sections_again) ();
11772
11773   /* Set up for second pass over toc sections to recalculate elf_gp
11774      on input sections.  */
11775   htab->toc_bfd = NULL;
11776   htab->toc_first_sec = NULL;
11777   htab->second_toc_pass = TRUE;
11778   return done_something;
11779 }
11780
11781 /* Called after second pass of multitoc partitioning.  */
11782
11783 void
11784 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11785 {
11786   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11787
11788   /* After the second pass, toc_curr tracks the TOC offset used
11789      for code sections below in ppc64_elf_next_input_section.  */
11790   htab->toc_curr = TOC_BASE_OFF;
11791 }
11792
11793 /* No toc references were found in ISEC.  If the code in ISEC makes no
11794    calls, then there's no need to use toc adjusting stubs when branching
11795    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11796    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11797    needed, and 2 if a cyclical call-graph was found but no other reason
11798    for a stub was detected.  If called from the top level, a return of
11799    2 means the same as a return of 0.  */
11800
11801 static int
11802 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11803 {
11804   int ret;
11805
11806   /* Mark this section as checked.  */
11807   isec->call_check_done = 1;
11808
11809   /* We know none of our code bearing sections will need toc stubs.  */
11810   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11811     return 0;
11812
11813   if (isec->size == 0)
11814     return 0;
11815
11816   if (isec->output_section == NULL)
11817     return 0;
11818
11819   ret = 0;
11820   if (isec->reloc_count != 0)
11821     {
11822       Elf_Internal_Rela *relstart, *rel;
11823       Elf_Internal_Sym *local_syms;
11824       struct ppc_link_hash_table *htab;
11825
11826       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11827                                             info->keep_memory);
11828       if (relstart == NULL)
11829         return -1;
11830
11831       /* Look for branches to outside of this section.  */
11832       local_syms = NULL;
11833       htab = ppc_hash_table (info);
11834       if (htab == NULL)
11835         return -1;
11836
11837       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11838         {
11839           enum elf_ppc64_reloc_type r_type;
11840           unsigned long r_symndx;
11841           struct elf_link_hash_entry *h;
11842           struct ppc_link_hash_entry *eh;
11843           Elf_Internal_Sym *sym;
11844           asection *sym_sec;
11845           struct _opd_sec_data *opd;
11846           bfd_vma sym_value;
11847           bfd_vma dest;
11848
11849           r_type = ELF64_R_TYPE (rel->r_info);
11850           if (r_type != R_PPC64_REL24
11851               && r_type != R_PPC64_REL14
11852               && r_type != R_PPC64_REL14_BRTAKEN
11853               && r_type != R_PPC64_REL14_BRNTAKEN)
11854             continue;
11855
11856           r_symndx = ELF64_R_SYM (rel->r_info);
11857           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11858                           isec->owner))
11859             {
11860               ret = -1;
11861               break;
11862             }
11863
11864           /* Calls to dynamic lib functions go through a plt call stub
11865              that uses r2.  */
11866           eh = (struct ppc_link_hash_entry *) h;
11867           if (eh != NULL
11868               && (eh->elf.plt.plist != NULL
11869                   || (eh->oh != NULL
11870                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11871             {
11872               ret = 1;
11873               break;
11874             }
11875
11876           if (sym_sec == NULL)
11877             /* Ignore other undefined symbols.  */
11878             continue;
11879
11880           /* Assume branches to other sections not included in the
11881              link need stubs too, to cover -R and absolute syms.  */
11882           if (sym_sec->output_section == NULL)
11883             {
11884               ret = 1;
11885               break;
11886             }
11887
11888           if (h == NULL)
11889             sym_value = sym->st_value;
11890           else
11891             {
11892               if (h->root.type != bfd_link_hash_defined
11893                   && h->root.type != bfd_link_hash_defweak)
11894                 abort ();
11895               sym_value = h->root.u.def.value;
11896             }
11897           sym_value += rel->r_addend;
11898
11899           /* If this branch reloc uses an opd sym, find the code section.  */
11900           opd = get_opd_info (sym_sec);
11901           if (opd != NULL)
11902             {
11903               if (h == NULL && opd->adjust != NULL)
11904                 {
11905                   long adjust;
11906
11907                   adjust = opd->adjust[OPD_NDX (sym_value)];
11908                   if (adjust == -1)
11909                     /* Assume deleted functions won't ever be called.  */
11910                     continue;
11911                   sym_value += adjust;
11912                 }
11913
11914               dest = opd_entry_value (sym_sec, sym_value,
11915                                       &sym_sec, NULL, FALSE);
11916               if (dest == (bfd_vma) -1)
11917                 continue;
11918             }
11919           else
11920             dest = (sym_value
11921                     + sym_sec->output_offset
11922                     + sym_sec->output_section->vma);
11923
11924           /* Ignore branch to self.  */
11925           if (sym_sec == isec)
11926             continue;
11927
11928           /* If the called function uses the toc, we need a stub.  */
11929           if (sym_sec->has_toc_reloc
11930               || sym_sec->makes_toc_func_call)
11931             {
11932               ret = 1;
11933               break;
11934             }
11935
11936           /* Assume any branch that needs a long branch stub might in fact
11937              need a plt_branch stub.  A plt_branch stub uses r2.  */
11938           else if (dest - (isec->output_offset
11939                            + isec->output_section->vma
11940                            + rel->r_offset) + (1 << 25)
11941                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11942                                                              ? h->other
11943                                                              : sym->st_other))
11944             {
11945               ret = 1;
11946               break;
11947             }
11948
11949           /* If calling back to a section in the process of being
11950              tested, we can't say for sure that no toc adjusting stubs
11951              are needed, so don't return zero.  */
11952           else if (sym_sec->call_check_in_progress)
11953             ret = 2;
11954
11955           /* Branches to another section that itself doesn't have any TOC
11956              references are OK.  Recursively call ourselves to check.  */
11957           else if (!sym_sec->call_check_done)
11958             {
11959               int recur;
11960
11961               /* Mark current section as indeterminate, so that other
11962                  sections that call back to current won't be marked as
11963                  known.  */
11964               isec->call_check_in_progress = 1;
11965               recur = toc_adjusting_stub_needed (info, sym_sec);
11966               isec->call_check_in_progress = 0;
11967
11968               if (recur != 0)
11969                 {
11970                   ret = recur;
11971                   if (recur != 2)
11972                     break;
11973                 }
11974             }
11975         }
11976
11977       if (local_syms != NULL
11978           && (elf_symtab_hdr (isec->owner).contents
11979               != (unsigned char *) local_syms))
11980         free (local_syms);
11981       if (elf_section_data (isec)->relocs != relstart)
11982         free (relstart);
11983     }
11984
11985   if ((ret & 1) == 0
11986       && isec->map_head.s != NULL
11987       && (strcmp (isec->output_section->name, ".init") == 0
11988           || strcmp (isec->output_section->name, ".fini") == 0))
11989     {
11990       if (isec->map_head.s->has_toc_reloc
11991           || isec->map_head.s->makes_toc_func_call)
11992         ret = 1;
11993       else if (!isec->map_head.s->call_check_done)
11994         {
11995           int recur;
11996           isec->call_check_in_progress = 1;
11997           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11998           isec->call_check_in_progress = 0;
11999           if (recur != 0)
12000             ret = recur;
12001         }
12002     }
12003
12004   if (ret == 1)
12005     isec->makes_toc_func_call = 1;
12006
12007   return ret;
12008 }
12009
12010 /* The linker repeatedly calls this function for each input section,
12011    in the order that input sections are linked into output sections.
12012    Build lists of input sections to determine groupings between which
12013    we may insert linker stubs.  */
12014
12015 bfd_boolean
12016 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12017 {
12018   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12019
12020   if (htab == NULL)
12021     return FALSE;
12022
12023   if ((isec->output_section->flags & SEC_CODE) != 0
12024       && isec->output_section->id < htab->sec_info_arr_size)
12025     {
12026       /* This happens to make the list in reverse order,
12027          which is what we want.  */
12028       htab->sec_info[isec->id].u.list
12029         = htab->sec_info[isec->output_section->id].u.list;
12030       htab->sec_info[isec->output_section->id].u.list = isec;
12031     }
12032
12033   if (htab->multi_toc_needed)
12034     {
12035       /* Analyse sections that aren't already flagged as needing a
12036          valid toc pointer.  Exclude .fixup for the linux kernel.
12037          .fixup contains branches, but only back to the function that
12038          hit an exception.  */
12039       if (!(isec->has_toc_reloc
12040             || (isec->flags & SEC_CODE) == 0
12041             || strcmp (isec->name, ".fixup") == 0
12042             || isec->call_check_done))
12043         {
12044           if (toc_adjusting_stub_needed (info, isec) < 0)
12045             return FALSE;
12046         }
12047       /* Make all sections use the TOC assigned for this object file.
12048          This will be wrong for pasted sections;  We fix that in
12049          check_pasted_section().  */
12050       if (elf_gp (isec->owner) != 0)
12051         htab->toc_curr = elf_gp (isec->owner);
12052     }
12053
12054   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12055   return TRUE;
12056 }
12057
12058 /* Check that all .init and .fini sections use the same toc, if they
12059    have toc relocs.  */
12060
12061 static bfd_boolean
12062 check_pasted_section (struct bfd_link_info *info, const char *name)
12063 {
12064   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12065
12066   if (o != NULL)
12067     {
12068       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12069       bfd_vma toc_off = 0;
12070       asection *i;
12071
12072       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12073         if (i->has_toc_reloc)
12074           {
12075             if (toc_off == 0)
12076               toc_off = htab->sec_info[i->id].toc_off;
12077             else if (toc_off != htab->sec_info[i->id].toc_off)
12078               return FALSE;
12079           }
12080
12081       if (toc_off == 0)
12082         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12083           if (i->makes_toc_func_call)
12084             {
12085               toc_off = htab->sec_info[i->id].toc_off;
12086               break;
12087             }
12088
12089       /* Make sure the whole pasted function uses the same toc offset.  */
12090       if (toc_off != 0)
12091         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12092           htab->sec_info[i->id].toc_off = toc_off;
12093     }
12094   return TRUE;
12095 }
12096
12097 bfd_boolean
12098 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12099 {
12100   return (check_pasted_section (info, ".init")
12101           & check_pasted_section (info, ".fini"));
12102 }
12103
12104 /* See whether we can group stub sections together.  Grouping stub
12105    sections may result in fewer stubs.  More importantly, we need to
12106    put all .init* and .fini* stubs at the beginning of the .init or
12107    .fini output sections respectively, because glibc splits the
12108    _init and _fini functions into multiple parts.  Putting a stub in
12109    the middle of a function is not a good idea.  */
12110
12111 static bfd_boolean
12112 group_sections (struct bfd_link_info *info,
12113                 bfd_size_type stub_group_size,
12114                 bfd_boolean stubs_always_before_branch)
12115 {
12116   struct ppc_link_hash_table *htab;
12117   asection *osec;
12118   bfd_boolean suppress_size_errors;
12119
12120   htab = ppc_hash_table (info);
12121   if (htab == NULL)
12122     return FALSE;
12123
12124   suppress_size_errors = FALSE;
12125   if (stub_group_size == 1)
12126     {
12127       /* Default values.  */
12128       if (stubs_always_before_branch)
12129         stub_group_size = 0x1e00000;
12130       else
12131         stub_group_size = 0x1c00000;
12132       suppress_size_errors = TRUE;
12133     }
12134
12135   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12136     {
12137       asection *tail;
12138
12139       if (osec->id >= htab->sec_info_arr_size)
12140         continue;
12141
12142       tail = htab->sec_info[osec->id].u.list;
12143       while (tail != NULL)
12144         {
12145           asection *curr;
12146           asection *prev;
12147           bfd_size_type total;
12148           bfd_boolean big_sec;
12149           bfd_vma curr_toc;
12150           struct map_stub *group;
12151           bfd_size_type group_size;
12152
12153           curr = tail;
12154           total = tail->size;
12155           group_size = (ppc64_elf_section_data (tail) != NULL
12156                         && ppc64_elf_section_data (tail)->has_14bit_branch
12157                         ? stub_group_size >> 10 : stub_group_size);
12158
12159           big_sec = total > group_size;
12160           if (big_sec && !suppress_size_errors)
12161             /* xgettext:c-format */
12162             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12163                                 tail->owner, tail);
12164           curr_toc = htab->sec_info[tail->id].toc_off;
12165
12166           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12167                  && ((total += curr->output_offset - prev->output_offset)
12168                      < (ppc64_elf_section_data (prev) != NULL
12169                         && ppc64_elf_section_data (prev)->has_14bit_branch
12170                         ? (group_size = stub_group_size >> 10) : group_size))
12171                  && htab->sec_info[prev->id].toc_off == curr_toc)
12172             curr = prev;
12173
12174           /* OK, the size from the start of CURR to the end is less
12175              than group_size and thus can be handled by one stub
12176              section.  (or the tail section is itself larger than
12177              group_size, in which case we may be toast.)  We should
12178              really be keeping track of the total size of stubs added
12179              here, as stubs contribute to the final output section
12180              size.  That's a little tricky, and this way will only
12181              break if stubs added make the total size more than 2^25,
12182              ie. for the default stub_group_size, if stubs total more
12183              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12184           group = bfd_alloc (curr->owner, sizeof (*group));
12185           if (group == NULL)
12186             return FALSE;
12187           group->link_sec = curr;
12188           group->stub_sec = NULL;
12189           group->needs_save_res = 0;
12190           group->tls_get_addr_opt_bctrl = -1u;
12191           group->next = htab->group;
12192           htab->group = group;
12193           do
12194             {
12195               prev = htab->sec_info[tail->id].u.list;
12196               /* Set up this stub group.  */
12197               htab->sec_info[tail->id].u.group = group;
12198             }
12199           while (tail != curr && (tail = prev) != NULL);
12200
12201           /* But wait, there's more!  Input sections up to group_size
12202              bytes before the stub section can be handled by it too.
12203              Don't do this if we have a really large section after the
12204              stubs, as adding more stubs increases the chance that
12205              branches may not reach into the stub section.  */
12206           if (!stubs_always_before_branch && !big_sec)
12207             {
12208               total = 0;
12209               while (prev != NULL
12210                      && ((total += tail->output_offset - prev->output_offset)
12211                          < (ppc64_elf_section_data (prev) != NULL
12212                             && ppc64_elf_section_data (prev)->has_14bit_branch
12213                             ? (group_size = stub_group_size >> 10) : group_size))
12214                      && htab->sec_info[prev->id].toc_off == curr_toc)
12215                 {
12216                   tail = prev;
12217                   prev = htab->sec_info[tail->id].u.list;
12218                   htab->sec_info[tail->id].u.group = group;
12219                 }
12220             }
12221           tail = prev;
12222         }
12223     }
12224   return TRUE;
12225 }
12226
12227 static const unsigned char glink_eh_frame_cie[] =
12228 {
12229   0, 0, 0, 16,                          /* length.  */
12230   0, 0, 0, 0,                           /* id.  */
12231   1,                                    /* CIE version.  */
12232   'z', 'R', 0,                          /* Augmentation string.  */
12233   4,                                    /* Code alignment.  */
12234   0x78,                                 /* Data alignment.  */
12235   65,                                   /* RA reg.  */
12236   1,                                    /* Augmentation size.  */
12237   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12238   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12239 };
12240
12241 static size_t
12242 stub_eh_frame_size (struct map_stub *group, size_t align)
12243 {
12244   size_t this_size = 17;
12245   if (group->tls_get_addr_opt_bctrl != -1u)
12246     {
12247       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12248       if (to_bctrl < 64)
12249         this_size += 1;
12250       else if (to_bctrl < 256)
12251         this_size += 2;
12252       else if (to_bctrl < 65536)
12253         this_size += 3;
12254       else
12255         this_size += 5;
12256       this_size += 6;
12257     }
12258   this_size = (this_size + align - 1) & -align;
12259   return this_size;
12260 }
12261
12262 /* Stripping output sections is normally done before dynamic section
12263    symbols have been allocated.  This function is called later, and
12264    handles cases like htab->brlt which is mapped to its own output
12265    section.  */
12266
12267 static void
12268 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12269 {
12270   if (isec->size == 0
12271       && isec->output_section->size == 0
12272       && !(isec->output_section->flags & SEC_KEEP)
12273       && !bfd_section_removed_from_list (info->output_bfd,
12274                                          isec->output_section)
12275       && elf_section_data (isec->output_section)->dynindx == 0)
12276     {
12277       isec->output_section->flags |= SEC_EXCLUDE;
12278       bfd_section_list_remove (info->output_bfd, isec->output_section);
12279       info->output_bfd->section_count--;
12280     }
12281 }
12282
12283 /* Determine and set the size of the stub section for a final link.
12284
12285    The basic idea here is to examine all the relocations looking for
12286    PC-relative calls to a target that is unreachable with a "bl"
12287    instruction.  */
12288
12289 bfd_boolean
12290 ppc64_elf_size_stubs (struct bfd_link_info *info)
12291 {
12292   bfd_size_type stub_group_size;
12293   bfd_boolean stubs_always_before_branch;
12294   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12295
12296   if (htab == NULL)
12297     return FALSE;
12298
12299   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12300     htab->params->plt_thread_safe = 1;
12301   if (!htab->opd_abi)
12302     htab->params->plt_thread_safe = 0;
12303   else if (htab->params->plt_thread_safe == -1)
12304     {
12305       static const char *const thread_starter[] =
12306         {
12307           "pthread_create",
12308           /* libstdc++ */
12309           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12310           /* librt */
12311           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12312           "mq_notify", "create_timer",
12313           /* libanl */
12314           "getaddrinfo_a",
12315           /* libgomp */
12316           "GOMP_parallel",
12317           "GOMP_parallel_start",
12318           "GOMP_parallel_loop_static",
12319           "GOMP_parallel_loop_static_start",
12320           "GOMP_parallel_loop_dynamic",
12321           "GOMP_parallel_loop_dynamic_start",
12322           "GOMP_parallel_loop_guided",
12323           "GOMP_parallel_loop_guided_start",
12324           "GOMP_parallel_loop_runtime",
12325           "GOMP_parallel_loop_runtime_start",
12326           "GOMP_parallel_sections",
12327           "GOMP_parallel_sections_start",
12328           /* libgo */
12329           "__go_go",
12330         };
12331       unsigned i;
12332
12333       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12334         {
12335           struct elf_link_hash_entry *h;
12336           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12337                                     FALSE, FALSE, TRUE);
12338           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12339           if (htab->params->plt_thread_safe)
12340             break;
12341         }
12342     }
12343   stubs_always_before_branch = htab->params->group_size < 0;
12344   if (htab->params->group_size < 0)
12345     stub_group_size = -htab->params->group_size;
12346   else
12347     stub_group_size = htab->params->group_size;
12348
12349   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12350     return FALSE;
12351
12352 #define STUB_SHRINK_ITER 20
12353   /* Loop until no stubs added.  After iteration 20 of this loop we may
12354      exit on a stub section shrinking.  This is to break out of a
12355      pathological case where adding stubs on one iteration decreases
12356      section gaps (perhaps due to alignment), which then requires
12357      fewer or smaller stubs on the next iteration.  */
12358
12359   while (1)
12360     {
12361       bfd *input_bfd;
12362       unsigned int bfd_indx;
12363       struct map_stub *group;
12364
12365       htab->stub_iteration += 1;
12366
12367       for (input_bfd = info->input_bfds, bfd_indx = 0;
12368            input_bfd != NULL;
12369            input_bfd = input_bfd->link.next, bfd_indx++)
12370         {
12371           Elf_Internal_Shdr *symtab_hdr;
12372           asection *section;
12373           Elf_Internal_Sym *local_syms = NULL;
12374
12375           if (!is_ppc64_elf (input_bfd))
12376             continue;
12377
12378           /* We'll need the symbol table in a second.  */
12379           symtab_hdr = &elf_symtab_hdr (input_bfd);
12380           if (symtab_hdr->sh_info == 0)
12381             continue;
12382
12383           /* Walk over each section attached to the input bfd.  */
12384           for (section = input_bfd->sections;
12385                section != NULL;
12386                section = section->next)
12387             {
12388               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12389
12390               /* If there aren't any relocs, then there's nothing more
12391                  to do.  */
12392               if ((section->flags & SEC_RELOC) == 0
12393                   || (section->flags & SEC_ALLOC) == 0
12394                   || (section->flags & SEC_LOAD) == 0
12395                   || (section->flags & SEC_CODE) == 0
12396                   || section->reloc_count == 0)
12397                 continue;
12398
12399               /* If this section is a link-once section that will be
12400                  discarded, then don't create any stubs.  */
12401               if (section->output_section == NULL
12402                   || section->output_section->owner != info->output_bfd)
12403                 continue;
12404
12405               /* Get the relocs.  */
12406               internal_relocs
12407                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12408                                              info->keep_memory);
12409               if (internal_relocs == NULL)
12410                 goto error_ret_free_local;
12411
12412               /* Now examine each relocation.  */
12413               irela = internal_relocs;
12414               irelaend = irela + section->reloc_count;
12415               for (; irela < irelaend; irela++)
12416                 {
12417                   enum elf_ppc64_reloc_type r_type;
12418                   unsigned int r_indx;
12419                   enum ppc_stub_type stub_type;
12420                   struct ppc_stub_hash_entry *stub_entry;
12421                   asection *sym_sec, *code_sec;
12422                   bfd_vma sym_value, code_value;
12423                   bfd_vma destination;
12424                   unsigned long local_off;
12425                   bfd_boolean ok_dest;
12426                   struct ppc_link_hash_entry *hash;
12427                   struct ppc_link_hash_entry *fdh;
12428                   struct elf_link_hash_entry *h;
12429                   Elf_Internal_Sym *sym;
12430                   char *stub_name;
12431                   const asection *id_sec;
12432                   struct _opd_sec_data *opd;
12433                   struct plt_entry *plt_ent;
12434
12435                   r_type = ELF64_R_TYPE (irela->r_info);
12436                   r_indx = ELF64_R_SYM (irela->r_info);
12437
12438                   if (r_type >= R_PPC64_max)
12439                     {
12440                       bfd_set_error (bfd_error_bad_value);
12441                       goto error_ret_free_internal;
12442                     }
12443
12444                   /* Only look for stubs on branch instructions.  */
12445                   if (r_type != R_PPC64_REL24
12446                       && r_type != R_PPC64_REL14
12447                       && r_type != R_PPC64_REL14_BRTAKEN
12448                       && r_type != R_PPC64_REL14_BRNTAKEN)
12449                     continue;
12450
12451                   /* Now determine the call target, its name, value,
12452                      section.  */
12453                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12454                                   r_indx, input_bfd))
12455                     goto error_ret_free_internal;
12456                   hash = (struct ppc_link_hash_entry *) h;
12457
12458                   ok_dest = FALSE;
12459                   fdh = NULL;
12460                   sym_value = 0;
12461                   if (hash == NULL)
12462                     {
12463                       sym_value = sym->st_value;
12464                       if (sym_sec != NULL
12465                           && sym_sec->output_section != NULL)
12466                         ok_dest = TRUE;
12467                     }
12468                   else if (hash->elf.root.type == bfd_link_hash_defined
12469                            || hash->elf.root.type == bfd_link_hash_defweak)
12470                     {
12471                       sym_value = hash->elf.root.u.def.value;
12472                       if (sym_sec->output_section != NULL)
12473                         ok_dest = TRUE;
12474                     }
12475                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12476                            || hash->elf.root.type == bfd_link_hash_undefined)
12477                     {
12478                       /* Recognise an old ABI func code entry sym, and
12479                          use the func descriptor sym instead if it is
12480                          defined.  */
12481                       if (hash->elf.root.root.string[0] == '.'
12482                           && hash->oh != NULL)
12483                         {
12484                           fdh = ppc_follow_link (hash->oh);
12485                           if (fdh->elf.root.type == bfd_link_hash_defined
12486                               || fdh->elf.root.type == bfd_link_hash_defweak)
12487                             {
12488                               sym_sec = fdh->elf.root.u.def.section;
12489                               sym_value = fdh->elf.root.u.def.value;
12490                               if (sym_sec->output_section != NULL)
12491                                 ok_dest = TRUE;
12492                             }
12493                           else
12494                             fdh = NULL;
12495                         }
12496                     }
12497                   else
12498                     {
12499                       bfd_set_error (bfd_error_bad_value);
12500                       goto error_ret_free_internal;
12501                     }
12502
12503                   destination = 0;
12504                   local_off = 0;
12505                   if (ok_dest)
12506                     {
12507                       sym_value += irela->r_addend;
12508                       destination = (sym_value
12509                                      + sym_sec->output_offset
12510                                      + sym_sec->output_section->vma);
12511                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12512                                                             ? hash->elf.other
12513                                                             : sym->st_other);
12514                     }
12515
12516                   code_sec = sym_sec;
12517                   code_value = sym_value;
12518                   opd = get_opd_info (sym_sec);
12519                   if (opd != NULL)
12520                     {
12521                       bfd_vma dest;
12522
12523                       if (hash == NULL && opd->adjust != NULL)
12524                         {
12525                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12526                           if (adjust == -1)
12527                             continue;
12528                           code_value += adjust;
12529                           sym_value += adjust;
12530                         }
12531                       dest = opd_entry_value (sym_sec, sym_value,
12532                                               &code_sec, &code_value, FALSE);
12533                       if (dest != (bfd_vma) -1)
12534                         {
12535                           destination = dest;
12536                           if (fdh != NULL)
12537                             {
12538                               /* Fixup old ABI sym to point at code
12539                                  entry.  */
12540                               hash->elf.root.type = bfd_link_hash_defweak;
12541                               hash->elf.root.u.def.section = code_sec;
12542                               hash->elf.root.u.def.value = code_value;
12543                             }
12544                         }
12545                     }
12546
12547                   /* Determine what (if any) linker stub is needed.  */
12548                   plt_ent = NULL;
12549                   stub_type = ppc_type_of_stub (section, irela, &hash,
12550                                                 &plt_ent, destination,
12551                                                 local_off);
12552
12553                   if (stub_type != ppc_stub_plt_call)
12554                     {
12555                       /* Check whether we need a TOC adjusting stub.
12556                          Since the linker pastes together pieces from
12557                          different object files when creating the
12558                          _init and _fini functions, it may be that a
12559                          call to what looks like a local sym is in
12560                          fact a call needing a TOC adjustment.  */
12561                       if (code_sec != NULL
12562                           && code_sec->output_section != NULL
12563                           && (htab->sec_info[code_sec->id].toc_off
12564                               != htab->sec_info[section->id].toc_off)
12565                           && (code_sec->has_toc_reloc
12566                               || code_sec->makes_toc_func_call))
12567                         stub_type = ppc_stub_long_branch_r2off;
12568                     }
12569
12570                   if (stub_type == ppc_stub_none)
12571                     continue;
12572
12573                   /* __tls_get_addr calls might be eliminated.  */
12574                   if (stub_type != ppc_stub_plt_call
12575                       && hash != NULL
12576                       && (hash == htab->tls_get_addr
12577                           || hash == htab->tls_get_addr_fd)
12578                       && section->has_tls_reloc
12579                       && irela != internal_relocs)
12580                     {
12581                       /* Get tls info.  */
12582                       unsigned char *tls_mask;
12583
12584                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12585                                          irela - 1, input_bfd))
12586                         goto error_ret_free_internal;
12587                       if ((*tls_mask & TLS_TLS) != 0)
12588                         continue;
12589                     }
12590
12591                   if (stub_type == ppc_stub_plt_call)
12592                     {
12593                       if (!htab->opd_abi
12594                           && htab->params->plt_localentry0 != 0
12595                           && is_elfv2_localentry0 (&hash->elf))
12596                         htab->has_plt_localentry0 = 1;
12597                       else if (irela + 1 < irelaend
12598                                && irela[1].r_offset == irela->r_offset + 4
12599                                && (ELF64_R_TYPE (irela[1].r_info)
12600                                    == R_PPC64_TOCSAVE))
12601                         {
12602                           if (!tocsave_find (htab, INSERT,
12603                                              &local_syms, irela + 1, input_bfd))
12604                             goto error_ret_free_internal;
12605                         }
12606                       else
12607                         stub_type = ppc_stub_plt_call_r2save;
12608                     }
12609
12610                   /* Support for grouping stub sections.  */
12611                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12612
12613                   /* Get the name of this stub.  */
12614                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12615                   if (!stub_name)
12616                     goto error_ret_free_internal;
12617
12618                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12619                                                      stub_name, FALSE, FALSE);
12620                   if (stub_entry != NULL)
12621                     {
12622                       /* The proper stub has already been created.  */
12623                       free (stub_name);
12624                       if (stub_type == ppc_stub_plt_call_r2save)
12625                         stub_entry->stub_type = stub_type;
12626                       continue;
12627                     }
12628
12629                   stub_entry = ppc_add_stub (stub_name, section, info);
12630                   if (stub_entry == NULL)
12631                     {
12632                       free (stub_name);
12633                     error_ret_free_internal:
12634                       if (elf_section_data (section)->relocs == NULL)
12635                         free (internal_relocs);
12636                     error_ret_free_local:
12637                       if (local_syms != NULL
12638                           && (symtab_hdr->contents
12639                               != (unsigned char *) local_syms))
12640                         free (local_syms);
12641                       return FALSE;
12642                     }
12643
12644                   stub_entry->stub_type = stub_type;
12645                   if (stub_type != ppc_stub_plt_call
12646                       && stub_type != ppc_stub_plt_call_r2save)
12647                     {
12648                       stub_entry->target_value = code_value;
12649                       stub_entry->target_section = code_sec;
12650                     }
12651                   else
12652                     {
12653                       stub_entry->target_value = sym_value;
12654                       stub_entry->target_section = sym_sec;
12655                     }
12656                   stub_entry->h = hash;
12657                   stub_entry->plt_ent = plt_ent;
12658                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12659
12660                   if (stub_entry->h != NULL)
12661                     htab->stub_globals += 1;
12662                 }
12663
12664               /* We're done with the internal relocs, free them.  */
12665               if (elf_section_data (section)->relocs != internal_relocs)
12666                 free (internal_relocs);
12667             }
12668
12669           if (local_syms != NULL
12670               && symtab_hdr->contents != (unsigned char *) local_syms)
12671             {
12672               if (!info->keep_memory)
12673                 free (local_syms);
12674               else
12675                 symtab_hdr->contents = (unsigned char *) local_syms;
12676             }
12677         }
12678
12679       /* We may have added some stubs.  Find out the new size of the
12680          stub sections.  */
12681       for (group = htab->group; group != NULL; group = group->next)
12682         if (group->stub_sec != NULL)
12683           {
12684             asection *stub_sec = group->stub_sec;
12685
12686             if (htab->stub_iteration <= STUB_SHRINK_ITER
12687                 || stub_sec->rawsize < stub_sec->size)
12688               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12689               stub_sec->rawsize = stub_sec->size;
12690             stub_sec->size = 0;
12691             stub_sec->reloc_count = 0;
12692             stub_sec->flags &= ~SEC_RELOC;
12693           }
12694
12695       if (htab->stub_iteration <= STUB_SHRINK_ITER
12696           || htab->brlt->rawsize < htab->brlt->size)
12697         htab->brlt->rawsize = htab->brlt->size;
12698       htab->brlt->size = 0;
12699       htab->brlt->reloc_count = 0;
12700       htab->brlt->flags &= ~SEC_RELOC;
12701       if (htab->relbrlt != NULL)
12702         htab->relbrlt->size = 0;
12703
12704       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12705
12706       for (group = htab->group; group != NULL; group = group->next)
12707         if (group->needs_save_res)
12708           group->stub_sec->size += htab->sfpr->size;
12709
12710       if (info->emitrelocations
12711           && htab->glink != NULL && htab->glink->size != 0)
12712         {
12713           htab->glink->reloc_count = 1;
12714           htab->glink->flags |= SEC_RELOC;
12715         }
12716
12717       if (htab->glink_eh_frame != NULL
12718           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12719           && htab->glink_eh_frame->output_section->size > 8)
12720         {
12721           size_t size = 0, align = 4;
12722
12723           for (group = htab->group; group != NULL; group = group->next)
12724             if (group->stub_sec != NULL)
12725               size += stub_eh_frame_size (group, align);
12726           if (htab->glink != NULL && htab->glink->size != 0)
12727             size += (24 + align - 1) & -align;
12728           if (size != 0)
12729             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12730           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12731           size = (size + align - 1) & -align;
12732           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12733           htab->glink_eh_frame->size = size;
12734         }
12735
12736       if (htab->params->plt_stub_align != 0)
12737         for (group = htab->group; group != NULL; group = group->next)
12738           if (group->stub_sec != NULL)
12739             {
12740               int align = abs (htab->params->plt_stub_align);
12741               group->stub_sec->size
12742                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
12743             }
12744
12745       for (group = htab->group; group != NULL; group = group->next)
12746         if (group->stub_sec != NULL
12747             && group->stub_sec->rawsize != group->stub_sec->size
12748             && (htab->stub_iteration <= STUB_SHRINK_ITER
12749                 || group->stub_sec->rawsize < group->stub_sec->size))
12750           break;
12751
12752       if (group == NULL
12753           && (htab->brlt->rawsize == htab->brlt->size
12754               || (htab->stub_iteration > STUB_SHRINK_ITER
12755                   && htab->brlt->rawsize > htab->brlt->size))
12756           && (htab->glink_eh_frame == NULL
12757               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12758         break;
12759
12760       /* Ask the linker to do its stuff.  */
12761       (*htab->params->layout_sections_again) ();
12762     }
12763
12764   if (htab->glink_eh_frame != NULL
12765       && htab->glink_eh_frame->size != 0)
12766     {
12767       bfd_vma val;
12768       bfd_byte *p, *last_fde;
12769       size_t last_fde_len, size, align, pad;
12770       struct map_stub *group;
12771
12772       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12773       if (p == NULL)
12774         return FALSE;
12775       htab->glink_eh_frame->contents = p;
12776       last_fde = p;
12777       align = 4;
12778
12779       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12780       /* CIE length (rewrite in case little-endian).  */
12781       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12782       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12783       p += last_fde_len + 4;
12784
12785       for (group = htab->group; group != NULL; group = group->next)
12786         if (group->stub_sec != NULL)
12787           {
12788             last_fde = p;
12789             last_fde_len = stub_eh_frame_size (group, align) - 4;
12790             /* FDE length.  */
12791             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12792             p += 4;
12793             /* CIE pointer.  */
12794             val = p - htab->glink_eh_frame->contents;
12795             bfd_put_32 (htab->elf.dynobj, val, p);
12796             p += 4;
12797             /* Offset to stub section, written later.  */
12798             p += 4;
12799             /* stub section size.  */
12800             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12801             p += 4;
12802             /* Augmentation.  */
12803             p += 1;
12804             if (group->tls_get_addr_opt_bctrl != -1u)
12805               {
12806                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12807
12808                 /* This FDE needs more than just the default.
12809                    Describe __tls_get_addr_opt stub LR.  */
12810                 if (to_bctrl < 64)
12811                   *p++ = DW_CFA_advance_loc + to_bctrl;
12812                 else if (to_bctrl < 256)
12813                   {
12814                     *p++ = DW_CFA_advance_loc1;
12815                     *p++ = to_bctrl;
12816                   }
12817                 else if (to_bctrl < 65536)
12818                   {
12819                     *p++ = DW_CFA_advance_loc2;
12820                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12821                     p += 2;
12822                   }
12823                 else
12824                   {
12825                     *p++ = DW_CFA_advance_loc4;
12826                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12827                     p += 4;
12828                   }
12829                 *p++ = DW_CFA_offset_extended_sf;
12830                 *p++ = 65;
12831                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12832                 *p++ = DW_CFA_advance_loc + 4;
12833                 *p++ = DW_CFA_restore_extended;
12834                 *p++ = 65;
12835               }
12836             /* Pad.  */
12837             p = last_fde + last_fde_len + 4;
12838           }
12839       if (htab->glink != NULL && htab->glink->size != 0)
12840         {
12841           last_fde = p;
12842           last_fde_len = ((24 + align - 1) & -align) - 4;
12843           /* FDE length.  */
12844           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12845           p += 4;
12846           /* CIE pointer.  */
12847           val = p - htab->glink_eh_frame->contents;
12848           bfd_put_32 (htab->elf.dynobj, val, p);
12849           p += 4;
12850           /* Offset to .glink, written later.  */
12851           p += 4;
12852           /* .glink size.  */
12853           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12854           p += 4;
12855           /* Augmentation.  */
12856           p += 1;
12857
12858           *p++ = DW_CFA_advance_loc + 1;
12859           *p++ = DW_CFA_register;
12860           *p++ = 65;
12861           *p++ = htab->opd_abi ? 12 : 0;
12862           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12863           *p++ = DW_CFA_restore_extended;
12864           *p++ = 65;
12865           p += ((24 + align - 1) & -align) - 24;
12866         }
12867       /* Subsume any padding into the last FDE if user .eh_frame
12868          sections are aligned more than glink_eh_frame.  Otherwise any
12869          zero padding will be seen as a terminator.  */
12870       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12871       size = p - htab->glink_eh_frame->contents;
12872       pad = ((size + align - 1) & -align) - size;
12873       htab->glink_eh_frame->size = size + pad;
12874       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12875     }
12876
12877   maybe_strip_output (info, htab->brlt);
12878   if (htab->glink_eh_frame != NULL)
12879     maybe_strip_output (info, htab->glink_eh_frame);
12880
12881   return TRUE;
12882 }
12883
12884 /* Called after we have determined section placement.  If sections
12885    move, we'll be called again.  Provide a value for TOCstart.  */
12886
12887 bfd_vma
12888 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12889 {
12890   asection *s;
12891   bfd_vma TOCstart, adjust;
12892
12893   if (info != NULL)
12894     {
12895       struct elf_link_hash_entry *h;
12896       struct elf_link_hash_table *htab = elf_hash_table (info);
12897
12898       if (is_elf_hash_table (htab)
12899           && htab->hgot != NULL)
12900         h = htab->hgot;
12901       else
12902         {
12903           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12904           if (is_elf_hash_table (htab))
12905             htab->hgot = h;
12906         }
12907       if (h != NULL
12908           && h->root.type == bfd_link_hash_defined
12909           && !h->root.linker_def
12910           && (!is_elf_hash_table (htab)
12911               || h->def_regular))
12912         {
12913           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12914                       + h->root.u.def.section->output_offset
12915                       + h->root.u.def.section->output_section->vma);
12916           _bfd_set_gp_value (obfd, TOCstart);
12917           return TOCstart;
12918         }
12919     }
12920
12921   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12922      order.  The TOC starts where the first of these sections starts.  */
12923   s = bfd_get_section_by_name (obfd, ".got");
12924   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12925     s = bfd_get_section_by_name (obfd, ".toc");
12926   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12927     s = bfd_get_section_by_name (obfd, ".tocbss");
12928   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12929     s = bfd_get_section_by_name (obfd, ".plt");
12930   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12931     {
12932       /* This may happen for
12933          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12934          .toc directive
12935          o  bad linker script
12936          o --gc-sections and empty TOC sections
12937
12938          FIXME: Warn user?  */
12939
12940       /* Look for a likely section.  We probably won't even be
12941          using TOCstart.  */
12942       for (s = obfd->sections; s != NULL; s = s->next)
12943         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12944                          | SEC_EXCLUDE))
12945             == (SEC_ALLOC | SEC_SMALL_DATA))
12946           break;
12947       if (s == NULL)
12948         for (s = obfd->sections; s != NULL; s = s->next)
12949           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12950               == (SEC_ALLOC | SEC_SMALL_DATA))
12951             break;
12952       if (s == NULL)
12953         for (s = obfd->sections; s != NULL; s = s->next)
12954           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12955               == SEC_ALLOC)
12956             break;
12957       if (s == NULL)
12958         for (s = obfd->sections; s != NULL; s = s->next)
12959           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12960             break;
12961     }
12962
12963   TOCstart = 0;
12964   if (s != NULL)
12965     TOCstart = s->output_section->vma + s->output_offset;
12966
12967   /* Force alignment.  */
12968   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12969   TOCstart -= adjust;
12970   _bfd_set_gp_value (obfd, TOCstart);
12971
12972   if (info != NULL && s != NULL)
12973     {
12974       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12975
12976       if (htab != NULL)
12977         {
12978           if (htab->elf.hgot != NULL)
12979             {
12980               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12981               htab->elf.hgot->root.u.def.section = s;
12982             }
12983         }
12984       else
12985         {
12986           struct bfd_link_hash_entry *bh = NULL;
12987           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12988                                             s, TOC_BASE_OFF - adjust,
12989                                             NULL, FALSE, FALSE, &bh);
12990         }
12991     }
12992   return TOCstart;
12993 }
12994
12995 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12996    write out any global entry stubs, and PLT relocations.  */
12997
12998 static bfd_boolean
12999 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13000 {
13001   struct bfd_link_info *info;
13002   struct ppc_link_hash_table *htab;
13003   struct plt_entry *ent;
13004   asection *s;
13005
13006   if (h->root.type == bfd_link_hash_indirect)
13007     return TRUE;
13008
13009   info = inf;
13010   htab = ppc_hash_table (info);
13011   if (htab == NULL)
13012     return FALSE;
13013
13014   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13015     if (ent->plt.offset != (bfd_vma) -1)
13016       {
13017         /* This symbol has an entry in the procedure linkage
13018            table.  Set it up.  */
13019         Elf_Internal_Rela rela;
13020         bfd_byte *loc;
13021
13022         if (!htab->elf.dynamic_sections_created
13023             || h->dynindx == -1)
13024           {
13025             if (!(h->def_regular
13026                   && (h->root.type == bfd_link_hash_defined
13027                       || h->root.type == bfd_link_hash_defweak)))
13028               continue;
13029             rela.r_offset = (htab->elf.iplt->output_section->vma
13030                              + htab->elf.iplt->output_offset
13031                              + ent->plt.offset);
13032             if (htab->opd_abi)
13033               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13034             else
13035               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13036             rela.r_addend = (h->root.u.def.value
13037                              + h->root.u.def.section->output_offset
13038                              + h->root.u.def.section->output_section->vma
13039                              + ent->addend);
13040             loc = (htab->elf.irelplt->contents
13041                    + (htab->elf.irelplt->reloc_count++
13042                       * sizeof (Elf64_External_Rela)));
13043             htab->local_ifunc_resolver = 1;
13044           }
13045         else
13046           {
13047             rela.r_offset = (htab->elf.splt->output_section->vma
13048                              + htab->elf.splt->output_offset
13049                              + ent->plt.offset);
13050             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13051             rela.r_addend = ent->addend;
13052             loc = (htab->elf.srelplt->contents
13053                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13054                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13055             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13056               htab->maybe_local_ifunc_resolver = 1;
13057           }
13058         bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13059       }
13060
13061   if (!h->pointer_equality_needed)
13062     return TRUE;
13063
13064   if (h->def_regular)
13065     return TRUE;
13066
13067   s = htab->global_entry;
13068   if (s == NULL || s->size == 0)
13069     return TRUE;
13070
13071   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13072     if (ent->plt.offset != (bfd_vma) -1
13073         && ent->addend == 0)
13074       {
13075         bfd_byte *p;
13076         asection *plt;
13077         bfd_vma off;
13078
13079         p = s->contents + h->root.u.def.value;
13080         plt = htab->elf.splt;
13081         if (!htab->elf.dynamic_sections_created
13082             || h->dynindx == -1)
13083           plt = htab->elf.iplt;
13084         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13085         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13086
13087         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13088           {
13089             info->callbacks->einfo
13090               (_("%P: linkage table error against `%pT'\n"),
13091                h->root.root.string);
13092             bfd_set_error (bfd_error_bad_value);
13093             htab->stub_error = TRUE;
13094           }
13095
13096         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13097         if (htab->params->emit_stub_syms)
13098           {
13099             size_t len = strlen (h->root.root.string);
13100             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13101
13102             if (name == NULL)
13103               return FALSE;
13104
13105             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13106             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13107             if (h == NULL)
13108               return FALSE;
13109             if (h->root.type == bfd_link_hash_new)
13110               {
13111                 h->root.type = bfd_link_hash_defined;
13112                 h->root.u.def.section = s;
13113                 h->root.u.def.value = p - s->contents;
13114                 h->ref_regular = 1;
13115                 h->def_regular = 1;
13116                 h->ref_regular_nonweak = 1;
13117                 h->forced_local = 1;
13118                 h->non_elf = 0;
13119                 h->root.linker_def = 1;
13120               }
13121           }
13122
13123         if (PPC_HA (off) != 0)
13124           {
13125             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13126             p += 4;
13127           }
13128         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13129         p += 4;
13130         bfd_put_32 (s->owner, MTCTR_R12, p);
13131         p += 4;
13132         bfd_put_32 (s->owner, BCTR, p);
13133         break;
13134       }
13135   return TRUE;
13136 }
13137
13138 /* Write PLT relocs for locals.  */
13139
13140 static bfd_boolean
13141 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13142 {
13143   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13144   bfd *ibfd;
13145
13146   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13147     {
13148       struct got_entry **lgot_ents, **end_lgot_ents;
13149       struct plt_entry **local_plt, **lplt, **end_local_plt;
13150       Elf_Internal_Shdr *symtab_hdr;
13151       bfd_size_type locsymcount;
13152       Elf_Internal_Sym *local_syms = NULL;
13153       struct plt_entry *ent;
13154
13155       if (!is_ppc64_elf (ibfd))
13156         continue;
13157
13158       lgot_ents = elf_local_got_ents (ibfd);
13159       if (!lgot_ents)
13160         continue;
13161
13162       symtab_hdr = &elf_symtab_hdr (ibfd);
13163       locsymcount = symtab_hdr->sh_info;
13164       end_lgot_ents = lgot_ents + locsymcount;
13165       local_plt = (struct plt_entry **) end_lgot_ents;
13166       end_local_plt = local_plt + locsymcount;
13167       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13168         for (ent = *lplt; ent != NULL; ent = ent->next)
13169           if (ent->plt.offset != (bfd_vma) -1)
13170             {
13171               Elf_Internal_Sym *sym;
13172               asection *sym_sec;
13173               asection *plt, *relplt;
13174               bfd_byte *loc;
13175               bfd_vma val;
13176               Elf_Internal_Rela rela;
13177
13178               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13179                               lplt - local_plt, ibfd))
13180                 {
13181                   if (local_syms != NULL
13182                       && symtab_hdr->contents != (unsigned char *) local_syms)
13183                     free (local_syms);
13184                   return FALSE;
13185                 }
13186
13187               val = sym->st_value + ent->addend;
13188               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13189               if (sym_sec != NULL && sym_sec->output_section != NULL)
13190                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13191
13192               BFD_ASSERT (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13193
13194               htab->local_ifunc_resolver = 1;
13195               plt = htab->elf.iplt;
13196               relplt = htab->elf.irelplt;
13197
13198               rela.r_offset = (ent->plt.offset
13199                                + plt->output_offset
13200                                + plt->output_section->vma);
13201               if (htab->opd_abi)
13202                 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13203               else
13204                 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13205               rela.r_addend = val;
13206               loc = relplt->contents + (relplt->reloc_count++
13207                                         * sizeof (Elf64_External_Rela));
13208               bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13209             }
13210
13211       if (local_syms != NULL
13212           && symtab_hdr->contents != (unsigned char *) local_syms)
13213         {
13214           if (!info->keep_memory)
13215             free (local_syms);
13216           else
13217             symtab_hdr->contents = (unsigned char *) local_syms;
13218         }
13219     }
13220   return TRUE;
13221 }
13222
13223 /* Build all the stubs associated with the current output file.
13224    The stubs are kept in a hash table attached to the main linker
13225    hash table.  This function is called via gldelf64ppc_finish.  */
13226
13227 bfd_boolean
13228 ppc64_elf_build_stubs (struct bfd_link_info *info,
13229                        char **stats)
13230 {
13231   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13232   struct map_stub *group;
13233   asection *stub_sec;
13234   bfd_byte *p;
13235   int stub_sec_count = 0;
13236
13237   if (htab == NULL)
13238     return FALSE;
13239
13240   /* Allocate memory to hold the linker stubs.  */
13241   for (group = htab->group; group != NULL; group = group->next)
13242     if ((stub_sec = group->stub_sec) != NULL
13243         && stub_sec->size != 0)
13244       {
13245         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13246         if (stub_sec->contents == NULL)
13247           return FALSE;
13248         stub_sec->size = 0;
13249       }
13250
13251   if (htab->glink != NULL && htab->glink->size != 0)
13252     {
13253       unsigned int indx;
13254       bfd_vma plt0;
13255
13256       /* Build the .glink plt call stub.  */
13257       if (htab->params->emit_stub_syms)
13258         {
13259           struct elf_link_hash_entry *h;
13260           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13261                                     TRUE, FALSE, FALSE);
13262           if (h == NULL)
13263             return FALSE;
13264           if (h->root.type == bfd_link_hash_new)
13265             {
13266               h->root.type = bfd_link_hash_defined;
13267               h->root.u.def.section = htab->glink;
13268               h->root.u.def.value = 8;
13269               h->ref_regular = 1;
13270               h->def_regular = 1;
13271               h->ref_regular_nonweak = 1;
13272               h->forced_local = 1;
13273               h->non_elf = 0;
13274               h->root.linker_def = 1;
13275             }
13276         }
13277       plt0 = (htab->elf.splt->output_section->vma
13278               + htab->elf.splt->output_offset
13279               - 16);
13280       if (info->emitrelocations)
13281         {
13282           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13283           if (r == NULL)
13284             return FALSE;
13285           r->r_offset = (htab->glink->output_offset
13286                          + htab->glink->output_section->vma);
13287           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13288           r->r_addend = plt0;
13289         }
13290       p = htab->glink->contents;
13291       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13292       bfd_put_64 (htab->glink->owner, plt0, p);
13293       p += 8;
13294       if (htab->opd_abi)
13295         {
13296           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13297           p += 4;
13298           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13299           p += 4;
13300           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13301           p += 4;
13302           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13303           p += 4;
13304           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13305           p += 4;
13306           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13307           p += 4;
13308           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13309           p += 4;
13310           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13311           p += 4;
13312           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13313           p += 4;
13314           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13315           p += 4;
13316         }
13317       else
13318         {
13319           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13320           p += 4;
13321           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13322           p += 4;
13323           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13324           p += 4;
13325           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13326           p += 4;
13327           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13328           p += 4;
13329           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13330           p += 4;
13331           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13332           p += 4;
13333           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13334           p += 4;
13335           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13336           p += 4;
13337           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13338           p += 4;
13339           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13340           p += 4;
13341           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13342           p += 4;
13343           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13344           p += 4;
13345         }
13346       bfd_put_32 (htab->glink->owner, BCTR, p);
13347       p += 4;
13348       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13349
13350       /* Build the .glink lazy link call stubs.  */
13351       indx = 0;
13352       while (p < htab->glink->contents + htab->glink->size)
13353         {
13354           if (htab->opd_abi)
13355             {
13356               if (indx < 0x8000)
13357                 {
13358                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13359                   p += 4;
13360                 }
13361               else
13362                 {
13363                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13364                   p += 4;
13365                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13366                               p);
13367                   p += 4;
13368                 }
13369             }
13370           bfd_put_32 (htab->glink->owner,
13371                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13372           indx++;
13373           p += 4;
13374         }
13375     }
13376
13377   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13378   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13379
13380   if (!write_plt_relocs_for_local_syms (info))
13381     return FALSE;
13382
13383   if (htab->brlt != NULL && htab->brlt->size != 0)
13384     {
13385       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13386                                          htab->brlt->size);
13387       if (htab->brlt->contents == NULL)
13388         return FALSE;
13389     }
13390   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13391     {
13392       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13393                                             htab->relbrlt->size);
13394       if (htab->relbrlt->contents == NULL)
13395         return FALSE;
13396     }
13397
13398   /* Build the stubs as directed by the stub hash table.  */
13399   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13400
13401   for (group = htab->group; group != NULL; group = group->next)
13402     if (group->needs_save_res)
13403       group->stub_sec->size += htab->sfpr->size;
13404
13405   if (htab->relbrlt != NULL)
13406     htab->relbrlt->reloc_count = 0;
13407
13408   if (htab->params->plt_stub_align != 0)
13409     for (group = htab->group; group != NULL; group = group->next)
13410       if ((stub_sec = group->stub_sec) != NULL)
13411         {
13412           int align = abs (htab->params->plt_stub_align);
13413           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13414         }
13415
13416   for (group = htab->group; group != NULL; group = group->next)
13417     if (group->needs_save_res)
13418       {
13419         stub_sec = group->stub_sec;
13420         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13421                 htab->sfpr->contents, htab->sfpr->size);
13422         if (htab->params->emit_stub_syms)
13423           {
13424             unsigned int i;
13425
13426             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13427               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13428                 return FALSE;
13429           }
13430       }
13431
13432   for (group = htab->group; group != NULL; group = group->next)
13433     if ((stub_sec = group->stub_sec) != NULL)
13434       {
13435         stub_sec_count += 1;
13436         if (stub_sec->rawsize != stub_sec->size
13437             && (htab->stub_iteration <= STUB_SHRINK_ITER
13438                 || stub_sec->rawsize < stub_sec->size))
13439           break;
13440       }
13441
13442   if (group != NULL)
13443     {
13444       htab->stub_error = TRUE;
13445       _bfd_error_handler (_("stubs don't match calculated size"));
13446     }
13447
13448   if (htab->stub_error)
13449     return FALSE;
13450
13451   if (stats != NULL)
13452     {
13453       size_t len;
13454       *stats = bfd_malloc (500);
13455       if (*stats == NULL)
13456         return FALSE;
13457
13458       len = sprintf (*stats,
13459                      ngettext ("linker stubs in %u group\n",
13460                                "linker stubs in %u groups\n",
13461                                stub_sec_count),
13462                      stub_sec_count);
13463       sprintf (*stats + len, _("  branch       %lu\n"
13464                                "  toc adjust   %lu\n"
13465                                "  long branch  %lu\n"
13466                                "  long toc adj %lu\n"
13467                                "  plt call     %lu\n"
13468                                "  plt call toc %lu\n"
13469                                "  global entry %lu"),
13470                htab->stub_count[ppc_stub_long_branch - 1],
13471                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13472                htab->stub_count[ppc_stub_plt_branch - 1],
13473                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13474                htab->stub_count[ppc_stub_plt_call - 1],
13475                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13476                htab->stub_count[ppc_stub_global_entry - 1]);
13477     }
13478   return TRUE;
13479 }
13480
13481 /* What to do when ld finds relocations against symbols defined in
13482    discarded sections.  */
13483
13484 static unsigned int
13485 ppc64_elf_action_discarded (asection *sec)
13486 {
13487   if (strcmp (".opd", sec->name) == 0)
13488     return 0;
13489
13490   if (strcmp (".toc", sec->name) == 0)
13491     return 0;
13492
13493   if (strcmp (".toc1", sec->name) == 0)
13494     return 0;
13495
13496   return _bfd_elf_default_action_discarded (sec);
13497 }
13498
13499 /* The RELOCATE_SECTION function is called by the ELF backend linker
13500    to handle the relocations for a section.
13501
13502    The relocs are always passed as Rela structures; if the section
13503    actually uses Rel structures, the r_addend field will always be
13504    zero.
13505
13506    This function is responsible for adjust the section contents as
13507    necessary, and (if using Rela relocs and generating a
13508    relocatable output file) adjusting the reloc addend as
13509    necessary.
13510
13511    This function does not have to worry about setting the reloc
13512    address or the reloc symbol index.
13513
13514    LOCAL_SYMS is a pointer to the swapped in local symbols.
13515
13516    LOCAL_SECTIONS is an array giving the section in the input file
13517    corresponding to the st_shndx field of each local symbol.
13518
13519    The global hash table entry for the global symbols can be found
13520    via elf_sym_hashes (input_bfd).
13521
13522    When generating relocatable output, this function must handle
13523    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13524    going to be the section symbol corresponding to the output
13525    section, which means that the addend must be adjusted
13526    accordingly.  */
13527
13528 static bfd_boolean
13529 ppc64_elf_relocate_section (bfd *output_bfd,
13530                             struct bfd_link_info *info,
13531                             bfd *input_bfd,
13532                             asection *input_section,
13533                             bfd_byte *contents,
13534                             Elf_Internal_Rela *relocs,
13535                             Elf_Internal_Sym *local_syms,
13536                             asection **local_sections)
13537 {
13538   struct ppc_link_hash_table *htab;
13539   Elf_Internal_Shdr *symtab_hdr;
13540   struct elf_link_hash_entry **sym_hashes;
13541   Elf_Internal_Rela *rel;
13542   Elf_Internal_Rela *wrel;
13543   Elf_Internal_Rela *relend;
13544   Elf_Internal_Rela outrel;
13545   bfd_byte *loc;
13546   struct got_entry **local_got_ents;
13547   bfd_vma TOCstart;
13548   bfd_boolean ret = TRUE;
13549   bfd_boolean is_opd;
13550   /* Assume 'at' branch hints.  */
13551   bfd_boolean is_isa_v2 = TRUE;
13552   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13553
13554   /* Initialize howto table if needed.  */
13555   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13556     ppc_howto_init ();
13557
13558   htab = ppc_hash_table (info);
13559   if (htab == NULL)
13560     return FALSE;
13561
13562   /* Don't relocate stub sections.  */
13563   if (input_section->owner == htab->params->stub_bfd)
13564     return TRUE;
13565
13566   BFD_ASSERT (is_ppc64_elf (input_bfd));
13567
13568   local_got_ents = elf_local_got_ents (input_bfd);
13569   TOCstart = elf_gp (output_bfd);
13570   symtab_hdr = &elf_symtab_hdr (input_bfd);
13571   sym_hashes = elf_sym_hashes (input_bfd);
13572   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13573
13574   rel = wrel = relocs;
13575   relend = relocs + input_section->reloc_count;
13576   for (; rel < relend; wrel++, rel++)
13577     {
13578       enum elf_ppc64_reloc_type r_type;
13579       bfd_vma addend;
13580       bfd_reloc_status_type r;
13581       Elf_Internal_Sym *sym;
13582       asection *sec;
13583       struct elf_link_hash_entry *h_elf;
13584       struct ppc_link_hash_entry *h;
13585       struct ppc_link_hash_entry *fdh;
13586       const char *sym_name;
13587       unsigned long r_symndx, toc_symndx;
13588       bfd_vma toc_addend;
13589       unsigned char tls_mask, tls_gd, tls_type;
13590       unsigned char sym_type;
13591       bfd_vma relocation;
13592       bfd_boolean unresolved_reloc;
13593       bfd_boolean warned;
13594       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13595       unsigned int insn;
13596       unsigned int mask;
13597       struct ppc_stub_hash_entry *stub_entry;
13598       bfd_vma max_br_offset;
13599       bfd_vma from;
13600       Elf_Internal_Rela orig_rel;
13601       reloc_howto_type *howto;
13602       struct reloc_howto_struct alt_howto;
13603
13604     again:
13605       orig_rel = *rel;
13606
13607       r_type = ELF64_R_TYPE (rel->r_info);
13608       r_symndx = ELF64_R_SYM (rel->r_info);
13609
13610       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13611          symbol of the previous ADDR64 reloc.  The symbol gives us the
13612          proper TOC base to use.  */
13613       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13614           && wrel != relocs
13615           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13616           && is_opd)
13617         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13618
13619       sym = NULL;
13620       sec = NULL;
13621       h_elf = NULL;
13622       sym_name = NULL;
13623       unresolved_reloc = FALSE;
13624       warned = FALSE;
13625
13626       if (r_symndx < symtab_hdr->sh_info)
13627         {
13628           /* It's a local symbol.  */
13629           struct _opd_sec_data *opd;
13630
13631           sym = local_syms + r_symndx;
13632           sec = local_sections[r_symndx];
13633           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13634           sym_type = ELF64_ST_TYPE (sym->st_info);
13635           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13636           opd = get_opd_info (sec);
13637           if (opd != NULL && opd->adjust != NULL)
13638             {
13639               long adjust = opd->adjust[OPD_NDX (sym->st_value
13640                                                  + rel->r_addend)];
13641               if (adjust == -1)
13642                 relocation = 0;
13643               else
13644                 {
13645                   /* If this is a relocation against the opd section sym
13646                      and we have edited .opd, adjust the reloc addend so
13647                      that ld -r and ld --emit-relocs output is correct.
13648                      If it is a reloc against some other .opd symbol,
13649                      then the symbol value will be adjusted later.  */
13650                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13651                     rel->r_addend += adjust;
13652                   else
13653                     relocation += adjust;
13654                 }
13655             }
13656         }
13657       else
13658         {
13659           bfd_boolean ignored;
13660
13661           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13662                                    r_symndx, symtab_hdr, sym_hashes,
13663                                    h_elf, sec, relocation,
13664                                    unresolved_reloc, warned, ignored);
13665           sym_name = h_elf->root.root.string;
13666           sym_type = h_elf->type;
13667           if (sec != NULL
13668               && sec->owner == output_bfd
13669               && strcmp (sec->name, ".opd") == 0)
13670             {
13671               /* This is a symbol defined in a linker script.  All
13672                  such are defined in output sections, even those
13673                  defined by simple assignment from a symbol defined in
13674                  an input section.  Transfer the symbol to an
13675                  appropriate input .opd section, so that a branch to
13676                  this symbol will be mapped to the location specified
13677                  by the opd entry.  */
13678               struct bfd_link_order *lo;
13679               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13680                 if (lo->type == bfd_indirect_link_order)
13681                   {
13682                     asection *isec = lo->u.indirect.section;
13683                     if (h_elf->root.u.def.value >= isec->output_offset
13684                         && h_elf->root.u.def.value < (isec->output_offset
13685                                                       + isec->size))
13686                       {
13687                         h_elf->root.u.def.value -= isec->output_offset;
13688                         h_elf->root.u.def.section = isec;
13689                         sec = isec;
13690                         break;
13691                       }
13692                   }
13693             }
13694         }
13695       h = (struct ppc_link_hash_entry *) h_elf;
13696
13697       if (sec != NULL && discarded_section (sec))
13698         {
13699           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13700                                input_bfd, input_section,
13701                                contents + rel->r_offset);
13702           wrel->r_offset = rel->r_offset;
13703           wrel->r_info = 0;
13704           wrel->r_addend = 0;
13705
13706           /* For ld -r, remove relocations in debug sections against
13707              symbols defined in discarded sections.  Not done for
13708              non-debug to preserve relocs in .eh_frame which the
13709              eh_frame editing code expects to be present.  */
13710           if (bfd_link_relocatable (info)
13711               && (input_section->flags & SEC_DEBUGGING))
13712             wrel--;
13713
13714           continue;
13715         }
13716
13717       if (bfd_link_relocatable (info))
13718         goto copy_reloc;
13719
13720       if (h != NULL && &h->elf == htab->elf.hgot)
13721         {
13722           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13723           sec = bfd_abs_section_ptr;
13724           unresolved_reloc = FALSE;
13725         }
13726
13727       /* TLS optimizations.  Replace instruction sequences and relocs
13728          based on information we collected in tls_optimize.  We edit
13729          RELOCS so that --emit-relocs will output something sensible
13730          for the final instruction stream.  */
13731       tls_mask = 0;
13732       tls_gd = 0;
13733       toc_symndx = 0;
13734       if (h != NULL)
13735         tls_mask = h->tls_mask;
13736       else if (local_got_ents != NULL)
13737         {
13738           struct plt_entry **local_plt = (struct plt_entry **)
13739             (local_got_ents + symtab_hdr->sh_info);
13740           unsigned char *lgot_masks = (unsigned char *)
13741             (local_plt + symtab_hdr->sh_info);
13742           tls_mask = lgot_masks[r_symndx];
13743         }
13744       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
13745           && (r_type == R_PPC64_TLS
13746               || r_type == R_PPC64_TLSGD
13747               || r_type == R_PPC64_TLSLD))
13748         {
13749           /* Check for toc tls entries.  */
13750           unsigned char *toc_tls;
13751
13752           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13753                              &local_syms, rel, input_bfd))
13754             return FALSE;
13755
13756           if (toc_tls)
13757             tls_mask = *toc_tls;
13758         }
13759
13760       /* Check that tls relocs are used with tls syms, and non-tls
13761          relocs are used with non-tls syms.  */
13762       if (r_symndx != STN_UNDEF
13763           && r_type != R_PPC64_NONE
13764           && (h == NULL
13765               || h->elf.root.type == bfd_link_hash_defined
13766               || h->elf.root.type == bfd_link_hash_defweak)
13767           && (IS_PPC64_TLS_RELOC (r_type)
13768               != (sym_type == STT_TLS
13769                   || (sym_type == STT_SECTION
13770                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13771         {
13772           if ((tls_mask & TLS_TLS) != 0
13773               && (r_type == R_PPC64_TLS
13774                   || r_type == R_PPC64_TLSGD
13775                   || r_type == R_PPC64_TLSLD))
13776             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13777             ;
13778           else
13779             info->callbacks->einfo
13780               (!IS_PPC64_TLS_RELOC (r_type)
13781                /* xgettext:c-format */
13782                ? _("%H: %s used with TLS symbol `%pT'\n")
13783                /* xgettext:c-format */
13784                : _("%H: %s used with non-TLS symbol `%pT'\n"),
13785                input_bfd, input_section, rel->r_offset,
13786                ppc64_elf_howto_table[r_type]->name,
13787                sym_name);
13788         }
13789
13790       /* Ensure reloc mapping code below stays sane.  */
13791       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13792           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13793           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13794           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13795           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13796           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13797           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13798           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13799           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13800           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13801         abort ();
13802
13803       switch (r_type)
13804         {
13805         default:
13806           break;
13807
13808         case R_PPC64_LO_DS_OPT:
13809           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13810           if ((insn & (0x3f << 26)) != 58u << 26)
13811             abort ();
13812           insn += (14u << 26) - (58u << 26);
13813           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13814           r_type = R_PPC64_TOC16_LO;
13815           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13816           break;
13817
13818         case R_PPC64_TOC16:
13819         case R_PPC64_TOC16_LO:
13820         case R_PPC64_TOC16_DS:
13821         case R_PPC64_TOC16_LO_DS:
13822           {
13823             /* Check for toc tls entries.  */
13824             unsigned char *toc_tls;
13825             int retval;
13826
13827             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13828                                    &local_syms, rel, input_bfd);
13829             if (retval == 0)
13830               return FALSE;
13831
13832             if (toc_tls)
13833               {
13834                 tls_mask = *toc_tls;
13835                 if (r_type == R_PPC64_TOC16_DS
13836                     || r_type == R_PPC64_TOC16_LO_DS)
13837                   {
13838                     if ((tls_mask & TLS_TLS) != 0
13839                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13840                       goto toctprel;
13841                   }
13842                 else
13843                   {
13844                     /* If we found a GD reloc pair, then we might be
13845                        doing a GD->IE transition.  */
13846                     if (retval == 2)
13847                       {
13848                         tls_gd = TLS_TPRELGD;
13849                         if ((tls_mask & TLS_TLS) != 0
13850                             && (tls_mask & TLS_GD) == 0)
13851                           goto tls_ldgd_opt;
13852                       }
13853                     else if (retval == 3)
13854                       {
13855                         if ((tls_mask & TLS_TLS) != 0
13856                             && (tls_mask & TLS_LD) == 0)
13857                           goto tls_ldgd_opt;
13858                       }
13859                   }
13860               }
13861           }
13862           break;
13863
13864         case R_PPC64_GOT_TPREL16_HI:
13865         case R_PPC64_GOT_TPREL16_HA:
13866           if ((tls_mask & TLS_TLS) != 0
13867               && (tls_mask & TLS_TPREL) == 0)
13868             {
13869               rel->r_offset -= d_offset;
13870               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13871               r_type = R_PPC64_NONE;
13872               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13873             }
13874           break;
13875
13876         case R_PPC64_GOT_TPREL16_DS:
13877         case R_PPC64_GOT_TPREL16_LO_DS:
13878           if ((tls_mask & TLS_TLS) != 0
13879               && (tls_mask & TLS_TPREL) == 0)
13880             {
13881             toctprel:
13882               insn = bfd_get_32 (input_bfd,
13883                                  contents + rel->r_offset - d_offset);
13884               insn &= 31 << 21;
13885               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13886               bfd_put_32 (input_bfd, insn,
13887                           contents + rel->r_offset - d_offset);
13888               r_type = R_PPC64_TPREL16_HA;
13889               if (toc_symndx != 0)
13890                 {
13891                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13892                   rel->r_addend = toc_addend;
13893                   /* We changed the symbol.  Start over in order to
13894                      get h, sym, sec etc. right.  */
13895                   goto again;
13896                 }
13897               else
13898                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13899             }
13900           break;
13901
13902         case R_PPC64_TLS:
13903           if ((tls_mask & TLS_TLS) != 0
13904               && (tls_mask & TLS_TPREL) == 0)
13905             {
13906               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13907               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13908               if (insn == 0)
13909                 abort ();
13910               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13911               /* Was PPC64_TLS which sits on insn boundary, now
13912                  PPC64_TPREL16_LO which is at low-order half-word.  */
13913               rel->r_offset += d_offset;
13914               r_type = R_PPC64_TPREL16_LO;
13915               if (toc_symndx != 0)
13916                 {
13917                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13918                   rel->r_addend = toc_addend;
13919                   /* We changed the symbol.  Start over in order to
13920                      get h, sym, sec etc. right.  */
13921                   goto again;
13922                 }
13923               else
13924                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13925             }
13926           break;
13927
13928         case R_PPC64_GOT_TLSGD16_HI:
13929         case R_PPC64_GOT_TLSGD16_HA:
13930           tls_gd = TLS_TPRELGD;
13931           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
13932             goto tls_gdld_hi;
13933           break;
13934
13935         case R_PPC64_GOT_TLSLD16_HI:
13936         case R_PPC64_GOT_TLSLD16_HA:
13937           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
13938             {
13939             tls_gdld_hi:
13940               if ((tls_mask & tls_gd) != 0)
13941                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13942                           + R_PPC64_GOT_TPREL16_DS);
13943               else
13944                 {
13945                   rel->r_offset -= d_offset;
13946                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13947                   r_type = R_PPC64_NONE;
13948                 }
13949               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13950             }
13951           break;
13952
13953         case R_PPC64_GOT_TLSGD16:
13954         case R_PPC64_GOT_TLSGD16_LO:
13955           tls_gd = TLS_TPRELGD;
13956           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
13957             goto tls_ldgd_opt;
13958           break;
13959
13960         case R_PPC64_GOT_TLSLD16:
13961         case R_PPC64_GOT_TLSLD16_LO:
13962           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
13963             {
13964               unsigned int insn1, insn2;
13965               bfd_vma offset;
13966
13967             tls_ldgd_opt:
13968               offset = (bfd_vma) -1;
13969               /* If not using the newer R_PPC64_TLSGD/LD to mark
13970                  __tls_get_addr calls, we must trust that the call
13971                  stays with its arg setup insns, ie. that the next
13972                  reloc is the __tls_get_addr call associated with
13973                  the current reloc.  Edit both insns.  */
13974               if (input_section->has_tls_get_addr_call
13975                   && rel + 1 < relend
13976                   && branch_reloc_hash_match (input_bfd, rel + 1,
13977                                               htab->tls_get_addr,
13978                                               htab->tls_get_addr_fd))
13979                 offset = rel[1].r_offset;
13980               /* We read the low GOT_TLS (or TOC16) insn because we
13981                  need to keep the destination reg.  It may be
13982                  something other than the usual r3, and moved to r3
13983                  before the call by intervening code.  */
13984               insn1 = bfd_get_32 (input_bfd,
13985                                   contents + rel->r_offset - d_offset);
13986               if ((tls_mask & tls_gd) != 0)
13987                 {
13988                   /* IE */
13989                   insn1 &= (0x1f << 21) | (0x1f << 16);
13990                   insn1 |= 58 << 26;    /* ld */
13991                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13992                   if (offset != (bfd_vma) -1)
13993                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13994                   if ((tls_mask & TLS_EXPLICIT) == 0)
13995                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13996                               + R_PPC64_GOT_TPREL16_DS);
13997                   else
13998                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13999                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14000                 }
14001               else
14002                 {
14003                   /* LE */
14004                   insn1 &= 0x1f << 21;
14005                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14006                   insn2 = 0x38630000;   /* addi 3,3,0 */
14007                   if (tls_gd == 0)
14008                     {
14009                       /* Was an LD reloc.  */
14010                       if (toc_symndx)
14011                         sec = local_sections[toc_symndx];
14012                       for (r_symndx = 0;
14013                            r_symndx < symtab_hdr->sh_info;
14014                            r_symndx++)
14015                         if (local_sections[r_symndx] == sec)
14016                           break;
14017                       if (r_symndx >= symtab_hdr->sh_info)
14018                         r_symndx = STN_UNDEF;
14019                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14020                       if (r_symndx != STN_UNDEF)
14021                         rel->r_addend -= (local_syms[r_symndx].st_value
14022                                           + sec->output_offset
14023                                           + sec->output_section->vma);
14024                     }
14025                   else if (toc_symndx != 0)
14026                     {
14027                       r_symndx = toc_symndx;
14028                       rel->r_addend = toc_addend;
14029                     }
14030                   r_type = R_PPC64_TPREL16_HA;
14031                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14032                   if (offset != (bfd_vma) -1)
14033                     {
14034                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14035                                                     R_PPC64_TPREL16_LO);
14036                       rel[1].r_offset = offset + d_offset;
14037                       rel[1].r_addend = rel->r_addend;
14038                     }
14039                 }
14040               bfd_put_32 (input_bfd, insn1,
14041                           contents + rel->r_offset - d_offset);
14042               if (offset != (bfd_vma) -1)
14043                 bfd_put_32 (input_bfd, insn2, contents + offset);
14044               if ((tls_mask & tls_gd) == 0
14045                   && (tls_gd == 0 || toc_symndx != 0))
14046                 {
14047                   /* We changed the symbol.  Start over in order
14048                      to get h, sym, sec etc. right.  */
14049                   goto again;
14050                 }
14051             }
14052           break;
14053
14054         case R_PPC64_TLSGD:
14055           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14056               && rel + 1 < relend)
14057             {
14058               unsigned int insn2;
14059               bfd_vma offset = rel->r_offset;
14060
14061               if ((tls_mask & TLS_TPRELGD) != 0)
14062                 {
14063                   /* IE */
14064                   r_type = R_PPC64_NONE;
14065                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14066                 }
14067               else
14068                 {
14069                   /* LE */
14070                   if (toc_symndx != 0)
14071                     {
14072                       r_symndx = toc_symndx;
14073                       rel->r_addend = toc_addend;
14074                     }
14075                   r_type = R_PPC64_TPREL16_LO;
14076                   rel->r_offset = offset + d_offset;
14077                   insn2 = 0x38630000;   /* addi 3,3,0 */
14078                 }
14079               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14080               /* Zap the reloc on the _tls_get_addr call too.  */
14081               BFD_ASSERT (offset == rel[1].r_offset);
14082               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14083               bfd_put_32 (input_bfd, insn2, contents + offset);
14084               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14085                 goto again;
14086             }
14087           break;
14088
14089         case R_PPC64_TLSLD:
14090           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14091               && rel + 1 < relend)
14092             {
14093               unsigned int insn2;
14094               bfd_vma offset = rel->r_offset;
14095
14096               if (toc_symndx)
14097                 sec = local_sections[toc_symndx];
14098               for (r_symndx = 0;
14099                    r_symndx < symtab_hdr->sh_info;
14100                    r_symndx++)
14101                 if (local_sections[r_symndx] == sec)
14102                   break;
14103               if (r_symndx >= symtab_hdr->sh_info)
14104                 r_symndx = STN_UNDEF;
14105               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14106               if (r_symndx != STN_UNDEF)
14107                 rel->r_addend -= (local_syms[r_symndx].st_value
14108                                   + sec->output_offset
14109                                   + sec->output_section->vma);
14110
14111               r_type = R_PPC64_TPREL16_LO;
14112               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14113               rel->r_offset = offset + d_offset;
14114               /* Zap the reloc on the _tls_get_addr call too.  */
14115               BFD_ASSERT (offset == rel[1].r_offset);
14116               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14117               insn2 = 0x38630000;       /* addi 3,3,0 */
14118               bfd_put_32 (input_bfd, insn2, contents + offset);
14119               goto again;
14120             }
14121           break;
14122
14123         case R_PPC64_DTPMOD64:
14124           if (rel + 1 < relend
14125               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14126               && rel[1].r_offset == rel->r_offset + 8)
14127             {
14128               if ((tls_mask & TLS_GD) == 0)
14129                 {
14130                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14131                   if ((tls_mask & TLS_TPRELGD) != 0)
14132                     r_type = R_PPC64_TPREL64;
14133                   else
14134                     {
14135                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14136                       r_type = R_PPC64_NONE;
14137                     }
14138                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14139                 }
14140             }
14141           else
14142             {
14143               if ((tls_mask & TLS_LD) == 0)
14144                 {
14145                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14146                   r_type = R_PPC64_NONE;
14147                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14148                 }
14149             }
14150           break;
14151
14152         case R_PPC64_TPREL64:
14153           if ((tls_mask & TLS_TPREL) == 0)
14154             {
14155               r_type = R_PPC64_NONE;
14156               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14157             }
14158           break;
14159
14160         case R_PPC64_ENTRY:
14161           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14162           if (!bfd_link_pic (info)
14163               && !info->traditional_format
14164               && relocation + 0x80008000 <= 0xffffffff)
14165             {
14166               unsigned int insn1, insn2;
14167
14168               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14169               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14170               if ((insn1 & ~0xfffc) == LD_R2_0R12
14171                   && insn2 == ADD_R2_R2_R12)
14172                 {
14173                   bfd_put_32 (input_bfd,
14174                               LIS_R2 + PPC_HA (relocation),
14175                               contents + rel->r_offset);
14176                   bfd_put_32 (input_bfd,
14177                               ADDI_R2_R2 + PPC_LO (relocation),
14178                               contents + rel->r_offset + 4);
14179                 }
14180             }
14181           else
14182             {
14183               relocation -= (rel->r_offset
14184                              + input_section->output_offset
14185                              + input_section->output_section->vma);
14186               if (relocation + 0x80008000 <= 0xffffffff)
14187                 {
14188                   unsigned int insn1, insn2;
14189
14190                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14191                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14192                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14193                       && insn2 == ADD_R2_R2_R12)
14194                     {
14195                       bfd_put_32 (input_bfd,
14196                                   ADDIS_R2_R12 + PPC_HA (relocation),
14197                                   contents + rel->r_offset);
14198                       bfd_put_32 (input_bfd,
14199                                   ADDI_R2_R2 + PPC_LO (relocation),
14200                                   contents + rel->r_offset + 4);
14201                     }
14202                 }
14203             }
14204           break;
14205
14206         case R_PPC64_REL16_HA:
14207           /* If we are generating a non-PIC executable, edit
14208              .  0:      addis 2,12,.TOC.-0b@ha
14209              .          addi 2,2,.TOC.-0b@l
14210              used by ELFv2 global entry points to set up r2, to
14211              .          lis 2,.TOC.@ha
14212              .          addi 2,2,.TOC.@l
14213              if .TOC. is in range.  */
14214           if (!bfd_link_pic (info)
14215               && !info->traditional_format
14216               && !htab->opd_abi
14217               && rel->r_addend == d_offset
14218               && h != NULL && &h->elf == htab->elf.hgot
14219               && rel + 1 < relend
14220               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14221               && rel[1].r_offset == rel->r_offset + 4
14222               && rel[1].r_addend == rel->r_addend + 4
14223               && relocation + 0x80008000 <= 0xffffffff)
14224             {
14225               unsigned int insn1, insn2;
14226               bfd_vma offset = rel->r_offset - d_offset;
14227               insn1 = bfd_get_32 (input_bfd, contents + offset);
14228               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14229               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14230                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14231                 {
14232                   r_type = R_PPC64_ADDR16_HA;
14233                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14234                   rel->r_addend -= d_offset;
14235                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14236                   rel[1].r_addend -= d_offset + 4;
14237                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14238                 }
14239             }
14240           break;
14241         }
14242
14243       /* Handle other relocations that tweak non-addend part of insn.  */
14244       insn = 0;
14245       max_br_offset = 1 << 25;
14246       addend = rel->r_addend;
14247       reloc_dest = DEST_NORMAL;
14248       switch (r_type)
14249         {
14250         default:
14251           break;
14252
14253         case R_PPC64_TOCSAVE:
14254           if (relocation + addend == (rel->r_offset
14255                                       + input_section->output_offset
14256                                       + input_section->output_section->vma)
14257               && tocsave_find (htab, NO_INSERT,
14258                                &local_syms, rel, input_bfd))
14259             {
14260               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14261               if (insn == NOP
14262                   || insn == CROR_151515 || insn == CROR_313131)
14263                 bfd_put_32 (input_bfd,
14264                             STD_R2_0R1 + STK_TOC (htab),
14265                             contents + rel->r_offset);
14266             }
14267           break;
14268
14269           /* Branch taken prediction relocations.  */
14270         case R_PPC64_ADDR14_BRTAKEN:
14271         case R_PPC64_REL14_BRTAKEN:
14272           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14273           /* Fall through.  */
14274
14275           /* Branch not taken prediction relocations.  */
14276         case R_PPC64_ADDR14_BRNTAKEN:
14277         case R_PPC64_REL14_BRNTAKEN:
14278           insn |= bfd_get_32 (input_bfd,
14279                               contents + rel->r_offset) & ~(0x01 << 21);
14280           /* Fall through.  */
14281
14282         case R_PPC64_REL14:
14283           max_br_offset = 1 << 15;
14284           /* Fall through.  */
14285
14286         case R_PPC64_REL24:
14287           /* Calls to functions with a different TOC, such as calls to
14288              shared objects, need to alter the TOC pointer.  This is
14289              done using a linkage stub.  A REL24 branching to these
14290              linkage stubs needs to be followed by a nop, as the nop
14291              will be replaced with an instruction to restore the TOC
14292              base pointer.  */
14293           fdh = h;
14294           if (h != NULL
14295               && h->oh != NULL
14296               && h->oh->is_func_descriptor)
14297             fdh = ppc_follow_link (h->oh);
14298           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14299                                            htab);
14300           if (stub_entry != NULL
14301               && (stub_entry->stub_type == ppc_stub_plt_call
14302                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14303                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14304                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14305             {
14306               bfd_boolean can_plt_call = FALSE;
14307
14308               if (stub_entry->stub_type == ppc_stub_plt_call
14309                   && !htab->opd_abi
14310                   && htab->params->plt_localentry0 != 0
14311                   && is_elfv2_localentry0 (&h->elf))
14312                 {
14313                   /* The function doesn't use or change r2.  */
14314                   can_plt_call = TRUE;
14315                 }
14316
14317               /* All of these stubs may modify r2, so there must be a
14318                  branch and link followed by a nop.  The nop is
14319                  replaced by an insn to restore r2.  */
14320               else if (rel->r_offset + 8 <= input_section->size)
14321                 {
14322                   unsigned long br;
14323
14324                   br = bfd_get_32 (input_bfd,
14325                                    contents + rel->r_offset);
14326                   if ((br & 1) != 0)
14327                     {
14328                       unsigned long nop;
14329
14330                       nop = bfd_get_32 (input_bfd,
14331                                         contents + rel->r_offset + 4);
14332                       if (nop == NOP
14333                           || nop == CROR_151515 || nop == CROR_313131)
14334                         {
14335                           if (h != NULL
14336                               && (h == htab->tls_get_addr_fd
14337                                   || h == htab->tls_get_addr)
14338                               && htab->params->tls_get_addr_opt)
14339                             {
14340                               /* Special stub used, leave nop alone.  */
14341                             }
14342                           else
14343                             bfd_put_32 (input_bfd,
14344                                         LD_R2_0R1 + STK_TOC (htab),
14345                                         contents + rel->r_offset + 4);
14346                           can_plt_call = TRUE;
14347                         }
14348                     }
14349                 }
14350
14351               if (!can_plt_call && h != NULL)
14352                 {
14353                   const char *name = h->elf.root.root.string;
14354
14355                   if (*name == '.')
14356                     ++name;
14357
14358                   if (strncmp (name, "__libc_start_main", 17) == 0
14359                       && (name[17] == 0 || name[17] == '@'))
14360                     {
14361                       /* Allow crt1 branch to go via a toc adjusting
14362                          stub.  Other calls that never return could do
14363                          the same, if we could detect such.  */
14364                       can_plt_call = TRUE;
14365                     }
14366                 }
14367
14368               if (!can_plt_call)
14369                 {
14370                   /* g++ as of 20130507 emits self-calls without a
14371                      following nop.  This is arguably wrong since we
14372                      have conflicting information.  On the one hand a
14373                      global symbol and on the other a local call
14374                      sequence, but don't error for this special case.
14375                      It isn't possible to cheaply verify we have
14376                      exactly such a call.  Allow all calls to the same
14377                      section.  */
14378                   asection *code_sec = sec;
14379
14380                   if (get_opd_info (sec) != NULL)
14381                     {
14382                       bfd_vma off = (relocation + addend
14383                                      - sec->output_section->vma
14384                                      - sec->output_offset);
14385
14386                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14387                     }
14388                   if (code_sec == input_section)
14389                     can_plt_call = TRUE;
14390                 }
14391
14392               if (!can_plt_call)
14393                 {
14394                   if (stub_entry->stub_type == ppc_stub_plt_call
14395                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14396                     info->callbacks->einfo
14397                       /* xgettext:c-format */
14398                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14399                          "recompile with -fPIC\n"),
14400                        input_bfd, input_section, rel->r_offset, sym_name);
14401                   else
14402                     info->callbacks->einfo
14403                       /* xgettext:c-format */
14404                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14405                          "(-mcmodel=small toc adjust stub)\n"),
14406                        input_bfd, input_section, rel->r_offset, sym_name);
14407
14408                   bfd_set_error (bfd_error_bad_value);
14409                   ret = FALSE;
14410                 }
14411
14412               if (can_plt_call
14413                   && (stub_entry->stub_type == ppc_stub_plt_call
14414                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14415                 unresolved_reloc = FALSE;
14416             }
14417
14418           if ((stub_entry == NULL
14419                || stub_entry->stub_type == ppc_stub_long_branch
14420                || stub_entry->stub_type == ppc_stub_plt_branch)
14421               && get_opd_info (sec) != NULL)
14422             {
14423               /* The branch destination is the value of the opd entry. */
14424               bfd_vma off = (relocation + addend
14425                              - sec->output_section->vma
14426                              - sec->output_offset);
14427               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14428               if (dest != (bfd_vma) -1)
14429                 {
14430                   relocation = dest;
14431                   addend = 0;
14432                   reloc_dest = DEST_OPD;
14433                 }
14434             }
14435
14436           /* If the branch is out of reach we ought to have a long
14437              branch stub.  */
14438           from = (rel->r_offset
14439                   + input_section->output_offset
14440                   + input_section->output_section->vma);
14441
14442           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14443                                                   ? fdh->elf.other
14444                                                   : sym->st_other);
14445
14446           if (stub_entry != NULL
14447               && (stub_entry->stub_type == ppc_stub_long_branch
14448                   || stub_entry->stub_type == ppc_stub_plt_branch)
14449               && (r_type == R_PPC64_ADDR14_BRTAKEN
14450                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14451                   || (relocation + addend - from + max_br_offset
14452                       < 2 * max_br_offset)))
14453             /* Don't use the stub if this branch is in range.  */
14454             stub_entry = NULL;
14455
14456           if (stub_entry != NULL)
14457             {
14458               /* Munge up the value and addend so that we call the stub
14459                  rather than the procedure directly.  */
14460               asection *stub_sec = stub_entry->group->stub_sec;
14461
14462               if (stub_entry->stub_type == ppc_stub_save_res)
14463                 relocation += (stub_sec->output_offset
14464                                + stub_sec->output_section->vma
14465                                + stub_sec->size - htab->sfpr->size
14466                                - htab->sfpr->output_offset
14467                                - htab->sfpr->output_section->vma);
14468               else
14469                 relocation = (stub_entry->stub_offset
14470                               + stub_sec->output_offset
14471                               + stub_sec->output_section->vma);
14472               addend = 0;
14473               reloc_dest = DEST_STUB;
14474
14475               if ((stub_entry->stub_type == ppc_stub_plt_call
14476                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14477                   && (ALWAYS_EMIT_R2SAVE
14478                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14479                   && rel + 1 < relend
14480                   && rel[1].r_offset == rel->r_offset + 4
14481                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14482                 relocation += 4;
14483             }
14484
14485           if (insn != 0)
14486             {
14487               if (is_isa_v2)
14488                 {
14489                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14490                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14491                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14492                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14493                     insn |= 0x02 << 21;
14494                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14495                     insn |= 0x08 << 21;
14496                   else
14497                     break;
14498                 }
14499               else
14500                 {
14501                   /* Invert 'y' bit if not the default.  */
14502                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14503                     insn ^= 0x01 << 21;
14504                 }
14505
14506               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14507             }
14508
14509           /* NOP out calls to undefined weak functions.
14510              We can thus call a weak function without first
14511              checking whether the function is defined.  */
14512           else if (h != NULL
14513                    && h->elf.root.type == bfd_link_hash_undefweak
14514                    && h->elf.dynindx == -1
14515                    && r_type == R_PPC64_REL24
14516                    && relocation == 0
14517                    && addend == 0)
14518             {
14519               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14520               goto copy_reloc;
14521             }
14522           break;
14523         }
14524
14525       /* Set `addend'.  */
14526       tls_type = 0;
14527       switch (r_type)
14528         {
14529         default:
14530           /* xgettext:c-format */
14531           _bfd_error_handler (_("%pB: %s unsupported"),
14532                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14533
14534           bfd_set_error (bfd_error_bad_value);
14535           ret = FALSE;
14536           goto copy_reloc;
14537
14538         case R_PPC64_NONE:
14539         case R_PPC64_TLS:
14540         case R_PPC64_TLSGD:
14541         case R_PPC64_TLSLD:
14542         case R_PPC64_TOCSAVE:
14543         case R_PPC64_GNU_VTINHERIT:
14544         case R_PPC64_GNU_VTENTRY:
14545         case R_PPC64_ENTRY:
14546           goto copy_reloc;
14547
14548           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14549              address in the GOT as relocation value instead of the
14550              symbol's value itself.  Also, create a GOT entry for the
14551              symbol and put the symbol value there.  */
14552         case R_PPC64_GOT_TLSGD16:
14553         case R_PPC64_GOT_TLSGD16_LO:
14554         case R_PPC64_GOT_TLSGD16_HI:
14555         case R_PPC64_GOT_TLSGD16_HA:
14556           tls_type = TLS_TLS | TLS_GD;
14557           goto dogot;
14558
14559         case R_PPC64_GOT_TLSLD16:
14560         case R_PPC64_GOT_TLSLD16_LO:
14561         case R_PPC64_GOT_TLSLD16_HI:
14562         case R_PPC64_GOT_TLSLD16_HA:
14563           tls_type = TLS_TLS | TLS_LD;
14564           goto dogot;
14565
14566         case R_PPC64_GOT_TPREL16_DS:
14567         case R_PPC64_GOT_TPREL16_LO_DS:
14568         case R_PPC64_GOT_TPREL16_HI:
14569         case R_PPC64_GOT_TPREL16_HA:
14570           tls_type = TLS_TLS | TLS_TPREL;
14571           goto dogot;
14572
14573         case R_PPC64_GOT_DTPREL16_DS:
14574         case R_PPC64_GOT_DTPREL16_LO_DS:
14575         case R_PPC64_GOT_DTPREL16_HI:
14576         case R_PPC64_GOT_DTPREL16_HA:
14577           tls_type = TLS_TLS | TLS_DTPREL;
14578           goto dogot;
14579
14580         case R_PPC64_GOT16:
14581         case R_PPC64_GOT16_LO:
14582         case R_PPC64_GOT16_HI:
14583         case R_PPC64_GOT16_HA:
14584         case R_PPC64_GOT16_DS:
14585         case R_PPC64_GOT16_LO_DS:
14586         dogot:
14587           {
14588             /* Relocation is to the entry for this symbol in the global
14589                offset table.  */
14590             asection *got;
14591             bfd_vma *offp;
14592             bfd_vma off;
14593             unsigned long indx = 0;
14594             struct got_entry *ent;
14595
14596             if (tls_type == (TLS_TLS | TLS_LD)
14597                 && (h == NULL
14598                     || !h->elf.def_dynamic))
14599               ent = ppc64_tlsld_got (input_bfd);
14600             else
14601               {
14602                 if (h != NULL)
14603                   {
14604                     if (!htab->elf.dynamic_sections_created
14605                         || h->elf.dynindx == -1
14606                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14607                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14608                       /* This is actually a static link, or it is a
14609                          -Bsymbolic link and the symbol is defined
14610                          locally, or the symbol was forced to be local
14611                          because of a version file.  */
14612                       ;
14613                     else
14614                       {
14615                         indx = h->elf.dynindx;
14616                         unresolved_reloc = FALSE;
14617                       }
14618                     ent = h->elf.got.glist;
14619                   }
14620                 else
14621                   {
14622                     if (local_got_ents == NULL)
14623                       abort ();
14624                     ent = local_got_ents[r_symndx];
14625                   }
14626
14627                 for (; ent != NULL; ent = ent->next)
14628                   if (ent->addend == orig_rel.r_addend
14629                       && ent->owner == input_bfd
14630                       && ent->tls_type == tls_type)
14631                     break;
14632               }
14633
14634             if (ent == NULL)
14635               abort ();
14636             if (ent->is_indirect)
14637               ent = ent->got.ent;
14638             offp = &ent->got.offset;
14639             got = ppc64_elf_tdata (ent->owner)->got;
14640             if (got == NULL)
14641               abort ();
14642
14643             /* The offset must always be a multiple of 8.  We use the
14644                least significant bit to record whether we have already
14645                processed this entry.  */
14646             off = *offp;
14647             if ((off & 1) != 0)
14648               off &= ~1;
14649             else
14650               {
14651                 /* Generate relocs for the dynamic linker, except in
14652                    the case of TLSLD where we'll use one entry per
14653                    module.  */
14654                 asection *relgot;
14655                 bfd_boolean ifunc;
14656
14657                 *offp = off | 1;
14658                 relgot = NULL;
14659                 ifunc = (h != NULL
14660                          ? h->elf.type == STT_GNU_IFUNC
14661                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14662                 if (ifunc)
14663                   {
14664                     relgot = htab->elf.irelplt;
14665                     if (indx == 0)
14666                       htab->local_ifunc_resolver = 1;
14667                     else if (is_static_defined (&h->elf))
14668                       htab->maybe_local_ifunc_resolver = 1;
14669                   }
14670                 else if (indx != 0
14671                          || (bfd_link_pic (info)
14672                              && (h == NULL
14673                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14674                                  || (tls_type == (TLS_TLS | TLS_LD)
14675                                      && !h->elf.def_dynamic))
14676                              && !(tls_type == (TLS_TLS | TLS_TPREL)
14677                                   && bfd_link_executable (info)
14678                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14679                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14680                 if (relgot != NULL)
14681                   {
14682                     outrel.r_offset = (got->output_section->vma
14683                                        + got->output_offset
14684                                        + off);
14685                     outrel.r_addend = addend;
14686                     if (tls_type & (TLS_LD | TLS_GD))
14687                       {
14688                         outrel.r_addend = 0;
14689                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14690                         if (tls_type == (TLS_TLS | TLS_GD))
14691                           {
14692                             loc = relgot->contents;
14693                             loc += (relgot->reloc_count++
14694                                     * sizeof (Elf64_External_Rela));
14695                             bfd_elf64_swap_reloca_out (output_bfd,
14696                                                        &outrel, loc);
14697                             outrel.r_offset += 8;
14698                             outrel.r_addend = addend;
14699                             outrel.r_info
14700                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14701                           }
14702                       }
14703                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14704                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14705                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14706                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14707                     else if (indx != 0)
14708                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14709                     else
14710                       {
14711                         if (ifunc)
14712                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14713                         else
14714                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14715
14716                         /* Write the .got section contents for the sake
14717                            of prelink.  */
14718                         loc = got->contents + off;
14719                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14720                                     loc);
14721                       }
14722
14723                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14724                       {
14725                         outrel.r_addend += relocation;
14726                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14727                           {
14728                             if (htab->elf.tls_sec == NULL)
14729                               outrel.r_addend = 0;
14730                             else
14731                               outrel.r_addend -= htab->elf.tls_sec->vma;
14732                           }
14733                       }
14734                     loc = relgot->contents;
14735                     loc += (relgot->reloc_count++
14736                             * sizeof (Elf64_External_Rela));
14737                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14738                   }
14739
14740                 /* Init the .got section contents here if we're not
14741                    emitting a reloc.  */
14742                 else
14743                   {
14744                     relocation += addend;
14745                     if (tls_type != 0)
14746                       {
14747                         if (htab->elf.tls_sec == NULL)
14748                           relocation = 0;
14749                         else
14750                           {
14751                             if (tls_type & TLS_LD)
14752                               relocation = 0;
14753                             else
14754                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14755                             if (tls_type & TLS_TPREL)
14756                               relocation += DTP_OFFSET - TP_OFFSET;
14757                           }
14758
14759                         if (tls_type & (TLS_GD | TLS_LD))
14760                           {
14761                             bfd_put_64 (output_bfd, relocation,
14762                                         got->contents + off + 8);
14763                             relocation = 1;
14764                           }
14765                       }
14766                     bfd_put_64 (output_bfd, relocation,
14767                                 got->contents + off);
14768                   }
14769               }
14770
14771             if (off >= (bfd_vma) -2)
14772               abort ();
14773
14774             relocation = got->output_section->vma + got->output_offset + off;
14775             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14776           }
14777           break;
14778
14779         case R_PPC64_PLT16_HA:
14780         case R_PPC64_PLT16_HI:
14781         case R_PPC64_PLT16_LO:
14782         case R_PPC64_PLT16_LO_DS:
14783         case R_PPC64_PLT32:
14784         case R_PPC64_PLT64:
14785           /* Relocation is to the entry for this symbol in the
14786              procedure linkage table.  */
14787           {
14788             struct plt_entry **plt_list = NULL;
14789             if (h != NULL)
14790               plt_list = &h->elf.plt.plist;
14791             else if (local_got_ents != NULL)
14792               {
14793                 struct plt_entry **local_plt = (struct plt_entry **)
14794                   (local_got_ents + symtab_hdr->sh_info);
14795                 unsigned char *local_got_tls_masks = (unsigned char *)
14796                   (local_plt + symtab_hdr->sh_info);
14797                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14798                   plt_list = local_plt + r_symndx;
14799               }
14800             if (plt_list)
14801               {
14802                 struct plt_entry *ent;
14803
14804                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14805                   if (ent->plt.offset != (bfd_vma) -1
14806                       && ent->addend == orig_rel.r_addend)
14807                     {
14808                       asection *plt;
14809                       bfd_vma got;
14810
14811                       plt = htab->elf.splt;
14812                       if (!htab->elf.dynamic_sections_created
14813                           || h == NULL
14814                           || h->elf.dynindx == -1)
14815                         plt = htab->elf.iplt;
14816                       if (r_type == R_PPC64_PLT16_HA
14817                           || r_type ==R_PPC64_PLT16_HI
14818                           || r_type ==R_PPC64_PLT16_LO
14819                           || r_type ==R_PPC64_PLT16_LO_DS)
14820                         {
14821                           got = (elf_gp (output_bfd)
14822                                  + htab->sec_info[input_section->id].toc_off);
14823                           relocation -= got;
14824                         }
14825                       relocation = (plt->output_section->vma
14826                                     + plt->output_offset
14827                                     + ent->plt.offset);
14828                       addend = 0;
14829                       unresolved_reloc = FALSE;
14830                       break;
14831                     }
14832               }
14833           }
14834           break;
14835
14836         case R_PPC64_TOC:
14837           /* Relocation value is TOC base.  */
14838           relocation = TOCstart;
14839           if (r_symndx == STN_UNDEF)
14840             relocation += htab->sec_info[input_section->id].toc_off;
14841           else if (unresolved_reloc)
14842             ;
14843           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14844             relocation += htab->sec_info[sec->id].toc_off;
14845           else
14846             unresolved_reloc = TRUE;
14847           goto dodyn;
14848
14849           /* TOC16 relocs.  We want the offset relative to the TOC base,
14850              which is the address of the start of the TOC plus 0x8000.
14851              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14852              in this order.  */
14853         case R_PPC64_TOC16:
14854         case R_PPC64_TOC16_LO:
14855         case R_PPC64_TOC16_HI:
14856         case R_PPC64_TOC16_DS:
14857         case R_PPC64_TOC16_LO_DS:
14858         case R_PPC64_TOC16_HA:
14859           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14860           break;
14861
14862           /* Relocate against the beginning of the section.  */
14863         case R_PPC64_SECTOFF:
14864         case R_PPC64_SECTOFF_LO:
14865         case R_PPC64_SECTOFF_HI:
14866         case R_PPC64_SECTOFF_DS:
14867         case R_PPC64_SECTOFF_LO_DS:
14868         case R_PPC64_SECTOFF_HA:
14869           if (sec != NULL)
14870             addend -= sec->output_section->vma;
14871           break;
14872
14873         case R_PPC64_REL16:
14874         case R_PPC64_REL16_LO:
14875         case R_PPC64_REL16_HI:
14876         case R_PPC64_REL16_HA:
14877         case R_PPC64_REL16DX_HA:
14878           break;
14879
14880         case R_PPC64_REL14:
14881         case R_PPC64_REL14_BRNTAKEN:
14882         case R_PPC64_REL14_BRTAKEN:
14883         case R_PPC64_REL24:
14884           break;
14885
14886         case R_PPC64_TPREL16:
14887         case R_PPC64_TPREL16_LO:
14888         case R_PPC64_TPREL16_HI:
14889         case R_PPC64_TPREL16_HA:
14890         case R_PPC64_TPREL16_DS:
14891         case R_PPC64_TPREL16_LO_DS:
14892         case R_PPC64_TPREL16_HIGH:
14893         case R_PPC64_TPREL16_HIGHA:
14894         case R_PPC64_TPREL16_HIGHER:
14895         case R_PPC64_TPREL16_HIGHERA:
14896         case R_PPC64_TPREL16_HIGHEST:
14897         case R_PPC64_TPREL16_HIGHESTA:
14898           if (h != NULL
14899               && h->elf.root.type == bfd_link_hash_undefweak
14900               && h->elf.dynindx == -1)
14901             {
14902               /* Make this relocation against an undefined weak symbol
14903                  resolve to zero.  This is really just a tweak, since
14904                  code using weak externs ought to check that they are
14905                  defined before using them.  */
14906               bfd_byte *p = contents + rel->r_offset - d_offset;
14907
14908               insn = bfd_get_32 (input_bfd, p);
14909               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14910               if (insn != 0)
14911                 bfd_put_32 (input_bfd, insn, p);
14912               break;
14913             }
14914           if (htab->elf.tls_sec != NULL)
14915             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14916           /* The TPREL16 relocs shouldn't really be used in shared
14917              libs or with non-local symbols as that will result in
14918              DT_TEXTREL being set, but support them anyway.  */
14919           goto dodyn;
14920
14921         case R_PPC64_DTPREL16:
14922         case R_PPC64_DTPREL16_LO:
14923         case R_PPC64_DTPREL16_HI:
14924         case R_PPC64_DTPREL16_HA:
14925         case R_PPC64_DTPREL16_DS:
14926         case R_PPC64_DTPREL16_LO_DS:
14927         case R_PPC64_DTPREL16_HIGH:
14928         case R_PPC64_DTPREL16_HIGHA:
14929         case R_PPC64_DTPREL16_HIGHER:
14930         case R_PPC64_DTPREL16_HIGHERA:
14931         case R_PPC64_DTPREL16_HIGHEST:
14932         case R_PPC64_DTPREL16_HIGHESTA:
14933           if (htab->elf.tls_sec != NULL)
14934             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14935           break;
14936
14937         case R_PPC64_ADDR64_LOCAL:
14938           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14939                                               ? h->elf.other
14940                                               : sym->st_other);
14941           break;
14942
14943         case R_PPC64_DTPMOD64:
14944           relocation = 1;
14945           addend = 0;
14946           goto dodyn;
14947
14948         case R_PPC64_TPREL64:
14949           if (htab->elf.tls_sec != NULL)
14950             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14951           goto dodyn;
14952
14953         case R_PPC64_DTPREL64:
14954           if (htab->elf.tls_sec != NULL)
14955             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14956           /* Fall through.  */
14957
14958           /* Relocations that may need to be propagated if this is a
14959              dynamic object.  */
14960         case R_PPC64_REL30:
14961         case R_PPC64_REL32:
14962         case R_PPC64_REL64:
14963         case R_PPC64_ADDR14:
14964         case R_PPC64_ADDR14_BRNTAKEN:
14965         case R_PPC64_ADDR14_BRTAKEN:
14966         case R_PPC64_ADDR16:
14967         case R_PPC64_ADDR16_DS:
14968         case R_PPC64_ADDR16_HA:
14969         case R_PPC64_ADDR16_HI:
14970         case R_PPC64_ADDR16_HIGH:
14971         case R_PPC64_ADDR16_HIGHA:
14972         case R_PPC64_ADDR16_HIGHER:
14973         case R_PPC64_ADDR16_HIGHERA:
14974         case R_PPC64_ADDR16_HIGHEST:
14975         case R_PPC64_ADDR16_HIGHESTA:
14976         case R_PPC64_ADDR16_LO:
14977         case R_PPC64_ADDR16_LO_DS:
14978         case R_PPC64_ADDR24:
14979         case R_PPC64_ADDR32:
14980         case R_PPC64_ADDR64:
14981         case R_PPC64_UADDR16:
14982         case R_PPC64_UADDR32:
14983         case R_PPC64_UADDR64:
14984         dodyn:
14985           if ((input_section->flags & SEC_ALLOC) == 0)
14986             break;
14987
14988           if (NO_OPD_RELOCS && is_opd)
14989             break;
14990
14991           if (bfd_link_pic (info)
14992               ? ((h == NULL
14993                   || h->dyn_relocs != NULL)
14994                  && ((h != NULL && pc_dynrelocs (h))
14995                      || must_be_dyn_reloc (info, r_type)))
14996               : (h != NULL
14997                  ? h->dyn_relocs != NULL
14998                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14999             {
15000               bfd_boolean skip, relocate;
15001               asection *sreloc;
15002               bfd_vma out_off;
15003               long indx = 0;
15004
15005               /* When generating a dynamic object, these relocations
15006                  are copied into the output file to be resolved at run
15007                  time.  */
15008
15009               skip = FALSE;
15010               relocate = FALSE;
15011
15012               out_off = _bfd_elf_section_offset (output_bfd, info,
15013                                                  input_section, rel->r_offset);
15014               if (out_off == (bfd_vma) -1)
15015                 skip = TRUE;
15016               else if (out_off == (bfd_vma) -2)
15017                 skip = TRUE, relocate = TRUE;
15018               out_off += (input_section->output_section->vma
15019                           + input_section->output_offset);
15020               outrel.r_offset = out_off;
15021               outrel.r_addend = rel->r_addend;
15022
15023               /* Optimize unaligned reloc use.  */
15024               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15025                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15026                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15027               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15028                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15029                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15030               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15031                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15032                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15033
15034               if (skip)
15035                 memset (&outrel, 0, sizeof outrel);
15036               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15037                        && !is_opd
15038                        && r_type != R_PPC64_TOC)
15039                 {
15040                   indx = h->elf.dynindx;
15041                   BFD_ASSERT (indx != -1);
15042                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15043                 }
15044               else
15045                 {
15046                   /* This symbol is local, or marked to become local,
15047                      or this is an opd section reloc which must point
15048                      at a local function.  */
15049                   outrel.r_addend += relocation;
15050                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15051                     {
15052                       if (is_opd && h != NULL)
15053                         {
15054                           /* Lie about opd entries.  This case occurs
15055                              when building shared libraries and we
15056                              reference a function in another shared
15057                              lib.  The same thing happens for a weak
15058                              definition in an application that's
15059                              overridden by a strong definition in a
15060                              shared lib.  (I believe this is a generic
15061                              bug in binutils handling of weak syms.)
15062                              In these cases we won't use the opd
15063                              entry in this lib.  */
15064                           unresolved_reloc = FALSE;
15065                         }
15066                       if (!is_opd
15067                           && r_type == R_PPC64_ADDR64
15068                           && (h != NULL
15069                               ? h->elf.type == STT_GNU_IFUNC
15070                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15071                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15072                       else
15073                         {
15074                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15075
15076                           /* We need to relocate .opd contents for ld.so.
15077                              Prelink also wants simple and consistent rules
15078                              for relocs.  This make all RELATIVE relocs have
15079                              *r_offset equal to r_addend.  */
15080                           relocate = TRUE;
15081                         }
15082                     }
15083                   else
15084                     {
15085                       if (h != NULL
15086                           ? h->elf.type == STT_GNU_IFUNC
15087                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15088                         {
15089                           info->callbacks->einfo
15090                             /* xgettext:c-format */
15091                             (_("%H: %s for indirect "
15092                                "function `%pT' unsupported\n"),
15093                              input_bfd, input_section, rel->r_offset,
15094                              ppc64_elf_howto_table[r_type]->name,
15095                              sym_name);
15096                           ret = FALSE;
15097                         }
15098                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15099                         ;
15100                       else if (sec == NULL || sec->owner == NULL)
15101                         {
15102                           bfd_set_error (bfd_error_bad_value);
15103                           return FALSE;
15104                         }
15105                       else
15106                         {
15107                           asection *osec;
15108
15109                           osec = sec->output_section;
15110                           indx = elf_section_data (osec)->dynindx;
15111
15112                           if (indx == 0)
15113                             {
15114                               if ((osec->flags & SEC_READONLY) == 0
15115                                   && htab->elf.data_index_section != NULL)
15116                                 osec = htab->elf.data_index_section;
15117                               else
15118                                 osec = htab->elf.text_index_section;
15119                               indx = elf_section_data (osec)->dynindx;
15120                             }
15121                           BFD_ASSERT (indx != 0);
15122
15123                           /* We are turning this relocation into one
15124                              against a section symbol, so subtract out
15125                              the output section's address but not the
15126                              offset of the input section in the output
15127                              section.  */
15128                           outrel.r_addend -= osec->vma;
15129                         }
15130
15131                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15132                     }
15133                 }
15134
15135               sreloc = elf_section_data (input_section)->sreloc;
15136               if (h != NULL
15137                   ? h->elf.type == STT_GNU_IFUNC
15138                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15139                 {
15140                   sreloc = htab->elf.irelplt;
15141                   if (indx == 0)
15142                     htab->local_ifunc_resolver = 1;
15143                   else if (is_static_defined (&h->elf))
15144                     htab->maybe_local_ifunc_resolver = 1;
15145                 }
15146               if (sreloc == NULL)
15147                 abort ();
15148
15149               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15150                   >= sreloc->size)
15151                 abort ();
15152               loc = sreloc->contents;
15153               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15154               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15155
15156               /* If this reloc is against an external symbol, it will
15157                  be computed at runtime, so there's no need to do
15158                  anything now.  However, for the sake of prelink ensure
15159                  that the section contents are a known value.  */
15160               if (! relocate)
15161                 {
15162                   unresolved_reloc = FALSE;
15163                   /* The value chosen here is quite arbitrary as ld.so
15164                      ignores section contents except for the special
15165                      case of .opd where the contents might be accessed
15166                      before relocation.  Choose zero, as that won't
15167                      cause reloc overflow.  */
15168                   relocation = 0;
15169                   addend = 0;
15170                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15171                      to improve backward compatibility with older
15172                      versions of ld.  */
15173                   if (r_type == R_PPC64_ADDR64)
15174                     addend = outrel.r_addend;
15175                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15176                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15177                     addend = outrel.r_offset;
15178                 }
15179             }
15180           break;
15181
15182         case R_PPC64_COPY:
15183         case R_PPC64_GLOB_DAT:
15184         case R_PPC64_JMP_SLOT:
15185         case R_PPC64_JMP_IREL:
15186         case R_PPC64_RELATIVE:
15187           /* We shouldn't ever see these dynamic relocs in relocatable
15188              files.  */
15189           /* Fall through.  */
15190
15191         case R_PPC64_PLTGOT16:
15192         case R_PPC64_PLTGOT16_DS:
15193         case R_PPC64_PLTGOT16_HA:
15194         case R_PPC64_PLTGOT16_HI:
15195         case R_PPC64_PLTGOT16_LO:
15196         case R_PPC64_PLTGOT16_LO_DS:
15197         case R_PPC64_PLTREL32:
15198         case R_PPC64_PLTREL64:
15199           /* These ones haven't been implemented yet.  */
15200
15201           info->callbacks->einfo
15202             /* xgettext:c-format */
15203             (_("%P: %pB: %s is not supported for `%pT'\n"),
15204              input_bfd,
15205              ppc64_elf_howto_table[r_type]->name, sym_name);
15206
15207           bfd_set_error (bfd_error_invalid_operation);
15208           ret = FALSE;
15209           goto copy_reloc;
15210         }
15211
15212       /* Multi-instruction sequences that access the TOC can be
15213          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15214          to             nop;           addi rb,r2,x;  */
15215       switch (r_type)
15216         {
15217         default:
15218           break;
15219
15220         case R_PPC64_GOT_TLSLD16_HI:
15221         case R_PPC64_GOT_TLSGD16_HI:
15222         case R_PPC64_GOT_TPREL16_HI:
15223         case R_PPC64_GOT_DTPREL16_HI:
15224         case R_PPC64_GOT16_HI:
15225         case R_PPC64_TOC16_HI:
15226           /* These relocs would only be useful if building up an
15227              offset to later add to r2, perhaps in an indexed
15228              addressing mode instruction.  Don't try to optimize.
15229              Unfortunately, the possibility of someone building up an
15230              offset like this or even with the HA relocs, means that
15231              we need to check the high insn when optimizing the low
15232              insn.  */
15233           break;
15234
15235         case R_PPC64_GOT_TLSLD16_HA:
15236         case R_PPC64_GOT_TLSGD16_HA:
15237         case R_PPC64_GOT_TPREL16_HA:
15238         case R_PPC64_GOT_DTPREL16_HA:
15239         case R_PPC64_GOT16_HA:
15240         case R_PPC64_TOC16_HA:
15241           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15242               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15243             {
15244               bfd_byte *p = contents + (rel->r_offset & ~3);
15245               bfd_put_32 (input_bfd, NOP, p);
15246               goto copy_reloc;
15247             }
15248           break;
15249
15250         case R_PPC64_GOT_TLSLD16_LO:
15251         case R_PPC64_GOT_TLSGD16_LO:
15252         case R_PPC64_GOT_TPREL16_LO_DS:
15253         case R_PPC64_GOT_DTPREL16_LO_DS:
15254         case R_PPC64_GOT16_LO:
15255         case R_PPC64_GOT16_LO_DS:
15256         case R_PPC64_TOC16_LO:
15257         case R_PPC64_TOC16_LO_DS:
15258           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15259               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15260             {
15261               bfd_byte *p = contents + (rel->r_offset & ~3);
15262               insn = bfd_get_32 (input_bfd, p);
15263               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15264                 {
15265                   /* Transform addic to addi when we change reg.  */
15266                   insn &= ~((0x3f << 26) | (0x1f << 16));
15267                   insn |= (14u << 26) | (2 << 16);
15268                 }
15269               else
15270                 {
15271                   insn &= ~(0x1f << 16);
15272                   insn |= 2 << 16;
15273                 }
15274               bfd_put_32 (input_bfd, insn, p);
15275             }
15276           break;
15277
15278         case R_PPC64_TPREL16_HA:
15279           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15280             {
15281               bfd_byte *p = contents + (rel->r_offset & ~3);
15282               insn = bfd_get_32 (input_bfd, p);
15283               if ((insn & ((0x3f << 26) | 0x1f << 16))
15284                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15285                 /* xgettext:c-format */
15286                 info->callbacks->minfo
15287                   (_("%H: warning: %s unexpected insn %#x.\n"),
15288                    input_bfd, input_section, rel->r_offset,
15289                    ppc64_elf_howto_table[r_type]->name, insn);
15290               else
15291                 {
15292                   bfd_put_32 (input_bfd, NOP, p);
15293                   goto copy_reloc;
15294                 }
15295             }
15296           break;
15297
15298         case R_PPC64_TPREL16_LO:
15299         case R_PPC64_TPREL16_LO_DS:
15300           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15301             {
15302               bfd_byte *p = contents + (rel->r_offset & ~3);
15303               insn = bfd_get_32 (input_bfd, p);
15304               insn &= ~(0x1f << 16);
15305               insn |= 13 << 16;
15306               bfd_put_32 (input_bfd, insn, p);
15307             }
15308           break;
15309         }
15310
15311       /* Do any further special processing.  */
15312       switch (r_type)
15313         {
15314         default:
15315           break;
15316
15317         case R_PPC64_REL16_HA:
15318         case R_PPC64_REL16DX_HA:
15319         case R_PPC64_ADDR16_HA:
15320         case R_PPC64_ADDR16_HIGHA:
15321         case R_PPC64_ADDR16_HIGHERA:
15322         case R_PPC64_ADDR16_HIGHESTA:
15323         case R_PPC64_TOC16_HA:
15324         case R_PPC64_SECTOFF_HA:
15325         case R_PPC64_TPREL16_HA:
15326         case R_PPC64_TPREL16_HIGHA:
15327         case R_PPC64_TPREL16_HIGHERA:
15328         case R_PPC64_TPREL16_HIGHESTA:
15329         case R_PPC64_DTPREL16_HA:
15330         case R_PPC64_DTPREL16_HIGHA:
15331         case R_PPC64_DTPREL16_HIGHERA:
15332         case R_PPC64_DTPREL16_HIGHESTA:
15333           /* It's just possible that this symbol is a weak symbol
15334              that's not actually defined anywhere. In that case,
15335              'sec' would be NULL, and we should leave the symbol
15336              alone (it will be set to zero elsewhere in the link).  */
15337           if (sec == NULL)
15338             break;
15339           /* Fall through.  */
15340
15341         case R_PPC64_GOT16_HA:
15342         case R_PPC64_PLTGOT16_HA:
15343         case R_PPC64_PLT16_HA:
15344         case R_PPC64_GOT_TLSGD16_HA:
15345         case R_PPC64_GOT_TLSLD16_HA:
15346         case R_PPC64_GOT_TPREL16_HA:
15347         case R_PPC64_GOT_DTPREL16_HA:
15348           /* Add 0x10000 if sign bit in 0:15 is set.
15349              Bits 0:15 are not used.  */
15350           addend += 0x8000;
15351           break;
15352
15353         case R_PPC64_ADDR16_DS:
15354         case R_PPC64_ADDR16_LO_DS:
15355         case R_PPC64_GOT16_DS:
15356         case R_PPC64_GOT16_LO_DS:
15357         case R_PPC64_PLT16_LO_DS:
15358         case R_PPC64_SECTOFF_DS:
15359         case R_PPC64_SECTOFF_LO_DS:
15360         case R_PPC64_TOC16_DS:
15361         case R_PPC64_TOC16_LO_DS:
15362         case R_PPC64_PLTGOT16_DS:
15363         case R_PPC64_PLTGOT16_LO_DS:
15364         case R_PPC64_GOT_TPREL16_DS:
15365         case R_PPC64_GOT_TPREL16_LO_DS:
15366         case R_PPC64_GOT_DTPREL16_DS:
15367         case R_PPC64_GOT_DTPREL16_LO_DS:
15368         case R_PPC64_TPREL16_DS:
15369         case R_PPC64_TPREL16_LO_DS:
15370         case R_PPC64_DTPREL16_DS:
15371         case R_PPC64_DTPREL16_LO_DS:
15372           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15373           mask = 3;
15374           /* If this reloc is against an lq, lxv, or stxv insn, then
15375              the value must be a multiple of 16.  This is somewhat of
15376              a hack, but the "correct" way to do this by defining _DQ
15377              forms of all the _DS relocs bloats all reloc switches in
15378              this file.  It doesn't make much sense to use these
15379              relocs in data, so testing the insn should be safe.  */
15380           if ((insn & (0x3f << 26)) == (56u << 26)
15381               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15382             mask = 15;
15383           relocation += addend;
15384           addend = insn & (mask ^ 3);
15385           if ((relocation & mask) != 0)
15386             {
15387               relocation ^= relocation & mask;
15388               info->callbacks->einfo
15389                 /* xgettext:c-format */
15390                 (_("%H: error: %s not a multiple of %u\n"),
15391                  input_bfd, input_section, rel->r_offset,
15392                  ppc64_elf_howto_table[r_type]->name,
15393                  mask + 1);
15394               bfd_set_error (bfd_error_bad_value);
15395               ret = FALSE;
15396               goto copy_reloc;
15397             }
15398           break;
15399         }
15400
15401       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15402          because such sections are not SEC_ALLOC and thus ld.so will
15403          not process them.  */
15404       howto = ppc64_elf_howto_table[(int) r_type];
15405       if (unresolved_reloc
15406           && !((input_section->flags & SEC_DEBUGGING) != 0
15407                && h->elf.def_dynamic)
15408           && _bfd_elf_section_offset (output_bfd, info, input_section,
15409                                       rel->r_offset) != (bfd_vma) -1)
15410         {
15411           info->callbacks->einfo
15412             /* xgettext:c-format */
15413             (_("%H: unresolvable %s against `%pT'\n"),
15414              input_bfd, input_section, rel->r_offset,
15415              howto->name,
15416              h->elf.root.root.string);
15417           ret = FALSE;
15418         }
15419
15420       /* 16-bit fields in insns mostly have signed values, but a
15421          few insns have 16-bit unsigned values.  Really, we should
15422          have different reloc types.  */
15423       if (howto->complain_on_overflow != complain_overflow_dont
15424           && howto->dst_mask == 0xffff
15425           && (input_section->flags & SEC_CODE) != 0)
15426         {
15427           enum complain_overflow complain = complain_overflow_signed;
15428
15429           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15430           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15431             complain = complain_overflow_bitfield;
15432           else if (howto->rightshift == 0
15433                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15434                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15435                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15436                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15437                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15438                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15439             complain = complain_overflow_unsigned;
15440           if (howto->complain_on_overflow != complain)
15441             {
15442               alt_howto = *howto;
15443               alt_howto.complain_on_overflow = complain;
15444               howto = &alt_howto;
15445             }
15446         }
15447
15448       if (r_type == R_PPC64_REL16DX_HA)
15449         {
15450           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15451           if (rel->r_offset + 4 > input_section->size)
15452             r = bfd_reloc_outofrange;
15453           else
15454             {
15455               relocation += addend;
15456               relocation -= (rel->r_offset
15457                              + input_section->output_offset
15458                              + input_section->output_section->vma);
15459               relocation = (bfd_signed_vma) relocation >> 16;
15460               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15461               insn &= ~0x1fffc1;
15462               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15463               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15464               r = bfd_reloc_ok;
15465               if (relocation + 0x8000 > 0xffff)
15466                 r = bfd_reloc_overflow;
15467             }
15468         }
15469       else
15470         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15471                                       rel->r_offset, relocation, addend);
15472
15473       if (r != bfd_reloc_ok)
15474         {
15475           char *more_info = NULL;
15476           const char *reloc_name = howto->name;
15477
15478           if (reloc_dest != DEST_NORMAL)
15479             {
15480               more_info = bfd_malloc (strlen (reloc_name) + 8);
15481               if (more_info != NULL)
15482                 {
15483                   strcpy (more_info, reloc_name);
15484                   strcat (more_info, (reloc_dest == DEST_OPD
15485                                       ? " (OPD)" : " (stub)"));
15486                   reloc_name = more_info;
15487                 }
15488             }
15489
15490           if (r == bfd_reloc_overflow)
15491             {
15492               /* On code like "if (foo) foo();" don't report overflow
15493                  on a branch to zero when foo is undefined.  */
15494               if (!warned
15495                   && (reloc_dest == DEST_STUB
15496                       || !(h != NULL
15497                            && (h->elf.root.type == bfd_link_hash_undefweak
15498                                || h->elf.root.type == bfd_link_hash_undefined)
15499                            && is_branch_reloc (r_type))))
15500                 info->callbacks->reloc_overflow (info, &h->elf.root,
15501                                                  sym_name, reloc_name,
15502                                                  orig_rel.r_addend,
15503                                                  input_bfd, input_section,
15504                                                  rel->r_offset);
15505             }
15506           else
15507             {
15508               info->callbacks->einfo
15509                 /* xgettext:c-format */
15510                 (_("%H: %s against `%pT': error %d\n"),
15511                  input_bfd, input_section, rel->r_offset,
15512                  reloc_name, sym_name, (int) r);
15513               ret = FALSE;
15514             }
15515           if (more_info != NULL)
15516             free (more_info);
15517         }
15518     copy_reloc:
15519       if (wrel != rel)
15520         *wrel = *rel;
15521     }
15522
15523   if (wrel != rel)
15524     {
15525       Elf_Internal_Shdr *rel_hdr;
15526       size_t deleted = rel - wrel;
15527
15528       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15529       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15530       if (rel_hdr->sh_size == 0)
15531         {
15532           /* It is too late to remove an empty reloc section.  Leave
15533              one NONE reloc.
15534              ??? What is wrong with an empty section???  */
15535           rel_hdr->sh_size = rel_hdr->sh_entsize;
15536           deleted -= 1;
15537         }
15538       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15539       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15540       input_section->reloc_count -= deleted;
15541     }
15542
15543   /* If we're emitting relocations, then shortly after this function
15544      returns, reloc offsets and addends for this section will be
15545      adjusted.  Worse, reloc symbol indices will be for the output
15546      file rather than the input.  Save a copy of the relocs for
15547      opd_entry_value.  */
15548   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15549     {
15550       bfd_size_type amt;
15551       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15552       rel = bfd_alloc (input_bfd, amt);
15553       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15554       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15555       if (rel == NULL)
15556         return FALSE;
15557       memcpy (rel, relocs, amt);
15558     }
15559   return ret;
15560 }
15561
15562 /* Adjust the value of any local symbols in opd sections.  */
15563
15564 static int
15565 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15566                               const char *name ATTRIBUTE_UNUSED,
15567                               Elf_Internal_Sym *elfsym,
15568                               asection *input_sec,
15569                               struct elf_link_hash_entry *h)
15570 {
15571   struct _opd_sec_data *opd;
15572   long adjust;
15573   bfd_vma value;
15574
15575   if (h != NULL)
15576     return 1;
15577
15578   opd = get_opd_info (input_sec);
15579   if (opd == NULL || opd->adjust == NULL)
15580     return 1;
15581
15582   value = elfsym->st_value - input_sec->output_offset;
15583   if (!bfd_link_relocatable (info))
15584     value -= input_sec->output_section->vma;
15585
15586   adjust = opd->adjust[OPD_NDX (value)];
15587   if (adjust == -1)
15588     return 2;
15589
15590   elfsym->st_value += adjust;
15591   return 1;
15592 }
15593
15594 /* Finish up dynamic symbol handling.  We set the contents of various
15595    dynamic sections here.  */
15596
15597 static bfd_boolean
15598 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15599                                  struct bfd_link_info *info,
15600                                  struct elf_link_hash_entry *h,
15601                                  Elf_Internal_Sym *sym)
15602 {
15603   struct ppc_link_hash_table *htab;
15604   struct plt_entry *ent;
15605
15606   htab = ppc_hash_table (info);
15607   if (htab == NULL)
15608     return FALSE;
15609
15610   if (!htab->opd_abi && !h->def_regular)
15611     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15612       if (ent->plt.offset != (bfd_vma) -1)
15613         {
15614           /* Mark the symbol as undefined, rather than as
15615              defined in glink.  Leave the value if there were
15616              any relocations where pointer equality matters
15617              (this is a clue for the dynamic linker, to make
15618              function pointer comparisons work between an
15619              application and shared library), otherwise set it
15620              to zero.  */
15621           sym->st_shndx = SHN_UNDEF;
15622           if (!h->pointer_equality_needed)
15623             sym->st_value = 0;
15624           else if (!h->ref_regular_nonweak)
15625             {
15626               /* This breaks function pointer comparisons, but
15627                  that is better than breaking tests for a NULL
15628                  function pointer.  */
15629               sym->st_value = 0;
15630             }
15631           break;
15632         }
15633
15634   if (h->needs_copy)
15635     {
15636       /* This symbol needs a copy reloc.  Set it up.  */
15637       Elf_Internal_Rela rela;
15638       asection *srel;
15639       bfd_byte *loc;
15640
15641       if (h->dynindx == -1
15642           || (h->root.type != bfd_link_hash_defined
15643               && h->root.type != bfd_link_hash_defweak)
15644           || htab->elf.srelbss == NULL
15645           || htab->elf.sreldynrelro == NULL)
15646         abort ();
15647
15648       rela.r_offset = (h->root.u.def.value
15649                        + h->root.u.def.section->output_section->vma
15650                        + h->root.u.def.section->output_offset);
15651       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15652       rela.r_addend = 0;
15653       if (h->root.u.def.section == htab->elf.sdynrelro)
15654         srel = htab->elf.sreldynrelro;
15655       else
15656         srel = htab->elf.srelbss;
15657       loc = srel->contents;
15658       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15659       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15660     }
15661
15662   return TRUE;
15663 }
15664
15665 /* Used to decide how to sort relocs in an optimal manner for the
15666    dynamic linker, before writing them out.  */
15667
15668 static enum elf_reloc_type_class
15669 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15670                             const asection *rel_sec,
15671                             const Elf_Internal_Rela *rela)
15672 {
15673   enum elf_ppc64_reloc_type r_type;
15674   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15675
15676   if (rel_sec == htab->elf.irelplt)
15677     return reloc_class_ifunc;
15678
15679   r_type = ELF64_R_TYPE (rela->r_info);
15680   switch (r_type)
15681     {
15682     case R_PPC64_RELATIVE:
15683       return reloc_class_relative;
15684     case R_PPC64_JMP_SLOT:
15685       return reloc_class_plt;
15686     case R_PPC64_COPY:
15687       return reloc_class_copy;
15688     default:
15689       return reloc_class_normal;
15690     }
15691 }
15692
15693 /* Finish up the dynamic sections.  */
15694
15695 static bfd_boolean
15696 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15697                                    struct bfd_link_info *info)
15698 {
15699   struct ppc_link_hash_table *htab;
15700   bfd *dynobj;
15701   asection *sdyn;
15702
15703   htab = ppc_hash_table (info);
15704   if (htab == NULL)
15705     return FALSE;
15706
15707   dynobj = htab->elf.dynobj;
15708   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15709
15710   if (htab->elf.dynamic_sections_created)
15711     {
15712       Elf64_External_Dyn *dyncon, *dynconend;
15713
15714       if (sdyn == NULL || htab->elf.sgot == NULL)
15715         abort ();
15716
15717       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15718       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15719       for (; dyncon < dynconend; dyncon++)
15720         {
15721           Elf_Internal_Dyn dyn;
15722           asection *s;
15723
15724           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15725
15726           switch (dyn.d_tag)
15727             {
15728             default:
15729               continue;
15730
15731             case DT_PPC64_GLINK:
15732               s = htab->glink;
15733               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15734               /* We stupidly defined DT_PPC64_GLINK to be the start
15735                  of glink rather than the first entry point, which is
15736                  what ld.so needs, and now have a bigger stub to
15737                  support automatic multiple TOCs.  */
15738               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
15739               break;
15740
15741             case DT_PPC64_OPD:
15742               s = bfd_get_section_by_name (output_bfd, ".opd");
15743               if (s == NULL)
15744                 continue;
15745               dyn.d_un.d_ptr = s->vma;
15746               break;
15747
15748             case DT_PPC64_OPT:
15749               if (htab->do_multi_toc && htab->multi_toc_needed)
15750                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15751               if (htab->has_plt_localentry0)
15752                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15753               break;
15754
15755             case DT_PPC64_OPDSZ:
15756               s = bfd_get_section_by_name (output_bfd, ".opd");
15757               if (s == NULL)
15758                 continue;
15759               dyn.d_un.d_val = s->size;
15760               break;
15761
15762             case DT_PLTGOT:
15763               s = htab->elf.splt;
15764               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15765               break;
15766
15767             case DT_JMPREL:
15768               s = htab->elf.srelplt;
15769               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15770               break;
15771
15772             case DT_PLTRELSZ:
15773               dyn.d_un.d_val = htab->elf.srelplt->size;
15774               break;
15775
15776             case DT_TEXTREL:
15777               if (htab->local_ifunc_resolver)
15778                 info->callbacks->einfo
15779                   (_("%X%P: text relocations and GNU indirect "
15780                      "functions will result in a segfault at runtime\n"));
15781               else if (htab->maybe_local_ifunc_resolver)
15782                 info->callbacks->einfo
15783                   (_("%P: warning: text relocations and GNU indirect "
15784                      "functions may result in a segfault at runtime\n"));
15785               continue;
15786             }
15787
15788           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15789         }
15790     }
15791
15792   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15793       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15794     {
15795       /* Fill in the first entry in the global offset table.
15796          We use it to hold the link-time TOCbase.  */
15797       bfd_put_64 (output_bfd,
15798                   elf_gp (output_bfd) + TOC_BASE_OFF,
15799                   htab->elf.sgot->contents);
15800
15801       /* Set .got entry size.  */
15802       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15803     }
15804
15805   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15806       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15807     {
15808       /* Set .plt entry size.  */
15809       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15810         = PLT_ENTRY_SIZE (htab);
15811     }
15812
15813   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15814      brlt ourselves if emitrelocations.  */
15815   if (htab->brlt != NULL
15816       && htab->brlt->reloc_count != 0
15817       && !_bfd_elf_link_output_relocs (output_bfd,
15818                                        htab->brlt,
15819                                        elf_section_data (htab->brlt)->rela.hdr,
15820                                        elf_section_data (htab->brlt)->relocs,
15821                                        NULL))
15822     return FALSE;
15823
15824   if (htab->glink != NULL
15825       && htab->glink->reloc_count != 0
15826       && !_bfd_elf_link_output_relocs (output_bfd,
15827                                        htab->glink,
15828                                        elf_section_data (htab->glink)->rela.hdr,
15829                                        elf_section_data (htab->glink)->relocs,
15830                                        NULL))
15831     return FALSE;
15832
15833   if (htab->glink_eh_frame != NULL
15834       && htab->glink_eh_frame->size != 0)
15835     {
15836       bfd_vma val;
15837       bfd_byte *p;
15838       struct map_stub *group;
15839       size_t align = 4;
15840
15841       p = htab->glink_eh_frame->contents;
15842       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15843
15844       for (group = htab->group; group != NULL; group = group->next)
15845         if (group->stub_sec != NULL)
15846           {
15847             /* Offset to stub section.  */
15848             val = (group->stub_sec->output_section->vma
15849                    + group->stub_sec->output_offset);
15850             val -= (htab->glink_eh_frame->output_section->vma
15851                     + htab->glink_eh_frame->output_offset
15852                     + (p + 8 - htab->glink_eh_frame->contents));
15853             if (val + 0x80000000 > 0xffffffff)
15854               {
15855                 _bfd_error_handler
15856                   (_("%s offset too large for .eh_frame sdata4 encoding"),
15857                    group->stub_sec->name);
15858                 return FALSE;
15859               }
15860             bfd_put_32 (dynobj, val, p + 8);
15861             p += stub_eh_frame_size (group, align);
15862           }
15863       if (htab->glink != NULL && htab->glink->size != 0)
15864         {
15865           /* Offset to .glink.  */
15866           val = (htab->glink->output_section->vma
15867                  + htab->glink->output_offset
15868                  + 8);
15869           val -= (htab->glink_eh_frame->output_section->vma
15870                   + htab->glink_eh_frame->output_offset
15871                   + (p + 8 - htab->glink_eh_frame->contents));
15872           if (val + 0x80000000 > 0xffffffff)
15873             {
15874               _bfd_error_handler
15875                 (_("%s offset too large for .eh_frame sdata4 encoding"),
15876                  htab->glink->name);
15877               return FALSE;
15878             }
15879           bfd_put_32 (dynobj, val, p + 8);
15880           p += (24 + align - 1) & -align;
15881         }
15882
15883       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15884           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15885                                                htab->glink_eh_frame,
15886                                                htab->glink_eh_frame->contents))
15887         return FALSE;
15888     }
15889
15890   /* We need to handle writing out multiple GOT sections ourselves,
15891      since we didn't add them to DYNOBJ.  We know dynobj is the first
15892      bfd.  */
15893   while ((dynobj = dynobj->link.next) != NULL)
15894     {
15895       asection *s;
15896
15897       if (!is_ppc64_elf (dynobj))
15898         continue;
15899
15900       s = ppc64_elf_tdata (dynobj)->got;
15901       if (s != NULL
15902           && s->size != 0
15903           && s->output_section != bfd_abs_section_ptr
15904           && !bfd_set_section_contents (output_bfd, s->output_section,
15905                                         s->contents, s->output_offset,
15906                                         s->size))
15907         return FALSE;
15908       s = ppc64_elf_tdata (dynobj)->relgot;
15909       if (s != NULL
15910           && s->size != 0
15911           && s->output_section != bfd_abs_section_ptr
15912           && !bfd_set_section_contents (output_bfd, s->output_section,
15913                                         s->contents, s->output_offset,
15914                                         s->size))
15915         return FALSE;
15916     }
15917
15918   return TRUE;
15919 }
15920
15921 #include "elf64-target.h"
15922
15923 /* FreeBSD support */
15924
15925 #undef  TARGET_LITTLE_SYM
15926 #undef  TARGET_LITTLE_NAME
15927
15928 #undef  TARGET_BIG_SYM
15929 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15930 #undef  TARGET_BIG_NAME
15931 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15932
15933 #undef  ELF_OSABI
15934 #define ELF_OSABI       ELFOSABI_FREEBSD
15935
15936 #undef  elf64_bed
15937 #define elf64_bed       elf64_powerpc_fbsd_bed
15938
15939 #include "elf64-target.h"