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   long i;
3273   long count;
3274   char *names;
3275   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3276   asection *opd = NULL;
3277   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3278   asymbol **syms;
3279   int abi = abiversion (abfd);
3280
3281   *ret = NULL;
3282
3283   if (abi < 2)
3284     {
3285       opd = bfd_get_section_by_name (abfd, ".opd");
3286       if (opd == NULL && abi == 1)
3287         return 0;
3288     }
3289
3290   syms = NULL;
3291   codesecsym = 0;
3292   codesecsymend = 0;
3293   secsymend = 0;
3294   opdsymend = 0;
3295   symcount = 0;
3296   if (opd != NULL)
3297     {
3298       symcount = static_count;
3299       if (!relocatable)
3300         symcount += dyn_count;
3301       if (symcount == 0)
3302         return 0;
3303
3304       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3305       if (syms == NULL)
3306         return -1;
3307
3308       if (!relocatable && static_count != 0 && dyn_count != 0)
3309         {
3310           /* Use both symbol tables.  */
3311           memcpy (syms, static_syms, static_count * sizeof (*syms));
3312           memcpy (syms + static_count, dyn_syms,
3313                   (dyn_count + 1) * sizeof (*syms));
3314         }
3315       else if (!relocatable && static_count == 0)
3316         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3317       else
3318         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3319
3320       synthetic_relocatable = relocatable;
3321       synthetic_opd = opd;
3322       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3323
3324       if (!relocatable && symcount > 1)
3325         {
3326           long j;
3327           /* Trim duplicate syms, since we may have merged the normal and
3328              dynamic symbols.  Actually, we only care about syms that have
3329              different values, so trim any with the same value.  */
3330           for (i = 1, j = 1; i < symcount; ++i)
3331             if (syms[i - 1]->value + syms[i - 1]->section->vma
3332                 != syms[i]->value + syms[i]->section->vma)
3333               syms[j++] = syms[i];
3334           symcount = j;
3335         }
3336
3337       i = 0;
3338       /* Note that here and in compare_symbols we can't compare opd and
3339          sym->section directly.  With separate debug info files, the
3340          symbols will be extracted from the debug file while abfd passed
3341          to this function is the real binary.  */
3342       if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3343         ++i;
3344       codesecsym = i;
3345
3346       for (; i < symcount; ++i)
3347         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3348                                          | SEC_THREAD_LOCAL))
3349              != (SEC_CODE | SEC_ALLOC))
3350             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3351           break;
3352       codesecsymend = i;
3353
3354       for (; i < symcount; ++i)
3355         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3356           break;
3357       secsymend = i;
3358
3359       for (; i < symcount; ++i)
3360         if (strcmp (syms[i]->section->name, ".opd") != 0)
3361           break;
3362       opdsymend = i;
3363
3364       for (; i < symcount; ++i)
3365         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3366             != (SEC_CODE | SEC_ALLOC))
3367           break;
3368       symcount = i;
3369     }
3370   count = 0;
3371
3372   if (relocatable)
3373     {
3374       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3375       arelent *r;
3376       size_t size;
3377       long relcount;
3378
3379       if (opdsymend == secsymend)
3380         goto done;
3381
3382       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3383       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3384       if (relcount == 0)
3385         goto done;
3386
3387       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3388         {
3389           count = -1;
3390           goto done;
3391         }
3392
3393       size = 0;
3394       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3395         {
3396           asymbol *sym;
3397
3398           while (r < opd->relocation + relcount
3399                  && r->address < syms[i]->value + opd->vma)
3400             ++r;
3401
3402           if (r == opd->relocation + relcount)
3403             break;
3404
3405           if (r->address != syms[i]->value + opd->vma)
3406             continue;
3407
3408           if (r->howto->type != R_PPC64_ADDR64)
3409             continue;
3410
3411           sym = *r->sym_ptr_ptr;
3412           if (!sym_exists_at (syms, opdsymend, symcount,
3413                               sym->section->id, sym->value + r->addend))
3414             {
3415               ++count;
3416               size += sizeof (asymbol);
3417               size += strlen (syms[i]->name) + 2;
3418             }
3419         }
3420
3421       if (size == 0)
3422         goto done;
3423       s = *ret = bfd_malloc (size);
3424       if (s == NULL)
3425         {
3426           count = -1;
3427           goto done;
3428         }
3429
3430       names = (char *) (s + count);
3431
3432       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3433         {
3434           asymbol *sym;
3435
3436           while (r < opd->relocation + relcount
3437                  && r->address < syms[i]->value + opd->vma)
3438             ++r;
3439
3440           if (r == opd->relocation + relcount)
3441             break;
3442
3443           if (r->address != syms[i]->value + opd->vma)
3444             continue;
3445
3446           if (r->howto->type != R_PPC64_ADDR64)
3447             continue;
3448
3449           sym = *r->sym_ptr_ptr;
3450           if (!sym_exists_at (syms, opdsymend, symcount,
3451                               sym->section->id, sym->value + r->addend))
3452             {
3453               size_t len;
3454
3455               *s = *syms[i];
3456               s->flags |= BSF_SYNTHETIC;
3457               s->section = sym->section;
3458               s->value = sym->value + r->addend;
3459               s->name = names;
3460               *names++ = '.';
3461               len = strlen (syms[i]->name);
3462               memcpy (names, syms[i]->name, len + 1);
3463               names += len + 1;
3464               /* Have udata.p point back to the original symbol this
3465                  synthetic symbol was derived from.  */
3466               s->udata.p = syms[i];
3467               s++;
3468             }
3469         }
3470     }
3471   else
3472     {
3473       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3474       bfd_byte *contents = NULL;
3475       size_t size;
3476       long plt_count = 0;
3477       bfd_vma glink_vma = 0, resolv_vma = 0;
3478       asection *dynamic, *glink = NULL, *relplt = NULL;
3479       arelent *p;
3480
3481       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3482         {
3483         free_contents_and_exit_err:
3484           count = -1;
3485         free_contents_and_exit:
3486           if (contents)
3487             free (contents);
3488           goto done;
3489         }
3490
3491       size = 0;
3492       for (i = secsymend; i < opdsymend; ++i)
3493         {
3494           bfd_vma ent;
3495
3496           /* Ignore bogus symbols.  */
3497           if (syms[i]->value > opd->size - 8)
3498             continue;
3499
3500           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3501           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3502             {
3503               ++count;
3504               size += sizeof (asymbol);
3505               size += strlen (syms[i]->name) + 2;
3506             }
3507         }
3508
3509       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3510       if (dyn_count != 0
3511           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3512         {
3513           bfd_byte *dynbuf, *extdyn, *extdynend;
3514           size_t extdynsize;
3515           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3516
3517           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3518             goto free_contents_and_exit_err;
3519
3520           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3521           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3522
3523           extdyn = dynbuf;
3524           extdynend = extdyn + dynamic->size;
3525           for (; extdyn < extdynend; extdyn += extdynsize)
3526             {
3527               Elf_Internal_Dyn dyn;
3528               (*swap_dyn_in) (abfd, extdyn, &dyn);
3529
3530               if (dyn.d_tag == DT_NULL)
3531                 break;
3532
3533               if (dyn.d_tag == DT_PPC64_GLINK)
3534                 {
3535                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3536                      See comment in ppc64_elf_finish_dynamic_sections. */
3537                   glink_vma = dyn.d_un.d_val + 8 * 4;
3538                   /* The .glink section usually does not survive the final
3539                      link; search for the section (usually .text) where the
3540                      glink stubs now reside.  */
3541                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3542                                                 &glink_vma);
3543                   break;
3544                 }
3545             }
3546
3547           free (dynbuf);
3548         }
3549
3550       if (glink != NULL)
3551         {
3552           /* Determine __glink trampoline by reading the relative branch
3553              from the first glink stub.  */
3554           bfd_byte buf[4];
3555           unsigned int off = 0;
3556
3557           while (bfd_get_section_contents (abfd, glink, buf,
3558                                            glink_vma + off - glink->vma, 4))
3559             {
3560               unsigned int insn = bfd_get_32 (abfd, buf);
3561               insn ^= B_DOT;
3562               if ((insn & ~0x3fffffc) == 0)
3563                 {
3564                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3565                   break;
3566                 }
3567               off += 4;
3568               if (off > 4)
3569                 break;
3570             }
3571
3572           if (resolv_vma)
3573             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3574
3575           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3576           if (relplt != NULL)
3577             {
3578               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3579               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3580                 goto free_contents_and_exit_err;
3581
3582               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3583               size += plt_count * sizeof (asymbol);
3584
3585               p = relplt->relocation;
3586               for (i = 0; i < plt_count; i++, p++)
3587                 {
3588                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3589                   if (p->addend != 0)
3590                     size += sizeof ("+0x") - 1 + 16;
3591                 }
3592             }
3593         }
3594
3595       if (size == 0)
3596         goto free_contents_and_exit;
3597       s = *ret = bfd_malloc (size);
3598       if (s == NULL)
3599         goto free_contents_and_exit_err;
3600
3601       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3602
3603       for (i = secsymend; i < opdsymend; ++i)
3604         {
3605           bfd_vma ent;
3606
3607           if (syms[i]->value > opd->size - 8)
3608             continue;
3609
3610           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3611           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3612             {
3613               long lo, hi;
3614               size_t len;
3615               asection *sec = abfd->sections;
3616
3617               *s = *syms[i];
3618               lo = codesecsym;
3619               hi = codesecsymend;
3620               while (lo < hi)
3621                 {
3622                   long mid = (lo + hi) >> 1;
3623                   if (syms[mid]->section->vma < ent)
3624                     lo = mid + 1;
3625                   else if (syms[mid]->section->vma > ent)
3626                     hi = mid;
3627                   else
3628                     {
3629                       sec = syms[mid]->section;
3630                       break;
3631                     }
3632                 }
3633
3634               if (lo >= hi && lo > codesecsym)
3635                 sec = syms[lo - 1]->section;
3636
3637               for (; sec != NULL; sec = sec->next)
3638                 {
3639                   if (sec->vma > ent)
3640                     break;
3641                   /* SEC_LOAD may not be set if SEC is from a separate debug
3642                      info file.  */
3643                   if ((sec->flags & SEC_ALLOC) == 0)
3644                     break;
3645                   if ((sec->flags & SEC_CODE) != 0)
3646                     s->section = sec;
3647                 }
3648               s->flags |= BSF_SYNTHETIC;
3649               s->value = ent - s->section->vma;
3650               s->name = names;
3651               *names++ = '.';
3652               len = strlen (syms[i]->name);
3653               memcpy (names, syms[i]->name, len + 1);
3654               names += len + 1;
3655               /* Have udata.p point back to the original symbol this
3656                  synthetic symbol was derived from.  */
3657               s->udata.p = syms[i];
3658               s++;
3659             }
3660         }
3661       free (contents);
3662
3663       if (glink != NULL && relplt != NULL)
3664         {
3665           if (resolv_vma)
3666             {
3667               /* Add a symbol for the main glink trampoline.  */
3668               memset (s, 0, sizeof *s);
3669               s->the_bfd = abfd;
3670               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3671               s->section = glink;
3672               s->value = resolv_vma - glink->vma;
3673               s->name = names;
3674               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3675               names += sizeof ("__glink_PLTresolve");
3676               s++;
3677               count++;
3678             }
3679
3680           /* FIXME: It would be very much nicer to put sym@plt on the
3681              stub rather than on the glink branch table entry.  The
3682              objdump disassembler would then use a sensible symbol
3683              name on plt calls.  The difficulty in doing so is
3684              a) finding the stubs, and,
3685              b) matching stubs against plt entries, and,
3686              c) there can be multiple stubs for a given plt entry.
3687
3688              Solving (a) could be done by code scanning, but older
3689              ppc64 binaries used different stubs to current code.
3690              (b) is the tricky one since you need to known the toc
3691              pointer for at least one function that uses a pic stub to
3692              be able to calculate the plt address referenced.
3693              (c) means gdb would need to set multiple breakpoints (or
3694              find the glink branch itself) when setting breakpoints
3695              for pending shared library loads.  */
3696           p = relplt->relocation;
3697           for (i = 0; i < plt_count; i++, p++)
3698             {
3699               size_t len;
3700
3701               *s = **p->sym_ptr_ptr;
3702               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3703                  we are defining a symbol, ensure one of them is set.  */
3704               if ((s->flags & BSF_LOCAL) == 0)
3705                 s->flags |= BSF_GLOBAL;
3706               s->flags |= BSF_SYNTHETIC;
3707               s->section = glink;
3708               s->value = glink_vma - glink->vma;
3709               s->name = names;
3710               s->udata.p = NULL;
3711               len = strlen ((*p->sym_ptr_ptr)->name);
3712               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3713               names += len;
3714               if (p->addend != 0)
3715                 {
3716                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3717                   names += sizeof ("+0x") - 1;
3718                   bfd_sprintf_vma (abfd, names, p->addend);
3719                   names += strlen (names);
3720                 }
3721               memcpy (names, "@plt", sizeof ("@plt"));
3722               names += sizeof ("@plt");
3723               s++;
3724               if (abi < 2)
3725                 {
3726                   glink_vma += 8;
3727                   if (i >= 0x8000)
3728                     glink_vma += 4;
3729                 }
3730               else
3731                 glink_vma += 4;
3732             }
3733           count += plt_count;
3734         }
3735     }
3736
3737  done:
3738   free (syms);
3739   return count;
3740 }
3741 \f
3742 /* The following functions are specific to the ELF linker, while
3743    functions above are used generally.  Those named ppc64_elf_* are
3744    called by the main ELF linker code.  They appear in this file more
3745    or less in the order in which they are called.  eg.
3746    ppc64_elf_check_relocs is called early in the link process,
3747    ppc64_elf_finish_dynamic_sections is one of the last functions
3748    called.
3749
3750    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3751    functions have both a function code symbol and a function descriptor
3752    symbol.  A call to foo in a relocatable object file looks like:
3753
3754    .            .text
3755    .    x:
3756    .            bl      .foo
3757    .            nop
3758
3759    The function definition in another object file might be:
3760
3761    .            .section .opd
3762    .    foo:    .quad   .foo
3763    .            .quad   .TOC.@tocbase
3764    .            .quad   0
3765    .
3766    .            .text
3767    .    .foo:   blr
3768
3769    When the linker resolves the call during a static link, the branch
3770    unsurprisingly just goes to .foo and the .opd information is unused.
3771    If the function definition is in a shared library, things are a little
3772    different:  The call goes via a plt call stub, the opd information gets
3773    copied to the plt, and the linker patches the nop.
3774
3775    .    x:
3776    .            bl      .foo_stub
3777    .            ld      2,40(1)
3778    .
3779    .
3780    .    .foo_stub:
3781    .            std     2,40(1)                 # in practice, the call stub
3782    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3783    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3784    .            ld      12,0(11)
3785    .            ld      2,8(11)
3786    .            mtctr   12
3787    .            ld      11,16(11)
3788    .            bctr
3789    .
3790    .            .section .plt
3791    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3792
3793    The "reloc ()" notation is supposed to indicate that the linker emits
3794    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3795    copying.
3796
3797    What are the difficulties here?  Well, firstly, the relocations
3798    examined by the linker in check_relocs are against the function code
3799    sym .foo, while the dynamic relocation in the plt is emitted against
3800    the function descriptor symbol, foo.  Somewhere along the line, we need
3801    to carefully copy dynamic link information from one symbol to the other.
3802    Secondly, the generic part of the elf linker will make .foo a dynamic
3803    symbol as is normal for most other backends.  We need foo dynamic
3804    instead, at least for an application final link.  However, when
3805    creating a shared library containing foo, we need to have both symbols
3806    dynamic so that references to .foo are satisfied during the early
3807    stages of linking.  Otherwise the linker might decide to pull in a
3808    definition from some other object, eg. a static library.
3809
3810    Update: As of August 2004, we support a new convention.  Function
3811    calls may use the function descriptor symbol, ie. "bl foo".  This
3812    behaves exactly as "bl .foo".  */
3813
3814 /* Of those relocs that might be copied as dynamic relocs, this
3815    function selects those that must be copied when linking a shared
3816    library or PIE, even when the symbol is local.  */
3817
3818 static int
3819 must_be_dyn_reloc (struct bfd_link_info *info,
3820                    enum elf_ppc64_reloc_type r_type)
3821 {
3822   switch (r_type)
3823     {
3824     default:
3825       /* Only relative relocs can be resolved when the object load
3826          address isn't fixed.  DTPREL64 is excluded because the
3827          dynamic linker needs to differentiate global dynamic from
3828          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3829       return 1;
3830
3831     case R_PPC64_REL32:
3832     case R_PPC64_REL64:
3833     case R_PPC64_REL30:
3834       return 0;
3835
3836     case R_PPC64_TPREL16:
3837     case R_PPC64_TPREL16_LO:
3838     case R_PPC64_TPREL16_HI:
3839     case R_PPC64_TPREL16_HA:
3840     case R_PPC64_TPREL16_DS:
3841     case R_PPC64_TPREL16_LO_DS:
3842     case R_PPC64_TPREL16_HIGH:
3843     case R_PPC64_TPREL16_HIGHA:
3844     case R_PPC64_TPREL16_HIGHER:
3845     case R_PPC64_TPREL16_HIGHERA:
3846     case R_PPC64_TPREL16_HIGHEST:
3847     case R_PPC64_TPREL16_HIGHESTA:
3848     case R_PPC64_TPREL64:
3849       /* These relocations are relative but in a shared library the
3850          linker doesn't know the thread pointer base.  */
3851       return bfd_link_dll (info);
3852     }
3853 }
3854
3855 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3856    copying dynamic variables from a shared lib into an app's dynbss
3857    section, and instead use a dynamic relocation to point into the
3858    shared lib.  With code that gcc generates, it's vital that this be
3859    enabled;  In the PowerPC64 ABI, the address of a function is actually
3860    the address of a function descriptor, which resides in the .opd
3861    section.  gcc uses the descriptor directly rather than going via the
3862    GOT as some other ABI's do, which means that initialized function
3863    pointers must reference the descriptor.  Thus, a function pointer
3864    initialized to the address of a function in a shared library will
3865    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3866    redefines the function descriptor symbol to point to the copy.  This
3867    presents a problem as a plt entry for that function is also
3868    initialized from the function descriptor symbol and the copy reloc
3869    may not be initialized first.  */
3870 #define ELIMINATE_COPY_RELOCS 1
3871
3872 /* Section name for stubs is the associated section name plus this
3873    string.  */
3874 #define STUB_SUFFIX ".stub"
3875
3876 /* Linker stubs.
3877    ppc_stub_long_branch:
3878    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3879    destination, but a 24 bit branch in a stub section will reach.
3880    .    b       dest
3881
3882    ppc_stub_plt_branch:
3883    Similar to the above, but a 24 bit branch in the stub section won't
3884    reach its destination.
3885    .    addis   %r11,%r2,xxx@toc@ha
3886    .    ld      %r12,xxx@toc@l(%r11)
3887    .    mtctr   %r12
3888    .    bctr
3889
3890    ppc_stub_plt_call:
3891    Used to call a function in a shared library.  If it so happens that
3892    the plt entry referenced crosses a 64k boundary, then an extra
3893    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3894    .    std     %r2,40(%r1)
3895    .    addis   %r11,%r2,xxx@toc@ha
3896    .    ld      %r12,xxx+0@toc@l(%r11)
3897    .    mtctr   %r12
3898    .    ld      %r2,xxx+8@toc@l(%r11)
3899    .    ld      %r11,xxx+16@toc@l(%r11)
3900    .    bctr
3901
3902    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3903    code to adjust the value and save r2 to support multiple toc sections.
3904    A ppc_stub_long_branch with an r2 offset looks like:
3905    .    std     %r2,40(%r1)
3906    .    addis   %r2,%r2,off@ha
3907    .    addi    %r2,%r2,off@l
3908    .    b       dest
3909
3910    A ppc_stub_plt_branch with an r2 offset looks like:
3911    .    std     %r2,40(%r1)
3912    .    addis   %r11,%r2,xxx@toc@ha
3913    .    ld      %r12,xxx@toc@l(%r11)
3914    .    addis   %r2,%r2,off@ha
3915    .    addi    %r2,%r2,off@l
3916    .    mtctr   %r12
3917    .    bctr
3918
3919    In cases where the "addis" instruction would add zero, the "addis" is
3920    omitted and following instructions modified slightly in some cases.
3921 */
3922
3923 enum ppc_stub_type {
3924   ppc_stub_none,
3925   ppc_stub_long_branch,
3926   ppc_stub_long_branch_r2off,
3927   ppc_stub_plt_branch,
3928   ppc_stub_plt_branch_r2off,
3929   ppc_stub_plt_call,
3930   ppc_stub_plt_call_r2save,
3931   ppc_stub_global_entry,
3932   ppc_stub_save_res
3933 };
3934
3935 /* Information on stub grouping.  */
3936 struct map_stub
3937 {
3938   /* The stub section.  */
3939   asection *stub_sec;
3940   /* This is the section to which stubs in the group will be attached.  */
3941   asection *link_sec;
3942   /* Next group.  */
3943   struct map_stub *next;
3944   /* Whether to emit a copy of register save/restore functions in this
3945      group.  */
3946   int needs_save_res;
3947   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3948      or -1u if no such stub with bctrl exists.  */
3949   unsigned int tls_get_addr_opt_bctrl;
3950 };
3951
3952 struct ppc_stub_hash_entry {
3953
3954   /* Base hash table entry structure.  */
3955   struct bfd_hash_entry root;
3956
3957   enum ppc_stub_type stub_type;
3958
3959   /* Group information.  */
3960   struct map_stub *group;
3961
3962   /* Offset within stub_sec of the beginning of this stub.  */
3963   bfd_vma stub_offset;
3964
3965   /* Given the symbol's value and its section we can determine its final
3966      value when building the stubs (so the stub knows where to jump.  */
3967   bfd_vma target_value;
3968   asection *target_section;
3969
3970   /* The symbol table entry, if any, that this was derived from.  */
3971   struct ppc_link_hash_entry *h;
3972   struct plt_entry *plt_ent;
3973
3974   /* Symbol st_other.  */
3975   unsigned char other;
3976 };
3977
3978 struct ppc_branch_hash_entry {
3979
3980   /* Base hash table entry structure.  */
3981   struct bfd_hash_entry root;
3982
3983   /* Offset within branch lookup table.  */
3984   unsigned int offset;
3985
3986   /* Generation marker.  */
3987   unsigned int iter;
3988 };
3989
3990 /* Used to track dynamic relocations for local symbols.  */
3991 struct ppc_dyn_relocs
3992 {
3993   struct ppc_dyn_relocs *next;
3994
3995   /* The input section of the reloc.  */
3996   asection *sec;
3997
3998   /* Total number of relocs copied for the input section.  */
3999   unsigned int count : 31;
4000
4001   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4002   unsigned int ifunc : 1;
4003 };
4004
4005 struct ppc_link_hash_entry
4006 {
4007   struct elf_link_hash_entry elf;
4008
4009   union {
4010     /* A pointer to the most recently used stub hash entry against this
4011        symbol.  */
4012     struct ppc_stub_hash_entry *stub_cache;
4013
4014     /* A pointer to the next symbol starting with a '.'  */
4015     struct ppc_link_hash_entry *next_dot_sym;
4016   } u;
4017
4018   /* Track dynamic relocs copied for this symbol.  */
4019   struct elf_dyn_relocs *dyn_relocs;
4020
4021   /* Link between function code and descriptor symbols.  */
4022   struct ppc_link_hash_entry *oh;
4023
4024   /* Flag function code and descriptor symbols.  */
4025   unsigned int is_func:1;
4026   unsigned int is_func_descriptor:1;
4027   unsigned int fake:1;
4028
4029   /* Whether global opd/toc sym has been adjusted or not.
4030      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4031      should be set for all globals defined in any opd/toc section.  */
4032   unsigned int adjust_done:1;
4033
4034   /* Set if this is an out-of-line register save/restore function,
4035      with non-standard calling convention.  */
4036   unsigned int save_res:1;
4037
4038   /* Set if a duplicate symbol with non-zero localentry is detected,
4039      even when the duplicate symbol does not provide a definition.  */
4040   unsigned int non_zero_localentry:1;
4041
4042   /* Contexts in which symbol is used in the GOT (or TOC).
4043      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4044      corresponding relocs are encountered during check_relocs.
4045      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4046      indicate the corresponding GOT entry type is not needed.
4047      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4048      a TPREL one.  We use a separate flag rather than setting TPREL
4049      just for convenience in distinguishing the two cases.  */
4050 #define TLS_GD           1      /* GD reloc. */
4051 #define TLS_LD           2      /* LD reloc. */
4052 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4053 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4054 #define TLS_TLS         16      /* Any TLS reloc.  */
4055 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4056 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4057 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4058   unsigned char tls_mask;
4059 };
4060
4061 /* ppc64 ELF linker hash table.  */
4062
4063 struct ppc_link_hash_table
4064 {
4065   struct elf_link_hash_table elf;
4066
4067   /* The stub hash table.  */
4068   struct bfd_hash_table stub_hash_table;
4069
4070   /* Another hash table for plt_branch stubs.  */
4071   struct bfd_hash_table branch_hash_table;
4072
4073   /* Hash table for function prologue tocsave.  */
4074   htab_t tocsave_htab;
4075
4076   /* Various options and other info passed from the linker.  */
4077   struct ppc64_elf_params *params;
4078
4079   /* The size of sec_info below.  */
4080   unsigned int sec_info_arr_size;
4081
4082   /* Per-section array of extra section info.  Done this way rather
4083      than as part of ppc64_elf_section_data so we have the info for
4084      non-ppc64 sections.  */
4085   struct
4086   {
4087     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4088     bfd_vma toc_off;
4089
4090     union
4091     {
4092       /* The section group that this section belongs to.  */
4093       struct map_stub *group;
4094       /* A temp section list pointer.  */
4095       asection *list;
4096     } u;
4097   } *sec_info;
4098
4099   /* Linked list of groups.  */
4100   struct map_stub *group;
4101
4102   /* Temp used when calculating TOC pointers.  */
4103   bfd_vma toc_curr;
4104   bfd *toc_bfd;
4105   asection *toc_first_sec;
4106
4107   /* Used when adding symbols.  */
4108   struct ppc_link_hash_entry *dot_syms;
4109
4110   /* Shortcuts to get to dynamic linker sections.  */
4111   asection *glink;
4112   asection *global_entry;
4113   asection *sfpr;
4114   asection *brlt;
4115   asection *relbrlt;
4116   asection *glink_eh_frame;
4117
4118   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4119   struct ppc_link_hash_entry *tls_get_addr;
4120   struct ppc_link_hash_entry *tls_get_addr_fd;
4121
4122   /* The size of reliplt used by got entry relocs.  */
4123   bfd_size_type got_reli_size;
4124
4125   /* Statistics.  */
4126   unsigned long stub_count[ppc_stub_global_entry];
4127
4128   /* Number of stubs against global syms.  */
4129   unsigned long stub_globals;
4130
4131   /* Set if we're linking code with function descriptors.  */
4132   unsigned int opd_abi:1;
4133
4134   /* Support for multiple toc sections.  */
4135   unsigned int do_multi_toc:1;
4136   unsigned int multi_toc_needed:1;
4137   unsigned int second_toc_pass:1;
4138   unsigned int do_toc_opt:1;
4139
4140   /* Set if tls optimization is enabled.  */
4141   unsigned int do_tls_opt:1;
4142
4143   /* Set on error.  */
4144   unsigned int stub_error:1;
4145
4146   /* Whether func_desc_adjust needs to be run over symbols.  */
4147   unsigned int need_func_desc_adj:1;
4148
4149   /* Whether there exist local gnu indirect function resolvers,
4150      referenced by dynamic relocations.  */
4151   unsigned int local_ifunc_resolver:1;
4152   unsigned int maybe_local_ifunc_resolver:1;
4153
4154   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4155   unsigned int has_plt_localentry0:1;
4156
4157   /* Incremented every time we size stubs.  */
4158   unsigned int stub_iteration;
4159
4160   /* Small local sym cache.  */
4161   struct sym_cache sym_cache;
4162 };
4163
4164 /* Rename some of the generic section flags to better document how they
4165    are used here.  */
4166
4167 /* Nonzero if this section has TLS related relocations.  */
4168 #define has_tls_reloc sec_flg0
4169
4170 /* Nonzero if this section has a call to __tls_get_addr.  */
4171 #define has_tls_get_addr_call sec_flg1
4172
4173 /* Nonzero if this section has any toc or got relocs.  */
4174 #define has_toc_reloc sec_flg2
4175
4176 /* Nonzero if this section has a call to another section that uses
4177    the toc or got.  */
4178 #define makes_toc_func_call sec_flg3
4179
4180 /* Recursion protection when determining above flag.  */
4181 #define call_check_in_progress sec_flg4
4182 #define call_check_done sec_flg5
4183
4184 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4185
4186 #define ppc_hash_table(p) \
4187   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4188   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4189
4190 #define ppc_stub_hash_lookup(table, string, create, copy) \
4191   ((struct ppc_stub_hash_entry *) \
4192    bfd_hash_lookup ((table), (string), (create), (copy)))
4193
4194 #define ppc_branch_hash_lookup(table, string, create, copy) \
4195   ((struct ppc_branch_hash_entry *) \
4196    bfd_hash_lookup ((table), (string), (create), (copy)))
4197
4198 /* Create an entry in the stub hash table.  */
4199
4200 static struct bfd_hash_entry *
4201 stub_hash_newfunc (struct bfd_hash_entry *entry,
4202                    struct bfd_hash_table *table,
4203                    const char *string)
4204 {
4205   /* Allocate the structure if it has not already been allocated by a
4206      subclass.  */
4207   if (entry == NULL)
4208     {
4209       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4210       if (entry == NULL)
4211         return entry;
4212     }
4213
4214   /* Call the allocation method of the superclass.  */
4215   entry = bfd_hash_newfunc (entry, table, string);
4216   if (entry != NULL)
4217     {
4218       struct ppc_stub_hash_entry *eh;
4219
4220       /* Initialize the local fields.  */
4221       eh = (struct ppc_stub_hash_entry *) entry;
4222       eh->stub_type = ppc_stub_none;
4223       eh->group = NULL;
4224       eh->stub_offset = 0;
4225       eh->target_value = 0;
4226       eh->target_section = NULL;
4227       eh->h = NULL;
4228       eh->plt_ent = NULL;
4229       eh->other = 0;
4230     }
4231
4232   return entry;
4233 }
4234
4235 /* Create an entry in the branch hash table.  */
4236
4237 static struct bfd_hash_entry *
4238 branch_hash_newfunc (struct bfd_hash_entry *entry,
4239                      struct bfd_hash_table *table,
4240                      const char *string)
4241 {
4242   /* Allocate the structure if it has not already been allocated by a
4243      subclass.  */
4244   if (entry == NULL)
4245     {
4246       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4247       if (entry == NULL)
4248         return entry;
4249     }
4250
4251   /* Call the allocation method of the superclass.  */
4252   entry = bfd_hash_newfunc (entry, table, string);
4253   if (entry != NULL)
4254     {
4255       struct ppc_branch_hash_entry *eh;
4256
4257       /* Initialize the local fields.  */
4258       eh = (struct ppc_branch_hash_entry *) entry;
4259       eh->offset = 0;
4260       eh->iter = 0;
4261     }
4262
4263   return entry;
4264 }
4265
4266 /* Create an entry in a ppc64 ELF linker hash table.  */
4267
4268 static struct bfd_hash_entry *
4269 link_hash_newfunc (struct bfd_hash_entry *entry,
4270                    struct bfd_hash_table *table,
4271                    const char *string)
4272 {
4273   /* Allocate the structure if it has not already been allocated by a
4274      subclass.  */
4275   if (entry == NULL)
4276     {
4277       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4278       if (entry == NULL)
4279         return entry;
4280     }
4281
4282   /* Call the allocation method of the superclass.  */
4283   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4284   if (entry != NULL)
4285     {
4286       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4287
4288       memset (&eh->u.stub_cache, 0,
4289               (sizeof (struct ppc_link_hash_entry)
4290                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4291
4292       /* When making function calls, old ABI code references function entry
4293          points (dot symbols), while new ABI code references the function
4294          descriptor symbol.  We need to make any combination of reference and
4295          definition work together, without breaking archive linking.
4296
4297          For a defined function "foo" and an undefined call to "bar":
4298          An old object defines "foo" and ".foo", references ".bar" (possibly
4299          "bar" too).
4300          A new object defines "foo" and references "bar".
4301
4302          A new object thus has no problem with its undefined symbols being
4303          satisfied by definitions in an old object.  On the other hand, the
4304          old object won't have ".bar" satisfied by a new object.
4305
4306          Keep a list of newly added dot-symbols.  */
4307
4308       if (string[0] == '.')
4309         {
4310           struct ppc_link_hash_table *htab;
4311
4312           htab = (struct ppc_link_hash_table *) table;
4313           eh->u.next_dot_sym = htab->dot_syms;
4314           htab->dot_syms = eh;
4315         }
4316     }
4317
4318   return entry;
4319 }
4320
4321 struct tocsave_entry {
4322   asection *sec;
4323   bfd_vma offset;
4324 };
4325
4326 static hashval_t
4327 tocsave_htab_hash (const void *p)
4328 {
4329   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4330   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4331 }
4332
4333 static int
4334 tocsave_htab_eq (const void *p1, const void *p2)
4335 {
4336   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4337   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4338   return e1->sec == e2->sec && e1->offset == e2->offset;
4339 }
4340
4341 /* Destroy a ppc64 ELF linker hash table.  */
4342
4343 static void
4344 ppc64_elf_link_hash_table_free (bfd *obfd)
4345 {
4346   struct ppc_link_hash_table *htab;
4347
4348   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4349   if (htab->tocsave_htab)
4350     htab_delete (htab->tocsave_htab);
4351   bfd_hash_table_free (&htab->branch_hash_table);
4352   bfd_hash_table_free (&htab->stub_hash_table);
4353   _bfd_elf_link_hash_table_free (obfd);
4354 }
4355
4356 /* Create a ppc64 ELF linker hash table.  */
4357
4358 static struct bfd_link_hash_table *
4359 ppc64_elf_link_hash_table_create (bfd *abfd)
4360 {
4361   struct ppc_link_hash_table *htab;
4362   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4363
4364   htab = bfd_zmalloc (amt);
4365   if (htab == NULL)
4366     return NULL;
4367
4368   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4369                                       sizeof (struct ppc_link_hash_entry),
4370                                       PPC64_ELF_DATA))
4371     {
4372       free (htab);
4373       return NULL;
4374     }
4375
4376   /* Init the stub hash table too.  */
4377   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4378                             sizeof (struct ppc_stub_hash_entry)))
4379     {
4380       _bfd_elf_link_hash_table_free (abfd);
4381       return NULL;
4382     }
4383
4384   /* And the branch hash table.  */
4385   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4386                             sizeof (struct ppc_branch_hash_entry)))
4387     {
4388       bfd_hash_table_free (&htab->stub_hash_table);
4389       _bfd_elf_link_hash_table_free (abfd);
4390       return NULL;
4391     }
4392
4393   htab->tocsave_htab = htab_try_create (1024,
4394                                         tocsave_htab_hash,
4395                                         tocsave_htab_eq,
4396                                         NULL);
4397   if (htab->tocsave_htab == NULL)
4398     {
4399       ppc64_elf_link_hash_table_free (abfd);
4400       return NULL;
4401     }
4402   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4403
4404   /* Initializing two fields of the union is just cosmetic.  We really
4405      only care about glist, but when compiled on a 32-bit host the
4406      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4407      debugger inspection of these fields look nicer.  */
4408   htab->elf.init_got_refcount.refcount = 0;
4409   htab->elf.init_got_refcount.glist = NULL;
4410   htab->elf.init_plt_refcount.refcount = 0;
4411   htab->elf.init_plt_refcount.glist = NULL;
4412   htab->elf.init_got_offset.offset = 0;
4413   htab->elf.init_got_offset.glist = NULL;
4414   htab->elf.init_plt_offset.offset = 0;
4415   htab->elf.init_plt_offset.glist = NULL;
4416
4417   return &htab->elf.root;
4418 }
4419
4420 /* Create sections for linker generated code.  */
4421
4422 static bfd_boolean
4423 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4424 {
4425   struct ppc_link_hash_table *htab;
4426   flagword flags;
4427
4428   htab = ppc_hash_table (info);
4429
4430   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4431            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4432   if (htab->params->save_restore_funcs)
4433     {
4434       /* Create .sfpr for code to save and restore fp regs.  */
4435       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4436                                                        flags);
4437       if (htab->sfpr == NULL
4438           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4439         return FALSE;
4440     }
4441
4442   if (bfd_link_relocatable (info))
4443     return TRUE;
4444
4445   /* Create .glink for lazy dynamic linking support.  */
4446   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4447                                                     flags);
4448   if (htab->glink == NULL
4449       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4450     return FALSE;
4451
4452   /* The part of .glink used by global entry stubs, separate so that
4453      it can be aligned appropriately without affecting htab->glink.  */
4454   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4455                                                            flags);
4456   if (htab->global_entry == NULL
4457       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4458     return FALSE;
4459
4460   if (!info->no_ld_generated_unwind_info)
4461     {
4462       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4463                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4464       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4465                                                                  ".eh_frame",
4466                                                                  flags);
4467       if (htab->glink_eh_frame == NULL
4468           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4469         return FALSE;
4470     }
4471
4472   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4473   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4474   if (htab->elf.iplt == NULL
4475       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4476     return FALSE;
4477
4478   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4479            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4480   htab->elf.irelplt
4481     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4482   if (htab->elf.irelplt == NULL
4483       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4484     return FALSE;
4485
4486   /* Create branch lookup table for plt_branch stubs.  */
4487   flags = (SEC_ALLOC | SEC_LOAD
4488            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4489   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4490                                                    flags);
4491   if (htab->brlt == NULL
4492       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4493     return FALSE;
4494
4495   if (!bfd_link_pic (info))
4496     return TRUE;
4497
4498   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4499            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4500   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4501                                                       ".rela.branch_lt",
4502                                                       flags);
4503   if (htab->relbrlt == NULL
4504       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4505     return FALSE;
4506
4507   return TRUE;
4508 }
4509
4510 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4511
4512 bfd_boolean
4513 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4514                          struct ppc64_elf_params *params)
4515 {
4516   struct ppc_link_hash_table *htab;
4517
4518   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4519
4520 /* Always hook our dynamic sections into the first bfd, which is the
4521    linker created stub bfd.  This ensures that the GOT header is at
4522    the start of the output TOC section.  */
4523   htab = ppc_hash_table (info);
4524   htab->elf.dynobj = params->stub_bfd;
4525   htab->params = params;
4526
4527   return create_linkage_sections (htab->elf.dynobj, info);
4528 }
4529
4530 /* Build a name for an entry in the stub hash table.  */
4531
4532 static char *
4533 ppc_stub_name (const asection *input_section,
4534                const asection *sym_sec,
4535                const struct ppc_link_hash_entry *h,
4536                const Elf_Internal_Rela *rel)
4537 {
4538   char *stub_name;
4539   ssize_t len;
4540
4541   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4542      offsets from a sym as a branch target?  In fact, we could
4543      probably assume the addend is always zero.  */
4544   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4545
4546   if (h)
4547     {
4548       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4549       stub_name = bfd_malloc (len);
4550       if (stub_name == NULL)
4551         return stub_name;
4552
4553       len = sprintf (stub_name, "%08x.%s+%x",
4554                      input_section->id & 0xffffffff,
4555                      h->elf.root.root.string,
4556                      (int) rel->r_addend & 0xffffffff);
4557     }
4558   else
4559     {
4560       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4561       stub_name = bfd_malloc (len);
4562       if (stub_name == NULL)
4563         return stub_name;
4564
4565       len = sprintf (stub_name, "%08x.%x:%x+%x",
4566                      input_section->id & 0xffffffff,
4567                      sym_sec->id & 0xffffffff,
4568                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4569                      (int) rel->r_addend & 0xffffffff);
4570     }
4571   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4572     stub_name[len - 2] = 0;
4573   return stub_name;
4574 }
4575
4576 /* Look up an entry in the stub hash.  Stub entries are cached because
4577    creating the stub name takes a bit of time.  */
4578
4579 static struct ppc_stub_hash_entry *
4580 ppc_get_stub_entry (const asection *input_section,
4581                     const asection *sym_sec,
4582                     struct ppc_link_hash_entry *h,
4583                     const Elf_Internal_Rela *rel,
4584                     struct ppc_link_hash_table *htab)
4585 {
4586   struct ppc_stub_hash_entry *stub_entry;
4587   struct map_stub *group;
4588
4589   /* If this input section is part of a group of sections sharing one
4590      stub section, then use the id of the first section in the group.
4591      Stub names need to include a section id, as there may well be
4592      more than one stub used to reach say, printf, and we need to
4593      distinguish between them.  */
4594   group = htab->sec_info[input_section->id].u.group;
4595   if (group == NULL)
4596     return NULL;
4597
4598   if (h != NULL && h->u.stub_cache != NULL
4599       && h->u.stub_cache->h == h
4600       && h->u.stub_cache->group == group)
4601     {
4602       stub_entry = h->u.stub_cache;
4603     }
4604   else
4605     {
4606       char *stub_name;
4607
4608       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4609       if (stub_name == NULL)
4610         return NULL;
4611
4612       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4613                                          stub_name, FALSE, FALSE);
4614       if (h != NULL)
4615         h->u.stub_cache = stub_entry;
4616
4617       free (stub_name);
4618     }
4619
4620   return stub_entry;
4621 }
4622
4623 /* Add a new stub entry to the stub hash.  Not all fields of the new
4624    stub entry are initialised.  */
4625
4626 static struct ppc_stub_hash_entry *
4627 ppc_add_stub (const char *stub_name,
4628               asection *section,
4629               struct bfd_link_info *info)
4630 {
4631   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4632   struct map_stub *group;
4633   asection *link_sec;
4634   asection *stub_sec;
4635   struct ppc_stub_hash_entry *stub_entry;
4636
4637   group = htab->sec_info[section->id].u.group;
4638   link_sec = group->link_sec;
4639   stub_sec = group->stub_sec;
4640   if (stub_sec == NULL)
4641     {
4642       size_t namelen;
4643       bfd_size_type len;
4644       char *s_name;
4645
4646       namelen = strlen (link_sec->name);
4647       len = namelen + sizeof (STUB_SUFFIX);
4648       s_name = bfd_alloc (htab->params->stub_bfd, len);
4649       if (s_name == NULL)
4650         return NULL;
4651
4652       memcpy (s_name, link_sec->name, namelen);
4653       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4654       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4655       if (stub_sec == NULL)
4656         return NULL;
4657       group->stub_sec = stub_sec;
4658     }
4659
4660   /* Enter this entry into the linker stub hash table.  */
4661   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4662                                      TRUE, FALSE);
4663   if (stub_entry == NULL)
4664     {
4665       /* xgettext:c-format */
4666       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4667                           section->owner, stub_name);
4668       return NULL;
4669     }
4670
4671   stub_entry->group = group;
4672   stub_entry->stub_offset = 0;
4673   return stub_entry;
4674 }
4675
4676 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4677    not already done.  */
4678
4679 static bfd_boolean
4680 create_got_section (bfd *abfd, struct bfd_link_info *info)
4681 {
4682   asection *got, *relgot;
4683   flagword flags;
4684   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4685
4686   if (!is_ppc64_elf (abfd))
4687     return FALSE;
4688   if (htab == NULL)
4689     return FALSE;
4690
4691   if (!htab->elf.sgot
4692       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4693     return FALSE;
4694
4695   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4696            | SEC_LINKER_CREATED);
4697
4698   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4699   if (!got
4700       || !bfd_set_section_alignment (abfd, got, 3))
4701     return FALSE;
4702
4703   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4704                                                flags | SEC_READONLY);
4705   if (!relgot
4706       || ! bfd_set_section_alignment (abfd, relgot, 3))
4707     return FALSE;
4708
4709   ppc64_elf_tdata (abfd)->got = got;
4710   ppc64_elf_tdata (abfd)->relgot = relgot;
4711   return TRUE;
4712 }
4713
4714 /* Follow indirect and warning symbol links.  */
4715
4716 static inline struct bfd_link_hash_entry *
4717 follow_link (struct bfd_link_hash_entry *h)
4718 {
4719   while (h->type == bfd_link_hash_indirect
4720          || h->type == bfd_link_hash_warning)
4721     h = h->u.i.link;
4722   return h;
4723 }
4724
4725 static inline struct elf_link_hash_entry *
4726 elf_follow_link (struct elf_link_hash_entry *h)
4727 {
4728   return (struct elf_link_hash_entry *) follow_link (&h->root);
4729 }
4730
4731 static inline struct ppc_link_hash_entry *
4732 ppc_follow_link (struct ppc_link_hash_entry *h)
4733 {
4734   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4735 }
4736
4737 /* Merge PLT info on FROM with that on TO.  */
4738
4739 static void
4740 move_plt_plist (struct ppc_link_hash_entry *from,
4741                 struct ppc_link_hash_entry *to)
4742 {
4743   if (from->elf.plt.plist != NULL)
4744     {
4745       if (to->elf.plt.plist != NULL)
4746         {
4747           struct plt_entry **entp;
4748           struct plt_entry *ent;
4749
4750           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4751             {
4752               struct plt_entry *dent;
4753
4754               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4755                 if (dent->addend == ent->addend)
4756                   {
4757                     dent->plt.refcount += ent->plt.refcount;
4758                     *entp = ent->next;
4759                     break;
4760                   }
4761               if (dent == NULL)
4762                 entp = &ent->next;
4763             }
4764           *entp = to->elf.plt.plist;
4765         }
4766
4767       to->elf.plt.plist = from->elf.plt.plist;
4768       from->elf.plt.plist = NULL;
4769     }
4770 }
4771
4772 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4773
4774 static void
4775 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4776                                 struct elf_link_hash_entry *dir,
4777                                 struct elf_link_hash_entry *ind)
4778 {
4779   struct ppc_link_hash_entry *edir, *eind;
4780
4781   edir = (struct ppc_link_hash_entry *) dir;
4782   eind = (struct ppc_link_hash_entry *) ind;
4783
4784   edir->is_func |= eind->is_func;
4785   edir->is_func_descriptor |= eind->is_func_descriptor;
4786   edir->tls_mask |= eind->tls_mask;
4787   if (eind->oh != NULL)
4788     edir->oh = ppc_follow_link (eind->oh);
4789
4790   if (edir->elf.versioned != versioned_hidden)
4791     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4792   edir->elf.ref_regular |= eind->elf.ref_regular;
4793   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4794   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4795   edir->elf.needs_plt |= eind->elf.needs_plt;
4796   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4797
4798   /* If we were called to copy over info for a weak sym, don't copy
4799      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4800      in order to simplify readonly_dynrelocs and save a field in the
4801      symbol hash entry, but that means dyn_relocs can't be used in any
4802      tests about a specific symbol, or affect other symbol flags which
4803      are then tested.  */
4804   if (eind->elf.root.type != bfd_link_hash_indirect)
4805     return;
4806
4807   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4808   if (eind->dyn_relocs != NULL)
4809     {
4810       if (edir->dyn_relocs != NULL)
4811         {
4812           struct elf_dyn_relocs **pp;
4813           struct elf_dyn_relocs *p;
4814
4815           /* Add reloc counts against the indirect sym to the direct sym
4816              list.  Merge any entries against the same section.  */
4817           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4818             {
4819               struct elf_dyn_relocs *q;
4820
4821               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4822                 if (q->sec == p->sec)
4823                   {
4824                     q->pc_count += p->pc_count;
4825                     q->count += p->count;
4826                     *pp = p->next;
4827                     break;
4828                   }
4829               if (q == NULL)
4830                 pp = &p->next;
4831             }
4832           *pp = edir->dyn_relocs;
4833         }
4834
4835       edir->dyn_relocs = eind->dyn_relocs;
4836       eind->dyn_relocs = NULL;
4837     }
4838
4839   /* Copy over got entries that we may have already seen to the
4840      symbol which just became indirect.  */
4841   if (eind->elf.got.glist != NULL)
4842     {
4843       if (edir->elf.got.glist != NULL)
4844         {
4845           struct got_entry **entp;
4846           struct got_entry *ent;
4847
4848           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4849             {
4850               struct got_entry *dent;
4851
4852               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4853                 if (dent->addend == ent->addend
4854                     && dent->owner == ent->owner
4855                     && dent->tls_type == ent->tls_type)
4856                   {
4857                     dent->got.refcount += ent->got.refcount;
4858                     *entp = ent->next;
4859                     break;
4860                   }
4861               if (dent == NULL)
4862                 entp = &ent->next;
4863             }
4864           *entp = edir->elf.got.glist;
4865         }
4866
4867       edir->elf.got.glist = eind->elf.got.glist;
4868       eind->elf.got.glist = NULL;
4869     }
4870
4871   /* And plt entries.  */
4872   move_plt_plist (eind, edir);
4873
4874   if (eind->elf.dynindx != -1)
4875     {
4876       if (edir->elf.dynindx != -1)
4877         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4878                                 edir->elf.dynstr_index);
4879       edir->elf.dynindx = eind->elf.dynindx;
4880       edir->elf.dynstr_index = eind->elf.dynstr_index;
4881       eind->elf.dynindx = -1;
4882       eind->elf.dynstr_index = 0;
4883     }
4884 }
4885
4886 /* Find the function descriptor hash entry from the given function code
4887    hash entry FH.  Link the entries via their OH fields.  */
4888
4889 static struct ppc_link_hash_entry *
4890 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4891 {
4892   struct ppc_link_hash_entry *fdh = fh->oh;
4893
4894   if (fdh == NULL)
4895     {
4896       const char *fd_name = fh->elf.root.root.string + 1;
4897
4898       fdh = (struct ppc_link_hash_entry *)
4899         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4900       if (fdh == NULL)
4901         return fdh;
4902
4903       fdh->is_func_descriptor = 1;
4904       fdh->oh = fh;
4905       fh->is_func = 1;
4906       fh->oh = fdh;
4907     }
4908
4909   fdh = ppc_follow_link (fdh);
4910   fdh->is_func_descriptor = 1;
4911   fdh->oh = fh;
4912   return fdh;
4913 }
4914
4915 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4916
4917 static struct ppc_link_hash_entry *
4918 make_fdh (struct bfd_link_info *info,
4919           struct ppc_link_hash_entry *fh)
4920 {
4921   bfd *abfd = fh->elf.root.u.undef.abfd;
4922   struct bfd_link_hash_entry *bh = NULL;
4923   struct ppc_link_hash_entry *fdh;
4924   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4925                     ? BSF_WEAK
4926                     : BSF_GLOBAL);
4927
4928   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4929                                          fh->elf.root.root.string + 1,
4930                                          flags, bfd_und_section_ptr, 0,
4931                                          NULL, FALSE, FALSE, &bh))
4932     return NULL;
4933
4934   fdh = (struct ppc_link_hash_entry *) bh;
4935   fdh->elf.non_elf = 0;
4936   fdh->fake = 1;
4937   fdh->is_func_descriptor = 1;
4938   fdh->oh = fh;
4939   fh->is_func = 1;
4940   fh->oh = fdh;
4941   return fdh;
4942 }
4943
4944 /* Fix function descriptor symbols defined in .opd sections to be
4945    function type.  */
4946
4947 static bfd_boolean
4948 ppc64_elf_add_symbol_hook (bfd *ibfd,
4949                            struct bfd_link_info *info,
4950                            Elf_Internal_Sym *isym,
4951                            const char **name,
4952                            flagword *flags ATTRIBUTE_UNUSED,
4953                            asection **sec,
4954                            bfd_vma *value)
4955 {
4956   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4957       && (ibfd->flags & DYNAMIC) == 0
4958       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4959     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4960
4961   if (*sec != NULL
4962       && strcmp ((*sec)->name, ".opd") == 0)
4963     {
4964       asection *code_sec;
4965
4966       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4967             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4968         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4969
4970       /* If the symbol is a function defined in .opd, and the function
4971          code is in a discarded group, let it appear to be undefined.  */
4972       if (!bfd_link_relocatable (info)
4973           && (*sec)->reloc_count != 0
4974           && opd_entry_value (*sec, *value, &code_sec, NULL,
4975                               FALSE) != (bfd_vma) -1
4976           && discarded_section (code_sec))
4977         {
4978           *sec = bfd_und_section_ptr;
4979           isym->st_shndx = SHN_UNDEF;
4980         }
4981     }
4982   else if (*sec != NULL
4983            && strcmp ((*sec)->name, ".toc") == 0
4984            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4985     {
4986       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4987       if (htab != NULL)
4988         htab->params->object_in_toc = 1;
4989     }
4990
4991   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4992     {
4993       if (abiversion (ibfd) == 0)
4994         set_abiversion (ibfd, 2);
4995       else if (abiversion (ibfd) == 1)
4996         {
4997           _bfd_error_handler (_("symbol '%s' has invalid st_other"
4998                                 " for ABI version 1"), *name);
4999           bfd_set_error (bfd_error_bad_value);
5000           return FALSE;
5001         }
5002     }
5003
5004   return TRUE;
5005 }
5006
5007 /* Merge non-visibility st_other attributes: local entry point.  */
5008
5009 static void
5010 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5011                                   const Elf_Internal_Sym *isym,
5012                                   bfd_boolean definition,
5013                                   bfd_boolean dynamic)
5014 {
5015   if (definition && (!dynamic || !h->def_regular))
5016     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5017                 | ELF_ST_VISIBILITY (h->other));
5018 }
5019
5020 /* Hook called on merging a symbol.  We use this to clear "fake" since
5021    we now have a real symbol.  */
5022
5023 static bfd_boolean
5024 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5025                         const Elf_Internal_Sym *isym,
5026                         asection **psec ATTRIBUTE_UNUSED,
5027                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5028                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5029                         bfd *oldbfd ATTRIBUTE_UNUSED,
5030                         const asection *oldsec ATTRIBUTE_UNUSED)
5031 {
5032   ((struct ppc_link_hash_entry *) h)->fake = 0;
5033   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5034     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5035   return TRUE;
5036 }
5037
5038 /* This function makes an old ABI object reference to ".bar" cause the
5039    inclusion of a new ABI object archive that defines "bar".
5040    NAME is a symbol defined in an archive.  Return a symbol in the hash
5041    table that might be satisfied by the archive symbols.  */
5042
5043 static struct elf_link_hash_entry *
5044 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5045                                  struct bfd_link_info *info,
5046                                  const char *name)
5047 {
5048   struct elf_link_hash_entry *h;
5049   char *dot_name;
5050   size_t len;
5051
5052   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5053   if (h != NULL
5054       /* Don't return this sym if it is a fake function descriptor
5055          created by add_symbol_adjust.  */
5056       && !((struct ppc_link_hash_entry *) h)->fake)
5057     return h;
5058
5059   if (name[0] == '.')
5060     return h;
5061
5062   len = strlen (name);
5063   dot_name = bfd_alloc (abfd, len + 2);
5064   if (dot_name == NULL)
5065     return (struct elf_link_hash_entry *) -1;
5066   dot_name[0] = '.';
5067   memcpy (dot_name + 1, name, len + 1);
5068   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5069   bfd_release (abfd, dot_name);
5070   return h;
5071 }
5072
5073 /* This function satisfies all old ABI object references to ".bar" if a
5074    new ABI object defines "bar".  Well, at least, undefined dot symbols
5075    are made weak.  This stops later archive searches from including an
5076    object if we already have a function descriptor definition.  It also
5077    prevents the linker complaining about undefined symbols.
5078    We also check and correct mismatched symbol visibility here.  The
5079    most restrictive visibility of the function descriptor and the
5080    function entry symbol is used.  */
5081
5082 static bfd_boolean
5083 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5084 {
5085   struct ppc_link_hash_table *htab;
5086   struct ppc_link_hash_entry *fdh;
5087
5088   if (eh->elf.root.type == bfd_link_hash_warning)
5089     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5090
5091   if (eh->elf.root.type == bfd_link_hash_indirect)
5092     return TRUE;
5093
5094   if (eh->elf.root.root.string[0] != '.')
5095     abort ();
5096
5097   htab = ppc_hash_table (info);
5098   if (htab == NULL)
5099     return FALSE;
5100
5101   fdh = lookup_fdh (eh, htab);
5102   if (fdh == NULL
5103       && !bfd_link_relocatable (info)
5104       && (eh->elf.root.type == bfd_link_hash_undefined
5105           || eh->elf.root.type == bfd_link_hash_undefweak)
5106       && eh->elf.ref_regular)
5107     {
5108       /* Make an undefined function descriptor sym, in order to
5109          pull in an --as-needed shared lib.  Archives are handled
5110          elsewhere.  */
5111       fdh = make_fdh (info, eh);
5112       if (fdh == NULL)
5113         return FALSE;
5114     }
5115
5116   if (fdh != NULL)
5117     {
5118       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5119       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5120
5121       /* Make both descriptor and entry symbol have the most
5122          constraining visibility of either symbol.  */
5123       if (entry_vis < descr_vis)
5124         fdh->elf.other += entry_vis - descr_vis;
5125       else if (entry_vis > descr_vis)
5126         eh->elf.other += descr_vis - entry_vis;
5127
5128       /* Propagate reference flags from entry symbol to function
5129          descriptor symbol.  */
5130       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5131       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5132       fdh->elf.ref_regular |= eh->elf.ref_regular;
5133       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5134
5135       if (!fdh->elf.forced_local
5136           && fdh->elf.dynindx == -1
5137           && fdh->elf.versioned != versioned_hidden
5138           && (bfd_link_dll (info)
5139               || fdh->elf.def_dynamic
5140               || fdh->elf.ref_dynamic)
5141           && (eh->elf.ref_regular
5142               || eh->elf.def_regular))
5143         {
5144           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5145             return FALSE;
5146         }
5147     }
5148
5149   return TRUE;
5150 }
5151
5152 /* Set up opd section info and abiversion for IBFD, and process list
5153    of dot-symbols we made in link_hash_newfunc.  */
5154
5155 static bfd_boolean
5156 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5157 {
5158   struct ppc_link_hash_table *htab;
5159   struct ppc_link_hash_entry **p, *eh;
5160   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5161
5162   if (opd != NULL && opd->size != 0)
5163     {
5164       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5165       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5166
5167       if (abiversion (ibfd) == 0)
5168         set_abiversion (ibfd, 1);
5169       else if (abiversion (ibfd) >= 2)
5170         {
5171           /* xgettext:c-format */
5172           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5173                               ibfd, abiversion (ibfd));
5174           bfd_set_error (bfd_error_bad_value);
5175           return FALSE;
5176         }
5177     }
5178
5179   if (is_ppc64_elf (info->output_bfd))
5180     {
5181       /* For input files without an explicit abiversion in e_flags
5182          we should have flagged any with symbol st_other bits set
5183          as ELFv1 and above flagged those with .opd as ELFv2.
5184          Set the output abiversion if not yet set, and for any input
5185          still ambiguous, take its abiversion from the output.
5186          Differences in ABI are reported later.  */
5187       if (abiversion (info->output_bfd) == 0)
5188         set_abiversion (info->output_bfd, abiversion (ibfd));
5189       else if (abiversion (ibfd) == 0)
5190         set_abiversion (ibfd, abiversion (info->output_bfd));
5191     }
5192
5193   htab = ppc_hash_table (info);
5194   if (htab == NULL)
5195     return TRUE;
5196
5197   if (opd != NULL && opd->size != 0
5198       && (ibfd->flags & DYNAMIC) == 0
5199       && (opd->flags & SEC_RELOC) != 0
5200       && opd->reloc_count != 0
5201       && !bfd_is_abs_section (opd->output_section)
5202       && info->gc_sections)
5203     {
5204       /* Garbage collection needs some extra help with .opd sections.
5205          We don't want to necessarily keep everything referenced by
5206          relocs in .opd, as that would keep all functions.  Instead,
5207          if we reference an .opd symbol (a function descriptor), we
5208          want to keep the function code symbol's section.  This is
5209          easy for global symbols, but for local syms we need to keep
5210          information about the associated function section.  */
5211       bfd_size_type amt;
5212       asection **opd_sym_map;
5213       Elf_Internal_Shdr *symtab_hdr;
5214       Elf_Internal_Rela *relocs, *rel_end, *rel;
5215
5216       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5217       opd_sym_map = bfd_zalloc (ibfd, amt);
5218       if (opd_sym_map == NULL)
5219         return FALSE;
5220       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5221       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5222                                           info->keep_memory);
5223       if (relocs == NULL)
5224         return FALSE;
5225       symtab_hdr = &elf_symtab_hdr (ibfd);
5226       rel_end = relocs + opd->reloc_count - 1;
5227       for (rel = relocs; rel < rel_end; rel++)
5228         {
5229           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5230           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5231
5232           if (r_type == R_PPC64_ADDR64
5233               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5234               && r_symndx < symtab_hdr->sh_info)
5235             {
5236               Elf_Internal_Sym *isym;
5237               asection *s;
5238
5239               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5240               if (isym == NULL)
5241                 {
5242                   if (elf_section_data (opd)->relocs != relocs)
5243                     free (relocs);
5244                   return FALSE;
5245                 }
5246
5247               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5248               if (s != NULL && s != opd)
5249                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5250             }
5251         }
5252       if (elf_section_data (opd)->relocs != relocs)
5253         free (relocs);
5254     }
5255
5256   p = &htab->dot_syms;
5257   while ((eh = *p) != NULL)
5258     {
5259       *p = NULL;
5260       if (&eh->elf == htab->elf.hgot)
5261         ;
5262       else if (htab->elf.hgot == NULL
5263                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5264         htab->elf.hgot = &eh->elf;
5265       else if (abiversion (ibfd) <= 1)
5266         {
5267           htab->need_func_desc_adj = 1;
5268           if (!add_symbol_adjust (eh, info))
5269             return FALSE;
5270         }
5271       p = &eh->u.next_dot_sym;
5272     }
5273   return TRUE;
5274 }
5275
5276 /* Undo hash table changes when an --as-needed input file is determined
5277    not to be needed.  */
5278
5279 static bfd_boolean
5280 ppc64_elf_notice_as_needed (bfd *ibfd,
5281                             struct bfd_link_info *info,
5282                             enum notice_asneeded_action act)
5283 {
5284   if (act == notice_not_needed)
5285     {
5286       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5287
5288       if (htab == NULL)
5289         return FALSE;
5290
5291       htab->dot_syms = NULL;
5292     }
5293   return _bfd_elf_notice_as_needed (ibfd, info, act);
5294 }
5295
5296 /* If --just-symbols against a final linked binary, then assume we need
5297    toc adjusting stubs when calling functions defined there.  */
5298
5299 static void
5300 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5301 {
5302   if ((sec->flags & SEC_CODE) != 0
5303       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5304       && is_ppc64_elf (sec->owner))
5305     {
5306       if (abiversion (sec->owner) >= 2
5307           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5308         sec->has_toc_reloc = 1;
5309     }
5310   _bfd_elf_link_just_syms (sec, info);
5311 }
5312
5313 static struct plt_entry **
5314 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5315                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5316 {
5317   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5318   struct plt_entry **local_plt;
5319   unsigned char *local_got_tls_masks;
5320
5321   if (local_got_ents == NULL)
5322     {
5323       bfd_size_type size = symtab_hdr->sh_info;
5324
5325       size *= (sizeof (*local_got_ents)
5326                + sizeof (*local_plt)
5327                + sizeof (*local_got_tls_masks));
5328       local_got_ents = bfd_zalloc (abfd, size);
5329       if (local_got_ents == NULL)
5330         return NULL;
5331       elf_local_got_ents (abfd) = local_got_ents;
5332     }
5333
5334   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5335     {
5336       struct got_entry *ent;
5337
5338       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5339         if (ent->addend == r_addend
5340             && ent->owner == abfd
5341             && ent->tls_type == tls_type)
5342           break;
5343       if (ent == NULL)
5344         {
5345           bfd_size_type amt = sizeof (*ent);
5346           ent = bfd_alloc (abfd, amt);
5347           if (ent == NULL)
5348             return FALSE;
5349           ent->next = local_got_ents[r_symndx];
5350           ent->addend = r_addend;
5351           ent->owner = abfd;
5352           ent->tls_type = tls_type;
5353           ent->is_indirect = FALSE;
5354           ent->got.refcount = 0;
5355           local_got_ents[r_symndx] = ent;
5356         }
5357       ent->got.refcount += 1;
5358     }
5359
5360   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5361   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5362   local_got_tls_masks[r_symndx] |= tls_type;
5363
5364   return local_plt + r_symndx;
5365 }
5366
5367 static bfd_boolean
5368 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5369 {
5370   struct plt_entry *ent;
5371
5372   for (ent = *plist; ent != NULL; ent = ent->next)
5373     if (ent->addend == addend)
5374       break;
5375   if (ent == NULL)
5376     {
5377       bfd_size_type amt = sizeof (*ent);
5378       ent = bfd_alloc (abfd, amt);
5379       if (ent == NULL)
5380         return FALSE;
5381       ent->next = *plist;
5382       ent->addend = addend;
5383       ent->plt.refcount = 0;
5384       *plist = ent;
5385     }
5386   ent->plt.refcount += 1;
5387   return TRUE;
5388 }
5389
5390 static bfd_boolean
5391 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5392 {
5393   return (r_type == R_PPC64_REL24
5394           || r_type == R_PPC64_REL14
5395           || r_type == R_PPC64_REL14_BRTAKEN
5396           || r_type == R_PPC64_REL14_BRNTAKEN
5397           || r_type == R_PPC64_ADDR24
5398           || r_type == R_PPC64_ADDR14
5399           || r_type == R_PPC64_ADDR14_BRTAKEN
5400           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5401 }
5402
5403 /* Look through the relocs for a section during the first phase, and
5404    calculate needed space in the global offset table, procedure
5405    linkage table, and dynamic reloc sections.  */
5406
5407 static bfd_boolean
5408 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5409                         asection *sec, const Elf_Internal_Rela *relocs)
5410 {
5411   struct ppc_link_hash_table *htab;
5412   Elf_Internal_Shdr *symtab_hdr;
5413   struct elf_link_hash_entry **sym_hashes;
5414   const Elf_Internal_Rela *rel;
5415   const Elf_Internal_Rela *rel_end;
5416   asection *sreloc;
5417   struct elf_link_hash_entry *tga, *dottga;
5418   bfd_boolean is_opd;
5419
5420   if (bfd_link_relocatable (info))
5421     return TRUE;
5422
5423   /* Don't do anything special with non-loaded, non-alloced sections.
5424      In particular, any relocs in such sections should not affect GOT
5425      and PLT reference counting (ie. we don't allow them to create GOT
5426      or PLT entries), there's no possibility or desire to optimize TLS
5427      relocs, and there's not much point in propagating relocs to shared
5428      libs that the dynamic linker won't relocate.  */
5429   if ((sec->flags & SEC_ALLOC) == 0)
5430     return TRUE;
5431
5432   BFD_ASSERT (is_ppc64_elf (abfd));
5433
5434   htab = ppc_hash_table (info);
5435   if (htab == NULL)
5436     return FALSE;
5437
5438   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5439                               FALSE, FALSE, TRUE);
5440   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5441                                  FALSE, FALSE, TRUE);
5442   symtab_hdr = &elf_symtab_hdr (abfd);
5443   sym_hashes = elf_sym_hashes (abfd);
5444   sreloc = NULL;
5445   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5446   rel_end = relocs + sec->reloc_count;
5447   for (rel = relocs; rel < rel_end; rel++)
5448     {
5449       unsigned long r_symndx;
5450       struct elf_link_hash_entry *h;
5451       enum elf_ppc64_reloc_type r_type;
5452       int tls_type;
5453       struct _ppc64_elf_section_data *ppc64_sec;
5454       struct plt_entry **ifunc, **plt_list;
5455
5456       r_symndx = ELF64_R_SYM (rel->r_info);
5457       if (r_symndx < symtab_hdr->sh_info)
5458         h = NULL;
5459       else
5460         {
5461           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5462           h = elf_follow_link (h);
5463
5464           if (h == htab->elf.hgot)
5465             sec->has_toc_reloc = 1;
5466         }
5467
5468       tls_type = 0;
5469       ifunc = NULL;
5470       if (h != NULL)
5471         {
5472           if (h->type == STT_GNU_IFUNC)
5473             {
5474               h->needs_plt = 1;
5475               ifunc = &h->plt.plist;
5476             }
5477         }
5478       else
5479         {
5480           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5481                                                           abfd, r_symndx);
5482           if (isym == NULL)
5483             return FALSE;
5484
5485           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5486             {
5487               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5488                                              rel->r_addend, PLT_IFUNC);
5489               if (ifunc == NULL)
5490                 return FALSE;
5491             }
5492         }
5493
5494       r_type = ELF64_R_TYPE (rel->r_info);
5495       switch (r_type)
5496         {
5497         case R_PPC64_TLSGD:
5498         case R_PPC64_TLSLD:
5499           /* These special tls relocs tie a call to __tls_get_addr with
5500              its parameter symbol.  */
5501           break;
5502
5503         case R_PPC64_GOT_TLSLD16:
5504         case R_PPC64_GOT_TLSLD16_LO:
5505         case R_PPC64_GOT_TLSLD16_HI:
5506         case R_PPC64_GOT_TLSLD16_HA:
5507           tls_type = TLS_TLS | TLS_LD;
5508           goto dogottls;
5509
5510         case R_PPC64_GOT_TLSGD16:
5511         case R_PPC64_GOT_TLSGD16_LO:
5512         case R_PPC64_GOT_TLSGD16_HI:
5513         case R_PPC64_GOT_TLSGD16_HA:
5514           tls_type = TLS_TLS | TLS_GD;
5515           goto dogottls;
5516
5517         case R_PPC64_GOT_TPREL16_DS:
5518         case R_PPC64_GOT_TPREL16_LO_DS:
5519         case R_PPC64_GOT_TPREL16_HI:
5520         case R_PPC64_GOT_TPREL16_HA:
5521           if (bfd_link_dll (info))
5522             info->flags |= DF_STATIC_TLS;
5523           tls_type = TLS_TLS | TLS_TPREL;
5524           goto dogottls;
5525
5526         case R_PPC64_GOT_DTPREL16_DS:
5527         case R_PPC64_GOT_DTPREL16_LO_DS:
5528         case R_PPC64_GOT_DTPREL16_HI:
5529         case R_PPC64_GOT_DTPREL16_HA:
5530           tls_type = TLS_TLS | TLS_DTPREL;
5531         dogottls:
5532           sec->has_tls_reloc = 1;
5533           /* Fall through */
5534
5535         case R_PPC64_GOT16:
5536         case R_PPC64_GOT16_DS:
5537         case R_PPC64_GOT16_HA:
5538         case R_PPC64_GOT16_HI:
5539         case R_PPC64_GOT16_LO:
5540         case R_PPC64_GOT16_LO_DS:
5541           /* This symbol requires a global offset table entry.  */
5542           sec->has_toc_reloc = 1;
5543           if (r_type == R_PPC64_GOT_TLSLD16
5544               || r_type == R_PPC64_GOT_TLSGD16
5545               || r_type == R_PPC64_GOT_TPREL16_DS
5546               || r_type == R_PPC64_GOT_DTPREL16_DS
5547               || r_type == R_PPC64_GOT16
5548               || r_type == R_PPC64_GOT16_DS)
5549             {
5550               htab->do_multi_toc = 1;
5551               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5552             }
5553
5554           if (ppc64_elf_tdata (abfd)->got == NULL
5555               && !create_got_section (abfd, info))
5556             return FALSE;
5557
5558           if (h != NULL)
5559             {
5560               struct ppc_link_hash_entry *eh;
5561               struct got_entry *ent;
5562
5563               eh = (struct ppc_link_hash_entry *) h;
5564               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5565                 if (ent->addend == rel->r_addend
5566                     && ent->owner == abfd
5567                     && ent->tls_type == tls_type)
5568                   break;
5569               if (ent == NULL)
5570                 {
5571                   bfd_size_type amt = sizeof (*ent);
5572                   ent = bfd_alloc (abfd, amt);
5573                   if (ent == NULL)
5574                     return FALSE;
5575                   ent->next = eh->elf.got.glist;
5576                   ent->addend = rel->r_addend;
5577                   ent->owner = abfd;
5578                   ent->tls_type = tls_type;
5579                   ent->is_indirect = FALSE;
5580                   ent->got.refcount = 0;
5581                   eh->elf.got.glist = ent;
5582                 }
5583               ent->got.refcount += 1;
5584               eh->tls_mask |= tls_type;
5585             }
5586           else
5587             /* This is a global offset table entry for a local symbol.  */
5588             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5589                                         rel->r_addend, tls_type))
5590               return FALSE;
5591
5592           /* We may also need a plt entry if the symbol turns out to be
5593              an ifunc.  */
5594           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5595             {
5596               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5597                 return FALSE;
5598             }
5599           break;
5600
5601         case R_PPC64_PLT16_HA:
5602         case R_PPC64_PLT16_HI:
5603         case R_PPC64_PLT16_LO:
5604         case R_PPC64_PLT32:
5605         case R_PPC64_PLT64:
5606           /* This symbol requires a procedure linkage table entry.  */
5607           plt_list = ifunc;
5608           if (h != NULL)
5609             {
5610               h->needs_plt = 1;
5611               if (h->root.root.string[0] == '.'
5612                   && h->root.root.string[1] != '\0')
5613                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5614               plt_list = &h->plt.plist;
5615             }
5616           if (plt_list == NULL)
5617             {
5618               /* It does not make sense to have a procedure linkage
5619                  table entry for a non-ifunc local symbol.  */
5620               info->callbacks->einfo
5621                 /* xgettext:c-format */
5622                 (_("%H: %s reloc against local symbol\n"),
5623                  abfd, sec, rel->r_offset,
5624                  ppc64_elf_howto_table[r_type]->name);
5625               bfd_set_error (bfd_error_bad_value);
5626               return FALSE;
5627             }
5628           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5629             return FALSE;
5630           break;
5631
5632           /* The following relocations don't need to propagate the
5633              relocation if linking a shared object since they are
5634              section relative.  */
5635         case R_PPC64_SECTOFF:
5636         case R_PPC64_SECTOFF_LO:
5637         case R_PPC64_SECTOFF_HI:
5638         case R_PPC64_SECTOFF_HA:
5639         case R_PPC64_SECTOFF_DS:
5640         case R_PPC64_SECTOFF_LO_DS:
5641         case R_PPC64_DTPREL16:
5642         case R_PPC64_DTPREL16_LO:
5643         case R_PPC64_DTPREL16_HI:
5644         case R_PPC64_DTPREL16_HA:
5645         case R_PPC64_DTPREL16_DS:
5646         case R_PPC64_DTPREL16_LO_DS:
5647         case R_PPC64_DTPREL16_HIGH:
5648         case R_PPC64_DTPREL16_HIGHA:
5649         case R_PPC64_DTPREL16_HIGHER:
5650         case R_PPC64_DTPREL16_HIGHERA:
5651         case R_PPC64_DTPREL16_HIGHEST:
5652         case R_PPC64_DTPREL16_HIGHESTA:
5653           break;
5654
5655           /* Nor do these.  */
5656         case R_PPC64_REL16:
5657         case R_PPC64_REL16_LO:
5658         case R_PPC64_REL16_HI:
5659         case R_PPC64_REL16_HA:
5660         case R_PPC64_REL16DX_HA:
5661           break;
5662
5663           /* Not supported as a dynamic relocation.  */
5664         case R_PPC64_ADDR64_LOCAL:
5665           if (bfd_link_pic (info))
5666             {
5667               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5668                 ppc_howto_init ();
5669               /* xgettext:c-format */
5670               info->callbacks->einfo (_("%H: %s reloc unsupported "
5671                                         "in shared libraries and PIEs\n"),
5672                                       abfd, sec, rel->r_offset,
5673                                       ppc64_elf_howto_table[r_type]->name);
5674               bfd_set_error (bfd_error_bad_value);
5675               return FALSE;
5676             }
5677           break;
5678
5679         case R_PPC64_TOC16:
5680         case R_PPC64_TOC16_DS:
5681           htab->do_multi_toc = 1;
5682           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5683           /* Fall through.  */
5684         case R_PPC64_TOC16_LO:
5685         case R_PPC64_TOC16_HI:
5686         case R_PPC64_TOC16_HA:
5687         case R_PPC64_TOC16_LO_DS:
5688           sec->has_toc_reloc = 1;
5689           break;
5690
5691           /* Marker reloc.  */
5692         case R_PPC64_ENTRY:
5693           break;
5694
5695           /* This relocation describes the C++ object vtable hierarchy.
5696              Reconstruct it for later use during GC.  */
5697         case R_PPC64_GNU_VTINHERIT:
5698           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5699             return FALSE;
5700           break;
5701
5702           /* This relocation describes which C++ vtable entries are actually
5703              used.  Record for later use during GC.  */
5704         case R_PPC64_GNU_VTENTRY:
5705           BFD_ASSERT (h != NULL);
5706           if (h != NULL
5707               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5708             return FALSE;
5709           break;
5710
5711         case R_PPC64_REL14:
5712         case R_PPC64_REL14_BRTAKEN:
5713         case R_PPC64_REL14_BRNTAKEN:
5714           {
5715             asection *dest = NULL;
5716
5717             /* Heuristic: If jumping outside our section, chances are
5718                we are going to need a stub.  */
5719             if (h != NULL)
5720               {
5721                 /* If the sym is weak it may be overridden later, so
5722                    don't assume we know where a weak sym lives.  */
5723                 if (h->root.type == bfd_link_hash_defined)
5724                   dest = h->root.u.def.section;
5725               }
5726             else
5727               {
5728                 Elf_Internal_Sym *isym;
5729
5730                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5731                                               abfd, r_symndx);
5732                 if (isym == NULL)
5733                   return FALSE;
5734
5735                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5736               }
5737
5738             if (dest != sec)
5739               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5740           }
5741           /* Fall through.  */
5742
5743         case R_PPC64_REL24:
5744           plt_list = ifunc;
5745           if (h != NULL)
5746             {
5747               h->needs_plt = 1;
5748               if (h->root.root.string[0] == '.'
5749                   && h->root.root.string[1] != '\0')
5750                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5751
5752               if (h == tga || h == dottga)
5753                 {
5754                   sec->has_tls_reloc = 1;
5755                   if (rel != relocs
5756                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5757                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5758                     /* We have a new-style __tls_get_addr call with
5759                        a marker reloc.  */
5760                     ;
5761                   else
5762                     /* Mark this section as having an old-style call.  */
5763                     sec->has_tls_get_addr_call = 1;
5764                 }
5765               plt_list = &h->plt.plist;
5766             }
5767
5768           /* We may need a .plt entry if the function this reloc
5769              refers to is in a shared lib.  */
5770           if (plt_list
5771               && !update_plt_info (abfd, plt_list, rel->r_addend))
5772             return FALSE;
5773           break;
5774
5775         case R_PPC64_ADDR14:
5776         case R_PPC64_ADDR14_BRNTAKEN:
5777         case R_PPC64_ADDR14_BRTAKEN:
5778         case R_PPC64_ADDR24:
5779           goto dodyn;
5780
5781         case R_PPC64_TPREL64:
5782           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5783           if (bfd_link_dll (info))
5784             info->flags |= DF_STATIC_TLS;
5785           goto dotlstoc;
5786
5787         case R_PPC64_DTPMOD64:
5788           if (rel + 1 < rel_end
5789               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5790               && rel[1].r_offset == rel->r_offset + 8)
5791             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5792           else
5793             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5794           goto dotlstoc;
5795
5796         case R_PPC64_DTPREL64:
5797           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5798           if (rel != relocs
5799               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5800               && rel[-1].r_offset == rel->r_offset - 8)
5801             /* This is the second reloc of a dtpmod, dtprel pair.
5802                Don't mark with TLS_DTPREL.  */
5803             goto dodyn;
5804
5805         dotlstoc:
5806           sec->has_tls_reloc = 1;
5807           if (h != NULL)
5808             {
5809               struct ppc_link_hash_entry *eh;
5810               eh = (struct ppc_link_hash_entry *) h;
5811               eh->tls_mask |= tls_type;
5812             }
5813           else
5814             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5815                                         rel->r_addend, tls_type))
5816               return FALSE;
5817
5818           ppc64_sec = ppc64_elf_section_data (sec);
5819           if (ppc64_sec->sec_type != sec_toc)
5820             {
5821               bfd_size_type amt;
5822
5823               /* One extra to simplify get_tls_mask.  */
5824               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5825               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5826               if (ppc64_sec->u.toc.symndx == NULL)
5827                 return FALSE;
5828               amt = sec->size * sizeof (bfd_vma) / 8;
5829               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5830               if (ppc64_sec->u.toc.add == NULL)
5831                 return FALSE;
5832               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5833               ppc64_sec->sec_type = sec_toc;
5834             }
5835           BFD_ASSERT (rel->r_offset % 8 == 0);
5836           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5837           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5838
5839           /* Mark the second slot of a GD or LD entry.
5840              -1 to indicate GD and -2 to indicate LD.  */
5841           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5842             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5843           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5844             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5845           goto dodyn;
5846
5847         case R_PPC64_TPREL16:
5848         case R_PPC64_TPREL16_LO:
5849         case R_PPC64_TPREL16_HI:
5850         case R_PPC64_TPREL16_HA:
5851         case R_PPC64_TPREL16_DS:
5852         case R_PPC64_TPREL16_LO_DS:
5853         case R_PPC64_TPREL16_HIGH:
5854         case R_PPC64_TPREL16_HIGHA:
5855         case R_PPC64_TPREL16_HIGHER:
5856         case R_PPC64_TPREL16_HIGHERA:
5857         case R_PPC64_TPREL16_HIGHEST:
5858         case R_PPC64_TPREL16_HIGHESTA:
5859           if (bfd_link_dll (info))
5860             info->flags |= DF_STATIC_TLS;
5861           goto dodyn;
5862
5863         case R_PPC64_ADDR64:
5864           if (is_opd
5865               && rel + 1 < rel_end
5866               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5867             {
5868               if (h != NULL)
5869                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5870             }
5871           /* Fall through.  */
5872
5873         case R_PPC64_ADDR16:
5874         case R_PPC64_ADDR16_DS:
5875         case R_PPC64_ADDR16_HA:
5876         case R_PPC64_ADDR16_HI:
5877         case R_PPC64_ADDR16_HIGH:
5878         case R_PPC64_ADDR16_HIGHA:
5879         case R_PPC64_ADDR16_HIGHER:
5880         case R_PPC64_ADDR16_HIGHERA:
5881         case R_PPC64_ADDR16_HIGHEST:
5882         case R_PPC64_ADDR16_HIGHESTA:
5883         case R_PPC64_ADDR16_LO:
5884         case R_PPC64_ADDR16_LO_DS:
5885           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5886               && rel->r_addend == 0)
5887             {
5888               /* We may need a .plt entry if this reloc refers to a
5889                  function in a shared lib.  */
5890               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5891                 return FALSE;
5892               h->pointer_equality_needed = 1;
5893             }
5894           /* Fall through.  */
5895
5896         case R_PPC64_REL30:
5897         case R_PPC64_REL32:
5898         case R_PPC64_REL64:
5899         case R_PPC64_ADDR32:
5900         case R_PPC64_UADDR16:
5901         case R_PPC64_UADDR32:
5902         case R_PPC64_UADDR64:
5903         case R_PPC64_TOC:
5904           if (h != NULL && !bfd_link_pic (info))
5905             /* We may need a copy reloc.  */
5906             h->non_got_ref = 1;
5907
5908           /* Don't propagate .opd relocs.  */
5909           if (NO_OPD_RELOCS && is_opd)
5910             break;
5911
5912           /* If we are creating a shared library, and this is a reloc
5913              against a global symbol, or a non PC relative reloc
5914              against a local symbol, then we need to copy the reloc
5915              into the shared library.  However, if we are linking with
5916              -Bsymbolic, we do not need to copy a reloc against a
5917              global symbol which is defined in an object we are
5918              including in the link (i.e., DEF_REGULAR is set).  At
5919              this point we have not seen all the input files, so it is
5920              possible that DEF_REGULAR is not set now but will be set
5921              later (it is never cleared).  In case of a weak definition,
5922              DEF_REGULAR may be cleared later by a strong definition in
5923              a shared library.  We account for that possibility below by
5924              storing information in the dyn_relocs field of the hash
5925              table entry.  A similar situation occurs when creating
5926              shared libraries and symbol visibility changes render the
5927              symbol local.
5928
5929              If on the other hand, we are creating an executable, we
5930              may need to keep relocations for symbols satisfied by a
5931              dynamic library if we manage to avoid copy relocs for the
5932              symbol.  */
5933         dodyn:
5934           if ((bfd_link_pic (info)
5935                && (must_be_dyn_reloc (info, r_type)
5936                    || (h != NULL
5937                        && (!SYMBOLIC_BIND (info, h)
5938                            || h->root.type == bfd_link_hash_defweak
5939                            || !h->def_regular))))
5940               || (ELIMINATE_COPY_RELOCS
5941                   && !bfd_link_pic (info)
5942                   && h != NULL
5943                   && (h->root.type == bfd_link_hash_defweak
5944                       || !h->def_regular))
5945               || (!bfd_link_pic (info)
5946                   && ifunc != NULL))
5947             {
5948               /* We must copy these reloc types into the output file.
5949                  Create a reloc section in dynobj and make room for
5950                  this reloc.  */
5951               if (sreloc == NULL)
5952                 {
5953                   sreloc = _bfd_elf_make_dynamic_reloc_section
5954                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5955
5956                   if (sreloc == NULL)
5957                     return FALSE;
5958                 }
5959
5960               /* If this is a global symbol, we count the number of
5961                  relocations we need for this symbol.  */
5962               if (h != NULL)
5963                 {
5964                   struct elf_dyn_relocs *p;
5965                   struct elf_dyn_relocs **head;
5966
5967                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5968                   p = *head;
5969                   if (p == NULL || p->sec != sec)
5970                     {
5971                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5972                       if (p == NULL)
5973                         return FALSE;
5974                       p->next = *head;
5975                       *head = p;
5976                       p->sec = sec;
5977                       p->count = 0;
5978                       p->pc_count = 0;
5979                     }
5980                   p->count += 1;
5981                   if (!must_be_dyn_reloc (info, r_type))
5982                     p->pc_count += 1;
5983                 }
5984               else
5985                 {
5986                   /* Track dynamic relocs needed for local syms too.
5987                      We really need local syms available to do this
5988                      easily.  Oh well.  */
5989                   struct ppc_dyn_relocs *p;
5990                   struct ppc_dyn_relocs **head;
5991                   bfd_boolean is_ifunc;
5992                   asection *s;
5993                   void *vpp;
5994                   Elf_Internal_Sym *isym;
5995
5996                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5997                                                 abfd, r_symndx);
5998                   if (isym == NULL)
5999                     return FALSE;
6000
6001                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6002                   if (s == NULL)
6003                     s = sec;
6004
6005                   vpp = &elf_section_data (s)->local_dynrel;
6006                   head = (struct ppc_dyn_relocs **) vpp;
6007                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6008                   p = *head;
6009                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6010                     p = p->next;
6011                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6012                     {
6013                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6014                       if (p == NULL)
6015                         return FALSE;
6016                       p->next = *head;
6017                       *head = p;
6018                       p->sec = sec;
6019                       p->ifunc = is_ifunc;
6020                       p->count = 0;
6021                     }
6022                   p->count += 1;
6023                 }
6024             }
6025           break;
6026
6027         default:
6028           break;
6029         }
6030     }
6031
6032   return TRUE;
6033 }
6034
6035 /* Merge backend specific data from an object file to the output
6036    object file when linking.  */
6037
6038 static bfd_boolean
6039 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6040 {
6041   bfd *obfd = info->output_bfd;
6042   unsigned long iflags, oflags;
6043
6044   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6045     return TRUE;
6046
6047   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6048     return TRUE;
6049
6050   if (!_bfd_generic_verify_endian_match (ibfd, info))
6051     return FALSE;
6052
6053   iflags = elf_elfheader (ibfd)->e_flags;
6054   oflags = elf_elfheader (obfd)->e_flags;
6055
6056   if (iflags & ~EF_PPC64_ABI)
6057     {
6058       _bfd_error_handler
6059         /* xgettext:c-format */
6060         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6061       bfd_set_error (bfd_error_bad_value);
6062       return FALSE;
6063     }
6064   else if (iflags != oflags && iflags != 0)
6065     {
6066       _bfd_error_handler
6067         /* xgettext:c-format */
6068         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6069          ibfd, iflags, oflags);
6070       bfd_set_error (bfd_error_bad_value);
6071       return FALSE;
6072     }
6073
6074   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6075
6076   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6077   _bfd_elf_merge_object_attributes (ibfd, info);
6078
6079   return TRUE;
6080 }
6081
6082 static bfd_boolean
6083 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6084 {
6085   /* Print normal ELF private data.  */
6086   _bfd_elf_print_private_bfd_data (abfd, ptr);
6087
6088   if (elf_elfheader (abfd)->e_flags != 0)
6089     {
6090       FILE *file = ptr;
6091
6092       fprintf (file, _("private flags = 0x%lx:"),
6093                elf_elfheader (abfd)->e_flags);
6094
6095       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6096         fprintf (file, _(" [abiv%ld]"),
6097                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6098       fputc ('\n', file);
6099     }
6100
6101   return TRUE;
6102 }
6103
6104 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6105    of the code entry point, and its section, which must be in the same
6106    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6107
6108 static bfd_vma
6109 opd_entry_value (asection *opd_sec,
6110                  bfd_vma offset,
6111                  asection **code_sec,
6112                  bfd_vma *code_off,
6113                  bfd_boolean in_code_sec)
6114 {
6115   bfd *opd_bfd = opd_sec->owner;
6116   Elf_Internal_Rela *relocs;
6117   Elf_Internal_Rela *lo, *hi, *look;
6118   bfd_vma val;
6119
6120   /* No relocs implies we are linking a --just-symbols object, or looking
6121      at a final linked executable with addr2line or somesuch.  */
6122   if (opd_sec->reloc_count == 0)
6123     {
6124       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6125
6126       if (contents == NULL)
6127         {
6128           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6129             return (bfd_vma) -1;
6130           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6131         }
6132
6133       /* PR 17512: file: 64b9dfbb.  */
6134       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6135         return (bfd_vma) -1;
6136
6137       val = bfd_get_64 (opd_bfd, contents + offset);
6138       if (code_sec != NULL)
6139         {
6140           asection *sec, *likely = NULL;
6141
6142           if (in_code_sec)
6143             {
6144               sec = *code_sec;
6145               if (sec->vma <= val
6146                   && val < sec->vma + sec->size)
6147                 likely = sec;
6148               else
6149                 val = -1;
6150             }
6151           else
6152             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6153               if (sec->vma <= val
6154                   && (sec->flags & SEC_LOAD) != 0
6155                   && (sec->flags & SEC_ALLOC) != 0)
6156                 likely = sec;
6157           if (likely != NULL)
6158             {
6159               *code_sec = likely;
6160               if (code_off != NULL)
6161                 *code_off = val - likely->vma;
6162             }
6163         }
6164       return val;
6165     }
6166
6167   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6168
6169   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6170   if (relocs == NULL)
6171     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6172   /* PR 17512: file: df8e1fd6.  */
6173   if (relocs == NULL)
6174     return (bfd_vma) -1;
6175
6176   /* Go find the opd reloc at the sym address.  */
6177   lo = relocs;
6178   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6179   val = (bfd_vma) -1;
6180   while (lo < hi)
6181     {
6182       look = lo + (hi - lo) / 2;
6183       if (look->r_offset < offset)
6184         lo = look + 1;
6185       else if (look->r_offset > offset)
6186         hi = look;
6187       else
6188         {
6189           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6190
6191           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6192               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6193             {
6194               unsigned long symndx = ELF64_R_SYM (look->r_info);
6195               asection *sec = NULL;
6196
6197               if (symndx >= symtab_hdr->sh_info
6198                   && elf_sym_hashes (opd_bfd) != NULL)
6199                 {
6200                   struct elf_link_hash_entry **sym_hashes;
6201                   struct elf_link_hash_entry *rh;
6202
6203                   sym_hashes = elf_sym_hashes (opd_bfd);
6204                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6205                   if (rh != NULL)
6206                     {
6207                       rh = elf_follow_link (rh);
6208                       if (rh->root.type != bfd_link_hash_defined
6209                           && rh->root.type != bfd_link_hash_defweak)
6210                         break;
6211                       if (rh->root.u.def.section->owner == opd_bfd)
6212                         {
6213                           val = rh->root.u.def.value;
6214                           sec = rh->root.u.def.section;
6215                         }
6216                     }
6217                 }
6218
6219               if (sec == NULL)
6220                 {
6221                   Elf_Internal_Sym *sym;
6222
6223                   if (symndx < symtab_hdr->sh_info)
6224                     {
6225                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6226                       if (sym == NULL)
6227                         {
6228                           size_t symcnt = symtab_hdr->sh_info;
6229                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6230                                                       symcnt, 0,
6231                                                       NULL, NULL, NULL);
6232                           if (sym == NULL)
6233                             break;
6234                           symtab_hdr->contents = (bfd_byte *) sym;
6235                         }
6236                       sym += symndx;
6237                     }
6238                   else
6239                     {
6240                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6241                                                   1, symndx,
6242                                                   NULL, NULL, NULL);
6243                       if (sym == NULL)
6244                         break;
6245                     }
6246                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6247                   if (sec == NULL)
6248                     break;
6249                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6250                   val = sym->st_value;
6251                 }
6252
6253               val += look->r_addend;
6254               if (code_off != NULL)
6255                 *code_off = val;
6256               if (code_sec != NULL)
6257                 {
6258                   if (in_code_sec && *code_sec != sec)
6259                     return -1;
6260                   else
6261                     *code_sec = sec;
6262                 }
6263               if (sec->output_section != NULL)
6264                 val += sec->output_section->vma + sec->output_offset;
6265             }
6266           break;
6267         }
6268     }
6269
6270   return val;
6271 }
6272
6273 /* If the ELF symbol SYM might be a function in SEC, return the
6274    function size and set *CODE_OFF to the function's entry point,
6275    otherwise return zero.  */
6276
6277 static bfd_size_type
6278 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6279                               bfd_vma *code_off)
6280 {
6281   bfd_size_type size;
6282
6283   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6284                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6285     return 0;
6286
6287   size = 0;
6288   if (!(sym->flags & BSF_SYNTHETIC))
6289     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6290
6291   if (strcmp (sym->section->name, ".opd") == 0)
6292     {
6293       struct _opd_sec_data *opd = get_opd_info (sym->section);
6294       bfd_vma symval = sym->value;
6295
6296       if (opd != NULL
6297           && opd->adjust != NULL
6298           && elf_section_data (sym->section)->relocs != NULL)
6299         {
6300           /* opd_entry_value will use cached relocs that have been
6301              adjusted, but with raw symbols.  That means both local
6302              and global symbols need adjusting.  */
6303           long adjust = opd->adjust[OPD_NDX (symval)];
6304           if (adjust == -1)
6305             return 0;
6306           symval += adjust;
6307         }
6308
6309       if (opd_entry_value (sym->section, symval,
6310                            &sec, code_off, TRUE) == (bfd_vma) -1)
6311         return 0;
6312       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6313          symbol.  This size has nothing to do with the code size of the
6314          function, which is what we're supposed to return, but the
6315          code size isn't available without looking up the dot-sym.
6316          However, doing that would be a waste of time particularly
6317          since elf_find_function will look at the dot-sym anyway.
6318          Now, elf_find_function will keep the largest size of any
6319          function sym found at the code address of interest, so return
6320          1 here to avoid it incorrectly caching a larger function size
6321          for a small function.  This does mean we return the wrong
6322          size for a new-ABI function of size 24, but all that does is
6323          disable caching for such functions.  */
6324       if (size == 24)
6325         size = 1;
6326     }
6327   else
6328     {
6329       if (sym->section != sec)
6330         return 0;
6331       *code_off = sym->value;
6332     }
6333   if (size == 0)
6334     size = 1;
6335   return size;
6336 }
6337
6338 /* Return true if symbol is a strong function defined in an ELFv2
6339    object with st_other localentry bits of zero, ie. its local entry
6340    point coincides with its global entry point.  */
6341
6342 static bfd_boolean
6343 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6344 {
6345   return (h != NULL
6346           && h->type == STT_FUNC
6347           && h->root.type == bfd_link_hash_defined
6348           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6349           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6350           && is_ppc64_elf (h->root.u.def.section->owner)
6351           && abiversion (h->root.u.def.section->owner) >= 2);
6352 }
6353
6354 /* Return true if symbol is defined in a regular object file.  */
6355
6356 static bfd_boolean
6357 is_static_defined (struct elf_link_hash_entry *h)
6358 {
6359   return ((h->root.type == bfd_link_hash_defined
6360            || h->root.type == bfd_link_hash_defweak)
6361           && h->root.u.def.section != NULL
6362           && h->root.u.def.section->output_section != NULL);
6363 }
6364
6365 /* If FDH is a function descriptor symbol, return the associated code
6366    entry symbol if it is defined.  Return NULL otherwise.  */
6367
6368 static struct ppc_link_hash_entry *
6369 defined_code_entry (struct ppc_link_hash_entry *fdh)
6370 {
6371   if (fdh->is_func_descriptor)
6372     {
6373       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6374       if (fh->elf.root.type == bfd_link_hash_defined
6375           || fh->elf.root.type == bfd_link_hash_defweak)
6376         return fh;
6377     }
6378   return NULL;
6379 }
6380
6381 /* If FH is a function code entry symbol, return the associated
6382    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6383
6384 static struct ppc_link_hash_entry *
6385 defined_func_desc (struct ppc_link_hash_entry *fh)
6386 {
6387   if (fh->oh != NULL
6388       && fh->oh->is_func_descriptor)
6389     {
6390       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6391       if (fdh->elf.root.type == bfd_link_hash_defined
6392           || fdh->elf.root.type == bfd_link_hash_defweak)
6393         return fdh;
6394     }
6395   return NULL;
6396 }
6397
6398 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6399
6400 /* Garbage collect sections, after first dealing with dot-symbols.  */
6401
6402 static bfd_boolean
6403 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6404 {
6405   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6406
6407   if (htab != NULL && htab->need_func_desc_adj)
6408     {
6409       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6410       htab->need_func_desc_adj = 0;
6411     }
6412   return bfd_elf_gc_sections (abfd, info);
6413 }
6414
6415 /* Mark all our entry sym sections, both opd and code section.  */
6416
6417 static void
6418 ppc64_elf_gc_keep (struct bfd_link_info *info)
6419 {
6420   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6421   struct bfd_sym_chain *sym;
6422
6423   if (htab == NULL)
6424     return;
6425
6426   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6427     {
6428       struct ppc_link_hash_entry *eh, *fh;
6429       asection *sec;
6430
6431       eh = (struct ppc_link_hash_entry *)
6432         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6433       if (eh == NULL)
6434         continue;
6435       if (eh->elf.root.type != bfd_link_hash_defined
6436           && eh->elf.root.type != bfd_link_hash_defweak)
6437         continue;
6438
6439       fh = defined_code_entry (eh);
6440       if (fh != NULL)
6441         {
6442           sec = fh->elf.root.u.def.section;
6443           sec->flags |= SEC_KEEP;
6444         }
6445       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6446                && opd_entry_value (eh->elf.root.u.def.section,
6447                                    eh->elf.root.u.def.value,
6448                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6449         sec->flags |= SEC_KEEP;
6450
6451       sec = eh->elf.root.u.def.section;
6452       sec->flags |= SEC_KEEP;
6453     }
6454 }
6455
6456 /* Mark sections containing dynamically referenced symbols.  When
6457    building shared libraries, we must assume that any visible symbol is
6458    referenced.  */
6459
6460 static bfd_boolean
6461 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6462 {
6463   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6464   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6465   struct ppc_link_hash_entry *fdh;
6466   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6467
6468   /* Dynamic linking info is on the func descriptor sym.  */
6469   fdh = defined_func_desc (eh);
6470   if (fdh != NULL)
6471     eh = fdh;
6472
6473   if ((eh->elf.root.type == bfd_link_hash_defined
6474        || eh->elf.root.type == bfd_link_hash_defweak)
6475       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6476           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6477               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6478               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6479               && (!bfd_link_executable (info)
6480                   || info->gc_keep_exported
6481                   || info->export_dynamic
6482                   || (eh->elf.dynamic
6483                       && d != NULL
6484                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6485               && (eh->elf.versioned >= versioned
6486                   || !bfd_hide_sym_by_version (info->version_info,
6487                                                eh->elf.root.root.string)))))
6488     {
6489       asection *code_sec;
6490       struct ppc_link_hash_entry *fh;
6491
6492       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6493
6494       /* Function descriptor syms cause the associated
6495          function code sym section to be marked.  */
6496       fh = defined_code_entry (eh);
6497       if (fh != NULL)
6498         {
6499           code_sec = fh->elf.root.u.def.section;
6500           code_sec->flags |= SEC_KEEP;
6501         }
6502       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6503                && opd_entry_value (eh->elf.root.u.def.section,
6504                                    eh->elf.root.u.def.value,
6505                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6506         code_sec->flags |= SEC_KEEP;
6507     }
6508
6509   return TRUE;
6510 }
6511
6512 /* Return the section that should be marked against GC for a given
6513    relocation.  */
6514
6515 static asection *
6516 ppc64_elf_gc_mark_hook (asection *sec,
6517                         struct bfd_link_info *info,
6518                         Elf_Internal_Rela *rel,
6519                         struct elf_link_hash_entry *h,
6520                         Elf_Internal_Sym *sym)
6521 {
6522   asection *rsec;
6523
6524   /* Syms return NULL if we're marking .opd, so we avoid marking all
6525      function sections, as all functions are referenced in .opd.  */
6526   rsec = NULL;
6527   if (get_opd_info (sec) != NULL)
6528     return rsec;
6529
6530   if (h != NULL)
6531     {
6532       enum elf_ppc64_reloc_type r_type;
6533       struct ppc_link_hash_entry *eh, *fh, *fdh;
6534
6535       r_type = ELF64_R_TYPE (rel->r_info);
6536       switch (r_type)
6537         {
6538         case R_PPC64_GNU_VTINHERIT:
6539         case R_PPC64_GNU_VTENTRY:
6540           break;
6541
6542         default:
6543           switch (h->root.type)
6544             {
6545             case bfd_link_hash_defined:
6546             case bfd_link_hash_defweak:
6547               eh = (struct ppc_link_hash_entry *) h;
6548               fdh = defined_func_desc (eh);
6549               if (fdh != NULL)
6550                 {
6551                   /* -mcall-aixdesc code references the dot-symbol on
6552                      a call reloc.  Mark the function descriptor too
6553                      against garbage collection.  */
6554                   fdh->elf.mark = 1;
6555                   if (fdh->elf.is_weakalias)
6556                     weakdef (&fdh->elf)->mark = 1;
6557                   eh = fdh;
6558                 }
6559
6560               /* Function descriptor syms cause the associated
6561                  function code sym section to be marked.  */
6562               fh = defined_code_entry (eh);
6563               if (fh != NULL)
6564                 {
6565                   /* They also mark their opd section.  */
6566                   eh->elf.root.u.def.section->gc_mark = 1;
6567
6568                   rsec = fh->elf.root.u.def.section;
6569                 }
6570               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6571                        && opd_entry_value (eh->elf.root.u.def.section,
6572                                            eh->elf.root.u.def.value,
6573                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6574                 eh->elf.root.u.def.section->gc_mark = 1;
6575               else
6576                 rsec = h->root.u.def.section;
6577               break;
6578
6579             case bfd_link_hash_common:
6580               rsec = h->root.u.c.p->section;
6581               break;
6582
6583             default:
6584               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6585             }
6586         }
6587     }
6588   else
6589     {
6590       struct _opd_sec_data *opd;
6591
6592       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6593       opd = get_opd_info (rsec);
6594       if (opd != NULL && opd->func_sec != NULL)
6595         {
6596           rsec->gc_mark = 1;
6597
6598           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6599         }
6600     }
6601
6602   return rsec;
6603 }
6604
6605 /* The maximum size of .sfpr.  */
6606 #define SFPR_MAX (218*4)
6607
6608 struct sfpr_def_parms
6609 {
6610   const char name[12];
6611   unsigned char lo, hi;
6612   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6613   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6614 };
6615
6616 /* Auto-generate _save*, _rest* functions in .sfpr.
6617    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6618    instead.  */
6619
6620 static bfd_boolean
6621 sfpr_define (struct bfd_link_info *info,
6622              const struct sfpr_def_parms *parm,
6623              asection *stub_sec)
6624 {
6625   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6626   unsigned int i;
6627   size_t len = strlen (parm->name);
6628   bfd_boolean writing = FALSE;
6629   char sym[16];
6630
6631   if (htab == NULL)
6632     return FALSE;
6633
6634   memcpy (sym, parm->name, len);
6635   sym[len + 2] = 0;
6636
6637   for (i = parm->lo; i <= parm->hi; i++)
6638     {
6639       struct ppc_link_hash_entry *h;
6640
6641       sym[len + 0] = i / 10 + '0';
6642       sym[len + 1] = i % 10 + '0';
6643       h = (struct ppc_link_hash_entry *)
6644         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6645       if (stub_sec != NULL)
6646         {
6647           if (h != NULL
6648               && h->elf.root.type == bfd_link_hash_defined
6649               && h->elf.root.u.def.section == htab->sfpr)
6650             {
6651               struct elf_link_hash_entry *s;
6652               char buf[32];
6653               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6654               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6655               if (s == NULL)
6656                 return FALSE;
6657               if (s->root.type == bfd_link_hash_new
6658                   || (s->root.type = bfd_link_hash_defined
6659                       && s->root.u.def.section == stub_sec))
6660                 {
6661                   s->root.type = bfd_link_hash_defined;
6662                   s->root.u.def.section = stub_sec;
6663                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6664                                          + h->elf.root.u.def.value);
6665                   s->ref_regular = 1;
6666                   s->def_regular = 1;
6667                   s->ref_regular_nonweak = 1;
6668                   s->forced_local = 1;
6669                   s->non_elf = 0;
6670                   s->root.linker_def = 1;
6671                 }
6672             }
6673           continue;
6674         }
6675       if (h != NULL)
6676         {
6677           h->save_res = 1;
6678           if (!h->elf.def_regular)
6679             {
6680               h->elf.root.type = bfd_link_hash_defined;
6681               h->elf.root.u.def.section = htab->sfpr;
6682               h->elf.root.u.def.value = htab->sfpr->size;
6683               h->elf.type = STT_FUNC;
6684               h->elf.def_regular = 1;
6685               h->elf.non_elf = 0;
6686               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6687               writing = TRUE;
6688               if (htab->sfpr->contents == NULL)
6689                 {
6690                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6691                   if (htab->sfpr->contents == NULL)
6692                     return FALSE;
6693                 }
6694             }
6695         }
6696       if (writing)
6697         {
6698           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6699           if (i != parm->hi)
6700             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6701           else
6702             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6703           htab->sfpr->size = p - htab->sfpr->contents;
6704         }
6705     }
6706
6707   return TRUE;
6708 }
6709
6710 static bfd_byte *
6711 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6712 {
6713   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6714   return p + 4;
6715 }
6716
6717 static bfd_byte *
6718 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6719 {
6720   p = savegpr0 (abfd, p, r);
6721   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6722   p = p + 4;
6723   bfd_put_32 (abfd, BLR, p);
6724   return p + 4;
6725 }
6726
6727 static bfd_byte *
6728 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6729 {
6730   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6731   return p + 4;
6732 }
6733
6734 static bfd_byte *
6735 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6736 {
6737   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6738   p = p + 4;
6739   p = restgpr0 (abfd, p, r);
6740   bfd_put_32 (abfd, MTLR_R0, p);
6741   p = p + 4;
6742   if (r == 29)
6743     {
6744       p = restgpr0 (abfd, p, 30);
6745       p = restgpr0 (abfd, p, 31);
6746     }
6747   bfd_put_32 (abfd, BLR, p);
6748   return p + 4;
6749 }
6750
6751 static bfd_byte *
6752 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6753 {
6754   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6755   return p + 4;
6756 }
6757
6758 static bfd_byte *
6759 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6760 {
6761   p = savegpr1 (abfd, p, r);
6762   bfd_put_32 (abfd, BLR, p);
6763   return p + 4;
6764 }
6765
6766 static bfd_byte *
6767 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6768 {
6769   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6770   return p + 4;
6771 }
6772
6773 static bfd_byte *
6774 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6775 {
6776   p = restgpr1 (abfd, p, r);
6777   bfd_put_32 (abfd, BLR, p);
6778   return p + 4;
6779 }
6780
6781 static bfd_byte *
6782 savefpr (bfd *abfd, bfd_byte *p, int r)
6783 {
6784   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6785   return p + 4;
6786 }
6787
6788 static bfd_byte *
6789 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6790 {
6791   p = savefpr (abfd, p, r);
6792   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6793   p = p + 4;
6794   bfd_put_32 (abfd, BLR, p);
6795   return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 restfpr (bfd *abfd, bfd_byte *p, int r)
6800 {
6801   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6802   return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6807 {
6808   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6809   p = p + 4;
6810   p = restfpr (abfd, p, r);
6811   bfd_put_32 (abfd, MTLR_R0, p);
6812   p = p + 4;
6813   if (r == 29)
6814     {
6815       p = restfpr (abfd, p, 30);
6816       p = restfpr (abfd, p, 31);
6817     }
6818   bfd_put_32 (abfd, BLR, p);
6819   return p + 4;
6820 }
6821
6822 static bfd_byte *
6823 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6824 {
6825   p = savefpr (abfd, p, r);
6826   bfd_put_32 (abfd, BLR, p);
6827   return p + 4;
6828 }
6829
6830 static bfd_byte *
6831 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6832 {
6833   p = restfpr (abfd, p, r);
6834   bfd_put_32 (abfd, BLR, p);
6835   return p + 4;
6836 }
6837
6838 static bfd_byte *
6839 savevr (bfd *abfd, bfd_byte *p, int r)
6840 {
6841   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6842   p = p + 4;
6843   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6844   return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850   p = savevr (abfd, p, r);
6851   bfd_put_32 (abfd, BLR, p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 restvr (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6859   p = p + 4;
6860   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6861   return p + 4;
6862 }
6863
6864 static bfd_byte *
6865 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6866 {
6867   p = restvr (abfd, p, r);
6868   bfd_put_32 (abfd, BLR, p);
6869   return p + 4;
6870 }
6871
6872 /* Called via elf_link_hash_traverse to transfer dynamic linking
6873    information on function code symbol entries to their corresponding
6874    function descriptor symbol entries.  */
6875
6876 static bfd_boolean
6877 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6878 {
6879   struct bfd_link_info *info;
6880   struct ppc_link_hash_table *htab;
6881   struct ppc_link_hash_entry *fh;
6882   struct ppc_link_hash_entry *fdh;
6883   bfd_boolean force_local;
6884
6885   fh = (struct ppc_link_hash_entry *) h;
6886   if (fh->elf.root.type == bfd_link_hash_indirect)
6887     return TRUE;
6888
6889   if (!fh->is_func)
6890     return TRUE;
6891
6892   if (fh->elf.root.root.string[0] != '.'
6893       || fh->elf.root.root.string[1] == '\0')
6894     return TRUE;
6895
6896   info = inf;
6897   htab = ppc_hash_table (info);
6898   if (htab == NULL)
6899     return FALSE;
6900
6901   /* Find the corresponding function descriptor symbol.  */
6902   fdh = lookup_fdh (fh, htab);
6903
6904   /* Resolve undefined references to dot-symbols as the value
6905      in the function descriptor, if we have one in a regular object.
6906      This is to satisfy cases like ".quad .foo".  Calls to functions
6907      in dynamic objects are handled elsewhere.  */
6908   if ((fh->elf.root.type == bfd_link_hash_undefined
6909        || fh->elf.root.type == bfd_link_hash_undefweak)
6910       && (fdh->elf.root.type == bfd_link_hash_defined
6911           || fdh->elf.root.type == bfd_link_hash_defweak)
6912       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6913       && opd_entry_value (fdh->elf.root.u.def.section,
6914                           fdh->elf.root.u.def.value,
6915                           &fh->elf.root.u.def.section,
6916                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6917     {
6918       fh->elf.root.type = fdh->elf.root.type;
6919       fh->elf.forced_local = 1;
6920       fh->elf.def_regular = fdh->elf.def_regular;
6921       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6922     }
6923
6924   if (!fh->elf.dynamic)
6925     {
6926       struct plt_entry *ent;
6927
6928       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6929         if (ent->plt.refcount > 0)
6930           break;
6931       if (ent == NULL)
6932         return TRUE;
6933     }
6934
6935   /* Create a descriptor as undefined if necessary.  */
6936   if (fdh == NULL
6937       && !bfd_link_executable (info)
6938       && (fh->elf.root.type == bfd_link_hash_undefined
6939           || fh->elf.root.type == bfd_link_hash_undefweak))
6940     {
6941       fdh = make_fdh (info, fh);
6942       if (fdh == NULL)
6943         return FALSE;
6944     }
6945
6946   /* We can't support overriding of symbols on a fake descriptor.  */
6947   if (fdh != NULL
6948       && fdh->fake
6949       && (fh->elf.root.type == bfd_link_hash_defined
6950           || fh->elf.root.type == bfd_link_hash_defweak))
6951     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6952
6953   /* Transfer dynamic linking information to the function descriptor.  */
6954   if (fdh != NULL)
6955     {
6956       fdh->elf.ref_regular |= fh->elf.ref_regular;
6957       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6958       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6959       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6960       fdh->elf.dynamic |= fh->elf.dynamic;
6961       fdh->elf.needs_plt |= (fh->elf.needs_plt
6962                              || fh->elf.type == STT_FUNC
6963                              || fh->elf.type == STT_GNU_IFUNC);
6964       move_plt_plist (fh, fdh);
6965
6966       if (!fdh->elf.forced_local
6967           && fh->elf.dynindx != -1)
6968         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6969           return FALSE;
6970     }
6971
6972   /* Now that the info is on the function descriptor, clear the
6973      function code sym info.  Any function code syms for which we
6974      don't have a definition in a regular file, we force local.
6975      This prevents a shared library from exporting syms that have
6976      been imported from another library.  Function code syms that
6977      are really in the library we must leave global to prevent the
6978      linker dragging in a definition from a static library.  */
6979   force_local = (!fh->elf.def_regular
6980                  || fdh == NULL
6981                  || !fdh->elf.def_regular
6982                  || fdh->elf.forced_local);
6983   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6984
6985   return TRUE;
6986 }
6987
6988 static const struct sfpr_def_parms save_res_funcs[] =
6989   {
6990     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6991     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6992     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6993     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6994     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6995     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6996     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6997     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6998     { "._savef", 14, 31, savefpr, savefpr1_tail },
6999     { "._restf", 14, 31, restfpr, restfpr1_tail },
7000     { "_savevr_", 20, 31, savevr, savevr_tail },
7001     { "_restvr_", 20, 31, restvr, restvr_tail }
7002   };
7003
7004 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7005    this hook to a) provide some gcc support functions, and b) transfer
7006    dynamic linking information gathered so far on function code symbol
7007    entries, to their corresponding function descriptor symbol entries.  */
7008
7009 static bfd_boolean
7010 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7011                             struct bfd_link_info *info)
7012 {
7013   struct ppc_link_hash_table *htab;
7014
7015   htab = ppc_hash_table (info);
7016   if (htab == NULL)
7017     return FALSE;
7018
7019   /* Provide any missing _save* and _rest* functions.  */
7020   if (htab->sfpr != NULL)
7021     {
7022       unsigned int i;
7023
7024       htab->sfpr->size = 0;
7025       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7026         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7027           return FALSE;
7028       if (htab->sfpr->size == 0)
7029         htab->sfpr->flags |= SEC_EXCLUDE;
7030     }
7031
7032   if (bfd_link_relocatable (info))
7033     return TRUE;
7034
7035   if (htab->elf.hgot != NULL)
7036     {
7037       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7038       /* Make .TOC. defined so as to prevent it being made dynamic.
7039          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7040       if (!htab->elf.hgot->def_regular
7041           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7042         {
7043           htab->elf.hgot->root.type = bfd_link_hash_defined;
7044           htab->elf.hgot->root.u.def.value = 0;
7045           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7046           htab->elf.hgot->def_regular = 1;
7047           htab->elf.hgot->root.linker_def = 1;
7048         }
7049       htab->elf.hgot->type = STT_OBJECT;
7050       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7051                                | STV_HIDDEN);
7052     }
7053
7054   if (htab->need_func_desc_adj)
7055     {
7056       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7057       htab->need_func_desc_adj = 0;
7058     }
7059
7060   return TRUE;
7061 }
7062
7063 /* Find dynamic relocs for H that apply to read-only sections.  */
7064
7065 static asection *
7066 readonly_dynrelocs (struct elf_link_hash_entry *h)
7067 {
7068   struct ppc_link_hash_entry *eh;
7069   struct elf_dyn_relocs *p;
7070
7071   eh = (struct ppc_link_hash_entry *) h;
7072   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7073     {
7074       asection *s = p->sec->output_section;
7075
7076       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7077         return p->sec;
7078     }
7079   return NULL;
7080 }
7081
7082 /* Return true if we have dynamic relocs against H or any of its weak
7083    aliases, that apply to read-only sections.  Cannot be used after
7084    size_dynamic_sections.  */
7085
7086 static bfd_boolean
7087 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7088 {
7089   struct ppc_link_hash_entry *eh;
7090
7091   eh = (struct ppc_link_hash_entry *) h;
7092   do
7093     {
7094       if (readonly_dynrelocs (&eh->elf))
7095         return TRUE;
7096       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7097     } while (eh != NULL && &eh->elf != h);
7098
7099   return FALSE;
7100 }
7101
7102 /* Return whether EH has pc-relative dynamic relocs.  */
7103
7104 static bfd_boolean
7105 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7106 {
7107   struct elf_dyn_relocs *p;
7108
7109   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7110     if (p->pc_count != 0)
7111       return TRUE;
7112   return FALSE;
7113 }
7114
7115 /* Return true if a global entry stub will be created for H.  Valid
7116    for ELFv2 before plt entries have been allocated.  */
7117
7118 static bfd_boolean
7119 global_entry_stub (struct elf_link_hash_entry *h)
7120 {
7121   struct plt_entry *pent;
7122
7123   if (!h->pointer_equality_needed
7124       || h->def_regular)
7125     return FALSE;
7126
7127   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7128     if (pent->plt.refcount > 0
7129         && pent->addend == 0)
7130       return TRUE;
7131
7132   return FALSE;
7133 }
7134
7135 /* Adjust a symbol defined by a dynamic object and referenced by a
7136    regular object.  The current definition is in some section of the
7137    dynamic object, but we're not including those sections.  We have to
7138    change the definition to something the rest of the link can
7139    understand.  */
7140
7141 static bfd_boolean
7142 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7143                                  struct elf_link_hash_entry *h)
7144 {
7145   struct ppc_link_hash_table *htab;
7146   asection *s, *srel;
7147
7148   htab = ppc_hash_table (info);
7149   if (htab == NULL)
7150     return FALSE;
7151
7152   /* Deal with function syms.  */
7153   if (h->type == STT_FUNC
7154       || h->type == STT_GNU_IFUNC
7155       || h->needs_plt)
7156     {
7157       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7158                            || SYMBOL_CALLS_LOCAL (info, h)
7159                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7160       /* Discard dyn_relocs when non-pic if we've decided that a
7161          function symbol is local and not an ifunc.  We keep dynamic
7162          relocs for ifuncs when local rather than always emitting a
7163          plt call stub for them and defining the symbol on the call
7164          stub.  We can't do that for ELFv1 anyway (a function symbol
7165          is defined on a descriptor, not code) and it can be faster at
7166          run-time due to not needing to bounce through a stub.  The
7167          dyn_relocs for ifuncs will be applied even in a static
7168          executable.  */
7169       if (!bfd_link_pic (info)
7170           && h->type != STT_GNU_IFUNC
7171           && local)
7172         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7173
7174       /* Clear procedure linkage table information for any symbol that
7175          won't need a .plt entry.  */
7176       struct plt_entry *ent;
7177       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7178         if (ent->plt.refcount > 0)
7179           break;
7180       if (ent == NULL
7181           || (h->type != STT_GNU_IFUNC && local))
7182         {
7183           h->plt.plist = NULL;
7184           h->needs_plt = 0;
7185           h->pointer_equality_needed = 0;
7186         }
7187       else if (abiversion (info->output_bfd) >= 2)
7188         {
7189           /* Taking a function's address in a read/write section
7190              doesn't require us to define the function symbol in the
7191              executable on a global entry stub.  A dynamic reloc can
7192              be used instead.  The reason we prefer a few more dynamic
7193              relocs is that calling via a global entry stub costs a
7194              few more instructions, and pointer_equality_needed causes
7195              extra work in ld.so when resolving these symbols.  */
7196           if (global_entry_stub (h))
7197             {
7198               if (!readonly_dynrelocs (h))
7199                 {
7200                   h->pointer_equality_needed = 0;
7201                   /* If we haven't seen a branch reloc then we don't need
7202                      a plt entry.  */
7203                   if (!h->needs_plt)
7204                     h->plt.plist = NULL;
7205                 }
7206               else if (!bfd_link_pic (info))
7207                 /* We are going to be defining the function symbol on the
7208                    plt stub, so no dyn_relocs needed when non-pic.  */
7209                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7210             }
7211
7212           /* ELFv2 function symbols can't have copy relocs.  */
7213           return TRUE;
7214         }
7215       else if (!h->needs_plt
7216                && !readonly_dynrelocs (h))
7217         {
7218           /* If we haven't seen a branch reloc then we don't need a
7219              plt entry.  */
7220           h->plt.plist = NULL;
7221           h->pointer_equality_needed = 0;
7222           return TRUE;
7223         }
7224     }
7225   else
7226     h->plt.plist = NULL;
7227
7228   /* If this is a weak symbol, and there is a real definition, the
7229      processor independent code will have arranged for us to see the
7230      real definition first, and we can just use the same value.  */
7231   if (h->is_weakalias)
7232     {
7233       struct elf_link_hash_entry *def = weakdef (h);
7234       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7235       h->root.u.def.section = def->root.u.def.section;
7236       h->root.u.def.value = def->root.u.def.value;
7237       if (def->root.u.def.section == htab->elf.sdynbss
7238           || def->root.u.def.section == htab->elf.sdynrelro)
7239         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7240       return TRUE;
7241     }
7242
7243   /* If we are creating a shared library, we must presume that the
7244      only references to the symbol are via the global offset table.
7245      For such cases we need not do anything here; the relocations will
7246      be handled correctly by relocate_section.  */
7247   if (bfd_link_pic (info))
7248     return TRUE;
7249
7250   /* If there are no references to this symbol that do not use the
7251      GOT, we don't need to generate a copy reloc.  */
7252   if (!h->non_got_ref)
7253     return TRUE;
7254
7255   /* Don't generate a copy reloc for symbols defined in the executable.  */
7256   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7257
7258       /* If -z nocopyreloc was given, don't generate them either.  */
7259       || info->nocopyreloc
7260
7261       /* If we don't find any dynamic relocs in read-only sections, then
7262          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7263       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7264
7265       /* Protected variables do not work with .dynbss.  The copy in
7266          .dynbss won't be used by the shared library with the protected
7267          definition for the variable.  Text relocations are preferable
7268          to an incorrect program.  */
7269       || h->protected_def)
7270     return TRUE;
7271
7272   if (h->plt.plist != NULL)
7273     {
7274       /* We should never get here, but unfortunately there are versions
7275          of gcc out there that improperly (for this ABI) put initialized
7276          function pointers, vtable refs and suchlike in read-only
7277          sections.  Allow them to proceed, but warn that this might
7278          break at runtime.  */
7279       info->callbacks->einfo
7280         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7281            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7282          h->root.root.string);
7283     }
7284
7285   /* This is a reference to a symbol defined by a dynamic object which
7286      is not a function.  */
7287
7288   /* We must allocate the symbol in our .dynbss section, which will
7289      become part of the .bss section of the executable.  There will be
7290      an entry for this symbol in the .dynsym section.  The dynamic
7291      object will contain position independent code, so all references
7292      from the dynamic object to this symbol will go through the global
7293      offset table.  The dynamic linker will use the .dynsym entry to
7294      determine the address it must put in the global offset table, so
7295      both the dynamic object and the regular object will refer to the
7296      same memory location for the variable.  */
7297   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7298     {
7299       s = htab->elf.sdynrelro;
7300       srel = htab->elf.sreldynrelro;
7301     }
7302   else
7303     {
7304       s = htab->elf.sdynbss;
7305       srel = htab->elf.srelbss;
7306     }
7307   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7308     {
7309       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7310          linker to copy the initial value out of the dynamic object
7311          and into the runtime process image.  */
7312       srel->size += sizeof (Elf64_External_Rela);
7313       h->needs_copy = 1;
7314     }
7315
7316   /* We no longer want dyn_relocs.  */
7317   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7318   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7319 }
7320
7321 /* If given a function descriptor symbol, hide both the function code
7322    sym and the descriptor.  */
7323 static void
7324 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7325                        struct elf_link_hash_entry *h,
7326                        bfd_boolean force_local)
7327 {
7328   struct ppc_link_hash_entry *eh;
7329   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7330
7331   eh = (struct ppc_link_hash_entry *) h;
7332   if (eh->is_func_descriptor)
7333     {
7334       struct ppc_link_hash_entry *fh = eh->oh;
7335
7336       if (fh == NULL)
7337         {
7338           const char *p, *q;
7339           struct elf_link_hash_table *htab = elf_hash_table (info);
7340           char save;
7341
7342           /* We aren't supposed to use alloca in BFD because on
7343              systems which do not have alloca the version in libiberty
7344              calls xmalloc, which might cause the program to crash
7345              when it runs out of memory.  This function doesn't have a
7346              return status, so there's no way to gracefully return an
7347              error.  So cheat.  We know that string[-1] can be safely
7348              accessed;  It's either a string in an ELF string table,
7349              or allocated in an objalloc structure.  */
7350
7351           p = eh->elf.root.root.string - 1;
7352           save = *p;
7353           *(char *) p = '.';
7354           fh = (struct ppc_link_hash_entry *)
7355             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7356           *(char *) p = save;
7357
7358           /* Unfortunately, if it so happens that the string we were
7359              looking for was allocated immediately before this string,
7360              then we overwrote the string terminator.  That's the only
7361              reason the lookup should fail.  */
7362           if (fh == NULL)
7363             {
7364               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7365               while (q >= eh->elf.root.root.string && *q == *p)
7366                 --q, --p;
7367               if (q < eh->elf.root.root.string && *p == '.')
7368                 fh = (struct ppc_link_hash_entry *)
7369                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7370             }
7371           if (fh != NULL)
7372             {
7373               eh->oh = fh;
7374               fh->oh = eh;
7375             }
7376         }
7377       if (fh != NULL)
7378         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7379     }
7380 }
7381
7382 static bfd_boolean
7383 get_sym_h (struct elf_link_hash_entry **hp,
7384            Elf_Internal_Sym **symp,
7385            asection **symsecp,
7386            unsigned char **tls_maskp,
7387            Elf_Internal_Sym **locsymsp,
7388            unsigned long r_symndx,
7389            bfd *ibfd)
7390 {
7391   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7392
7393   if (r_symndx >= symtab_hdr->sh_info)
7394     {
7395       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7396       struct elf_link_hash_entry *h;
7397
7398       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7399       h = elf_follow_link (h);
7400
7401       if (hp != NULL)
7402         *hp = h;
7403
7404       if (symp != NULL)
7405         *symp = NULL;
7406
7407       if (symsecp != NULL)
7408         {
7409           asection *symsec = NULL;
7410           if (h->root.type == bfd_link_hash_defined
7411               || h->root.type == bfd_link_hash_defweak)
7412             symsec = h->root.u.def.section;
7413           *symsecp = symsec;
7414         }
7415
7416       if (tls_maskp != NULL)
7417         {
7418           struct ppc_link_hash_entry *eh;
7419
7420           eh = (struct ppc_link_hash_entry *) h;
7421           *tls_maskp = &eh->tls_mask;
7422         }
7423     }
7424   else
7425     {
7426       Elf_Internal_Sym *sym;
7427       Elf_Internal_Sym *locsyms = *locsymsp;
7428
7429       if (locsyms == NULL)
7430         {
7431           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7432           if (locsyms == NULL)
7433             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7434                                             symtab_hdr->sh_info,
7435                                             0, NULL, NULL, NULL);
7436           if (locsyms == NULL)
7437             return FALSE;
7438           *locsymsp = locsyms;
7439         }
7440       sym = locsyms + r_symndx;
7441
7442       if (hp != NULL)
7443         *hp = NULL;
7444
7445       if (symp != NULL)
7446         *symp = sym;
7447
7448       if (symsecp != NULL)
7449         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7450
7451       if (tls_maskp != NULL)
7452         {
7453           struct got_entry **lgot_ents;
7454           unsigned char *tls_mask;
7455
7456           tls_mask = NULL;
7457           lgot_ents = elf_local_got_ents (ibfd);
7458           if (lgot_ents != NULL)
7459             {
7460               struct plt_entry **local_plt = (struct plt_entry **)
7461                 (lgot_ents + symtab_hdr->sh_info);
7462               unsigned char *lgot_masks = (unsigned char *)
7463                 (local_plt + symtab_hdr->sh_info);
7464               tls_mask = &lgot_masks[r_symndx];
7465             }
7466           *tls_maskp = tls_mask;
7467         }
7468     }
7469   return TRUE;
7470 }
7471
7472 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7473    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7474    type suitable for optimization, and 1 otherwise.  */
7475
7476 static int
7477 get_tls_mask (unsigned char **tls_maskp,
7478               unsigned long *toc_symndx,
7479               bfd_vma *toc_addend,
7480               Elf_Internal_Sym **locsymsp,
7481               const Elf_Internal_Rela *rel,
7482               bfd *ibfd)
7483 {
7484   unsigned long r_symndx;
7485   int next_r;
7486   struct elf_link_hash_entry *h;
7487   Elf_Internal_Sym *sym;
7488   asection *sec;
7489   bfd_vma off;
7490
7491   r_symndx = ELF64_R_SYM (rel->r_info);
7492   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7493     return 0;
7494
7495   if ((*tls_maskp != NULL && **tls_maskp != 0)
7496       || sec == NULL
7497       || ppc64_elf_section_data (sec) == NULL
7498       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7499     return 1;
7500
7501   /* Look inside a TOC section too.  */
7502   if (h != NULL)
7503     {
7504       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7505       off = h->root.u.def.value;
7506     }
7507   else
7508     off = sym->st_value;
7509   off += rel->r_addend;
7510   BFD_ASSERT (off % 8 == 0);
7511   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7512   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7513   if (toc_symndx != NULL)
7514     *toc_symndx = r_symndx;
7515   if (toc_addend != NULL)
7516     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7517   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7518     return 0;
7519   if ((h == NULL || is_static_defined (h))
7520       && (next_r == -1 || next_r == -2))
7521     return 1 - next_r;
7522   return 1;
7523 }
7524
7525 /* Find (or create) an entry in the tocsave hash table.  */
7526
7527 static struct tocsave_entry *
7528 tocsave_find (struct ppc_link_hash_table *htab,
7529               enum insert_option insert,
7530               Elf_Internal_Sym **local_syms,
7531               const Elf_Internal_Rela *irela,
7532               bfd *ibfd)
7533 {
7534   unsigned long r_indx;
7535   struct elf_link_hash_entry *h;
7536   Elf_Internal_Sym *sym;
7537   struct tocsave_entry ent, *p;
7538   hashval_t hash;
7539   struct tocsave_entry **slot;
7540
7541   r_indx = ELF64_R_SYM (irela->r_info);
7542   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7543     return NULL;
7544   if (ent.sec == NULL || ent.sec->output_section == NULL)
7545     {
7546       _bfd_error_handler
7547         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7548       return NULL;
7549     }
7550
7551   if (h != NULL)
7552     ent.offset = h->root.u.def.value;
7553   else
7554     ent.offset = sym->st_value;
7555   ent.offset += irela->r_addend;
7556
7557   hash = tocsave_htab_hash (&ent);
7558   slot = ((struct tocsave_entry **)
7559           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7560   if (slot == NULL)
7561     return NULL;
7562
7563   if (*slot == NULL)
7564     {
7565       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7566       if (p == NULL)
7567         return NULL;
7568       *p = ent;
7569       *slot = p;
7570     }
7571   return *slot;
7572 }
7573
7574 /* Adjust all global syms defined in opd sections.  In gcc generated
7575    code for the old ABI, these will already have been done.  */
7576
7577 static bfd_boolean
7578 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7579 {
7580   struct ppc_link_hash_entry *eh;
7581   asection *sym_sec;
7582   struct _opd_sec_data *opd;
7583
7584   if (h->root.type == bfd_link_hash_indirect)
7585     return TRUE;
7586
7587   if (h->root.type != bfd_link_hash_defined
7588       && h->root.type != bfd_link_hash_defweak)
7589     return TRUE;
7590
7591   eh = (struct ppc_link_hash_entry *) h;
7592   if (eh->adjust_done)
7593     return TRUE;
7594
7595   sym_sec = eh->elf.root.u.def.section;
7596   opd = get_opd_info (sym_sec);
7597   if (opd != NULL && opd->adjust != NULL)
7598     {
7599       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7600       if (adjust == -1)
7601         {
7602           /* This entry has been deleted.  */
7603           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7604           if (dsec == NULL)
7605             {
7606               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7607                 if (discarded_section (dsec))
7608                   {
7609                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7610                     break;
7611                   }
7612             }
7613           eh->elf.root.u.def.value = 0;
7614           eh->elf.root.u.def.section = dsec;
7615         }
7616       else
7617         eh->elf.root.u.def.value += adjust;
7618       eh->adjust_done = 1;
7619     }
7620   return TRUE;
7621 }
7622
7623 /* Handles decrementing dynamic reloc counts for the reloc specified by
7624    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7625    have already been determined.  */
7626
7627 static bfd_boolean
7628 dec_dynrel_count (bfd_vma r_info,
7629                   asection *sec,
7630                   struct bfd_link_info *info,
7631                   Elf_Internal_Sym **local_syms,
7632                   struct elf_link_hash_entry *h,
7633                   Elf_Internal_Sym *sym)
7634 {
7635   enum elf_ppc64_reloc_type r_type;
7636   asection *sym_sec = NULL;
7637
7638   /* Can this reloc be dynamic?  This switch, and later tests here
7639      should be kept in sync with the code in check_relocs.  */
7640   r_type = ELF64_R_TYPE (r_info);
7641   switch (r_type)
7642     {
7643     default:
7644       return TRUE;
7645
7646     case R_PPC64_TPREL16:
7647     case R_PPC64_TPREL16_LO:
7648     case R_PPC64_TPREL16_HI:
7649     case R_PPC64_TPREL16_HA:
7650     case R_PPC64_TPREL16_DS:
7651     case R_PPC64_TPREL16_LO_DS:
7652     case R_PPC64_TPREL16_HIGH:
7653     case R_PPC64_TPREL16_HIGHA:
7654     case R_PPC64_TPREL16_HIGHER:
7655     case R_PPC64_TPREL16_HIGHERA:
7656     case R_PPC64_TPREL16_HIGHEST:
7657     case R_PPC64_TPREL16_HIGHESTA:
7658     case R_PPC64_TPREL64:
7659     case R_PPC64_DTPMOD64:
7660     case R_PPC64_DTPREL64:
7661     case R_PPC64_ADDR64:
7662     case R_PPC64_REL30:
7663     case R_PPC64_REL32:
7664     case R_PPC64_REL64:
7665     case R_PPC64_ADDR14:
7666     case R_PPC64_ADDR14_BRNTAKEN:
7667     case R_PPC64_ADDR14_BRTAKEN:
7668     case R_PPC64_ADDR16:
7669     case R_PPC64_ADDR16_DS:
7670     case R_PPC64_ADDR16_HA:
7671     case R_PPC64_ADDR16_HI:
7672     case R_PPC64_ADDR16_HIGH:
7673     case R_PPC64_ADDR16_HIGHA:
7674     case R_PPC64_ADDR16_HIGHER:
7675     case R_PPC64_ADDR16_HIGHERA:
7676     case R_PPC64_ADDR16_HIGHEST:
7677     case R_PPC64_ADDR16_HIGHESTA:
7678     case R_PPC64_ADDR16_LO:
7679     case R_PPC64_ADDR16_LO_DS:
7680     case R_PPC64_ADDR24:
7681     case R_PPC64_ADDR32:
7682     case R_PPC64_UADDR16:
7683     case R_PPC64_UADDR32:
7684     case R_PPC64_UADDR64:
7685     case R_PPC64_TOC:
7686       break;
7687     }
7688
7689   if (local_syms != NULL)
7690     {
7691       unsigned long r_symndx;
7692       bfd *ibfd = sec->owner;
7693
7694       r_symndx = ELF64_R_SYM (r_info);
7695       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7696         return FALSE;
7697     }
7698
7699   if ((bfd_link_pic (info)
7700        && (must_be_dyn_reloc (info, r_type)
7701            || (h != NULL
7702                && (!SYMBOLIC_BIND (info, h)
7703                    || h->root.type == bfd_link_hash_defweak
7704                    || !h->def_regular))))
7705       || (ELIMINATE_COPY_RELOCS
7706           && !bfd_link_pic (info)
7707           && h != NULL
7708           && (h->root.type == bfd_link_hash_defweak
7709               || !h->def_regular)))
7710     ;
7711   else
7712     return TRUE;
7713
7714   if (h != NULL)
7715     {
7716       struct elf_dyn_relocs *p;
7717       struct elf_dyn_relocs **pp;
7718       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7719
7720       /* elf_gc_sweep may have already removed all dyn relocs associated
7721          with local syms for a given section.  Also, symbol flags are
7722          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7723          report a dynreloc miscount.  */
7724       if (*pp == NULL && info->gc_sections)
7725         return TRUE;
7726
7727       while ((p = *pp) != NULL)
7728         {
7729           if (p->sec == sec)
7730             {
7731               if (!must_be_dyn_reloc (info, r_type))
7732                 p->pc_count -= 1;
7733               p->count -= 1;
7734               if (p->count == 0)
7735                 *pp = p->next;
7736               return TRUE;
7737             }
7738           pp = &p->next;
7739         }
7740     }
7741   else
7742     {
7743       struct ppc_dyn_relocs *p;
7744       struct ppc_dyn_relocs **pp;
7745       void *vpp;
7746       bfd_boolean is_ifunc;
7747
7748       if (local_syms == NULL)
7749         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7750       if (sym_sec == NULL)
7751         sym_sec = sec;
7752
7753       vpp = &elf_section_data (sym_sec)->local_dynrel;
7754       pp = (struct ppc_dyn_relocs **) vpp;
7755
7756       if (*pp == NULL && info->gc_sections)
7757         return TRUE;
7758
7759       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7760       while ((p = *pp) != NULL)
7761         {
7762           if (p->sec == sec && p->ifunc == is_ifunc)
7763             {
7764               p->count -= 1;
7765               if (p->count == 0)
7766                 *pp = p->next;
7767               return TRUE;
7768             }
7769           pp = &p->next;
7770         }
7771     }
7772
7773   /* xgettext:c-format */
7774   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7775                       sec->owner, sec);
7776   bfd_set_error (bfd_error_bad_value);
7777   return FALSE;
7778 }
7779
7780 /* Remove unused Official Procedure Descriptor entries.  Currently we
7781    only remove those associated with functions in discarded link-once
7782    sections, or weakly defined functions that have been overridden.  It
7783    would be possible to remove many more entries for statically linked
7784    applications.  */
7785
7786 bfd_boolean
7787 ppc64_elf_edit_opd (struct bfd_link_info *info)
7788 {
7789   bfd *ibfd;
7790   bfd_boolean some_edited = FALSE;
7791   asection *need_pad = NULL;
7792   struct ppc_link_hash_table *htab;
7793
7794   htab = ppc_hash_table (info);
7795   if (htab == NULL)
7796     return FALSE;
7797
7798   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7799     {
7800       asection *sec;
7801       Elf_Internal_Rela *relstart, *rel, *relend;
7802       Elf_Internal_Shdr *symtab_hdr;
7803       Elf_Internal_Sym *local_syms;
7804       struct _opd_sec_data *opd;
7805       bfd_boolean need_edit, add_aux_fields, broken;
7806       bfd_size_type cnt_16b = 0;
7807
7808       if (!is_ppc64_elf (ibfd))
7809         continue;
7810
7811       sec = bfd_get_section_by_name (ibfd, ".opd");
7812       if (sec == NULL || sec->size == 0)
7813         continue;
7814
7815       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7816         continue;
7817
7818       if (sec->output_section == bfd_abs_section_ptr)
7819         continue;
7820
7821       /* Look through the section relocs.  */
7822       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7823         continue;
7824
7825       local_syms = NULL;
7826       symtab_hdr = &elf_symtab_hdr (ibfd);
7827
7828       /* Read the relocations.  */
7829       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7830                                             info->keep_memory);
7831       if (relstart == NULL)
7832         return FALSE;
7833
7834       /* First run through the relocs to check they are sane, and to
7835          determine whether we need to edit this opd section.  */
7836       need_edit = FALSE;
7837       broken = FALSE;
7838       need_pad = sec;
7839       relend = relstart + sec->reloc_count;
7840       for (rel = relstart; rel < relend; )
7841         {
7842           enum elf_ppc64_reloc_type r_type;
7843           unsigned long r_symndx;
7844           asection *sym_sec;
7845           struct elf_link_hash_entry *h;
7846           Elf_Internal_Sym *sym;
7847           bfd_vma offset;
7848
7849           /* .opd contains an array of 16 or 24 byte entries.  We're
7850              only interested in the reloc pointing to a function entry
7851              point.  */
7852           offset = rel->r_offset;
7853           if (rel + 1 == relend
7854               || rel[1].r_offset != offset + 8)
7855             {
7856               /* If someone messes with .opd alignment then after a
7857                  "ld -r" we might have padding in the middle of .opd.
7858                  Also, there's nothing to prevent someone putting
7859                  something silly in .opd with the assembler.  No .opd
7860                  optimization for them!  */
7861             broken_opd:
7862               _bfd_error_handler
7863                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7864               broken = TRUE;
7865               break;
7866             }
7867
7868           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7869               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7870             {
7871               _bfd_error_handler
7872                 /* xgettext:c-format */
7873                 (_("%pB: unexpected reloc type %u in .opd section"),
7874                  ibfd, r_type);
7875               broken = TRUE;
7876               break;
7877             }
7878
7879           r_symndx = ELF64_R_SYM (rel->r_info);
7880           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7881                           r_symndx, ibfd))
7882             goto error_ret;
7883
7884           if (sym_sec == NULL || sym_sec->owner == NULL)
7885             {
7886               const char *sym_name;
7887               if (h != NULL)
7888                 sym_name = h->root.root.string;
7889               else
7890                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7891                                              sym_sec);
7892
7893               _bfd_error_handler
7894                 /* xgettext:c-format */
7895                 (_("%pB: undefined sym `%s' in .opd section"),
7896                  ibfd, sym_name);
7897               broken = TRUE;
7898               break;
7899             }
7900
7901           /* opd entries are always for functions defined in the
7902              current input bfd.  If the symbol isn't defined in the
7903              input bfd, then we won't be using the function in this
7904              bfd;  It must be defined in a linkonce section in another
7905              bfd, or is weak.  It's also possible that we are
7906              discarding the function due to a linker script /DISCARD/,
7907              which we test for via the output_section.  */
7908           if (sym_sec->owner != ibfd
7909               || sym_sec->output_section == bfd_abs_section_ptr)
7910             need_edit = TRUE;
7911
7912           rel += 2;
7913           if (rel + 1 == relend
7914               || (rel + 2 < relend
7915                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7916             ++rel;
7917
7918           if (rel == relend)
7919             {
7920               if (sec->size == offset + 24)
7921                 {
7922                   need_pad = NULL;
7923                   break;
7924                 }
7925               if (sec->size == offset + 16)
7926                 {
7927                   cnt_16b++;
7928                   break;
7929                 }
7930               goto broken_opd;
7931             }
7932           else if (rel + 1 < relend
7933                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7934                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7935             {
7936               if (rel[0].r_offset == offset + 16)
7937                 cnt_16b++;
7938               else if (rel[0].r_offset != offset + 24)
7939                 goto broken_opd;
7940             }
7941           else
7942             goto broken_opd;
7943         }
7944
7945       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7946
7947       if (!broken && (need_edit || add_aux_fields))
7948         {
7949           Elf_Internal_Rela *write_rel;
7950           Elf_Internal_Shdr *rel_hdr;
7951           bfd_byte *rptr, *wptr;
7952           bfd_byte *new_contents;
7953           bfd_size_type amt;
7954
7955           new_contents = NULL;
7956           amt = OPD_NDX (sec->size) * sizeof (long);
7957           opd = &ppc64_elf_section_data (sec)->u.opd;
7958           opd->adjust = bfd_zalloc (sec->owner, amt);
7959           if (opd->adjust == NULL)
7960             return FALSE;
7961
7962           /* This seems a waste of time as input .opd sections are all
7963              zeros as generated by gcc, but I suppose there's no reason
7964              this will always be so.  We might start putting something in
7965              the third word of .opd entries.  */
7966           if ((sec->flags & SEC_IN_MEMORY) == 0)
7967             {
7968               bfd_byte *loc;
7969               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7970                 {
7971                   if (loc != NULL)
7972                     free (loc);
7973                 error_ret:
7974                   if (local_syms != NULL
7975                       && symtab_hdr->contents != (unsigned char *) local_syms)
7976                     free (local_syms);
7977                   if (elf_section_data (sec)->relocs != relstart)
7978                     free (relstart);
7979                   return FALSE;
7980                 }
7981               sec->contents = loc;
7982               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7983             }
7984
7985           elf_section_data (sec)->relocs = relstart;
7986
7987           new_contents = sec->contents;
7988           if (add_aux_fields)
7989             {
7990               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7991               if (new_contents == NULL)
7992                 return FALSE;
7993               need_pad = NULL;
7994             }
7995           wptr = new_contents;
7996           rptr = sec->contents;
7997           write_rel = relstart;
7998           for (rel = relstart; rel < relend; )
7999             {
8000               unsigned long r_symndx;
8001               asection *sym_sec;
8002               struct elf_link_hash_entry *h;
8003               struct ppc_link_hash_entry *fdh = NULL;
8004               Elf_Internal_Sym *sym;
8005               long opd_ent_size;
8006               Elf_Internal_Rela *next_rel;
8007               bfd_boolean skip;
8008
8009               r_symndx = ELF64_R_SYM (rel->r_info);
8010               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8011                               r_symndx, ibfd))
8012                 goto error_ret;
8013
8014               next_rel = rel + 2;
8015               if (next_rel + 1 == relend
8016                   || (next_rel + 2 < relend
8017                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8018                 ++next_rel;
8019
8020               /* See if the .opd entry is full 24 byte or
8021                  16 byte (with fd_aux entry overlapped with next
8022                  fd_func).  */
8023               opd_ent_size = 24;
8024               if (next_rel == relend)
8025                 {
8026                   if (sec->size == rel->r_offset + 16)
8027                     opd_ent_size = 16;
8028                 }
8029               else if (next_rel->r_offset == rel->r_offset + 16)
8030                 opd_ent_size = 16;
8031
8032               if (h != NULL
8033                   && h->root.root.string[0] == '.')
8034                 {
8035                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8036                   if (fdh != NULL)
8037                     {
8038                       fdh = ppc_follow_link (fdh);
8039                       if (fdh->elf.root.type != bfd_link_hash_defined
8040                           && fdh->elf.root.type != bfd_link_hash_defweak)
8041                         fdh = NULL;
8042                     }
8043                 }
8044
8045               skip = (sym_sec->owner != ibfd
8046                       || sym_sec->output_section == bfd_abs_section_ptr);
8047               if (skip)
8048                 {
8049                   if (fdh != NULL && sym_sec->owner == ibfd)
8050                     {
8051                       /* Arrange for the function descriptor sym
8052                          to be dropped.  */
8053                       fdh->elf.root.u.def.value = 0;
8054                       fdh->elf.root.u.def.section = sym_sec;
8055                     }
8056                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8057
8058                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8059                     rel = next_rel;
8060                   else
8061                     while (1)
8062                       {
8063                         if (!dec_dynrel_count (rel->r_info, sec, info,
8064                                                NULL, h, sym))
8065                           goto error_ret;
8066
8067                         if (++rel == next_rel)
8068                           break;
8069
8070                         r_symndx = ELF64_R_SYM (rel->r_info);
8071                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8072                                         r_symndx, ibfd))
8073                           goto error_ret;
8074                       }
8075                 }
8076               else
8077                 {
8078                   /* We'll be keeping this opd entry.  */
8079                   long adjust;
8080
8081                   if (fdh != NULL)
8082                     {
8083                       /* Redefine the function descriptor symbol to
8084                          this location in the opd section.  It is
8085                          necessary to update the value here rather
8086                          than using an array of adjustments as we do
8087                          for local symbols, because various places
8088                          in the generic ELF code use the value
8089                          stored in u.def.value.  */
8090                       fdh->elf.root.u.def.value = wptr - new_contents;
8091                       fdh->adjust_done = 1;
8092                     }
8093
8094                   /* Local syms are a bit tricky.  We could
8095                      tweak them as they can be cached, but
8096                      we'd need to look through the local syms
8097                      for the function descriptor sym which we
8098                      don't have at the moment.  So keep an
8099                      array of adjustments.  */
8100                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8101                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8102
8103                   if (wptr != rptr)
8104                     memcpy (wptr, rptr, opd_ent_size);
8105                   wptr += opd_ent_size;
8106                   if (add_aux_fields && opd_ent_size == 16)
8107                     {
8108                       memset (wptr, '\0', 8);
8109                       wptr += 8;
8110                     }
8111
8112                   /* We need to adjust any reloc offsets to point to the
8113                      new opd entries.  */
8114                   for ( ; rel != next_rel; ++rel)
8115                     {
8116                       rel->r_offset += adjust;
8117                       if (write_rel != rel)
8118                         memcpy (write_rel, rel, sizeof (*rel));
8119                       ++write_rel;
8120                     }
8121                 }
8122
8123               rptr += opd_ent_size;
8124             }
8125
8126           sec->size = wptr - new_contents;
8127           sec->reloc_count = write_rel - relstart;
8128           if (add_aux_fields)
8129             {
8130               free (sec->contents);
8131               sec->contents = new_contents;
8132             }
8133
8134           /* Fudge the header size too, as this is used later in
8135              elf_bfd_final_link if we are emitting relocs.  */
8136           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8137           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8138           some_edited = TRUE;
8139         }
8140       else if (elf_section_data (sec)->relocs != relstart)
8141         free (relstart);
8142
8143       if (local_syms != NULL
8144           && symtab_hdr->contents != (unsigned char *) local_syms)
8145         {
8146           if (!info->keep_memory)
8147             free (local_syms);
8148           else
8149             symtab_hdr->contents = (unsigned char *) local_syms;
8150         }
8151     }
8152
8153   if (some_edited)
8154     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8155
8156   /* If we are doing a final link and the last .opd entry is just 16 byte
8157      long, add a 8 byte padding after it.  */
8158   if (need_pad != NULL && !bfd_link_relocatable (info))
8159     {
8160       bfd_byte *p;
8161
8162       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8163         {
8164           BFD_ASSERT (need_pad->size > 0);
8165
8166           p = bfd_malloc (need_pad->size + 8);
8167           if (p == NULL)
8168             return FALSE;
8169
8170           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8171                                           p, 0, need_pad->size))
8172             return FALSE;
8173
8174           need_pad->contents = p;
8175           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8176         }
8177       else
8178         {
8179           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8180           if (p == NULL)
8181             return FALSE;
8182
8183           need_pad->contents = p;
8184         }
8185
8186       memset (need_pad->contents + need_pad->size, 0, 8);
8187       need_pad->size += 8;
8188     }
8189
8190   return TRUE;
8191 }
8192
8193 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8194
8195 asection *
8196 ppc64_elf_tls_setup (struct bfd_link_info *info)
8197 {
8198   struct ppc_link_hash_table *htab;
8199
8200   htab = ppc_hash_table (info);
8201   if (htab == NULL)
8202     return NULL;
8203
8204   if (abiversion (info->output_bfd) == 1)
8205     htab->opd_abi = 1;
8206
8207   if (htab->params->no_multi_toc)
8208     htab->do_multi_toc = 0;
8209   else if (!htab->do_multi_toc)
8210     htab->params->no_multi_toc = 1;
8211
8212   /* Default to --no-plt-localentry, as this option can cause problems
8213      with symbol interposition.  For example, glibc libpthread.so and
8214      libc.so duplicate many pthread symbols, with a fallback
8215      implementation in libc.so.  In some cases the fallback does more
8216      work than the pthread implementation.  __pthread_condattr_destroy
8217      is one such symbol: the libpthread.so implementation is
8218      localentry:0 while the libc.so implementation is localentry:8.
8219      An app that "cleverly" uses dlopen to only load necessary
8220      libraries at runtime may omit loading libpthread.so when not
8221      running multi-threaded, which then results in the libc.so
8222      fallback symbols being used and ld.so complaining.  Now there
8223      are workarounds in ld (see non_zero_localentry) to detect the
8224      pthread situation, but that may not be the only case where
8225      --plt-localentry can cause trouble.  */
8226   if (htab->params->plt_localentry0 < 0)
8227     htab->params->plt_localentry0 = 0;
8228   if (htab->params->plt_localentry0
8229       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8230                                FALSE, FALSE, FALSE) == NULL)
8231     _bfd_error_handler
8232       (_("warning: --plt-localentry is especially dangerous without "
8233          "ld.so support to detect ABI violations"));
8234
8235   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8236                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8237                                               FALSE, FALSE, TRUE));
8238   /* Move dynamic linking info to the function descriptor sym.  */
8239   if (htab->tls_get_addr != NULL)
8240     func_desc_adjust (&htab->tls_get_addr->elf, info);
8241   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8242                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8243                                                  FALSE, FALSE, TRUE));
8244   if (htab->params->tls_get_addr_opt)
8245     {
8246       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8247
8248       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8249                                   FALSE, FALSE, TRUE);
8250       if (opt != NULL)
8251         func_desc_adjust (opt, info);
8252       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8253                                      FALSE, FALSE, TRUE);
8254       if (opt_fd != NULL
8255           && (opt_fd->root.type == bfd_link_hash_defined
8256               || opt_fd->root.type == bfd_link_hash_defweak))
8257         {
8258           /* If glibc supports an optimized __tls_get_addr call stub,
8259              signalled by the presence of __tls_get_addr_opt, and we'll
8260              be calling __tls_get_addr via a plt call stub, then
8261              make __tls_get_addr point to __tls_get_addr_opt.  */
8262           tga_fd = &htab->tls_get_addr_fd->elf;
8263           if (htab->elf.dynamic_sections_created
8264               && tga_fd != NULL
8265               && (tga_fd->type == STT_FUNC
8266                   || tga_fd->needs_plt)
8267               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8268                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8269             {
8270               struct plt_entry *ent;
8271
8272               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8273                 if (ent->plt.refcount > 0)
8274                   break;
8275               if (ent != NULL)
8276                 {
8277                   tga_fd->root.type = bfd_link_hash_indirect;
8278                   tga_fd->root.u.i.link = &opt_fd->root;
8279                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8280                   opt_fd->mark = 1;
8281                   if (opt_fd->dynindx != -1)
8282                     {
8283                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8284                       opt_fd->dynindx = -1;
8285                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8286                                               opt_fd->dynstr_index);
8287                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8288                         return NULL;
8289                     }
8290                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8291                   tga = &htab->tls_get_addr->elf;
8292                   if (opt != NULL && tga != NULL)
8293                     {
8294                       tga->root.type = bfd_link_hash_indirect;
8295                       tga->root.u.i.link = &opt->root;
8296                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8297                       opt->mark = 1;
8298                       _bfd_elf_link_hash_hide_symbol (info, opt,
8299                                                       tga->forced_local);
8300                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8301                     }
8302                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8303                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8304                   if (htab->tls_get_addr != NULL)
8305                     {
8306                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8307                       htab->tls_get_addr->is_func = 1;
8308                     }
8309                 }
8310             }
8311         }
8312       else if (htab->params->tls_get_addr_opt < 0)
8313         htab->params->tls_get_addr_opt = 0;
8314     }
8315   return _bfd_elf_tls_setup (info->output_bfd, info);
8316 }
8317
8318 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8319    HASH1 or HASH2.  */
8320
8321 static bfd_boolean
8322 branch_reloc_hash_match (const bfd *ibfd,
8323                          const Elf_Internal_Rela *rel,
8324                          const struct ppc_link_hash_entry *hash1,
8325                          const struct ppc_link_hash_entry *hash2)
8326 {
8327   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8328   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8329   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8330
8331   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8332     {
8333       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8334       struct elf_link_hash_entry *h;
8335
8336       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8337       h = elf_follow_link (h);
8338       if (h == &hash1->elf || h == &hash2->elf)
8339         return TRUE;
8340     }
8341   return FALSE;
8342 }
8343
8344 /* Run through all the TLS relocs looking for optimization
8345    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8346    a preliminary section layout so that we know the TLS segment
8347    offsets.  We can't optimize earlier because some optimizations need
8348    to know the tp offset, and we need to optimize before allocating
8349    dynamic relocations.  */
8350
8351 bfd_boolean
8352 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8353 {
8354   bfd *ibfd;
8355   asection *sec;
8356   struct ppc_link_hash_table *htab;
8357   unsigned char *toc_ref;
8358   int pass;
8359
8360   if (!bfd_link_executable (info))
8361     return TRUE;
8362
8363   htab = ppc_hash_table (info);
8364   if (htab == NULL)
8365     return FALSE;
8366
8367   /* Make two passes over the relocs.  On the first pass, mark toc
8368      entries involved with tls relocs, and check that tls relocs
8369      involved in setting up a tls_get_addr call are indeed followed by
8370      such a call.  If they are not, we can't do any tls optimization.
8371      On the second pass twiddle tls_mask flags to notify
8372      relocate_section that optimization can be done, and adjust got
8373      and plt refcounts.  */
8374   toc_ref = NULL;
8375   for (pass = 0; pass < 2; ++pass)
8376     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8377       {
8378         Elf_Internal_Sym *locsyms = NULL;
8379         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8380
8381         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8382           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8383             {
8384               Elf_Internal_Rela *relstart, *rel, *relend;
8385               bfd_boolean found_tls_get_addr_arg = 0;
8386
8387               /* Read the relocations.  */
8388               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8389                                                     info->keep_memory);
8390               if (relstart == NULL)
8391                 {
8392                   free (toc_ref);
8393                   return FALSE;
8394                 }
8395
8396               relend = relstart + sec->reloc_count;
8397               for (rel = relstart; rel < relend; rel++)
8398                 {
8399                   enum elf_ppc64_reloc_type r_type;
8400                   unsigned long r_symndx;
8401                   struct elf_link_hash_entry *h;
8402                   Elf_Internal_Sym *sym;
8403                   asection *sym_sec;
8404                   unsigned char *tls_mask;
8405                   unsigned char tls_set, tls_clear, tls_type = 0;
8406                   bfd_vma value;
8407                   bfd_boolean ok_tprel, is_local;
8408                   long toc_ref_index = 0;
8409                   int expecting_tls_get_addr = 0;
8410                   bfd_boolean ret = FALSE;
8411
8412                   r_symndx = ELF64_R_SYM (rel->r_info);
8413                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8414                                   r_symndx, ibfd))
8415                     {
8416                     err_free_rel:
8417                       if (elf_section_data (sec)->relocs != relstart)
8418                         free (relstart);
8419                       if (toc_ref != NULL)
8420                         free (toc_ref);
8421                       if (locsyms != NULL
8422                           && (elf_symtab_hdr (ibfd).contents
8423                               != (unsigned char *) locsyms))
8424                         free (locsyms);
8425                       return ret;
8426                     }
8427
8428                   if (h != NULL)
8429                     {
8430                       if (h->root.type == bfd_link_hash_defined
8431                           || h->root.type == bfd_link_hash_defweak)
8432                         value = h->root.u.def.value;
8433                       else if (h->root.type == bfd_link_hash_undefweak)
8434                         value = 0;
8435                       else
8436                         {
8437                           found_tls_get_addr_arg = 0;
8438                           continue;
8439                         }
8440                     }
8441                   else
8442                     /* Symbols referenced by TLS relocs must be of type
8443                        STT_TLS.  So no need for .opd local sym adjust.  */
8444                     value = sym->st_value;
8445
8446                   ok_tprel = FALSE;
8447                   is_local = FALSE;
8448                   if (h == NULL
8449                       || !h->def_dynamic)
8450                     {
8451                       is_local = TRUE;
8452                       if (h != NULL
8453                           && h->root.type == bfd_link_hash_undefweak)
8454                         ok_tprel = TRUE;
8455                       else if (sym_sec != NULL
8456                                && sym_sec->output_section != NULL)
8457                         {
8458                           value += sym_sec->output_offset;
8459                           value += sym_sec->output_section->vma;
8460                           value -= htab->elf.tls_sec->vma;
8461                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8462                                       < (bfd_vma) 1 << 32);
8463                         }
8464                     }
8465
8466                   r_type = ELF64_R_TYPE (rel->r_info);
8467                   /* If this section has old-style __tls_get_addr calls
8468                      without marker relocs, then check that each
8469                      __tls_get_addr call reloc is preceded by a reloc
8470                      that conceivably belongs to the __tls_get_addr arg
8471                      setup insn.  If we don't find matching arg setup
8472                      relocs, don't do any tls optimization.  */
8473                   if (pass == 0
8474                       && sec->has_tls_get_addr_call
8475                       && h != NULL
8476                       && (h == &htab->tls_get_addr->elf
8477                           || h == &htab->tls_get_addr_fd->elf)
8478                       && !found_tls_get_addr_arg
8479                       && is_branch_reloc (r_type))
8480                     {
8481                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8482                                                 "TLS optimization disabled\n"),
8483                                               ibfd, sec, rel->r_offset);
8484                       ret = TRUE;
8485                       goto err_free_rel;
8486                     }
8487
8488                   found_tls_get_addr_arg = 0;
8489                   switch (r_type)
8490                     {
8491                     case R_PPC64_GOT_TLSLD16:
8492                     case R_PPC64_GOT_TLSLD16_LO:
8493                       expecting_tls_get_addr = 1;
8494                       found_tls_get_addr_arg = 1;
8495                       /* Fall through.  */
8496
8497                     case R_PPC64_GOT_TLSLD16_HI:
8498                     case R_PPC64_GOT_TLSLD16_HA:
8499                       /* These relocs should never be against a symbol
8500                          defined in a shared lib.  Leave them alone if
8501                          that turns out to be the case.  */
8502                       if (!is_local)
8503                         continue;
8504
8505                       /* LD -> LE */
8506                       tls_set = 0;
8507                       tls_clear = TLS_LD;
8508                       tls_type = TLS_TLS | TLS_LD;
8509                       break;
8510
8511                     case R_PPC64_GOT_TLSGD16:
8512                     case R_PPC64_GOT_TLSGD16_LO:
8513                       expecting_tls_get_addr = 1;
8514                       found_tls_get_addr_arg = 1;
8515                       /* Fall through. */
8516
8517                     case R_PPC64_GOT_TLSGD16_HI:
8518                     case R_PPC64_GOT_TLSGD16_HA:
8519                       if (ok_tprel)
8520                         /* GD -> LE */
8521                         tls_set = 0;
8522                       else
8523                         /* GD -> IE */
8524                         tls_set = TLS_TLS | TLS_TPRELGD;
8525                       tls_clear = TLS_GD;
8526                       tls_type = TLS_TLS | TLS_GD;
8527                       break;
8528
8529                     case R_PPC64_GOT_TPREL16_DS:
8530                     case R_PPC64_GOT_TPREL16_LO_DS:
8531                     case R_PPC64_GOT_TPREL16_HI:
8532                     case R_PPC64_GOT_TPREL16_HA:
8533                       if (ok_tprel)
8534                         {
8535                           /* IE -> LE */
8536                           tls_set = 0;
8537                           tls_clear = TLS_TPREL;
8538                           tls_type = TLS_TLS | TLS_TPREL;
8539                           break;
8540                         }
8541                       continue;
8542
8543                     case R_PPC64_TLSGD:
8544                     case R_PPC64_TLSLD:
8545                       found_tls_get_addr_arg = 1;
8546                       /* Fall through.  */
8547
8548                     case R_PPC64_TLS:
8549                     case R_PPC64_TOC16:
8550                     case R_PPC64_TOC16_LO:
8551                       if (sym_sec == NULL || sym_sec != toc)
8552                         continue;
8553
8554                       /* Mark this toc entry as referenced by a TLS
8555                          code sequence.  We can do that now in the
8556                          case of R_PPC64_TLS, and after checking for
8557                          tls_get_addr for the TOC16 relocs.  */
8558                       if (toc_ref == NULL)
8559                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8560                       if (toc_ref == NULL)
8561                         goto err_free_rel;
8562
8563                       if (h != NULL)
8564                         value = h->root.u.def.value;
8565                       else
8566                         value = sym->st_value;
8567                       value += rel->r_addend;
8568                       if (value % 8 != 0)
8569                         continue;
8570                       BFD_ASSERT (value < toc->size
8571                                   && toc->output_offset % 8 == 0);
8572                       toc_ref_index = (value + toc->output_offset) / 8;
8573                       if (r_type == R_PPC64_TLS
8574                           || r_type == R_PPC64_TLSGD
8575                           || r_type == R_PPC64_TLSLD)
8576                         {
8577                           toc_ref[toc_ref_index] = 1;
8578                           continue;
8579                         }
8580
8581                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8582                         continue;
8583
8584                       tls_set = 0;
8585                       tls_clear = 0;
8586                       expecting_tls_get_addr = 2;
8587                       break;
8588
8589                     case R_PPC64_TPREL64:
8590                       if (pass == 0
8591                           || sec != toc
8592                           || toc_ref == NULL
8593                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8594                         continue;
8595                       if (ok_tprel)
8596                         {
8597                           /* IE -> LE */
8598                           tls_set = TLS_EXPLICIT;
8599                           tls_clear = TLS_TPREL;
8600                           break;
8601                         }
8602                       continue;
8603
8604                     case R_PPC64_DTPMOD64:
8605                       if (pass == 0
8606                           || sec != toc
8607                           || toc_ref == NULL
8608                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8609                         continue;
8610                       if (rel + 1 < relend
8611                           && (rel[1].r_info
8612                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8613                           && rel[1].r_offset == rel->r_offset + 8)
8614                         {
8615                           if (ok_tprel)
8616                             /* GD -> LE */
8617                             tls_set = TLS_EXPLICIT | TLS_GD;
8618                           else
8619                             /* GD -> IE */
8620                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8621                           tls_clear = TLS_GD;
8622                         }
8623                       else
8624                         {
8625                           if (!is_local)
8626                             continue;
8627
8628                           /* LD -> LE */
8629                           tls_set = TLS_EXPLICIT;
8630                           tls_clear = TLS_LD;
8631                         }
8632                       break;
8633
8634                     default:
8635                       continue;
8636                     }
8637
8638                   if (pass == 0)
8639                     {
8640                       if (!expecting_tls_get_addr
8641                           || !sec->has_tls_get_addr_call)
8642                         continue;
8643
8644                       if (rel + 1 < relend
8645                           && branch_reloc_hash_match (ibfd, rel + 1,
8646                                                       htab->tls_get_addr,
8647                                                       htab->tls_get_addr_fd))
8648                         {
8649                           if (expecting_tls_get_addr == 2)
8650                             {
8651                               /* Check for toc tls entries.  */
8652                               unsigned char *toc_tls;
8653                               int retval;
8654
8655                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8656                                                      &locsyms,
8657                                                      rel, ibfd);
8658                               if (retval == 0)
8659                                 goto err_free_rel;
8660                               if (toc_tls != NULL)
8661                                 {
8662                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8663                                     found_tls_get_addr_arg = 1;
8664                                   if (retval > 1)
8665                                     toc_ref[toc_ref_index] = 1;
8666                                 }
8667                             }
8668                           continue;
8669                         }
8670
8671                       if (expecting_tls_get_addr != 1)
8672                         continue;
8673
8674                       /* Uh oh, we didn't find the expected call.  We
8675                          could just mark this symbol to exclude it
8676                          from tls optimization but it's safer to skip
8677                          the entire optimization.  */
8678                       /* xgettext:c-format */
8679                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8680                                                 "TLS optimization disabled\n"),
8681                                               ibfd, sec, rel->r_offset);
8682                       ret = TRUE;
8683                       goto err_free_rel;
8684                     }
8685
8686                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8687                     {
8688                       struct plt_entry *ent;
8689                       for (ent = htab->tls_get_addr->elf.plt.plist;
8690                            ent != NULL;
8691                            ent = ent->next)
8692                         if (ent->addend == 0)
8693                           {
8694                             if (ent->plt.refcount > 0)
8695                               {
8696                                 ent->plt.refcount -= 1;
8697                                 expecting_tls_get_addr = 0;
8698                               }
8699                             break;
8700                           }
8701                     }
8702
8703                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8704                     {
8705                       struct plt_entry *ent;
8706                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8707                            ent != NULL;
8708                            ent = ent->next)
8709                         if (ent->addend == 0)
8710                           {
8711                             if (ent->plt.refcount > 0)
8712                               ent->plt.refcount -= 1;
8713                             break;
8714                           }
8715                     }
8716
8717                   if (tls_clear == 0)
8718                     continue;
8719
8720                   if ((tls_set & TLS_EXPLICIT) == 0)
8721                     {
8722                       struct got_entry *ent;
8723
8724                       /* Adjust got entry for this reloc.  */
8725                       if (h != NULL)
8726                         ent = h->got.glist;
8727                       else
8728                         ent = elf_local_got_ents (ibfd)[r_symndx];
8729
8730                       for (; ent != NULL; ent = ent->next)
8731                         if (ent->addend == rel->r_addend
8732                             && ent->owner == ibfd
8733                             && ent->tls_type == tls_type)
8734                           break;
8735                       if (ent == NULL)
8736                         abort ();
8737
8738                       if (tls_set == 0)
8739                         {
8740                           /* We managed to get rid of a got entry.  */
8741                           if (ent->got.refcount > 0)
8742                             ent->got.refcount -= 1;
8743                         }
8744                     }
8745                   else
8746                     {
8747                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8748                          we'll lose one or two dyn relocs.  */
8749                       if (!dec_dynrel_count (rel->r_info, sec, info,
8750                                              NULL, h, sym))
8751                         return FALSE;
8752
8753                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8754                         {
8755                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8756                                                  NULL, h, sym))
8757                             return FALSE;
8758                         }
8759                     }
8760
8761                   *tls_mask |= tls_set;
8762                   *tls_mask &= ~tls_clear;
8763                 }
8764
8765               if (elf_section_data (sec)->relocs != relstart)
8766                 free (relstart);
8767             }
8768
8769         if (locsyms != NULL
8770             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8771           {
8772             if (!info->keep_memory)
8773               free (locsyms);
8774             else
8775               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8776           }
8777       }
8778
8779   if (toc_ref != NULL)
8780     free (toc_ref);
8781   htab->do_tls_opt = 1;
8782   return TRUE;
8783 }
8784
8785 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8786    the values of any global symbols in a toc section that has been
8787    edited.  Globals in toc sections should be a rarity, so this function
8788    sets a flag if any are found in toc sections other than the one just
8789    edited, so that further hash table traversals can be avoided.  */
8790
8791 struct adjust_toc_info
8792 {
8793   asection *toc;
8794   unsigned long *skip;
8795   bfd_boolean global_toc_syms;
8796 };
8797
8798 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8799
8800 static bfd_boolean
8801 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8802 {
8803   struct ppc_link_hash_entry *eh;
8804   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8805   unsigned long i;
8806
8807   if (h->root.type != bfd_link_hash_defined
8808       && h->root.type != bfd_link_hash_defweak)
8809     return TRUE;
8810
8811   eh = (struct ppc_link_hash_entry *) h;
8812   if (eh->adjust_done)
8813     return TRUE;
8814
8815   if (eh->elf.root.u.def.section == toc_inf->toc)
8816     {
8817       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8818         i = toc_inf->toc->rawsize >> 3;
8819       else
8820         i = eh->elf.root.u.def.value >> 3;
8821
8822       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8823         {
8824           _bfd_error_handler
8825             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8826           do
8827             ++i;
8828           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8829           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8830         }
8831
8832       eh->elf.root.u.def.value -= toc_inf->skip[i];
8833       eh->adjust_done = 1;
8834     }
8835   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8836     toc_inf->global_toc_syms = TRUE;
8837
8838   return TRUE;
8839 }
8840
8841 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8842    on a _LO variety toc/got reloc.  */
8843
8844 static bfd_boolean
8845 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8846 {
8847   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8848           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8849           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8850           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8851           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8852           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8853           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8854           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8855           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8856           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8857           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8858           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8859           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8860           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8861           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8862           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8863           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8864               /* Exclude lfqu by testing reloc.  If relocs are ever
8865                  defined for the reduced D field in psq_lu then those
8866                  will need testing too.  */
8867               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8868           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8869               && (insn & 1) == 0)
8870           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8871           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8872               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8873               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8874           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8875               && (insn & 1) == 0));
8876 }
8877
8878 /* Examine all relocs referencing .toc sections in order to remove
8879    unused .toc entries.  */
8880
8881 bfd_boolean
8882 ppc64_elf_edit_toc (struct bfd_link_info *info)
8883 {
8884   bfd *ibfd;
8885   struct adjust_toc_info toc_inf;
8886   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8887
8888   htab->do_toc_opt = 1;
8889   toc_inf.global_toc_syms = TRUE;
8890   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8891     {
8892       asection *toc, *sec;
8893       Elf_Internal_Shdr *symtab_hdr;
8894       Elf_Internal_Sym *local_syms;
8895       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8896       unsigned long *skip, *drop;
8897       unsigned char *used;
8898       unsigned char *keep, last, some_unused;
8899
8900       if (!is_ppc64_elf (ibfd))
8901         continue;
8902
8903       toc = bfd_get_section_by_name (ibfd, ".toc");
8904       if (toc == NULL
8905           || toc->size == 0
8906           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8907           || discarded_section (toc))
8908         continue;
8909
8910       toc_relocs = NULL;
8911       local_syms = NULL;
8912       symtab_hdr = &elf_symtab_hdr (ibfd);
8913
8914       /* Look at sections dropped from the final link.  */
8915       skip = NULL;
8916       relstart = NULL;
8917       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8918         {
8919           if (sec->reloc_count == 0
8920               || !discarded_section (sec)
8921               || get_opd_info (sec)
8922               || (sec->flags & SEC_ALLOC) == 0
8923               || (sec->flags & SEC_DEBUGGING) != 0)
8924             continue;
8925
8926           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8927           if (relstart == NULL)
8928             goto error_ret;
8929
8930           /* Run through the relocs to see which toc entries might be
8931              unused.  */
8932           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8933             {
8934               enum elf_ppc64_reloc_type r_type;
8935               unsigned long r_symndx;
8936               asection *sym_sec;
8937               struct elf_link_hash_entry *h;
8938               Elf_Internal_Sym *sym;
8939               bfd_vma val;
8940
8941               r_type = ELF64_R_TYPE (rel->r_info);
8942               switch (r_type)
8943                 {
8944                 default:
8945                   continue;
8946
8947                 case R_PPC64_TOC16:
8948                 case R_PPC64_TOC16_LO:
8949                 case R_PPC64_TOC16_HI:
8950                 case R_PPC64_TOC16_HA:
8951                 case R_PPC64_TOC16_DS:
8952                 case R_PPC64_TOC16_LO_DS:
8953                   break;
8954                 }
8955
8956               r_symndx = ELF64_R_SYM (rel->r_info);
8957               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8958                               r_symndx, ibfd))
8959                 goto error_ret;
8960
8961               if (sym_sec != toc)
8962                 continue;
8963
8964               if (h != NULL)
8965                 val = h->root.u.def.value;
8966               else
8967                 val = sym->st_value;
8968               val += rel->r_addend;
8969
8970               if (val >= toc->size)
8971                 continue;
8972
8973               /* Anything in the toc ought to be aligned to 8 bytes.
8974                  If not, don't mark as unused.  */
8975               if (val & 7)
8976                 continue;
8977
8978               if (skip == NULL)
8979                 {
8980                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8981                   if (skip == NULL)
8982                     goto error_ret;
8983                 }
8984
8985               skip[val >> 3] = ref_from_discarded;
8986             }
8987
8988           if (elf_section_data (sec)->relocs != relstart)
8989             free (relstart);
8990         }
8991
8992       /* For largetoc loads of address constants, we can convert
8993          .  addis rx,2,addr@got@ha
8994          .  ld ry,addr@got@l(rx)
8995          to
8996          .  addis rx,2,addr@toc@ha
8997          .  addi ry,rx,addr@toc@l
8998          when addr is within 2G of the toc pointer.  This then means
8999          that the word storing "addr" in the toc is no longer needed.  */
9000
9001       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9002           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9003           && toc->reloc_count != 0)
9004         {
9005           /* Read toc relocs.  */
9006           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9007                                                   info->keep_memory);
9008           if (toc_relocs == NULL)
9009             goto error_ret;
9010
9011           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9012             {
9013               enum elf_ppc64_reloc_type r_type;
9014               unsigned long r_symndx;
9015               asection *sym_sec;
9016               struct elf_link_hash_entry *h;
9017               Elf_Internal_Sym *sym;
9018               bfd_vma val, addr;
9019
9020               r_type = ELF64_R_TYPE (rel->r_info);
9021               if (r_type != R_PPC64_ADDR64)
9022                 continue;
9023
9024               r_symndx = ELF64_R_SYM (rel->r_info);
9025               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9026                               r_symndx, ibfd))
9027                 goto error_ret;
9028
9029               if (sym_sec == NULL
9030                   || sym_sec->output_section == NULL
9031                   || discarded_section (sym_sec))
9032                 continue;
9033
9034               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9035                 continue;
9036
9037               if (h != NULL)
9038                 {
9039                   if (h->type == STT_GNU_IFUNC)
9040                     continue;
9041                   val = h->root.u.def.value;
9042                 }
9043               else
9044                 {
9045                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9046                     continue;
9047                   val = sym->st_value;
9048                 }
9049               val += rel->r_addend;
9050               val += sym_sec->output_section->vma + sym_sec->output_offset;
9051
9052               /* We don't yet know the exact toc pointer value, but we
9053                  know it will be somewhere in the toc section.  Don't
9054                  optimize if the difference from any possible toc
9055                  pointer is outside [ff..f80008000, 7fff7fff].  */
9056               addr = toc->output_section->vma + TOC_BASE_OFF;
9057               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9058                 continue;
9059
9060               addr = toc->output_section->vma + toc->output_section->rawsize;
9061               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9062                 continue;
9063
9064               if (skip == NULL)
9065                 {
9066                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9067                   if (skip == NULL)
9068                     goto error_ret;
9069                 }
9070
9071               skip[rel->r_offset >> 3]
9072                 |= can_optimize | ((rel - toc_relocs) << 2);
9073             }
9074         }
9075
9076       if (skip == NULL)
9077         continue;
9078
9079       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9080       if (used == NULL)
9081         {
9082         error_ret:
9083           if (local_syms != NULL
9084               && symtab_hdr->contents != (unsigned char *) local_syms)
9085             free (local_syms);
9086           if (sec != NULL
9087               && relstart != NULL
9088               && elf_section_data (sec)->relocs != relstart)
9089             free (relstart);
9090           if (toc_relocs != NULL
9091               && elf_section_data (toc)->relocs != toc_relocs)
9092             free (toc_relocs);
9093           if (skip != NULL)
9094             free (skip);
9095           return FALSE;
9096         }
9097
9098       /* Now check all kept sections that might reference the toc.
9099          Check the toc itself last.  */
9100       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9101                   : ibfd->sections);
9102            sec != NULL;
9103            sec = (sec == toc ? NULL
9104                   : sec->next == NULL ? toc
9105                   : sec->next == toc && toc->next ? toc->next
9106                   : sec->next))
9107         {
9108           int repeat;
9109
9110           if (sec->reloc_count == 0
9111               || discarded_section (sec)
9112               || get_opd_info (sec)
9113               || (sec->flags & SEC_ALLOC) == 0
9114               || (sec->flags & SEC_DEBUGGING) != 0)
9115             continue;
9116
9117           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9118                                                 info->keep_memory);
9119           if (relstart == NULL)
9120             {
9121               free (used);
9122               goto error_ret;
9123             }
9124
9125           /* Mark toc entries referenced as used.  */
9126           do
9127             {
9128               repeat = 0;
9129               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9130                 {
9131                   enum elf_ppc64_reloc_type r_type;
9132                   unsigned long r_symndx;
9133                   asection *sym_sec;
9134                   struct elf_link_hash_entry *h;
9135                   Elf_Internal_Sym *sym;
9136                   bfd_vma val;
9137                   enum {no_check, check_lo, check_ha} insn_check;
9138
9139                   r_type = ELF64_R_TYPE (rel->r_info);
9140                   switch (r_type)
9141                     {
9142                     default:
9143                       insn_check = no_check;
9144                       break;
9145
9146                     case R_PPC64_GOT_TLSLD16_HA:
9147                     case R_PPC64_GOT_TLSGD16_HA:
9148                     case R_PPC64_GOT_TPREL16_HA:
9149                     case R_PPC64_GOT_DTPREL16_HA:
9150                     case R_PPC64_GOT16_HA:
9151                     case R_PPC64_TOC16_HA:
9152                       insn_check = check_ha;
9153                       break;
9154
9155                     case R_PPC64_GOT_TLSLD16_LO:
9156                     case R_PPC64_GOT_TLSGD16_LO:
9157                     case R_PPC64_GOT_TPREL16_LO_DS:
9158                     case R_PPC64_GOT_DTPREL16_LO_DS:
9159                     case R_PPC64_GOT16_LO:
9160                     case R_PPC64_GOT16_LO_DS:
9161                     case R_PPC64_TOC16_LO:
9162                     case R_PPC64_TOC16_LO_DS:
9163                       insn_check = check_lo;
9164                       break;
9165                     }
9166
9167                   if (insn_check != no_check)
9168                     {
9169                       bfd_vma off = rel->r_offset & ~3;
9170                       unsigned char buf[4];
9171                       unsigned int insn;
9172
9173                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9174                         {
9175                           free (used);
9176                           goto error_ret;
9177                         }
9178                       insn = bfd_get_32 (ibfd, buf);
9179                       if (insn_check == check_lo
9180                           ? !ok_lo_toc_insn (insn, r_type)
9181                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9182                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9183                         {
9184                           char str[12];
9185
9186                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9187                           sprintf (str, "%#08x", insn);
9188                           info->callbacks->einfo
9189                             /* xgettext:c-format */
9190                             (_("%H: toc optimization is not supported for"
9191                                " %s instruction\n"),
9192                              ibfd, sec, rel->r_offset & ~3, str);
9193                         }
9194                     }
9195
9196                   switch (r_type)
9197                     {
9198                     case R_PPC64_TOC16:
9199                     case R_PPC64_TOC16_LO:
9200                     case R_PPC64_TOC16_HI:
9201                     case R_PPC64_TOC16_HA:
9202                     case R_PPC64_TOC16_DS:
9203                     case R_PPC64_TOC16_LO_DS:
9204                       /* In case we're taking addresses of toc entries.  */
9205                     case R_PPC64_ADDR64:
9206                       break;
9207
9208                     default:
9209                       continue;
9210                     }
9211
9212                   r_symndx = ELF64_R_SYM (rel->r_info);
9213                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9214                                   r_symndx, ibfd))
9215                     {
9216                       free (used);
9217                       goto error_ret;
9218                     }
9219
9220                   if (sym_sec != toc)
9221                     continue;
9222
9223                   if (h != NULL)
9224                     val = h->root.u.def.value;
9225                   else
9226                     val = sym->st_value;
9227                   val += rel->r_addend;
9228
9229                   if (val >= toc->size)
9230                     continue;
9231
9232                   if ((skip[val >> 3] & can_optimize) != 0)
9233                     {
9234                       bfd_vma off;
9235                       unsigned char opc;
9236
9237                       switch (r_type)
9238                         {
9239                         case R_PPC64_TOC16_HA:
9240                           break;
9241
9242                         case R_PPC64_TOC16_LO_DS:
9243                           off = rel->r_offset;
9244                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9245                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9246                                                          off, 1))
9247                             {
9248                               free (used);
9249                               goto error_ret;
9250                             }
9251                           if ((opc & (0x3f << 2)) == (58u << 2))
9252                             break;
9253                           /* Fall through.  */
9254
9255                         default:
9256                           /* Wrong sort of reloc, or not a ld.  We may
9257                              as well clear ref_from_discarded too.  */
9258                           skip[val >> 3] = 0;
9259                         }
9260                     }
9261
9262                   if (sec != toc)
9263                     used[val >> 3] = 1;
9264                   /* For the toc section, we only mark as used if this
9265                      entry itself isn't unused.  */
9266                   else if ((used[rel->r_offset >> 3]
9267                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9268                            && !used[val >> 3])
9269                     {
9270                       /* Do all the relocs again, to catch reference
9271                          chains.  */
9272                       repeat = 1;
9273                       used[val >> 3] = 1;
9274                     }
9275                 }
9276             }
9277           while (repeat);
9278
9279           if (elf_section_data (sec)->relocs != relstart)
9280             free (relstart);
9281         }
9282
9283       /* Merge the used and skip arrays.  Assume that TOC
9284          doublewords not appearing as either used or unused belong
9285          to an entry more than one doubleword in size.  */
9286       for (drop = skip, keep = used, last = 0, some_unused = 0;
9287            drop < skip + (toc->size + 7) / 8;
9288            ++drop, ++keep)
9289         {
9290           if (*keep)
9291             {
9292               *drop &= ~ref_from_discarded;
9293               if ((*drop & can_optimize) != 0)
9294                 some_unused = 1;
9295               last = 0;
9296             }
9297           else if ((*drop & ref_from_discarded) != 0)
9298             {
9299               some_unused = 1;
9300               last = ref_from_discarded;
9301             }
9302           else
9303             *drop = last;
9304         }
9305
9306       free (used);
9307
9308       if (some_unused)
9309         {
9310           bfd_byte *contents, *src;
9311           unsigned long off;
9312           Elf_Internal_Sym *sym;
9313           bfd_boolean local_toc_syms = FALSE;
9314
9315           /* Shuffle the toc contents, and at the same time convert the
9316              skip array from booleans into offsets.  */
9317           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9318             goto error_ret;
9319
9320           elf_section_data (toc)->this_hdr.contents = contents;
9321
9322           for (src = contents, off = 0, drop = skip;
9323                src < contents + toc->size;
9324                src += 8, ++drop)
9325             {
9326               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9327                 off += 8;
9328               else if (off != 0)
9329                 {
9330                   *drop = off;
9331                   memcpy (src - off, src, 8);
9332                 }
9333             }
9334           *drop = off;
9335           toc->rawsize = toc->size;
9336           toc->size = src - contents - off;
9337
9338           /* Adjust addends for relocs against the toc section sym,
9339              and optimize any accesses we can.  */
9340           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9341             {
9342               if (sec->reloc_count == 0
9343                   || discarded_section (sec))
9344                 continue;
9345
9346               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9347                                                     info->keep_memory);
9348               if (relstart == NULL)
9349                 goto error_ret;
9350
9351               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9352                 {
9353                   enum elf_ppc64_reloc_type r_type;
9354                   unsigned long r_symndx;
9355                   asection *sym_sec;
9356                   struct elf_link_hash_entry *h;
9357                   bfd_vma val;
9358
9359                   r_type = ELF64_R_TYPE (rel->r_info);
9360                   switch (r_type)
9361                     {
9362                     default:
9363                       continue;
9364
9365                     case R_PPC64_TOC16:
9366                     case R_PPC64_TOC16_LO:
9367                     case R_PPC64_TOC16_HI:
9368                     case R_PPC64_TOC16_HA:
9369                     case R_PPC64_TOC16_DS:
9370                     case R_PPC64_TOC16_LO_DS:
9371                     case R_PPC64_ADDR64:
9372                       break;
9373                     }
9374
9375                   r_symndx = ELF64_R_SYM (rel->r_info);
9376                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9377                                   r_symndx, ibfd))
9378                     goto error_ret;
9379
9380                   if (sym_sec != toc)
9381                     continue;
9382
9383                   if (h != NULL)
9384                     val = h->root.u.def.value;
9385                   else
9386                     {
9387                       val = sym->st_value;
9388                       if (val != 0)
9389                         local_toc_syms = TRUE;
9390                     }
9391
9392                   val += rel->r_addend;
9393
9394                   if (val > toc->rawsize)
9395                     val = toc->rawsize;
9396                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9397                     continue;
9398                   else if ((skip[val >> 3] & can_optimize) != 0)
9399                     {
9400                       Elf_Internal_Rela *tocrel
9401                         = toc_relocs + (skip[val >> 3] >> 2);
9402                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9403
9404                       switch (r_type)
9405                         {
9406                         case R_PPC64_TOC16_HA:
9407                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9408                           break;
9409
9410                         case R_PPC64_TOC16_LO_DS:
9411                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9412                           break;
9413
9414                         default:
9415                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9416                             ppc_howto_init ();
9417                           info->callbacks->einfo
9418                             /* xgettext:c-format */
9419                             (_("%H: %s references "
9420                                "optimized away TOC entry\n"),
9421                              ibfd, sec, rel->r_offset,
9422                              ppc64_elf_howto_table[r_type]->name);
9423                           bfd_set_error (bfd_error_bad_value);
9424                           goto error_ret;
9425                         }
9426                       rel->r_addend = tocrel->r_addend;
9427                       elf_section_data (sec)->relocs = relstart;
9428                       continue;
9429                     }
9430
9431                   if (h != NULL || sym->st_value != 0)
9432                     continue;
9433
9434                   rel->r_addend -= skip[val >> 3];
9435                   elf_section_data (sec)->relocs = relstart;
9436                 }
9437
9438               if (elf_section_data (sec)->relocs != relstart)
9439                 free (relstart);
9440             }
9441
9442           /* We shouldn't have local or global symbols defined in the TOC,
9443              but handle them anyway.  */
9444           if (local_syms != NULL)
9445             for (sym = local_syms;
9446                  sym < local_syms + symtab_hdr->sh_info;
9447                  ++sym)
9448               if (sym->st_value != 0
9449                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9450                 {
9451                   unsigned long i;
9452
9453                   if (sym->st_value > toc->rawsize)
9454                     i = toc->rawsize >> 3;
9455                   else
9456                     i = sym->st_value >> 3;
9457
9458                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9459                     {
9460                       if (local_toc_syms)
9461                         _bfd_error_handler
9462                           (_("%s defined on removed toc entry"),
9463                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9464                       do
9465                         ++i;
9466                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9467                       sym->st_value = (bfd_vma) i << 3;
9468                     }
9469
9470                   sym->st_value -= skip[i];
9471                   symtab_hdr->contents = (unsigned char *) local_syms;
9472                 }
9473
9474           /* Adjust any global syms defined in this toc input section.  */
9475           if (toc_inf.global_toc_syms)
9476             {
9477               toc_inf.toc = toc;
9478               toc_inf.skip = skip;
9479               toc_inf.global_toc_syms = FALSE;
9480               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9481                                       &toc_inf);
9482             }
9483
9484           if (toc->reloc_count != 0)
9485             {
9486               Elf_Internal_Shdr *rel_hdr;
9487               Elf_Internal_Rela *wrel;
9488               bfd_size_type sz;
9489
9490               /* Remove unused toc relocs, and adjust those we keep.  */
9491               if (toc_relocs == NULL)
9492                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9493                                                         info->keep_memory);
9494               if (toc_relocs == NULL)
9495                 goto error_ret;
9496
9497               wrel = toc_relocs;
9498               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9499                 if ((skip[rel->r_offset >> 3]
9500                      & (ref_from_discarded | can_optimize)) == 0)
9501                   {
9502                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9503                     wrel->r_info = rel->r_info;
9504                     wrel->r_addend = rel->r_addend;
9505                     ++wrel;
9506                   }
9507                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9508                                             &local_syms, NULL, NULL))
9509                   goto error_ret;
9510
9511               elf_section_data (toc)->relocs = toc_relocs;
9512               toc->reloc_count = wrel - toc_relocs;
9513               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9514               sz = rel_hdr->sh_entsize;
9515               rel_hdr->sh_size = toc->reloc_count * sz;
9516             }
9517         }
9518       else if (toc_relocs != NULL
9519                && elf_section_data (toc)->relocs != toc_relocs)
9520         free (toc_relocs);
9521
9522       if (local_syms != NULL
9523           && symtab_hdr->contents != (unsigned char *) local_syms)
9524         {
9525           if (!info->keep_memory)
9526             free (local_syms);
9527           else
9528             symtab_hdr->contents = (unsigned char *) local_syms;
9529         }
9530       free (skip);
9531     }
9532
9533   return TRUE;
9534 }
9535
9536 /* Return true iff input section I references the TOC using
9537    instructions limited to +/-32k offsets.  */
9538
9539 bfd_boolean
9540 ppc64_elf_has_small_toc_reloc (asection *i)
9541 {
9542   return (is_ppc64_elf (i->owner)
9543           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9544 }
9545
9546 /* Allocate space for one GOT entry.  */
9547
9548 static void
9549 allocate_got (struct elf_link_hash_entry *h,
9550               struct bfd_link_info *info,
9551               struct got_entry *gent)
9552 {
9553   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9554   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9555   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9556                  ? 16 : 8);
9557   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9558                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9559   asection *got = ppc64_elf_tdata (gent->owner)->got;
9560
9561   gent->got.offset = got->size;
9562   got->size += entsize;
9563
9564   if (h->type == STT_GNU_IFUNC)
9565     {
9566       htab->elf.irelplt->size += rentsize;
9567       htab->got_reli_size += rentsize;
9568     }
9569   else if (((bfd_link_pic (info)
9570              && !((gent->tls_type & TLS_TPREL) != 0
9571                   && bfd_link_executable (info)
9572                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9573             || (htab->elf.dynamic_sections_created
9574                 && h->dynindx != -1
9575                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9576            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9577     {
9578       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9579       relgot->size += rentsize;
9580     }
9581 }
9582
9583 /* This function merges got entries in the same toc group.  */
9584
9585 static void
9586 merge_got_entries (struct got_entry **pent)
9587 {
9588   struct got_entry *ent, *ent2;
9589
9590   for (ent = *pent; ent != NULL; ent = ent->next)
9591     if (!ent->is_indirect)
9592       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9593         if (!ent2->is_indirect
9594             && ent2->addend == ent->addend
9595             && ent2->tls_type == ent->tls_type
9596             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9597           {
9598             ent2->is_indirect = TRUE;
9599             ent2->got.ent = ent;
9600           }
9601 }
9602
9603 /* If H is undefined, make it dynamic if that makes sense.  */
9604
9605 static bfd_boolean
9606 ensure_undef_dynamic (struct bfd_link_info *info,
9607                       struct elf_link_hash_entry *h)
9608 {
9609   struct elf_link_hash_table *htab = elf_hash_table (info);
9610
9611   if (htab->dynamic_sections_created
9612       && ((info->dynamic_undefined_weak != 0
9613            && h->root.type == bfd_link_hash_undefweak)
9614           || h->root.type == bfd_link_hash_undefined)
9615       && h->dynindx == -1
9616       && !h->forced_local
9617       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9618     return bfd_elf_link_record_dynamic_symbol (info, h);
9619   return TRUE;
9620 }
9621
9622 /* Allocate space in .plt, .got and associated reloc sections for
9623    dynamic relocs.  */
9624
9625 static bfd_boolean
9626 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9627 {
9628   struct bfd_link_info *info;
9629   struct ppc_link_hash_table *htab;
9630   asection *s;
9631   struct ppc_link_hash_entry *eh;
9632   struct got_entry **pgent, *gent;
9633
9634   if (h->root.type == bfd_link_hash_indirect)
9635     return TRUE;
9636
9637   info = (struct bfd_link_info *) inf;
9638   htab = ppc_hash_table (info);
9639   if (htab == NULL)
9640     return FALSE;
9641
9642   eh = (struct ppc_link_hash_entry *) h;
9643   /* Run through the TLS GD got entries first if we're changing them
9644      to TPREL.  */
9645   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9646     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9647       if (gent->got.refcount > 0
9648           && (gent->tls_type & TLS_GD) != 0)
9649         {
9650           /* This was a GD entry that has been converted to TPREL.  If
9651              there happens to be a TPREL entry we can use that one.  */
9652           struct got_entry *ent;
9653           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9654             if (ent->got.refcount > 0
9655                 && (ent->tls_type & TLS_TPREL) != 0
9656                 && ent->addend == gent->addend
9657                 && ent->owner == gent->owner)
9658               {
9659                 gent->got.refcount = 0;
9660                 break;
9661               }
9662
9663           /* If not, then we'll be using our own TPREL entry.  */
9664           if (gent->got.refcount != 0)
9665             gent->tls_type = TLS_TLS | TLS_TPREL;
9666         }
9667
9668   /* Remove any list entry that won't generate a word in the GOT before
9669      we call merge_got_entries.  Otherwise we risk merging to empty
9670      entries.  */
9671   pgent = &h->got.glist;
9672   while ((gent = *pgent) != NULL)
9673     if (gent->got.refcount > 0)
9674       {
9675         if ((gent->tls_type & TLS_LD) != 0
9676             && !h->def_dynamic)
9677           {
9678             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9679             *pgent = gent->next;
9680           }
9681         else
9682           pgent = &gent->next;
9683       }
9684     else
9685       *pgent = gent->next;
9686
9687   if (!htab->do_multi_toc)
9688     merge_got_entries (&h->got.glist);
9689
9690   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9691     if (!gent->is_indirect)
9692       {
9693         /* Make sure this symbol is output as a dynamic symbol.  */
9694         if (!ensure_undef_dynamic (info, h))
9695           return FALSE;
9696
9697         if (!is_ppc64_elf (gent->owner))
9698           abort ();
9699
9700         allocate_got (h, info, gent);
9701       }
9702
9703   /* If no dynamic sections we can't have dynamic relocs, except for
9704      IFUNCs which are handled even in static executables.  */
9705   if (!htab->elf.dynamic_sections_created
9706       && h->type != STT_GNU_IFUNC)
9707     eh->dyn_relocs = NULL;
9708
9709   /* Discard relocs on undefined symbols that must be local.  */
9710   else if (h->root.type == bfd_link_hash_undefined
9711            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9712     eh->dyn_relocs = NULL;
9713
9714   /* Also discard relocs on undefined weak syms with non-default
9715      visibility, or when dynamic_undefined_weak says so.  */
9716   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9717     eh->dyn_relocs = NULL;
9718
9719   if (eh->dyn_relocs != NULL)
9720     {
9721       struct elf_dyn_relocs *p, **pp;
9722
9723       /* In the shared -Bsymbolic case, discard space allocated for
9724          dynamic pc-relative relocs against symbols which turn out to
9725          be defined in regular objects.  For the normal shared case,
9726          discard space for relocs that have become local due to symbol
9727          visibility changes.  */
9728
9729       if (bfd_link_pic (info))
9730         {
9731           /* Relocs that use pc_count are those that appear on a call
9732              insn, or certain REL relocs (see must_be_dyn_reloc) that
9733              can be generated via assembly.  We want calls to
9734              protected symbols to resolve directly to the function
9735              rather than going via the plt.  If people want function
9736              pointer comparisons to work as expected then they should
9737              avoid writing weird assembly.  */
9738           if (SYMBOL_CALLS_LOCAL (info, h))
9739             {
9740               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9741                 {
9742                   p->count -= p->pc_count;
9743                   p->pc_count = 0;
9744                   if (p->count == 0)
9745                     *pp = p->next;
9746                   else
9747                     pp = &p->next;
9748                 }
9749             }
9750
9751           if (eh->dyn_relocs != NULL)
9752             {
9753               /* Make sure this symbol is output as a dynamic symbol.  */
9754               if (!ensure_undef_dynamic (info, h))
9755                 return FALSE;
9756             }
9757         }
9758       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9759         {
9760           /* For the non-pic case, discard space for relocs against
9761              symbols which turn out to need copy relocs or are not
9762              dynamic.  */
9763           if (h->dynamic_adjusted
9764               && !h->def_regular
9765               && !ELF_COMMON_DEF_P (h))
9766             {
9767               /* Make sure this symbol is output as a dynamic symbol.  */
9768               if (!ensure_undef_dynamic (info, h))
9769                 return FALSE;
9770
9771               if (h->dynindx == -1)
9772                 eh->dyn_relocs = NULL;
9773             }
9774           else
9775             eh->dyn_relocs = NULL;
9776         }
9777
9778       /* Finally, allocate space.  */
9779       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9780         {
9781           asection *sreloc = elf_section_data (p->sec)->sreloc;
9782           if (eh->elf.type == STT_GNU_IFUNC)
9783             sreloc = htab->elf.irelplt;
9784           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9785         }
9786     }
9787
9788   if ((htab->elf.dynamic_sections_created
9789        && h->dynindx != -1)
9790       || h->type == STT_GNU_IFUNC)
9791     {
9792       struct plt_entry *pent;
9793       bfd_boolean doneone = FALSE;
9794       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9795         if (pent->plt.refcount > 0)
9796           {
9797             if (!htab->elf.dynamic_sections_created
9798                 || h->dynindx == -1)
9799               {
9800                 s = htab->elf.iplt;
9801                 pent->plt.offset = s->size;
9802                 s->size += PLT_ENTRY_SIZE (htab);
9803                 s = htab->elf.irelplt;
9804               }
9805             else
9806               {
9807                 /* If this is the first .plt entry, make room for the special
9808                    first entry.  */
9809                 s = htab->elf.splt;
9810                 if (s->size == 0)
9811                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9812
9813                 pent->plt.offset = s->size;
9814
9815                 /* Make room for this entry.  */
9816                 s->size += PLT_ENTRY_SIZE (htab);
9817
9818                 /* Make room for the .glink code.  */
9819                 s = htab->glink;
9820                 if (s->size == 0)
9821                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
9822                 if (htab->opd_abi)
9823                   {
9824                     /* We need bigger stubs past index 32767.  */
9825                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9826                       s->size += 4;
9827                     s->size += 2*4;
9828                   }
9829                 else
9830                   s->size += 4;
9831
9832                 /* We also need to make an entry in the .rela.plt section.  */
9833                 s = htab->elf.srelplt;
9834               }
9835             s->size += sizeof (Elf64_External_Rela);
9836             doneone = TRUE;
9837           }
9838         else
9839           pent->plt.offset = (bfd_vma) -1;
9840       if (!doneone)
9841         {
9842           h->plt.plist = NULL;
9843           h->needs_plt = 0;
9844         }
9845     }
9846   else
9847     {
9848       h->plt.plist = NULL;
9849       h->needs_plt = 0;
9850     }
9851
9852   return TRUE;
9853 }
9854
9855 #define PPC_LO(v) ((v) & 0xffff)
9856 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9857 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9858
9859 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9860    to set up space for global entry stubs.  These are put in glink,
9861    after the branch table.  */
9862
9863 static bfd_boolean
9864 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9865 {
9866   struct bfd_link_info *info;
9867   struct ppc_link_hash_table *htab;
9868   struct plt_entry *pent;
9869   asection *s, *plt;
9870
9871   if (h->root.type == bfd_link_hash_indirect)
9872     return TRUE;
9873
9874   if (!h->pointer_equality_needed)
9875     return TRUE;
9876
9877   if (h->def_regular)
9878     return TRUE;
9879
9880   info = inf;
9881   htab = ppc_hash_table (info);
9882   if (htab == NULL)
9883     return FALSE;
9884
9885   s = htab->global_entry;
9886   plt = htab->elf.splt;
9887   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9888     if (pent->plt.offset != (bfd_vma) -1
9889         && pent->addend == 0)
9890       {
9891         /* For ELFv2, if this symbol is not defined in a regular file
9892            and we are not generating a shared library or pie, then we
9893            need to define the symbol in the executable on a call stub.
9894            This is to avoid text relocations.  */
9895         bfd_vma off, stub_align, stub_off, stub_size;
9896         unsigned int align_power;
9897
9898         stub_size = 16;
9899         stub_off = s->size;
9900         if (htab->params->plt_stub_align >= 0)
9901           align_power = htab->params->plt_stub_align;
9902         else
9903           align_power = -htab->params->plt_stub_align;
9904         /* Setting section alignment is delayed until we know it is
9905            non-empty.  Otherwise the .text output section will be
9906            aligned at least to plt_stub_align even when no global
9907            entry stubs are needed.  */
9908         if (s->alignment_power < align_power)
9909           s->alignment_power = align_power;
9910         stub_align = (bfd_vma) 1 << align_power;
9911         if (htab->params->plt_stub_align >= 0
9912             || ((((stub_off + stub_size - 1) & -stub_align)
9913                  - (stub_off & -stub_align))
9914                 > ((stub_size - 1) & -stub_align)))
9915           stub_off = (stub_off + stub_align - 1) & -stub_align;
9916         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9917         off -= stub_off + s->output_offset + s->output_section->vma;
9918         /* Note that for --plt-stub-align negative we have a possible
9919            dependency between stub offset and size.  Break that
9920            dependency by assuming the max stub size when calculating
9921            the stub offset.  */
9922         if (PPC_HA (off) == 0)
9923           stub_size -= 4;
9924         h->root.type = bfd_link_hash_defined;
9925         h->root.u.def.section = s;
9926         h->root.u.def.value = stub_off;
9927         s->size = stub_off + stub_size;
9928         break;
9929       }
9930   return TRUE;
9931 }
9932
9933 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9934    read-only sections.  */
9935
9936 static bfd_boolean
9937 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9938 {
9939   asection *sec;
9940
9941   if (h->root.type == bfd_link_hash_indirect)
9942     return TRUE;
9943
9944   sec = readonly_dynrelocs (h);
9945   if (sec != NULL)
9946     {
9947       struct bfd_link_info *info = (struct bfd_link_info *) inf;
9948
9949       info->flags |= DF_TEXTREL;
9950       info->callbacks->minfo
9951         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
9952          sec->owner, h->root.root.string, sec);
9953
9954       /* Not an error, just cut short the traversal.  */
9955       return FALSE;
9956     }
9957   return TRUE;
9958 }
9959
9960 /* Set the sizes of the dynamic sections.  */
9961
9962 static bfd_boolean
9963 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9964                                  struct bfd_link_info *info)
9965 {
9966   struct ppc_link_hash_table *htab;
9967   bfd *dynobj;
9968   asection *s;
9969   bfd_boolean relocs;
9970   bfd *ibfd;
9971   struct got_entry *first_tlsld;
9972
9973   htab = ppc_hash_table (info);
9974   if (htab == NULL)
9975     return FALSE;
9976
9977   dynobj = htab->elf.dynobj;
9978   if (dynobj == NULL)
9979     abort ();
9980
9981   if (htab->elf.dynamic_sections_created)
9982     {
9983       /* Set the contents of the .interp section to the interpreter.  */
9984       if (bfd_link_executable (info) && !info->nointerp)
9985         {
9986           s = bfd_get_linker_section (dynobj, ".interp");
9987           if (s == NULL)
9988             abort ();
9989           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9990           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9991         }
9992     }
9993
9994   /* Set up .got offsets for local syms, and space for local dynamic
9995      relocs.  */
9996   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9997     {
9998       struct got_entry **lgot_ents;
9999       struct got_entry **end_lgot_ents;
10000       struct plt_entry **local_plt;
10001       struct plt_entry **end_local_plt;
10002       unsigned char *lgot_masks;
10003       bfd_size_type locsymcount;
10004       Elf_Internal_Shdr *symtab_hdr;
10005
10006       if (!is_ppc64_elf (ibfd))
10007         continue;
10008
10009       for (s = ibfd->sections; s != NULL; s = s->next)
10010         {
10011           struct ppc_dyn_relocs *p;
10012
10013           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10014             {
10015               if (!bfd_is_abs_section (p->sec)
10016                   && bfd_is_abs_section (p->sec->output_section))
10017                 {
10018                   /* Input section has been discarded, either because
10019                      it is a copy of a linkonce section or due to
10020                      linker script /DISCARD/, so we'll be discarding
10021                      the relocs too.  */
10022                 }
10023               else if (p->count != 0)
10024                 {
10025                   asection *srel = elf_section_data (p->sec)->sreloc;
10026                   if (p->ifunc)
10027                     srel = htab->elf.irelplt;
10028                   srel->size += p->count * sizeof (Elf64_External_Rela);
10029                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10030                     info->flags |= DF_TEXTREL;
10031                 }
10032             }
10033         }
10034
10035       lgot_ents = elf_local_got_ents (ibfd);
10036       if (!lgot_ents)
10037         continue;
10038
10039       symtab_hdr = &elf_symtab_hdr (ibfd);
10040       locsymcount = symtab_hdr->sh_info;
10041       end_lgot_ents = lgot_ents + locsymcount;
10042       local_plt = (struct plt_entry **) end_lgot_ents;
10043       end_local_plt = local_plt + locsymcount;
10044       lgot_masks = (unsigned char *) end_local_plt;
10045       s = ppc64_elf_tdata (ibfd)->got;
10046       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10047         {
10048           struct got_entry **pent, *ent;
10049
10050           pent = lgot_ents;
10051           while ((ent = *pent) != NULL)
10052             if (ent->got.refcount > 0)
10053               {
10054                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10055                   {
10056                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10057                     *pent = ent->next;
10058                   }
10059                 else
10060                   {
10061                     unsigned int ent_size = 8;
10062                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10063
10064                     ent->got.offset = s->size;
10065                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10066                       {
10067                         ent_size *= 2;
10068                         rel_size *= 2;
10069                       }
10070                     s->size += ent_size;
10071                     if ((*lgot_masks & PLT_IFUNC) != 0)
10072                       {
10073                         htab->elf.irelplt->size += rel_size;
10074                         htab->got_reli_size += rel_size;
10075                       }
10076                     else if (bfd_link_pic (info)
10077                              && !((ent->tls_type & TLS_TPREL) != 0
10078                                   && bfd_link_executable (info)))
10079                       {
10080                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10081                         srel->size += rel_size;
10082                       }
10083                     pent = &ent->next;
10084                   }
10085               }
10086             else
10087               *pent = ent->next;
10088         }
10089
10090       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10091       for (; local_plt < end_local_plt; ++local_plt)
10092         {
10093           struct plt_entry *ent;
10094
10095           for (ent = *local_plt; ent != NULL; ent = ent->next)
10096             if (ent->plt.refcount > 0)
10097               {
10098                 s = htab->elf.iplt;
10099                 ent->plt.offset = s->size;
10100                 s->size += PLT_ENTRY_SIZE (htab);
10101
10102                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10103               }
10104             else
10105               ent->plt.offset = (bfd_vma) -1;
10106         }
10107     }
10108
10109   /* Allocate global sym .plt and .got entries, and space for global
10110      sym dynamic relocs.  */
10111   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10112
10113   if (!htab->opd_abi && !bfd_link_pic (info))
10114     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10115
10116   first_tlsld = NULL;
10117   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10118     {
10119       struct got_entry *ent;
10120
10121       if (!is_ppc64_elf (ibfd))
10122         continue;
10123
10124       ent = ppc64_tlsld_got (ibfd);
10125       if (ent->got.refcount > 0)
10126         {
10127           if (!htab->do_multi_toc && first_tlsld != NULL)
10128             {
10129               ent->is_indirect = TRUE;
10130               ent->got.ent = first_tlsld;
10131             }
10132           else
10133             {
10134               if (first_tlsld == NULL)
10135                 first_tlsld = ent;
10136               s = ppc64_elf_tdata (ibfd)->got;
10137               ent->got.offset = s->size;
10138               ent->owner = ibfd;
10139               s->size += 16;
10140               if (bfd_link_pic (info))
10141                 {
10142                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10143                   srel->size += sizeof (Elf64_External_Rela);
10144                 }
10145             }
10146         }
10147       else
10148         ent->got.offset = (bfd_vma) -1;
10149     }
10150
10151   /* We now have determined the sizes of the various dynamic sections.
10152      Allocate memory for them.  */
10153   relocs = FALSE;
10154   for (s = dynobj->sections; s != NULL; s = s->next)
10155     {
10156       if ((s->flags & SEC_LINKER_CREATED) == 0)
10157         continue;
10158
10159       if (s == htab->brlt || s == htab->relbrlt)
10160         /* These haven't been allocated yet;  don't strip.  */
10161         continue;
10162       else if (s == htab->elf.sgot
10163                || s == htab->elf.splt
10164                || s == htab->elf.iplt
10165                || s == htab->glink
10166                || s == htab->global_entry
10167                || s == htab->elf.sdynbss
10168                || s == htab->elf.sdynrelro)
10169         {
10170           /* Strip this section if we don't need it; see the
10171              comment below.  */
10172         }
10173       else if (s == htab->glink_eh_frame)
10174         {
10175           if (!bfd_is_abs_section (s->output_section))
10176             /* Not sized yet.  */
10177             continue;
10178         }
10179       else if (CONST_STRNEQ (s->name, ".rela"))
10180         {
10181           if (s->size != 0)
10182             {
10183               if (s != htab->elf.srelplt)
10184                 relocs = TRUE;
10185
10186               /* We use the reloc_count field as a counter if we need
10187                  to copy relocs into the output file.  */
10188               s->reloc_count = 0;
10189             }
10190         }
10191       else
10192         {
10193           /* It's not one of our sections, so don't allocate space.  */
10194           continue;
10195         }
10196
10197       if (s->size == 0)
10198         {
10199           /* If we don't need this section, strip it from the
10200              output file.  This is mostly to handle .rela.bss and
10201              .rela.plt.  We must create both sections in
10202              create_dynamic_sections, because they must be created
10203              before the linker maps input sections to output
10204              sections.  The linker does that before
10205              adjust_dynamic_symbol is called, and it is that
10206              function which decides whether anything needs to go
10207              into these sections.  */
10208           s->flags |= SEC_EXCLUDE;
10209           continue;
10210         }
10211
10212       if (bfd_is_abs_section (s->output_section))
10213         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10214                             s->name);
10215
10216       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10217         continue;
10218
10219       /* Allocate memory for the section contents.  We use bfd_zalloc
10220          here in case unused entries are not reclaimed before the
10221          section's contents are written out.  This should not happen,
10222          but this way if it does we get a R_PPC64_NONE reloc in .rela
10223          sections instead of garbage.
10224          We also rely on the section contents being zero when writing
10225          the GOT and .dynrelro.  */
10226       s->contents = bfd_zalloc (dynobj, s->size);
10227       if (s->contents == NULL)
10228         return FALSE;
10229     }
10230
10231   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10232     {
10233       if (!is_ppc64_elf (ibfd))
10234         continue;
10235
10236       s = ppc64_elf_tdata (ibfd)->got;
10237       if (s != NULL && s != htab->elf.sgot)
10238         {
10239           if (s->size == 0)
10240             s->flags |= SEC_EXCLUDE;
10241           else
10242             {
10243               s->contents = bfd_zalloc (ibfd, s->size);
10244               if (s->contents == NULL)
10245                 return FALSE;
10246             }
10247         }
10248       s = ppc64_elf_tdata (ibfd)->relgot;
10249       if (s != NULL)
10250         {
10251           if (s->size == 0)
10252             s->flags |= SEC_EXCLUDE;
10253           else
10254             {
10255               s->contents = bfd_zalloc (ibfd, s->size);
10256               if (s->contents == NULL)
10257                 return FALSE;
10258               relocs = TRUE;
10259               s->reloc_count = 0;
10260             }
10261         }
10262     }
10263
10264   if (htab->elf.dynamic_sections_created)
10265     {
10266       bfd_boolean tls_opt;
10267
10268       /* Add some entries to the .dynamic section.  We fill in the
10269          values later, in ppc64_elf_finish_dynamic_sections, but we
10270          must add the entries now so that we get the correct size for
10271          the .dynamic section.  The DT_DEBUG entry is filled in by the
10272          dynamic linker and used by the debugger.  */
10273 #define add_dynamic_entry(TAG, VAL) \
10274   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10275
10276       if (bfd_link_executable (info))
10277         {
10278           if (!add_dynamic_entry (DT_DEBUG, 0))
10279             return FALSE;
10280         }
10281
10282       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10283         {
10284           if (!add_dynamic_entry (DT_PLTGOT, 0)
10285               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10286               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10287               || !add_dynamic_entry (DT_JMPREL, 0)
10288               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10289             return FALSE;
10290         }
10291
10292       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10293         {
10294           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10295               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10296             return FALSE;
10297         }
10298
10299       tls_opt = (htab->params->tls_get_addr_opt
10300                  && htab->tls_get_addr_fd != NULL
10301                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10302       if (tls_opt || !htab->opd_abi)
10303         {
10304           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10305             return FALSE;
10306         }
10307
10308       if (relocs)
10309         {
10310           if (!add_dynamic_entry (DT_RELA, 0)
10311               || !add_dynamic_entry (DT_RELASZ, 0)
10312               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10313             return FALSE;
10314
10315           /* If any dynamic relocs apply to a read-only section,
10316              then we need a DT_TEXTREL entry.  */
10317           if ((info->flags & DF_TEXTREL) == 0)
10318             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10319
10320           if ((info->flags & DF_TEXTREL) != 0)
10321             {
10322               if (!add_dynamic_entry (DT_TEXTREL, 0))
10323                 return FALSE;
10324             }
10325         }
10326     }
10327 #undef add_dynamic_entry
10328
10329   return TRUE;
10330 }
10331
10332 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10333
10334 static bfd_boolean
10335 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10336 {
10337   if (h->plt.plist != NULL
10338       && !h->def_regular
10339       && !h->pointer_equality_needed)
10340     return FALSE;
10341
10342   return _bfd_elf_hash_symbol (h);
10343 }
10344
10345 /* Determine the type of stub needed, if any, for a call.  */
10346
10347 static inline enum ppc_stub_type
10348 ppc_type_of_stub (asection *input_sec,
10349                   const Elf_Internal_Rela *rel,
10350                   struct ppc_link_hash_entry **hash,
10351                   struct plt_entry **plt_ent,
10352                   bfd_vma destination,
10353                   unsigned long local_off)
10354 {
10355   struct ppc_link_hash_entry *h = *hash;
10356   bfd_vma location;
10357   bfd_vma branch_offset;
10358   bfd_vma max_branch_offset;
10359   enum elf_ppc64_reloc_type r_type;
10360
10361   if (h != NULL)
10362     {
10363       struct plt_entry *ent;
10364       struct ppc_link_hash_entry *fdh = h;
10365       if (h->oh != NULL
10366           && h->oh->is_func_descriptor)
10367         {
10368           fdh = ppc_follow_link (h->oh);
10369           *hash = fdh;
10370         }
10371
10372       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10373         if (ent->addend == rel->r_addend
10374             && ent->plt.offset != (bfd_vma) -1)
10375           {
10376             *plt_ent = ent;
10377             return ppc_stub_plt_call;
10378           }
10379
10380       /* Here, we know we don't have a plt entry.  If we don't have a
10381          either a defined function descriptor or a defined entry symbol
10382          in a regular object file, then it is pointless trying to make
10383          any other type of stub.  */
10384       if (!is_static_defined (&fdh->elf)
10385           && !is_static_defined (&h->elf))
10386         return ppc_stub_none;
10387     }
10388   else if (elf_local_got_ents (input_sec->owner) != NULL)
10389     {
10390       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10391       struct plt_entry **local_plt = (struct plt_entry **)
10392         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10393       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10394
10395       if (local_plt[r_symndx] != NULL)
10396         {
10397           struct plt_entry *ent;
10398
10399           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10400             if (ent->addend == rel->r_addend
10401                 && ent->plt.offset != (bfd_vma) -1)
10402               {
10403                 *plt_ent = ent;
10404                 return ppc_stub_plt_call;
10405               }
10406         }
10407     }
10408
10409   /* Determine where the call point is.  */
10410   location = (input_sec->output_offset
10411               + input_sec->output_section->vma
10412               + rel->r_offset);
10413
10414   branch_offset = destination - location;
10415   r_type = ELF64_R_TYPE (rel->r_info);
10416
10417   /* Determine if a long branch stub is needed.  */
10418   max_branch_offset = 1 << 25;
10419   if (r_type != R_PPC64_REL24)
10420     max_branch_offset = 1 << 15;
10421
10422   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10423     /* We need a stub.  Figure out whether a long_branch or plt_branch
10424        is needed later.  */
10425     return ppc_stub_long_branch;
10426
10427   return ppc_stub_none;
10428 }
10429
10430 /* With power7 weakly ordered memory model, it is possible for ld.so
10431    to update a plt entry in one thread and have another thread see a
10432    stale zero toc entry.  To avoid this we need some sort of acquire
10433    barrier in the call stub.  One solution is to make the load of the
10434    toc word seem to appear to depend on the load of the function entry
10435    word.  Another solution is to test for r2 being zero, and branch to
10436    the appropriate glink entry if so.
10437
10438    .    fake dep barrier        compare
10439    .    ld 12,xxx(2)            ld 12,xxx(2)
10440    .    mtctr 12                mtctr 12
10441    .    xor 11,12,12            ld 2,xxx+8(2)
10442    .    add 2,2,11              cmpldi 2,0
10443    .    ld 2,xxx+8(2)           bnectr+
10444    .    bctr                    b <glink_entry>
10445
10446    The solution involving the compare turns out to be faster, so
10447    that's what we use unless the branch won't reach.  */
10448
10449 #define ALWAYS_USE_FAKE_DEP 0
10450 #define ALWAYS_EMIT_R2SAVE 0
10451
10452 static inline unsigned int
10453 plt_stub_size (struct ppc_link_hash_table *htab,
10454                struct ppc_stub_hash_entry *stub_entry,
10455                bfd_vma off)
10456 {
10457   unsigned size = 12;
10458
10459   if (ALWAYS_EMIT_R2SAVE
10460       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10461     size += 4;
10462   if (PPC_HA (off) != 0)
10463     size += 4;
10464   if (htab->opd_abi)
10465     {
10466       size += 4;
10467       if (htab->params->plt_static_chain)
10468         size += 4;
10469       if (htab->params->plt_thread_safe
10470           && htab->elf.dynamic_sections_created
10471           && stub_entry->h != NULL
10472           && stub_entry->h->elf.dynindx != -1)
10473         size += 8;
10474       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10475         size += 4;
10476     }
10477   if (stub_entry->h != NULL
10478       && (stub_entry->h == htab->tls_get_addr_fd
10479           || stub_entry->h == htab->tls_get_addr)
10480       && htab->params->tls_get_addr_opt)
10481     {
10482       size += 7 * 4;
10483       if (ALWAYS_EMIT_R2SAVE
10484           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10485         size += 6 * 4;
10486     }
10487   return size;
10488 }
10489
10490 /* Depending on the sign of plt_stub_align:
10491    If positive, return the padding to align to a 2**plt_stub_align
10492    boundary.
10493    If negative, if this stub would cross fewer 2**plt_stub_align
10494    boundaries if we align, then return the padding needed to do so.  */
10495
10496 static inline unsigned int
10497 plt_stub_pad (struct ppc_link_hash_table *htab,
10498               struct ppc_stub_hash_entry *stub_entry,
10499               bfd_vma plt_off)
10500 {
10501   int stub_align;
10502   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10503   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10504
10505   if (htab->params->plt_stub_align >= 0)
10506     {
10507       stub_align = 1 << htab->params->plt_stub_align;
10508       if ((stub_off & (stub_align - 1)) != 0)
10509         return stub_align - (stub_off & (stub_align - 1));
10510       return 0;
10511     }
10512
10513   stub_align = 1 << -htab->params->plt_stub_align;
10514   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10515       > ((stub_size - 1) & -stub_align))
10516     return stub_align - (stub_off & (stub_align - 1));
10517   return 0;
10518 }
10519
10520 /* Build a .plt call stub.  */
10521
10522 static inline bfd_byte *
10523 build_plt_stub (struct ppc_link_hash_table *htab,
10524                 struct ppc_stub_hash_entry *stub_entry,
10525                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10526 {
10527   bfd *obfd = htab->params->stub_bfd;
10528   bfd_boolean plt_load_toc = htab->opd_abi;
10529   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10530   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10531                                  && htab->elf.dynamic_sections_created
10532                                  && stub_entry->h != NULL
10533                                  && stub_entry->h->elf.dynindx != -1);
10534   bfd_boolean use_fake_dep = plt_thread_safe;
10535   bfd_vma cmp_branch_off = 0;
10536
10537   if (!ALWAYS_USE_FAKE_DEP
10538       && plt_load_toc
10539       && plt_thread_safe
10540       && !((stub_entry->h == htab->tls_get_addr_fd
10541             || stub_entry->h == htab->tls_get_addr)
10542            && htab->params->tls_get_addr_opt))
10543     {
10544       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10545       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10546                           / PLT_ENTRY_SIZE (htab));
10547       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10548       bfd_vma to, from;
10549
10550       if (pltindex > 32768)
10551         glinkoff += (pltindex - 32768) * 4;
10552       to = (glinkoff
10553             + htab->glink->output_offset
10554             + htab->glink->output_section->vma);
10555       from = (p - stub_entry->group->stub_sec->contents
10556               + 4 * (ALWAYS_EMIT_R2SAVE
10557                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10558               + 4 * (PPC_HA (offset) != 0)
10559               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10560                      != PPC_HA (offset))
10561               + 4 * (plt_static_chain != 0)
10562               + 20
10563               + stub_entry->group->stub_sec->output_offset
10564               + stub_entry->group->stub_sec->output_section->vma);
10565       cmp_branch_off = to - from;
10566       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10567     }
10568
10569   if (PPC_HA (offset) != 0)
10570     {
10571       if (r != NULL)
10572         {
10573           if (ALWAYS_EMIT_R2SAVE
10574               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10575             r[0].r_offset += 4;
10576           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10577           r[1].r_offset = r[0].r_offset + 4;
10578           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10579           r[1].r_addend = r[0].r_addend;
10580           if (plt_load_toc)
10581             {
10582               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10583                 {
10584                   r[2].r_offset = r[1].r_offset + 4;
10585                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10586                   r[2].r_addend = r[0].r_addend;
10587                 }
10588               else
10589                 {
10590                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10591                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10592                   r[2].r_addend = r[0].r_addend + 8;
10593                   if (plt_static_chain)
10594                     {
10595                       r[3].r_offset = r[2].r_offset + 4;
10596                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10597                       r[3].r_addend = r[0].r_addend + 16;
10598                     }
10599                 }
10600             }
10601         }
10602       if (ALWAYS_EMIT_R2SAVE
10603           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10604         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10605       if (plt_load_toc)
10606         {
10607           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10608           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10609         }
10610       else
10611         {
10612           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10613           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10614         }
10615       if (plt_load_toc
10616           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10617         {
10618           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10619           offset = 0;
10620         }
10621       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10622       if (plt_load_toc)
10623         {
10624           if (use_fake_dep)
10625             {
10626               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10627               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10628             }
10629           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10630           if (plt_static_chain)
10631             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10632         }
10633     }
10634   else
10635     {
10636       if (r != NULL)
10637         {
10638           if (ALWAYS_EMIT_R2SAVE
10639               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10640             r[0].r_offset += 4;
10641           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10642           if (plt_load_toc)
10643             {
10644               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10645                 {
10646                   r[1].r_offset = r[0].r_offset + 4;
10647                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10648                   r[1].r_addend = r[0].r_addend;
10649                 }
10650               else
10651                 {
10652                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10653                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10654                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10655                   if (plt_static_chain)
10656                     {
10657                       r[2].r_offset = r[1].r_offset + 4;
10658                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10659                       r[2].r_addend = r[0].r_addend + 8;
10660                     }
10661                 }
10662             }
10663         }
10664       if (ALWAYS_EMIT_R2SAVE
10665           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10666         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10667       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10668       if (plt_load_toc
10669           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10670         {
10671           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10672           offset = 0;
10673         }
10674       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10675       if (plt_load_toc)
10676         {
10677           if (use_fake_dep)
10678             {
10679               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10680               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10681             }
10682           if (plt_static_chain)
10683             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10684           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10685         }
10686     }
10687   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10688     {
10689       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10690       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10691       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10692     }
10693   else
10694     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10695   return p;
10696 }
10697
10698 /* Build a special .plt call stub for __tls_get_addr.  */
10699
10700 #define LD_R11_0R3      0xe9630000
10701 #define LD_R12_0R3      0xe9830000
10702 #define MR_R0_R3        0x7c601b78
10703 #define CMPDI_R11_0     0x2c2b0000
10704 #define ADD_R3_R12_R13  0x7c6c6a14
10705 #define BEQLR           0x4d820020
10706 #define MR_R3_R0        0x7c030378
10707 #define STD_R11_0R1     0xf9610000
10708 #define BCTRL           0x4e800421
10709 #define LD_R11_0R1      0xe9610000
10710 #define MTLR_R11        0x7d6803a6
10711
10712 static inline bfd_byte *
10713 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10714                          struct ppc_stub_hash_entry *stub_entry,
10715                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10716 {
10717   bfd *obfd = htab->params->stub_bfd;
10718
10719   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10720   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10721   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10722   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10723   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10724   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10725   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10726   if (r != NULL)
10727     r[0].r_offset += 7 * 4;
10728   if (!ALWAYS_EMIT_R2SAVE
10729       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10730     return build_plt_stub (htab, stub_entry, p, offset, r);
10731
10732   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10733   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10734
10735   if (r != NULL)
10736     r[0].r_offset += 2 * 4;
10737   p = build_plt_stub (htab, stub_entry, p, offset, r);
10738   bfd_put_32 (obfd, BCTRL, p - 4);
10739
10740   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10741   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10742   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10743   bfd_put_32 (obfd, BLR, p),                    p += 4;
10744
10745   return p;
10746 }
10747
10748 static Elf_Internal_Rela *
10749 get_relocs (asection *sec, int count)
10750 {
10751   Elf_Internal_Rela *relocs;
10752   struct bfd_elf_section_data *elfsec_data;
10753
10754   elfsec_data = elf_section_data (sec);
10755   relocs = elfsec_data->relocs;
10756   if (relocs == NULL)
10757     {
10758       bfd_size_type relsize;
10759       relsize = sec->reloc_count * sizeof (*relocs);
10760       relocs = bfd_alloc (sec->owner, relsize);
10761       if (relocs == NULL)
10762         return NULL;
10763       elfsec_data->relocs = relocs;
10764       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10765                                           sizeof (Elf_Internal_Shdr));
10766       if (elfsec_data->rela.hdr == NULL)
10767         return NULL;
10768       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10769                                         * sizeof (Elf64_External_Rela));
10770       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10771       sec->reloc_count = 0;
10772     }
10773   relocs += sec->reloc_count;
10774   sec->reloc_count += count;
10775   return relocs;
10776 }
10777
10778 static bfd_vma
10779 get_r2off (struct bfd_link_info *info,
10780            struct ppc_stub_hash_entry *stub_entry)
10781 {
10782   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10783   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10784
10785   if (r2off == 0)
10786     {
10787       /* Support linking -R objects.  Get the toc pointer from the
10788          opd entry.  */
10789       char buf[8];
10790       if (!htab->opd_abi)
10791         return r2off;
10792       asection *opd = stub_entry->h->elf.root.u.def.section;
10793       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10794
10795       if (strcmp (opd->name, ".opd") != 0
10796           || opd->reloc_count != 0)
10797         {
10798           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
10799                                   stub_entry->h->elf.root.root.string);
10800           bfd_set_error (bfd_error_bad_value);
10801           return (bfd_vma) -1;
10802         }
10803       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10804         return (bfd_vma) -1;
10805       r2off = bfd_get_64 (opd->owner, buf);
10806       r2off -= elf_gp (info->output_bfd);
10807     }
10808   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10809   return r2off;
10810 }
10811
10812 static bfd_boolean
10813 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10814 {
10815   struct ppc_stub_hash_entry *stub_entry;
10816   struct ppc_branch_hash_entry *br_entry;
10817   struct bfd_link_info *info;
10818   struct ppc_link_hash_table *htab;
10819   bfd_byte *loc;
10820   bfd_byte *p;
10821   bfd_vma dest, off;
10822   Elf_Internal_Rela *r;
10823   asection *plt;
10824
10825   /* Massage our args to the form they really have.  */
10826   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10827   info = in_arg;
10828
10829   htab = ppc_hash_table (info);
10830   if (htab == NULL)
10831     return FALSE;
10832
10833   /* Make a note of the offset within the stubs for this entry.  */
10834   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10835   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10836
10837   htab->stub_count[stub_entry->stub_type - 1] += 1;
10838   switch (stub_entry->stub_type)
10839     {
10840     case ppc_stub_long_branch:
10841     case ppc_stub_long_branch_r2off:
10842       /* Branches are relative.  This is where we are going to.  */
10843       dest = (stub_entry->target_value
10844               + stub_entry->target_section->output_offset
10845               + stub_entry->target_section->output_section->vma);
10846       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10847       off = dest;
10848
10849       /* And this is where we are coming from.  */
10850       off -= (stub_entry->stub_offset
10851               + stub_entry->group->stub_sec->output_offset
10852               + stub_entry->group->stub_sec->output_section->vma);
10853
10854       p = loc;
10855       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10856         {
10857           bfd_vma r2off = get_r2off (info, stub_entry);
10858
10859           if (r2off == (bfd_vma) -1)
10860             {
10861               htab->stub_error = TRUE;
10862               return FALSE;
10863             }
10864           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
10865           p += 4;
10866           if (PPC_HA (r2off) != 0)
10867             {
10868               bfd_put_32 (htab->params->stub_bfd,
10869                           ADDIS_R2_R2 | PPC_HA (r2off), p);
10870               p += 4;
10871             }
10872           if (PPC_LO (r2off) != 0)
10873             {
10874               bfd_put_32 (htab->params->stub_bfd,
10875                           ADDI_R2_R2 | PPC_LO (r2off), p);
10876               p += 4;
10877             }
10878           off -= p - loc;
10879         }
10880       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
10881       p += 4;
10882
10883       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10884         {
10885           _bfd_error_handler
10886             (_("long branch stub `%s' offset overflow"),
10887              stub_entry->root.string);
10888           htab->stub_error = TRUE;
10889           return FALSE;
10890         }
10891
10892       if (info->emitrelocations)
10893         {
10894           r = get_relocs (stub_entry->group->stub_sec, 1);
10895           if (r == NULL)
10896             return FALSE;
10897           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
10898           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10899           r->r_addend = dest;
10900           if (stub_entry->h != NULL)
10901             {
10902               struct elf_link_hash_entry **hashes;
10903               unsigned long symndx;
10904               struct ppc_link_hash_entry *h;
10905
10906               hashes = elf_sym_hashes (htab->params->stub_bfd);
10907               if (hashes == NULL)
10908                 {
10909                   bfd_size_type hsize;
10910
10911                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10912                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10913                   if (hashes == NULL)
10914                     return FALSE;
10915                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10916                   htab->stub_globals = 1;
10917                 }
10918               symndx = htab->stub_globals++;
10919               h = stub_entry->h;
10920               hashes[symndx] = &h->elf;
10921               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10922               if (h->oh != NULL && h->oh->is_func)
10923                 h = ppc_follow_link (h->oh);
10924               if (h->elf.root.u.def.section != stub_entry->target_section)
10925                 /* H is an opd symbol.  The addend must be zero.  */
10926                 r->r_addend = 0;
10927               else
10928                 {
10929                   off = (h->elf.root.u.def.value
10930                          + h->elf.root.u.def.section->output_offset
10931                          + h->elf.root.u.def.section->output_section->vma);
10932                   r->r_addend -= off;
10933                 }
10934             }
10935         }
10936       break;
10937
10938     case ppc_stub_plt_branch:
10939     case ppc_stub_plt_branch_r2off:
10940       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10941                                          stub_entry->root.string + 9,
10942                                          FALSE, FALSE);
10943       if (br_entry == NULL)
10944         {
10945           _bfd_error_handler (_("can't find branch stub `%s'"),
10946                               stub_entry->root.string);
10947           htab->stub_error = TRUE;
10948           return FALSE;
10949         }
10950
10951       dest = (stub_entry->target_value
10952               + stub_entry->target_section->output_offset
10953               + stub_entry->target_section->output_section->vma);
10954       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10955         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10956
10957       bfd_put_64 (htab->brlt->owner, dest,
10958                   htab->brlt->contents + br_entry->offset);
10959
10960       if (br_entry->iter == htab->stub_iteration)
10961         {
10962           br_entry->iter = 0;
10963
10964           if (htab->relbrlt != NULL)
10965             {
10966               /* Create a reloc for the branch lookup table entry.  */
10967               Elf_Internal_Rela rela;
10968               bfd_byte *rl;
10969
10970               rela.r_offset = (br_entry->offset
10971                                + htab->brlt->output_offset
10972                                + htab->brlt->output_section->vma);
10973               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10974               rela.r_addend = dest;
10975
10976               rl = htab->relbrlt->contents;
10977               rl += (htab->relbrlt->reloc_count++
10978                      * sizeof (Elf64_External_Rela));
10979               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10980             }
10981           else if (info->emitrelocations)
10982             {
10983               r = get_relocs (htab->brlt, 1);
10984               if (r == NULL)
10985                 return FALSE;
10986               /* brlt, being SEC_LINKER_CREATED does not go through the
10987                  normal reloc processing.  Symbols and offsets are not
10988                  translated from input file to output file form, so
10989                  set up the offset per the output file.  */
10990               r->r_offset = (br_entry->offset
10991                              + htab->brlt->output_offset
10992                              + htab->brlt->output_section->vma);
10993               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10994               r->r_addend = dest;
10995             }
10996         }
10997
10998       dest = (br_entry->offset
10999               + htab->brlt->output_offset
11000               + htab->brlt->output_section->vma);
11001
11002       off = (dest
11003              - elf_gp (info->output_bfd)
11004              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11005
11006       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11007         {
11008           info->callbacks->einfo
11009             (_("%P: linkage table error against `%pT'\n"),
11010              stub_entry->root.string);
11011           bfd_set_error (bfd_error_bad_value);
11012           htab->stub_error = TRUE;
11013           return FALSE;
11014         }
11015
11016       if (info->emitrelocations)
11017         {
11018           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11019           if (r == NULL)
11020             return FALSE;
11021           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11022           if (bfd_big_endian (info->output_bfd))
11023             r[0].r_offset += 2;
11024           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11025             r[0].r_offset += 4;
11026           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11027           r[0].r_addend = dest;
11028           if (PPC_HA (off) != 0)
11029             {
11030               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11031               r[1].r_offset = r[0].r_offset + 4;
11032               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11033               r[1].r_addend = r[0].r_addend;
11034             }
11035         }
11036
11037       p = loc;
11038       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11039         {
11040           if (PPC_HA (off) != 0)
11041             {
11042               bfd_put_32 (htab->params->stub_bfd,
11043                           ADDIS_R12_R2 | PPC_HA (off), p);
11044               p += 4;
11045               bfd_put_32 (htab->params->stub_bfd,
11046                           LD_R12_0R12 | PPC_LO (off), p);
11047             }
11048           else
11049             bfd_put_32 (htab->params->stub_bfd,
11050                         LD_R12_0R2 | PPC_LO (off), p);
11051         }
11052       else
11053         {
11054           bfd_vma r2off = get_r2off (info, stub_entry);
11055
11056           if (r2off == (bfd_vma) -1)
11057             {
11058               htab->stub_error = TRUE;
11059               return FALSE;
11060             }
11061
11062           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11063           p += 4;
11064           if (PPC_HA (off) != 0)
11065             {
11066               bfd_put_32 (htab->params->stub_bfd,
11067                           ADDIS_R12_R2 | PPC_HA (off), p);
11068               p += 4;
11069               bfd_put_32 (htab->params->stub_bfd,
11070                           LD_R12_0R12 | PPC_LO (off), p);
11071             }
11072           else
11073             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11074
11075           if (PPC_HA (r2off) != 0)
11076             {
11077               p += 4;
11078               bfd_put_32 (htab->params->stub_bfd,
11079                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11080             }
11081           if (PPC_LO (r2off) != 0)
11082             {
11083               p += 4;
11084               bfd_put_32 (htab->params->stub_bfd,
11085                           ADDI_R2_R2 | PPC_LO (r2off), p);
11086             }
11087         }
11088       p += 4;
11089       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11090       p += 4;
11091       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11092       p += 4;
11093       break;
11094
11095     case ppc_stub_plt_call:
11096     case ppc_stub_plt_call_r2save:
11097       if (stub_entry->h != NULL
11098           && stub_entry->h->is_func_descriptor
11099           && stub_entry->h->oh != NULL)
11100         {
11101           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11102
11103           /* If the old-ABI "dot-symbol" is undefined make it weak so
11104              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11105           if (fh->elf.root.type == bfd_link_hash_undefined
11106               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11107                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11108             fh->elf.root.type = bfd_link_hash_undefweak;
11109         }
11110
11111       /* Now build the stub.  */
11112       dest = stub_entry->plt_ent->plt.offset & ~1;
11113       if (dest >= (bfd_vma) -2)
11114         abort ();
11115
11116       plt = htab->elf.splt;
11117       if (!htab->elf.dynamic_sections_created
11118           || stub_entry->h == NULL
11119           || stub_entry->h->elf.dynindx == -1)
11120         plt = htab->elf.iplt;
11121
11122       dest += plt->output_offset + plt->output_section->vma;
11123
11124       if (stub_entry->h == NULL
11125           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11126         {
11127           Elf_Internal_Rela rela;
11128           bfd_byte *rl;
11129
11130           rela.r_offset = dest;
11131           if (htab->opd_abi)
11132             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11133           else
11134             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11135           rela.r_addend = (stub_entry->target_value
11136                            + stub_entry->target_section->output_offset
11137                            + stub_entry->target_section->output_section->vma);
11138
11139           rl = (htab->elf.irelplt->contents
11140                 + (htab->elf.irelplt->reloc_count++
11141                    * sizeof (Elf64_External_Rela)));
11142           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11143           stub_entry->plt_ent->plt.offset |= 1;
11144           htab->local_ifunc_resolver = 1;
11145         }
11146
11147       off = (dest
11148              - elf_gp (info->output_bfd)
11149              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11150
11151       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11152         {
11153           info->callbacks->einfo
11154             /* xgettext:c-format */
11155             (_("%P: linkage table error against `%pT'\n"),
11156              stub_entry->h != NULL
11157              ? stub_entry->h->elf.root.root.string
11158              : "<local sym>");
11159           bfd_set_error (bfd_error_bad_value);
11160           htab->stub_error = TRUE;
11161           return FALSE;
11162         }
11163
11164       if (htab->params->plt_stub_align != 0)
11165         {
11166           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11167
11168           stub_entry->group->stub_sec->size += pad;
11169           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11170           loc += pad;
11171         }
11172
11173       r = NULL;
11174       if (info->emitrelocations)
11175         {
11176           r = get_relocs (stub_entry->group->stub_sec,
11177                           ((PPC_HA (off) != 0)
11178                            + (htab->opd_abi
11179                               ? 2 + (htab->params->plt_static_chain
11180                                      && PPC_HA (off + 16) == PPC_HA (off))
11181                               : 1)));
11182           if (r == NULL)
11183             return FALSE;
11184           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11185           if (bfd_big_endian (info->output_bfd))
11186             r[0].r_offset += 2;
11187           r[0].r_addend = dest;
11188         }
11189       if (stub_entry->h != NULL
11190           && (stub_entry->h == htab->tls_get_addr_fd
11191               || stub_entry->h == htab->tls_get_addr)
11192           && htab->params->tls_get_addr_opt)
11193         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11194       else
11195         p = build_plt_stub (htab, stub_entry, loc, off, r);
11196       break;
11197
11198     case ppc_stub_save_res:
11199       return TRUE;
11200
11201     default:
11202       BFD_FAIL ();
11203       return FALSE;
11204     }
11205
11206   stub_entry->group->stub_sec->size += p - loc;
11207
11208   if (htab->params->emit_stub_syms)
11209     {
11210       struct elf_link_hash_entry *h;
11211       size_t len1, len2;
11212       char *name;
11213       const char *const stub_str[] = { "long_branch",
11214                                        "long_branch_r2off",
11215                                        "plt_branch",
11216                                        "plt_branch_r2off",
11217                                        "plt_call",
11218                                        "plt_call" };
11219
11220       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11221       len2 = strlen (stub_entry->root.string);
11222       name = bfd_malloc (len1 + len2 + 2);
11223       if (name == NULL)
11224         return FALSE;
11225       memcpy (name, stub_entry->root.string, 9);
11226       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11227       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11228       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11229       if (h == NULL)
11230         return FALSE;
11231       if (h->root.type == bfd_link_hash_new)
11232         {
11233           h->root.type = bfd_link_hash_defined;
11234           h->root.u.def.section = stub_entry->group->stub_sec;
11235           h->root.u.def.value = stub_entry->stub_offset;
11236           h->ref_regular = 1;
11237           h->def_regular = 1;
11238           h->ref_regular_nonweak = 1;
11239           h->forced_local = 1;
11240           h->non_elf = 0;
11241           h->root.linker_def = 1;
11242         }
11243     }
11244
11245   return TRUE;
11246 }
11247
11248 /* As above, but don't actually build the stub.  Just bump offset so
11249    we know stub section sizes, and select plt_branch stubs where
11250    long_branch stubs won't do.  */
11251
11252 static bfd_boolean
11253 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11254 {
11255   struct ppc_stub_hash_entry *stub_entry;
11256   struct bfd_link_info *info;
11257   struct ppc_link_hash_table *htab;
11258   bfd_vma off;
11259   int size;
11260
11261   /* Massage our args to the form they really have.  */
11262   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11263   info = in_arg;
11264
11265   htab = ppc_hash_table (info);
11266   if (htab == NULL)
11267     return FALSE;
11268
11269   if (stub_entry->h != NULL
11270       && stub_entry->h->save_res
11271       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11272       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11273     {
11274       /* Don't make stubs to out-of-line register save/restore
11275          functions.  Instead, emit copies of the functions.  */
11276       stub_entry->group->needs_save_res = 1;
11277       stub_entry->stub_type = ppc_stub_save_res;
11278       return TRUE;
11279     }
11280
11281   if (stub_entry->stub_type == ppc_stub_plt_call
11282       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11283     {
11284       asection *plt;
11285       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11286       if (off >= (bfd_vma) -2)
11287         abort ();
11288       plt = htab->elf.splt;
11289       if (!htab->elf.dynamic_sections_created
11290           || stub_entry->h == NULL
11291           || stub_entry->h->elf.dynindx == -1)
11292         plt = htab->elf.iplt;
11293       off += (plt->output_offset
11294               + plt->output_section->vma
11295               - elf_gp (info->output_bfd)
11296               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11297
11298       size = plt_stub_size (htab, stub_entry, off);
11299       if (stub_entry->h != NULL
11300           && (stub_entry->h == htab->tls_get_addr_fd
11301               || stub_entry->h == htab->tls_get_addr)
11302           && htab->params->tls_get_addr_opt
11303           && (ALWAYS_EMIT_R2SAVE
11304               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11305         stub_entry->group->tls_get_addr_opt_bctrl
11306           = stub_entry->group->stub_sec->size + size - 5 * 4;
11307
11308       if (htab->params->plt_stub_align)
11309         size += plt_stub_pad (htab, stub_entry, off);
11310       if (info->emitrelocations)
11311         {
11312           stub_entry->group->stub_sec->reloc_count
11313             += ((PPC_HA (off) != 0)
11314                 + (htab->opd_abi
11315                    ? 2 + (htab->params->plt_static_chain
11316                           && PPC_HA (off + 16) == PPC_HA (off))
11317                    : 1));
11318           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11319         }
11320     }
11321   else
11322     {
11323       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11324          variants.  */
11325       bfd_vma r2off = 0;
11326       bfd_vma local_off = 0;
11327
11328       off = (stub_entry->target_value
11329              + stub_entry->target_section->output_offset
11330              + stub_entry->target_section->output_section->vma);
11331       off -= (stub_entry->group->stub_sec->size
11332               + stub_entry->group->stub_sec->output_offset
11333               + stub_entry->group->stub_sec->output_section->vma);
11334
11335       /* Reset the stub type from the plt variant in case we now
11336          can reach with a shorter stub.  */
11337       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11338         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11339
11340       size = 4;
11341       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11342         {
11343           r2off = get_r2off (info, stub_entry);
11344           if (r2off == (bfd_vma) -1)
11345             {
11346               htab->stub_error = TRUE;
11347               return FALSE;
11348             }
11349           size = 8;
11350           if (PPC_HA (r2off) != 0)
11351             size += 4;
11352           if (PPC_LO (r2off) != 0)
11353             size += 4;
11354           off -= size - 4;
11355         }
11356
11357       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11358
11359       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11360          Do the same for -R objects without function descriptors.  */
11361       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11362           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11363               && r2off == 0
11364               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11365         {
11366           struct ppc_branch_hash_entry *br_entry;
11367
11368           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11369                                              stub_entry->root.string + 9,
11370                                              TRUE, FALSE);
11371           if (br_entry == NULL)
11372             {
11373               _bfd_error_handler (_("can't build branch stub `%s'"),
11374                                   stub_entry->root.string);
11375               htab->stub_error = TRUE;
11376               return FALSE;
11377             }
11378
11379           if (br_entry->iter != htab->stub_iteration)
11380             {
11381               br_entry->iter = htab->stub_iteration;
11382               br_entry->offset = htab->brlt->size;
11383               htab->brlt->size += 8;
11384
11385               if (htab->relbrlt != NULL)
11386                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11387               else if (info->emitrelocations)
11388                 {
11389                   htab->brlt->reloc_count += 1;
11390                   htab->brlt->flags |= SEC_RELOC;
11391                 }
11392             }
11393
11394           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11395           off = (br_entry->offset
11396                  + htab->brlt->output_offset
11397                  + htab->brlt->output_section->vma
11398                  - elf_gp (info->output_bfd)
11399                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11400
11401           if (info->emitrelocations)
11402             {
11403               stub_entry->group->stub_sec->reloc_count
11404                 += 1 + (PPC_HA (off) != 0);
11405               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11406             }
11407
11408           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11409             {
11410               size = 12;
11411               if (PPC_HA (off) != 0)
11412                 size = 16;
11413             }
11414           else
11415             {
11416               size = 16;
11417               if (PPC_HA (off) != 0)
11418                 size += 4;
11419
11420               if (PPC_HA (r2off) != 0)
11421                 size += 4;
11422               if (PPC_LO (r2off) != 0)
11423                 size += 4;
11424             }
11425         }
11426       else if (info->emitrelocations)
11427         {
11428           stub_entry->group->stub_sec->reloc_count += 1;
11429           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11430         }
11431     }
11432
11433   stub_entry->group->stub_sec->size += size;
11434   return TRUE;
11435 }
11436
11437 /* Set up various things so that we can make a list of input sections
11438    for each output section included in the link.  Returns -1 on error,
11439    0 when no stubs will be needed, and 1 on success.  */
11440
11441 int
11442 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11443 {
11444   unsigned int id;
11445   bfd_size_type amt;
11446   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11447
11448   if (htab == NULL)
11449     return -1;
11450
11451   htab->sec_info_arr_size = bfd_get_next_section_id ();
11452   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11453   htab->sec_info = bfd_zmalloc (amt);
11454   if (htab->sec_info == NULL)
11455     return -1;
11456
11457   /* Set toc_off for com, und, abs and ind sections.  */
11458   for (id = 0; id < 3; id++)
11459     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11460
11461   return 1;
11462 }
11463
11464 /* Set up for first pass at multitoc partitioning.  */
11465
11466 void
11467 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11468 {
11469   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11470
11471   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11472   htab->toc_bfd = NULL;
11473   htab->toc_first_sec = NULL;
11474 }
11475
11476 /* The linker repeatedly calls this function for each TOC input section
11477    and linker generated GOT section.  Group input bfds such that the toc
11478    within a group is less than 64k in size.  */
11479
11480 bfd_boolean
11481 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11482 {
11483   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11484   bfd_vma addr, off, limit;
11485
11486   if (htab == NULL)
11487     return FALSE;
11488
11489   if (!htab->second_toc_pass)
11490     {
11491       /* Keep track of the first .toc or .got section for this input bfd.  */
11492       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11493
11494       if (new_bfd)
11495         {
11496           htab->toc_bfd = isec->owner;
11497           htab->toc_first_sec = isec;
11498         }
11499
11500       addr = isec->output_offset + isec->output_section->vma;
11501       off = addr - htab->toc_curr;
11502       limit = 0x80008000;
11503       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11504         limit = 0x10000;
11505       if (off + isec->size > limit)
11506         {
11507           addr = (htab->toc_first_sec->output_offset
11508                   + htab->toc_first_sec->output_section->vma);
11509           htab->toc_curr = addr;
11510           htab->toc_curr &= -TOC_BASE_ALIGN;
11511         }
11512
11513       /* toc_curr is the base address of this toc group.  Set elf_gp
11514          for the input section to be the offset relative to the
11515          output toc base plus 0x8000.  Making the input elf_gp an
11516          offset allows us to move the toc as a whole without
11517          recalculating input elf_gp.  */
11518       off = htab->toc_curr - elf_gp (info->output_bfd);
11519       off += TOC_BASE_OFF;
11520
11521       /* Die if someone uses a linker script that doesn't keep input
11522          file .toc and .got together.  */
11523       if (new_bfd
11524           && elf_gp (isec->owner) != 0
11525           && elf_gp (isec->owner) != off)
11526         return FALSE;
11527
11528       elf_gp (isec->owner) = off;
11529       return TRUE;
11530     }
11531
11532   /* During the second pass toc_first_sec points to the start of
11533      a toc group, and toc_curr is used to track the old elf_gp.
11534      We use toc_bfd to ensure we only look at each bfd once.  */
11535   if (htab->toc_bfd == isec->owner)
11536     return TRUE;
11537   htab->toc_bfd = isec->owner;
11538
11539   if (htab->toc_first_sec == NULL
11540       || htab->toc_curr != elf_gp (isec->owner))
11541     {
11542       htab->toc_curr = elf_gp (isec->owner);
11543       htab->toc_first_sec = isec;
11544     }
11545   addr = (htab->toc_first_sec->output_offset
11546           + htab->toc_first_sec->output_section->vma);
11547   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11548   elf_gp (isec->owner) = off;
11549
11550   return TRUE;
11551 }
11552
11553 /* Called via elf_link_hash_traverse to merge GOT entries for global
11554    symbol H.  */
11555
11556 static bfd_boolean
11557 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11558 {
11559   if (h->root.type == bfd_link_hash_indirect)
11560     return TRUE;
11561
11562   merge_got_entries (&h->got.glist);
11563
11564   return TRUE;
11565 }
11566
11567 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11568    symbol H.  */
11569
11570 static bfd_boolean
11571 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11572 {
11573   struct got_entry *gent;
11574
11575   if (h->root.type == bfd_link_hash_indirect)
11576     return TRUE;
11577
11578   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11579     if (!gent->is_indirect)
11580       allocate_got (h, (struct bfd_link_info *) inf, gent);
11581   return TRUE;
11582 }
11583
11584 /* Called on the first multitoc pass after the last call to
11585    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11586    entries.  */
11587
11588 bfd_boolean
11589 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11590 {
11591   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11592   struct bfd *ibfd, *ibfd2;
11593   bfd_boolean done_something;
11594
11595   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11596
11597   if (!htab->do_multi_toc)
11598     return FALSE;
11599
11600   /* Merge global sym got entries within a toc group.  */
11601   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11602
11603   /* And tlsld_got.  */
11604   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11605     {
11606       struct got_entry *ent, *ent2;
11607
11608       if (!is_ppc64_elf (ibfd))
11609         continue;
11610
11611       ent = ppc64_tlsld_got (ibfd);
11612       if (!ent->is_indirect
11613           && ent->got.offset != (bfd_vma) -1)
11614         {
11615           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11616             {
11617               if (!is_ppc64_elf (ibfd2))
11618                 continue;
11619
11620               ent2 = ppc64_tlsld_got (ibfd2);
11621               if (!ent2->is_indirect
11622                   && ent2->got.offset != (bfd_vma) -1
11623                   && elf_gp (ibfd2) == elf_gp (ibfd))
11624                 {
11625                   ent2->is_indirect = TRUE;
11626                   ent2->got.ent = ent;
11627                 }
11628             }
11629         }
11630     }
11631
11632   /* Zap sizes of got sections.  */
11633   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11634   htab->elf.irelplt->size -= htab->got_reli_size;
11635   htab->got_reli_size = 0;
11636
11637   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11638     {
11639       asection *got, *relgot;
11640
11641       if (!is_ppc64_elf (ibfd))
11642         continue;
11643
11644       got = ppc64_elf_tdata (ibfd)->got;
11645       if (got != NULL)
11646         {
11647           got->rawsize = got->size;
11648           got->size = 0;
11649           relgot = ppc64_elf_tdata (ibfd)->relgot;
11650           relgot->rawsize = relgot->size;
11651           relgot->size = 0;
11652         }
11653     }
11654
11655   /* Now reallocate the got, local syms first.  We don't need to
11656      allocate section contents again since we never increase size.  */
11657   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11658     {
11659       struct got_entry **lgot_ents;
11660       struct got_entry **end_lgot_ents;
11661       struct plt_entry **local_plt;
11662       struct plt_entry **end_local_plt;
11663       unsigned char *lgot_masks;
11664       bfd_size_type locsymcount;
11665       Elf_Internal_Shdr *symtab_hdr;
11666       asection *s;
11667
11668       if (!is_ppc64_elf (ibfd))
11669         continue;
11670
11671       lgot_ents = elf_local_got_ents (ibfd);
11672       if (!lgot_ents)
11673         continue;
11674
11675       symtab_hdr = &elf_symtab_hdr (ibfd);
11676       locsymcount = symtab_hdr->sh_info;
11677       end_lgot_ents = lgot_ents + locsymcount;
11678       local_plt = (struct plt_entry **) end_lgot_ents;
11679       end_local_plt = local_plt + locsymcount;
11680       lgot_masks = (unsigned char *) end_local_plt;
11681       s = ppc64_elf_tdata (ibfd)->got;
11682       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11683         {
11684           struct got_entry *ent;
11685
11686           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11687             {
11688               unsigned int ent_size = 8;
11689               unsigned int rel_size = sizeof (Elf64_External_Rela);
11690
11691               ent->got.offset = s->size;
11692               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11693                 {
11694                   ent_size *= 2;
11695                   rel_size *= 2;
11696                 }
11697               s->size += ent_size;
11698               if ((*lgot_masks & PLT_IFUNC) != 0)
11699                 {
11700                   htab->elf.irelplt->size += rel_size;
11701                   htab->got_reli_size += rel_size;
11702                 }
11703               else if (bfd_link_pic (info))
11704                 {
11705                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11706                   srel->size += rel_size;
11707                 }
11708             }
11709         }
11710     }
11711
11712   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11713
11714   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11715     {
11716       struct got_entry *ent;
11717
11718       if (!is_ppc64_elf (ibfd))
11719         continue;
11720
11721       ent = ppc64_tlsld_got (ibfd);
11722       if (!ent->is_indirect
11723           && ent->got.offset != (bfd_vma) -1)
11724         {
11725           asection *s = ppc64_elf_tdata (ibfd)->got;
11726           ent->got.offset = s->size;
11727           s->size += 16;
11728           if (bfd_link_pic (info))
11729             {
11730               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11731               srel->size += sizeof (Elf64_External_Rela);
11732             }
11733         }
11734     }
11735
11736   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11737   if (!done_something)
11738     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11739       {
11740         asection *got;
11741
11742         if (!is_ppc64_elf (ibfd))
11743           continue;
11744
11745         got = ppc64_elf_tdata (ibfd)->got;
11746         if (got != NULL)
11747           {
11748             done_something = got->rawsize != got->size;
11749             if (done_something)
11750               break;
11751           }
11752       }
11753
11754   if (done_something)
11755     (*htab->params->layout_sections_again) ();
11756
11757   /* Set up for second pass over toc sections to recalculate elf_gp
11758      on input sections.  */
11759   htab->toc_bfd = NULL;
11760   htab->toc_first_sec = NULL;
11761   htab->second_toc_pass = TRUE;
11762   return done_something;
11763 }
11764
11765 /* Called after second pass of multitoc partitioning.  */
11766
11767 void
11768 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11769 {
11770   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11771
11772   /* After the second pass, toc_curr tracks the TOC offset used
11773      for code sections below in ppc64_elf_next_input_section.  */
11774   htab->toc_curr = TOC_BASE_OFF;
11775 }
11776
11777 /* No toc references were found in ISEC.  If the code in ISEC makes no
11778    calls, then there's no need to use toc adjusting stubs when branching
11779    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11780    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11781    needed, and 2 if a cyclical call-graph was found but no other reason
11782    for a stub was detected.  If called from the top level, a return of
11783    2 means the same as a return of 0.  */
11784
11785 static int
11786 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11787 {
11788   int ret;
11789
11790   /* Mark this section as checked.  */
11791   isec->call_check_done = 1;
11792
11793   /* We know none of our code bearing sections will need toc stubs.  */
11794   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11795     return 0;
11796
11797   if (isec->size == 0)
11798     return 0;
11799
11800   if (isec->output_section == NULL)
11801     return 0;
11802
11803   ret = 0;
11804   if (isec->reloc_count != 0)
11805     {
11806       Elf_Internal_Rela *relstart, *rel;
11807       Elf_Internal_Sym *local_syms;
11808       struct ppc_link_hash_table *htab;
11809
11810       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11811                                             info->keep_memory);
11812       if (relstart == NULL)
11813         return -1;
11814
11815       /* Look for branches to outside of this section.  */
11816       local_syms = NULL;
11817       htab = ppc_hash_table (info);
11818       if (htab == NULL)
11819         return -1;
11820
11821       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11822         {
11823           enum elf_ppc64_reloc_type r_type;
11824           unsigned long r_symndx;
11825           struct elf_link_hash_entry *h;
11826           struct ppc_link_hash_entry *eh;
11827           Elf_Internal_Sym *sym;
11828           asection *sym_sec;
11829           struct _opd_sec_data *opd;
11830           bfd_vma sym_value;
11831           bfd_vma dest;
11832
11833           r_type = ELF64_R_TYPE (rel->r_info);
11834           if (r_type != R_PPC64_REL24
11835               && r_type != R_PPC64_REL14
11836               && r_type != R_PPC64_REL14_BRTAKEN
11837               && r_type != R_PPC64_REL14_BRNTAKEN)
11838             continue;
11839
11840           r_symndx = ELF64_R_SYM (rel->r_info);
11841           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11842                           isec->owner))
11843             {
11844               ret = -1;
11845               break;
11846             }
11847
11848           /* Calls to dynamic lib functions go through a plt call stub
11849              that uses r2.  */
11850           eh = (struct ppc_link_hash_entry *) h;
11851           if (eh != NULL
11852               && (eh->elf.plt.plist != NULL
11853                   || (eh->oh != NULL
11854                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11855             {
11856               ret = 1;
11857               break;
11858             }
11859
11860           if (sym_sec == NULL)
11861             /* Ignore other undefined symbols.  */
11862             continue;
11863
11864           /* Assume branches to other sections not included in the
11865              link need stubs too, to cover -R and absolute syms.  */
11866           if (sym_sec->output_section == NULL)
11867             {
11868               ret = 1;
11869               break;
11870             }
11871
11872           if (h == NULL)
11873             sym_value = sym->st_value;
11874           else
11875             {
11876               if (h->root.type != bfd_link_hash_defined
11877                   && h->root.type != bfd_link_hash_defweak)
11878                 abort ();
11879               sym_value = h->root.u.def.value;
11880             }
11881           sym_value += rel->r_addend;
11882
11883           /* If this branch reloc uses an opd sym, find the code section.  */
11884           opd = get_opd_info (sym_sec);
11885           if (opd != NULL)
11886             {
11887               if (h == NULL && opd->adjust != NULL)
11888                 {
11889                   long adjust;
11890
11891                   adjust = opd->adjust[OPD_NDX (sym_value)];
11892                   if (adjust == -1)
11893                     /* Assume deleted functions won't ever be called.  */
11894                     continue;
11895                   sym_value += adjust;
11896                 }
11897
11898               dest = opd_entry_value (sym_sec, sym_value,
11899                                       &sym_sec, NULL, FALSE);
11900               if (dest == (bfd_vma) -1)
11901                 continue;
11902             }
11903           else
11904             dest = (sym_value
11905                     + sym_sec->output_offset
11906                     + sym_sec->output_section->vma);
11907
11908           /* Ignore branch to self.  */
11909           if (sym_sec == isec)
11910             continue;
11911
11912           /* If the called function uses the toc, we need a stub.  */
11913           if (sym_sec->has_toc_reloc
11914               || sym_sec->makes_toc_func_call)
11915             {
11916               ret = 1;
11917               break;
11918             }
11919
11920           /* Assume any branch that needs a long branch stub might in fact
11921              need a plt_branch stub.  A plt_branch stub uses r2.  */
11922           else if (dest - (isec->output_offset
11923                            + isec->output_section->vma
11924                            + rel->r_offset) + (1 << 25)
11925                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11926                                                              ? h->other
11927                                                              : sym->st_other))
11928             {
11929               ret = 1;
11930               break;
11931             }
11932
11933           /* If calling back to a section in the process of being
11934              tested, we can't say for sure that no toc adjusting stubs
11935              are needed, so don't return zero.  */
11936           else if (sym_sec->call_check_in_progress)
11937             ret = 2;
11938
11939           /* Branches to another section that itself doesn't have any TOC
11940              references are OK.  Recursively call ourselves to check.  */
11941           else if (!sym_sec->call_check_done)
11942             {
11943               int recur;
11944
11945               /* Mark current section as indeterminate, so that other
11946                  sections that call back to current won't be marked as
11947                  known.  */
11948               isec->call_check_in_progress = 1;
11949               recur = toc_adjusting_stub_needed (info, sym_sec);
11950               isec->call_check_in_progress = 0;
11951
11952               if (recur != 0)
11953                 {
11954                   ret = recur;
11955                   if (recur != 2)
11956                     break;
11957                 }
11958             }
11959         }
11960
11961       if (local_syms != NULL
11962           && (elf_symtab_hdr (isec->owner).contents
11963               != (unsigned char *) local_syms))
11964         free (local_syms);
11965       if (elf_section_data (isec)->relocs != relstart)
11966         free (relstart);
11967     }
11968
11969   if ((ret & 1) == 0
11970       && isec->map_head.s != NULL
11971       && (strcmp (isec->output_section->name, ".init") == 0
11972           || strcmp (isec->output_section->name, ".fini") == 0))
11973     {
11974       if (isec->map_head.s->has_toc_reloc
11975           || isec->map_head.s->makes_toc_func_call)
11976         ret = 1;
11977       else if (!isec->map_head.s->call_check_done)
11978         {
11979           int recur;
11980           isec->call_check_in_progress = 1;
11981           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11982           isec->call_check_in_progress = 0;
11983           if (recur != 0)
11984             ret = recur;
11985         }
11986     }
11987
11988   if (ret == 1)
11989     isec->makes_toc_func_call = 1;
11990
11991   return ret;
11992 }
11993
11994 /* The linker repeatedly calls this function for each input section,
11995    in the order that input sections are linked into output sections.
11996    Build lists of input sections to determine groupings between which
11997    we may insert linker stubs.  */
11998
11999 bfd_boolean
12000 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12001 {
12002   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12003
12004   if (htab == NULL)
12005     return FALSE;
12006
12007   if ((isec->output_section->flags & SEC_CODE) != 0
12008       && isec->output_section->id < htab->sec_info_arr_size)
12009     {
12010       /* This happens to make the list in reverse order,
12011          which is what we want.  */
12012       htab->sec_info[isec->id].u.list
12013         = htab->sec_info[isec->output_section->id].u.list;
12014       htab->sec_info[isec->output_section->id].u.list = isec;
12015     }
12016
12017   if (htab->multi_toc_needed)
12018     {
12019       /* Analyse sections that aren't already flagged as needing a
12020          valid toc pointer.  Exclude .fixup for the linux kernel.
12021          .fixup contains branches, but only back to the function that
12022          hit an exception.  */
12023       if (!(isec->has_toc_reloc
12024             || (isec->flags & SEC_CODE) == 0
12025             || strcmp (isec->name, ".fixup") == 0
12026             || isec->call_check_done))
12027         {
12028           if (toc_adjusting_stub_needed (info, isec) < 0)
12029             return FALSE;
12030         }
12031       /* Make all sections use the TOC assigned for this object file.
12032          This will be wrong for pasted sections;  We fix that in
12033          check_pasted_section().  */
12034       if (elf_gp (isec->owner) != 0)
12035         htab->toc_curr = elf_gp (isec->owner);
12036     }
12037
12038   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12039   return TRUE;
12040 }
12041
12042 /* Check that all .init and .fini sections use the same toc, if they
12043    have toc relocs.  */
12044
12045 static bfd_boolean
12046 check_pasted_section (struct bfd_link_info *info, const char *name)
12047 {
12048   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12049
12050   if (o != NULL)
12051     {
12052       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12053       bfd_vma toc_off = 0;
12054       asection *i;
12055
12056       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12057         if (i->has_toc_reloc)
12058           {
12059             if (toc_off == 0)
12060               toc_off = htab->sec_info[i->id].toc_off;
12061             else if (toc_off != htab->sec_info[i->id].toc_off)
12062               return FALSE;
12063           }
12064
12065       if (toc_off == 0)
12066         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12067           if (i->makes_toc_func_call)
12068             {
12069               toc_off = htab->sec_info[i->id].toc_off;
12070               break;
12071             }
12072
12073       /* Make sure the whole pasted function uses the same toc offset.  */
12074       if (toc_off != 0)
12075         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12076           htab->sec_info[i->id].toc_off = toc_off;
12077     }
12078   return TRUE;
12079 }
12080
12081 bfd_boolean
12082 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12083 {
12084   return (check_pasted_section (info, ".init")
12085           & check_pasted_section (info, ".fini"));
12086 }
12087
12088 /* See whether we can group stub sections together.  Grouping stub
12089    sections may result in fewer stubs.  More importantly, we need to
12090    put all .init* and .fini* stubs at the beginning of the .init or
12091    .fini output sections respectively, because glibc splits the
12092    _init and _fini functions into multiple parts.  Putting a stub in
12093    the middle of a function is not a good idea.  */
12094
12095 static bfd_boolean
12096 group_sections (struct bfd_link_info *info,
12097                 bfd_size_type stub_group_size,
12098                 bfd_boolean stubs_always_before_branch)
12099 {
12100   struct ppc_link_hash_table *htab;
12101   asection *osec;
12102   bfd_boolean suppress_size_errors;
12103
12104   htab = ppc_hash_table (info);
12105   if (htab == NULL)
12106     return FALSE;
12107
12108   suppress_size_errors = FALSE;
12109   if (stub_group_size == 1)
12110     {
12111       /* Default values.  */
12112       if (stubs_always_before_branch)
12113         stub_group_size = 0x1e00000;
12114       else
12115         stub_group_size = 0x1c00000;
12116       suppress_size_errors = TRUE;
12117     }
12118
12119   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12120     {
12121       asection *tail;
12122
12123       if (osec->id >= htab->sec_info_arr_size)
12124         continue;
12125
12126       tail = htab->sec_info[osec->id].u.list;
12127       while (tail != NULL)
12128         {
12129           asection *curr;
12130           asection *prev;
12131           bfd_size_type total;
12132           bfd_boolean big_sec;
12133           bfd_vma curr_toc;
12134           struct map_stub *group;
12135           bfd_size_type group_size;
12136
12137           curr = tail;
12138           total = tail->size;
12139           group_size = (ppc64_elf_section_data (tail) != NULL
12140                         && ppc64_elf_section_data (tail)->has_14bit_branch
12141                         ? stub_group_size >> 10 : stub_group_size);
12142
12143           big_sec = total > group_size;
12144           if (big_sec && !suppress_size_errors)
12145             /* xgettext:c-format */
12146             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12147                                 tail->owner, tail);
12148           curr_toc = htab->sec_info[tail->id].toc_off;
12149
12150           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12151                  && ((total += curr->output_offset - prev->output_offset)
12152                      < (ppc64_elf_section_data (prev) != NULL
12153                         && ppc64_elf_section_data (prev)->has_14bit_branch
12154                         ? (group_size = stub_group_size >> 10) : group_size))
12155                  && htab->sec_info[prev->id].toc_off == curr_toc)
12156             curr = prev;
12157
12158           /* OK, the size from the start of CURR to the end is less
12159              than group_size and thus can be handled by one stub
12160              section.  (or the tail section is itself larger than
12161              group_size, in which case we may be toast.)  We should
12162              really be keeping track of the total size of stubs added
12163              here, as stubs contribute to the final output section
12164              size.  That's a little tricky, and this way will only
12165              break if stubs added make the total size more than 2^25,
12166              ie. for the default stub_group_size, if stubs total more
12167              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12168           group = bfd_alloc (curr->owner, sizeof (*group));
12169           if (group == NULL)
12170             return FALSE;
12171           group->link_sec = curr;
12172           group->stub_sec = NULL;
12173           group->needs_save_res = 0;
12174           group->tls_get_addr_opt_bctrl = -1u;
12175           group->next = htab->group;
12176           htab->group = group;
12177           do
12178             {
12179               prev = htab->sec_info[tail->id].u.list;
12180               /* Set up this stub group.  */
12181               htab->sec_info[tail->id].u.group = group;
12182             }
12183           while (tail != curr && (tail = prev) != NULL);
12184
12185           /* But wait, there's more!  Input sections up to group_size
12186              bytes before the stub section can be handled by it too.
12187              Don't do this if we have a really large section after the
12188              stubs, as adding more stubs increases the chance that
12189              branches may not reach into the stub section.  */
12190           if (!stubs_always_before_branch && !big_sec)
12191             {
12192               total = 0;
12193               while (prev != NULL
12194                      && ((total += tail->output_offset - prev->output_offset)
12195                          < (ppc64_elf_section_data (prev) != NULL
12196                             && ppc64_elf_section_data (prev)->has_14bit_branch
12197                             ? (group_size = stub_group_size >> 10) : group_size))
12198                      && htab->sec_info[prev->id].toc_off == curr_toc)
12199                 {
12200                   tail = prev;
12201                   prev = htab->sec_info[tail->id].u.list;
12202                   htab->sec_info[tail->id].u.group = group;
12203                 }
12204             }
12205           tail = prev;
12206         }
12207     }
12208   return TRUE;
12209 }
12210
12211 static const unsigned char glink_eh_frame_cie[] =
12212 {
12213   0, 0, 0, 16,                          /* length.  */
12214   0, 0, 0, 0,                           /* id.  */
12215   1,                                    /* CIE version.  */
12216   'z', 'R', 0,                          /* Augmentation string.  */
12217   4,                                    /* Code alignment.  */
12218   0x78,                                 /* Data alignment.  */
12219   65,                                   /* RA reg.  */
12220   1,                                    /* Augmentation size.  */
12221   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12222   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12223 };
12224
12225 static size_t
12226 stub_eh_frame_size (struct map_stub *group, size_t align)
12227 {
12228   size_t this_size = 17;
12229   if (group->tls_get_addr_opt_bctrl != -1u)
12230     {
12231       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12232       if (to_bctrl < 64)
12233         this_size += 1;
12234       else if (to_bctrl < 256)
12235         this_size += 2;
12236       else if (to_bctrl < 65536)
12237         this_size += 3;
12238       else
12239         this_size += 5;
12240       this_size += 6;
12241     }
12242   this_size = (this_size + align - 1) & -align;
12243   return this_size;
12244 }
12245
12246 /* Stripping output sections is normally done before dynamic section
12247    symbols have been allocated.  This function is called later, and
12248    handles cases like htab->brlt which is mapped to its own output
12249    section.  */
12250
12251 static void
12252 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12253 {
12254   if (isec->size == 0
12255       && isec->output_section->size == 0
12256       && !(isec->output_section->flags & SEC_KEEP)
12257       && !bfd_section_removed_from_list (info->output_bfd,
12258                                          isec->output_section)
12259       && elf_section_data (isec->output_section)->dynindx == 0)
12260     {
12261       isec->output_section->flags |= SEC_EXCLUDE;
12262       bfd_section_list_remove (info->output_bfd, isec->output_section);
12263       info->output_bfd->section_count--;
12264     }
12265 }
12266
12267 /* Determine and set the size of the stub section for a final link.
12268
12269    The basic idea here is to examine all the relocations looking for
12270    PC-relative calls to a target that is unreachable with a "bl"
12271    instruction.  */
12272
12273 bfd_boolean
12274 ppc64_elf_size_stubs (struct bfd_link_info *info)
12275 {
12276   bfd_size_type stub_group_size;
12277   bfd_boolean stubs_always_before_branch;
12278   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12279
12280   if (htab == NULL)
12281     return FALSE;
12282
12283   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12284     htab->params->plt_thread_safe = 1;
12285   if (!htab->opd_abi)
12286     htab->params->plt_thread_safe = 0;
12287   else if (htab->params->plt_thread_safe == -1)
12288     {
12289       static const char *const thread_starter[] =
12290         {
12291           "pthread_create",
12292           /* libstdc++ */
12293           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12294           /* librt */
12295           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12296           "mq_notify", "create_timer",
12297           /* libanl */
12298           "getaddrinfo_a",
12299           /* libgomp */
12300           "GOMP_parallel",
12301           "GOMP_parallel_start",
12302           "GOMP_parallel_loop_static",
12303           "GOMP_parallel_loop_static_start",
12304           "GOMP_parallel_loop_dynamic",
12305           "GOMP_parallel_loop_dynamic_start",
12306           "GOMP_parallel_loop_guided",
12307           "GOMP_parallel_loop_guided_start",
12308           "GOMP_parallel_loop_runtime",
12309           "GOMP_parallel_loop_runtime_start",
12310           "GOMP_parallel_sections",
12311           "GOMP_parallel_sections_start",
12312           /* libgo */
12313           "__go_go",
12314         };
12315       unsigned i;
12316
12317       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12318         {
12319           struct elf_link_hash_entry *h;
12320           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12321                                     FALSE, FALSE, TRUE);
12322           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12323           if (htab->params->plt_thread_safe)
12324             break;
12325         }
12326     }
12327   stubs_always_before_branch = htab->params->group_size < 0;
12328   if (htab->params->group_size < 0)
12329     stub_group_size = -htab->params->group_size;
12330   else
12331     stub_group_size = htab->params->group_size;
12332
12333   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12334     return FALSE;
12335
12336 #define STUB_SHRINK_ITER 20
12337   /* Loop until no stubs added.  After iteration 20 of this loop we may
12338      exit on a stub section shrinking.  This is to break out of a
12339      pathological case where adding stubs on one iteration decreases
12340      section gaps (perhaps due to alignment), which then requires
12341      fewer or smaller stubs on the next iteration.  */
12342
12343   while (1)
12344     {
12345       bfd *input_bfd;
12346       unsigned int bfd_indx;
12347       struct map_stub *group;
12348
12349       htab->stub_iteration += 1;
12350
12351       for (input_bfd = info->input_bfds, bfd_indx = 0;
12352            input_bfd != NULL;
12353            input_bfd = input_bfd->link.next, bfd_indx++)
12354         {
12355           Elf_Internal_Shdr *symtab_hdr;
12356           asection *section;
12357           Elf_Internal_Sym *local_syms = NULL;
12358
12359           if (!is_ppc64_elf (input_bfd))
12360             continue;
12361
12362           /* We'll need the symbol table in a second.  */
12363           symtab_hdr = &elf_symtab_hdr (input_bfd);
12364           if (symtab_hdr->sh_info == 0)
12365             continue;
12366
12367           /* Walk over each section attached to the input bfd.  */
12368           for (section = input_bfd->sections;
12369                section != NULL;
12370                section = section->next)
12371             {
12372               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12373
12374               /* If there aren't any relocs, then there's nothing more
12375                  to do.  */
12376               if ((section->flags & SEC_RELOC) == 0
12377                   || (section->flags & SEC_ALLOC) == 0
12378                   || (section->flags & SEC_LOAD) == 0
12379                   || (section->flags & SEC_CODE) == 0
12380                   || section->reloc_count == 0)
12381                 continue;
12382
12383               /* If this section is a link-once section that will be
12384                  discarded, then don't create any stubs.  */
12385               if (section->output_section == NULL
12386                   || section->output_section->owner != info->output_bfd)
12387                 continue;
12388
12389               /* Get the relocs.  */
12390               internal_relocs
12391                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12392                                              info->keep_memory);
12393               if (internal_relocs == NULL)
12394                 goto error_ret_free_local;
12395
12396               /* Now examine each relocation.  */
12397               irela = internal_relocs;
12398               irelaend = irela + section->reloc_count;
12399               for (; irela < irelaend; irela++)
12400                 {
12401                   enum elf_ppc64_reloc_type r_type;
12402                   unsigned int r_indx;
12403                   enum ppc_stub_type stub_type;
12404                   struct ppc_stub_hash_entry *stub_entry;
12405                   asection *sym_sec, *code_sec;
12406                   bfd_vma sym_value, code_value;
12407                   bfd_vma destination;
12408                   unsigned long local_off;
12409                   bfd_boolean ok_dest;
12410                   struct ppc_link_hash_entry *hash;
12411                   struct ppc_link_hash_entry *fdh;
12412                   struct elf_link_hash_entry *h;
12413                   Elf_Internal_Sym *sym;
12414                   char *stub_name;
12415                   const asection *id_sec;
12416                   struct _opd_sec_data *opd;
12417                   struct plt_entry *plt_ent;
12418
12419                   r_type = ELF64_R_TYPE (irela->r_info);
12420                   r_indx = ELF64_R_SYM (irela->r_info);
12421
12422                   if (r_type >= R_PPC64_max)
12423                     {
12424                       bfd_set_error (bfd_error_bad_value);
12425                       goto error_ret_free_internal;
12426                     }
12427
12428                   /* Only look for stubs on branch instructions.  */
12429                   if (r_type != R_PPC64_REL24
12430                       && r_type != R_PPC64_REL14
12431                       && r_type != R_PPC64_REL14_BRTAKEN
12432                       && r_type != R_PPC64_REL14_BRNTAKEN)
12433                     continue;
12434
12435                   /* Now determine the call target, its name, value,
12436                      section.  */
12437                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12438                                   r_indx, input_bfd))
12439                     goto error_ret_free_internal;
12440                   hash = (struct ppc_link_hash_entry *) h;
12441
12442                   ok_dest = FALSE;
12443                   fdh = NULL;
12444                   sym_value = 0;
12445                   if (hash == NULL)
12446                     {
12447                       sym_value = sym->st_value;
12448                       if (sym_sec != NULL
12449                           && sym_sec->output_section != NULL)
12450                         ok_dest = TRUE;
12451                     }
12452                   else if (hash->elf.root.type == bfd_link_hash_defined
12453                            || hash->elf.root.type == bfd_link_hash_defweak)
12454                     {
12455                       sym_value = hash->elf.root.u.def.value;
12456                       if (sym_sec->output_section != NULL)
12457                         ok_dest = TRUE;
12458                     }
12459                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12460                            || hash->elf.root.type == bfd_link_hash_undefined)
12461                     {
12462                       /* Recognise an old ABI func code entry sym, and
12463                          use the func descriptor sym instead if it is
12464                          defined.  */
12465                       if (hash->elf.root.root.string[0] == '.'
12466                           && hash->oh != NULL)
12467                         {
12468                           fdh = ppc_follow_link (hash->oh);
12469                           if (fdh->elf.root.type == bfd_link_hash_defined
12470                               || fdh->elf.root.type == bfd_link_hash_defweak)
12471                             {
12472                               sym_sec = fdh->elf.root.u.def.section;
12473                               sym_value = fdh->elf.root.u.def.value;
12474                               if (sym_sec->output_section != NULL)
12475                                 ok_dest = TRUE;
12476                             }
12477                           else
12478                             fdh = NULL;
12479                         }
12480                     }
12481                   else
12482                     {
12483                       bfd_set_error (bfd_error_bad_value);
12484                       goto error_ret_free_internal;
12485                     }
12486
12487                   destination = 0;
12488                   local_off = 0;
12489                   if (ok_dest)
12490                     {
12491                       sym_value += irela->r_addend;
12492                       destination = (sym_value
12493                                      + sym_sec->output_offset
12494                                      + sym_sec->output_section->vma);
12495                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12496                                                             ? hash->elf.other
12497                                                             : sym->st_other);
12498                     }
12499
12500                   code_sec = sym_sec;
12501                   code_value = sym_value;
12502                   opd = get_opd_info (sym_sec);
12503                   if (opd != NULL)
12504                     {
12505                       bfd_vma dest;
12506
12507                       if (hash == NULL && opd->adjust != NULL)
12508                         {
12509                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12510                           if (adjust == -1)
12511                             continue;
12512                           code_value += adjust;
12513                           sym_value += adjust;
12514                         }
12515                       dest = opd_entry_value (sym_sec, sym_value,
12516                                               &code_sec, &code_value, FALSE);
12517                       if (dest != (bfd_vma) -1)
12518                         {
12519                           destination = dest;
12520                           if (fdh != NULL)
12521                             {
12522                               /* Fixup old ABI sym to point at code
12523                                  entry.  */
12524                               hash->elf.root.type = bfd_link_hash_defweak;
12525                               hash->elf.root.u.def.section = code_sec;
12526                               hash->elf.root.u.def.value = code_value;
12527                             }
12528                         }
12529                     }
12530
12531                   /* Determine what (if any) linker stub is needed.  */
12532                   plt_ent = NULL;
12533                   stub_type = ppc_type_of_stub (section, irela, &hash,
12534                                                 &plt_ent, destination,
12535                                                 local_off);
12536
12537                   if (stub_type != ppc_stub_plt_call)
12538                     {
12539                       /* Check whether we need a TOC adjusting stub.
12540                          Since the linker pastes together pieces from
12541                          different object files when creating the
12542                          _init and _fini functions, it may be that a
12543                          call to what looks like a local sym is in
12544                          fact a call needing a TOC adjustment.  */
12545                       if (code_sec != NULL
12546                           && code_sec->output_section != NULL
12547                           && (htab->sec_info[code_sec->id].toc_off
12548                               != htab->sec_info[section->id].toc_off)
12549                           && (code_sec->has_toc_reloc
12550                               || code_sec->makes_toc_func_call))
12551                         stub_type = ppc_stub_long_branch_r2off;
12552                     }
12553
12554                   if (stub_type == ppc_stub_none)
12555                     continue;
12556
12557                   /* __tls_get_addr calls might be eliminated.  */
12558                   if (stub_type != ppc_stub_plt_call
12559                       && hash != NULL
12560                       && (hash == htab->tls_get_addr
12561                           || hash == htab->tls_get_addr_fd)
12562                       && section->has_tls_reloc
12563                       && irela != internal_relocs)
12564                     {
12565                       /* Get tls info.  */
12566                       unsigned char *tls_mask;
12567
12568                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12569                                          irela - 1, input_bfd))
12570                         goto error_ret_free_internal;
12571                       if (*tls_mask != 0)
12572                         continue;
12573                     }
12574
12575                   if (stub_type == ppc_stub_plt_call)
12576                     {
12577                       if (!htab->opd_abi
12578                           && htab->params->plt_localentry0 != 0
12579                           && is_elfv2_localentry0 (&hash->elf))
12580                         htab->has_plt_localentry0 = 1;
12581                       else if (irela + 1 < irelaend
12582                                && irela[1].r_offset == irela->r_offset + 4
12583                                && (ELF64_R_TYPE (irela[1].r_info)
12584                                    == R_PPC64_TOCSAVE))
12585                         {
12586                           if (!tocsave_find (htab, INSERT,
12587                                              &local_syms, irela + 1, input_bfd))
12588                             goto error_ret_free_internal;
12589                         }
12590                       else
12591                         stub_type = ppc_stub_plt_call_r2save;
12592                     }
12593
12594                   /* Support for grouping stub sections.  */
12595                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12596
12597                   /* Get the name of this stub.  */
12598                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12599                   if (!stub_name)
12600                     goto error_ret_free_internal;
12601
12602                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12603                                                      stub_name, FALSE, FALSE);
12604                   if (stub_entry != NULL)
12605                     {
12606                       /* The proper stub has already been created.  */
12607                       free (stub_name);
12608                       if (stub_type == ppc_stub_plt_call_r2save)
12609                         stub_entry->stub_type = stub_type;
12610                       continue;
12611                     }
12612
12613                   stub_entry = ppc_add_stub (stub_name, section, info);
12614                   if (stub_entry == NULL)
12615                     {
12616                       free (stub_name);
12617                     error_ret_free_internal:
12618                       if (elf_section_data (section)->relocs == NULL)
12619                         free (internal_relocs);
12620                     error_ret_free_local:
12621                       if (local_syms != NULL
12622                           && (symtab_hdr->contents
12623                               != (unsigned char *) local_syms))
12624                         free (local_syms);
12625                       return FALSE;
12626                     }
12627
12628                   stub_entry->stub_type = stub_type;
12629                   if (stub_type != ppc_stub_plt_call
12630                       && stub_type != ppc_stub_plt_call_r2save)
12631                     {
12632                       stub_entry->target_value = code_value;
12633                       stub_entry->target_section = code_sec;
12634                     }
12635                   else
12636                     {
12637                       stub_entry->target_value = sym_value;
12638                       stub_entry->target_section = sym_sec;
12639                     }
12640                   stub_entry->h = hash;
12641                   stub_entry->plt_ent = plt_ent;
12642                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12643
12644                   if (stub_entry->h != NULL)
12645                     htab->stub_globals += 1;
12646                 }
12647
12648               /* We're done with the internal relocs, free them.  */
12649               if (elf_section_data (section)->relocs != internal_relocs)
12650                 free (internal_relocs);
12651             }
12652
12653           if (local_syms != NULL
12654               && symtab_hdr->contents != (unsigned char *) local_syms)
12655             {
12656               if (!info->keep_memory)
12657                 free (local_syms);
12658               else
12659                 symtab_hdr->contents = (unsigned char *) local_syms;
12660             }
12661         }
12662
12663       /* We may have added some stubs.  Find out the new size of the
12664          stub sections.  */
12665       for (group = htab->group; group != NULL; group = group->next)
12666         if (group->stub_sec != NULL)
12667           {
12668             asection *stub_sec = group->stub_sec;
12669
12670             if (htab->stub_iteration <= STUB_SHRINK_ITER
12671                 || stub_sec->rawsize < stub_sec->size)
12672               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12673               stub_sec->rawsize = stub_sec->size;
12674             stub_sec->size = 0;
12675             stub_sec->reloc_count = 0;
12676             stub_sec->flags &= ~SEC_RELOC;
12677           }
12678
12679       if (htab->stub_iteration <= STUB_SHRINK_ITER
12680           || htab->brlt->rawsize < htab->brlt->size)
12681         htab->brlt->rawsize = htab->brlt->size;
12682       htab->brlt->size = 0;
12683       htab->brlt->reloc_count = 0;
12684       htab->brlt->flags &= ~SEC_RELOC;
12685       if (htab->relbrlt != NULL)
12686         htab->relbrlt->size = 0;
12687
12688       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12689
12690       for (group = htab->group; group != NULL; group = group->next)
12691         if (group->needs_save_res)
12692           group->stub_sec->size += htab->sfpr->size;
12693
12694       if (info->emitrelocations
12695           && htab->glink != NULL && htab->glink->size != 0)
12696         {
12697           htab->glink->reloc_count = 1;
12698           htab->glink->flags |= SEC_RELOC;
12699         }
12700
12701       if (htab->glink_eh_frame != NULL
12702           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12703           && htab->glink_eh_frame->output_section->size > 8)
12704         {
12705           size_t size = 0, align = 4;
12706
12707           for (group = htab->group; group != NULL; group = group->next)
12708             if (group->stub_sec != NULL)
12709               size += stub_eh_frame_size (group, align);
12710           if (htab->glink != NULL && htab->glink->size != 0)
12711             size += (24 + align - 1) & -align;
12712           if (size != 0)
12713             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12714           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12715           size = (size + align - 1) & -align;
12716           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12717           htab->glink_eh_frame->size = size;
12718         }
12719
12720       if (htab->params->plt_stub_align != 0)
12721         for (group = htab->group; group != NULL; group = group->next)
12722           if (group->stub_sec != NULL)
12723             {
12724               int align = abs (htab->params->plt_stub_align);
12725               group->stub_sec->size
12726                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
12727             }
12728
12729       for (group = htab->group; group != NULL; group = group->next)
12730         if (group->stub_sec != NULL
12731             && group->stub_sec->rawsize != group->stub_sec->size
12732             && (htab->stub_iteration <= STUB_SHRINK_ITER
12733                 || group->stub_sec->rawsize < group->stub_sec->size))
12734           break;
12735
12736       if (group == NULL
12737           && (htab->brlt->rawsize == htab->brlt->size
12738               || (htab->stub_iteration > STUB_SHRINK_ITER
12739                   && htab->brlt->rawsize > htab->brlt->size))
12740           && (htab->glink_eh_frame == NULL
12741               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12742         break;
12743
12744       /* Ask the linker to do its stuff.  */
12745       (*htab->params->layout_sections_again) ();
12746     }
12747
12748   if (htab->glink_eh_frame != NULL
12749       && htab->glink_eh_frame->size != 0)
12750     {
12751       bfd_vma val;
12752       bfd_byte *p, *last_fde;
12753       size_t last_fde_len, size, align, pad;
12754       struct map_stub *group;
12755
12756       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12757       if (p == NULL)
12758         return FALSE;
12759       htab->glink_eh_frame->contents = p;
12760       last_fde = p;
12761       align = 4;
12762
12763       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12764       /* CIE length (rewrite in case little-endian).  */
12765       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12766       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12767       p += last_fde_len + 4;
12768
12769       for (group = htab->group; group != NULL; group = group->next)
12770         if (group->stub_sec != NULL)
12771           {
12772             last_fde = p;
12773             last_fde_len = stub_eh_frame_size (group, align) - 4;
12774             /* FDE length.  */
12775             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12776             p += 4;
12777             /* CIE pointer.  */
12778             val = p - htab->glink_eh_frame->contents;
12779             bfd_put_32 (htab->elf.dynobj, val, p);
12780             p += 4;
12781             /* Offset to stub section, written later.  */
12782             p += 4;
12783             /* stub section size.  */
12784             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12785             p += 4;
12786             /* Augmentation.  */
12787             p += 1;
12788             if (group->tls_get_addr_opt_bctrl != -1u)
12789               {
12790                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12791
12792                 /* This FDE needs more than just the default.
12793                    Describe __tls_get_addr_opt stub LR.  */
12794                 if (to_bctrl < 64)
12795                   *p++ = DW_CFA_advance_loc + to_bctrl;
12796                 else if (to_bctrl < 256)
12797                   {
12798                     *p++ = DW_CFA_advance_loc1;
12799                     *p++ = to_bctrl;
12800                   }
12801                 else if (to_bctrl < 65536)
12802                   {
12803                     *p++ = DW_CFA_advance_loc2;
12804                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12805                     p += 2;
12806                   }
12807                 else
12808                   {
12809                     *p++ = DW_CFA_advance_loc4;
12810                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12811                     p += 4;
12812                   }
12813                 *p++ = DW_CFA_offset_extended_sf;
12814                 *p++ = 65;
12815                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12816                 *p++ = DW_CFA_advance_loc + 4;
12817                 *p++ = DW_CFA_restore_extended;
12818                 *p++ = 65;
12819               }
12820             /* Pad.  */
12821             p = last_fde + last_fde_len + 4;
12822           }
12823       if (htab->glink != NULL && htab->glink->size != 0)
12824         {
12825           last_fde = p;
12826           last_fde_len = ((24 + align - 1) & -align) - 4;
12827           /* FDE length.  */
12828           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12829           p += 4;
12830           /* CIE pointer.  */
12831           val = p - htab->glink_eh_frame->contents;
12832           bfd_put_32 (htab->elf.dynobj, val, p);
12833           p += 4;
12834           /* Offset to .glink, written later.  */
12835           p += 4;
12836           /* .glink size.  */
12837           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12838           p += 4;
12839           /* Augmentation.  */
12840           p += 1;
12841
12842           *p++ = DW_CFA_advance_loc + 1;
12843           *p++ = DW_CFA_register;
12844           *p++ = 65;
12845           *p++ = htab->opd_abi ? 12 : 0;
12846           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12847           *p++ = DW_CFA_restore_extended;
12848           *p++ = 65;
12849           p += ((24 + align - 1) & -align) - 24;
12850         }
12851       /* Subsume any padding into the last FDE if user .eh_frame
12852          sections are aligned more than glink_eh_frame.  Otherwise any
12853          zero padding will be seen as a terminator.  */
12854       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12855       size = p - htab->glink_eh_frame->contents;
12856       pad = ((size + align - 1) & -align) - size;
12857       htab->glink_eh_frame->size = size + pad;
12858       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12859     }
12860
12861   maybe_strip_output (info, htab->brlt);
12862   if (htab->glink_eh_frame != NULL)
12863     maybe_strip_output (info, htab->glink_eh_frame);
12864
12865   return TRUE;
12866 }
12867
12868 /* Called after we have determined section placement.  If sections
12869    move, we'll be called again.  Provide a value for TOCstart.  */
12870
12871 bfd_vma
12872 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12873 {
12874   asection *s;
12875   bfd_vma TOCstart, adjust;
12876
12877   if (info != NULL)
12878     {
12879       struct elf_link_hash_entry *h;
12880       struct elf_link_hash_table *htab = elf_hash_table (info);
12881
12882       if (is_elf_hash_table (htab)
12883           && htab->hgot != NULL)
12884         h = htab->hgot;
12885       else
12886         {
12887           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12888           if (is_elf_hash_table (htab))
12889             htab->hgot = h;
12890         }
12891       if (h != NULL
12892           && h->root.type == bfd_link_hash_defined
12893           && !h->root.linker_def
12894           && (!is_elf_hash_table (htab)
12895               || h->def_regular))
12896         {
12897           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12898                       + h->root.u.def.section->output_offset
12899                       + h->root.u.def.section->output_section->vma);
12900           _bfd_set_gp_value (obfd, TOCstart);
12901           return TOCstart;
12902         }
12903     }
12904
12905   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12906      order.  The TOC starts where the first of these sections starts.  */
12907   s = bfd_get_section_by_name (obfd, ".got");
12908   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12909     s = bfd_get_section_by_name (obfd, ".toc");
12910   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12911     s = bfd_get_section_by_name (obfd, ".tocbss");
12912   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12913     s = bfd_get_section_by_name (obfd, ".plt");
12914   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12915     {
12916       /* This may happen for
12917          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12918          .toc directive
12919          o  bad linker script
12920          o --gc-sections and empty TOC sections
12921
12922          FIXME: Warn user?  */
12923
12924       /* Look for a likely section.  We probably won't even be
12925          using TOCstart.  */
12926       for (s = obfd->sections; s != NULL; s = s->next)
12927         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12928                          | SEC_EXCLUDE))
12929             == (SEC_ALLOC | SEC_SMALL_DATA))
12930           break;
12931       if (s == NULL)
12932         for (s = obfd->sections; s != NULL; s = s->next)
12933           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12934               == (SEC_ALLOC | SEC_SMALL_DATA))
12935             break;
12936       if (s == NULL)
12937         for (s = obfd->sections; s != NULL; s = s->next)
12938           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12939               == SEC_ALLOC)
12940             break;
12941       if (s == NULL)
12942         for (s = obfd->sections; s != NULL; s = s->next)
12943           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12944             break;
12945     }
12946
12947   TOCstart = 0;
12948   if (s != NULL)
12949     TOCstart = s->output_section->vma + s->output_offset;
12950
12951   /* Force alignment.  */
12952   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12953   TOCstart -= adjust;
12954   _bfd_set_gp_value (obfd, TOCstart);
12955
12956   if (info != NULL && s != NULL)
12957     {
12958       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12959
12960       if (htab != NULL)
12961         {
12962           if (htab->elf.hgot != NULL)
12963             {
12964               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12965               htab->elf.hgot->root.u.def.section = s;
12966             }
12967         }
12968       else
12969         {
12970           struct bfd_link_hash_entry *bh = NULL;
12971           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12972                                             s, TOC_BASE_OFF - adjust,
12973                                             NULL, FALSE, FALSE, &bh);
12974         }
12975     }
12976   return TOCstart;
12977 }
12978
12979 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12980    write out any global entry stubs.  */
12981
12982 static bfd_boolean
12983 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12984 {
12985   struct bfd_link_info *info;
12986   struct ppc_link_hash_table *htab;
12987   struct plt_entry *pent;
12988   asection *s;
12989
12990   if (h->root.type == bfd_link_hash_indirect)
12991     return TRUE;
12992
12993   if (!h->pointer_equality_needed)
12994     return TRUE;
12995
12996   if (h->def_regular)
12997     return TRUE;
12998
12999   info = inf;
13000   htab = ppc_hash_table (info);
13001   if (htab == NULL)
13002     return FALSE;
13003
13004   s = htab->global_entry;
13005   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13006     if (pent->plt.offset != (bfd_vma) -1
13007         && pent->addend == 0)
13008       {
13009         bfd_byte *p;
13010         asection *plt;
13011         bfd_vma off;
13012
13013         p = s->contents + h->root.u.def.value;
13014         plt = htab->elf.splt;
13015         if (!htab->elf.dynamic_sections_created
13016             || h->dynindx == -1)
13017           plt = htab->elf.iplt;
13018         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13019         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13020
13021         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13022           {
13023             info->callbacks->einfo
13024               (_("%P: linkage table error against `%pT'\n"),
13025                h->root.root.string);
13026             bfd_set_error (bfd_error_bad_value);
13027             htab->stub_error = TRUE;
13028           }
13029
13030         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13031         if (htab->params->emit_stub_syms)
13032           {
13033             size_t len = strlen (h->root.root.string);
13034             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13035
13036             if (name == NULL)
13037               return FALSE;
13038
13039             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13040             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13041             if (h == NULL)
13042               return FALSE;
13043             if (h->root.type == bfd_link_hash_new)
13044               {
13045                 h->root.type = bfd_link_hash_defined;
13046                 h->root.u.def.section = s;
13047                 h->root.u.def.value = p - s->contents;
13048                 h->ref_regular = 1;
13049                 h->def_regular = 1;
13050                 h->ref_regular_nonweak = 1;
13051                 h->forced_local = 1;
13052                 h->non_elf = 0;
13053                 h->root.linker_def = 1;
13054               }
13055           }
13056
13057         if (PPC_HA (off) != 0)
13058           {
13059             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13060             p += 4;
13061           }
13062         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13063         p += 4;
13064         bfd_put_32 (s->owner, MTCTR_R12, p);
13065         p += 4;
13066         bfd_put_32 (s->owner, BCTR, p);
13067         break;
13068       }
13069   return TRUE;
13070 }
13071
13072 /* Build all the stubs associated with the current output file.
13073    The stubs are kept in a hash table attached to the main linker
13074    hash table.  This function is called via gldelf64ppc_finish.  */
13075
13076 bfd_boolean
13077 ppc64_elf_build_stubs (struct bfd_link_info *info,
13078                        char **stats)
13079 {
13080   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13081   struct map_stub *group;
13082   asection *stub_sec;
13083   bfd_byte *p;
13084   int stub_sec_count = 0;
13085
13086   if (htab == NULL)
13087     return FALSE;
13088
13089   /* Allocate memory to hold the linker stubs.  */
13090   for (group = htab->group; group != NULL; group = group->next)
13091     if ((stub_sec = group->stub_sec) != NULL
13092         && stub_sec->size != 0)
13093       {
13094         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13095         if (stub_sec->contents == NULL)
13096           return FALSE;
13097         stub_sec->size = 0;
13098       }
13099
13100   if (htab->glink != NULL && htab->glink->size != 0)
13101     {
13102       unsigned int indx;
13103       bfd_vma plt0;
13104
13105       /* Build the .glink plt call stub.  */
13106       if (htab->params->emit_stub_syms)
13107         {
13108           struct elf_link_hash_entry *h;
13109           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13110                                     TRUE, FALSE, FALSE);
13111           if (h == NULL)
13112             return FALSE;
13113           if (h->root.type == bfd_link_hash_new)
13114             {
13115               h->root.type = bfd_link_hash_defined;
13116               h->root.u.def.section = htab->glink;
13117               h->root.u.def.value = 8;
13118               h->ref_regular = 1;
13119               h->def_regular = 1;
13120               h->ref_regular_nonweak = 1;
13121               h->forced_local = 1;
13122               h->non_elf = 0;
13123               h->root.linker_def = 1;
13124             }
13125         }
13126       plt0 = (htab->elf.splt->output_section->vma
13127               + htab->elf.splt->output_offset
13128               - 16);
13129       if (info->emitrelocations)
13130         {
13131           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13132           if (r == NULL)
13133             return FALSE;
13134           r->r_offset = (htab->glink->output_offset
13135                          + htab->glink->output_section->vma);
13136           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13137           r->r_addend = plt0;
13138         }
13139       p = htab->glink->contents;
13140       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13141       bfd_put_64 (htab->glink->owner, plt0, p);
13142       p += 8;
13143       if (htab->opd_abi)
13144         {
13145           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13146           p += 4;
13147           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13148           p += 4;
13149           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13150           p += 4;
13151           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13152           p += 4;
13153           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13154           p += 4;
13155           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13156           p += 4;
13157           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13158           p += 4;
13159           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13160           p += 4;
13161           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13162           p += 4;
13163           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13164           p += 4;
13165         }
13166       else
13167         {
13168           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13169           p += 4;
13170           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13171           p += 4;
13172           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13173           p += 4;
13174           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13175           p += 4;
13176           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13177           p += 4;
13178           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13179           p += 4;
13180           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13181           p += 4;
13182           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13183           p += 4;
13184           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13185           p += 4;
13186           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13187           p += 4;
13188           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13189           p += 4;
13190           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13191           p += 4;
13192           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13193           p += 4;
13194         }
13195       bfd_put_32 (htab->glink->owner, BCTR, p);
13196       p += 4;
13197       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13198
13199       /* Build the .glink lazy link call stubs.  */
13200       indx = 0;
13201       while (p < htab->glink->contents + htab->glink->size)
13202         {
13203           if (htab->opd_abi)
13204             {
13205               if (indx < 0x8000)
13206                 {
13207                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13208                   p += 4;
13209                 }
13210               else
13211                 {
13212                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13213                   p += 4;
13214                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13215                               p);
13216                   p += 4;
13217                 }
13218             }
13219           bfd_put_32 (htab->glink->owner,
13220                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13221           indx++;
13222           p += 4;
13223         }
13224     }
13225
13226   /* Build .glink global entry stubs.  */
13227   if (htab->global_entry != NULL && htab->global_entry->size != 0)
13228     elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13229
13230   if (htab->brlt != NULL && htab->brlt->size != 0)
13231     {
13232       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13233                                          htab->brlt->size);
13234       if (htab->brlt->contents == NULL)
13235         return FALSE;
13236     }
13237   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13238     {
13239       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13240                                             htab->relbrlt->size);
13241       if (htab->relbrlt->contents == NULL)
13242         return FALSE;
13243     }
13244
13245   /* Build the stubs as directed by the stub hash table.  */
13246   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13247
13248   for (group = htab->group; group != NULL; group = group->next)
13249     if (group->needs_save_res)
13250       group->stub_sec->size += htab->sfpr->size;
13251
13252   if (htab->relbrlt != NULL)
13253     htab->relbrlt->reloc_count = 0;
13254
13255   if (htab->params->plt_stub_align != 0)
13256     for (group = htab->group; group != NULL; group = group->next)
13257       if ((stub_sec = group->stub_sec) != NULL)
13258         {
13259           int align = abs (htab->params->plt_stub_align);
13260           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13261         }
13262
13263   for (group = htab->group; group != NULL; group = group->next)
13264     if (group->needs_save_res)
13265       {
13266         stub_sec = group->stub_sec;
13267         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13268                 htab->sfpr->contents, htab->sfpr->size);
13269         if (htab->params->emit_stub_syms)
13270           {
13271             unsigned int i;
13272
13273             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13274               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13275                 return FALSE;
13276           }
13277       }
13278
13279   for (group = htab->group; group != NULL; group = group->next)
13280     if ((stub_sec = group->stub_sec) != NULL)
13281       {
13282         stub_sec_count += 1;
13283         if (stub_sec->rawsize != stub_sec->size
13284             && (htab->stub_iteration <= STUB_SHRINK_ITER
13285                 || stub_sec->rawsize < stub_sec->size))
13286           break;
13287       }
13288
13289   if (group != NULL)
13290     {
13291       htab->stub_error = TRUE;
13292       _bfd_error_handler (_("stubs don't match calculated size"));
13293     }
13294
13295   if (htab->stub_error)
13296     return FALSE;
13297
13298   if (stats != NULL)
13299     {
13300       size_t len;
13301       *stats = bfd_malloc (500);
13302       if (*stats == NULL)
13303         return FALSE;
13304
13305       len = sprintf (*stats,
13306                      ngettext ("linker stubs in %u group\n",
13307                                "linker stubs in %u groups\n",
13308                                stub_sec_count),
13309                      stub_sec_count);
13310       sprintf (*stats + len, _("  branch       %lu\n"
13311                                "  toc adjust   %lu\n"
13312                                "  long branch  %lu\n"
13313                                "  long toc adj %lu\n"
13314                                "  plt call     %lu\n"
13315                                "  plt call toc %lu\n"
13316                                "  global entry %lu"),
13317                htab->stub_count[ppc_stub_long_branch - 1],
13318                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13319                htab->stub_count[ppc_stub_plt_branch - 1],
13320                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13321                htab->stub_count[ppc_stub_plt_call - 1],
13322                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13323                htab->stub_count[ppc_stub_global_entry - 1]);
13324     }
13325   return TRUE;
13326 }
13327
13328 /* What to do when ld finds relocations against symbols defined in
13329    discarded sections.  */
13330
13331 static unsigned int
13332 ppc64_elf_action_discarded (asection *sec)
13333 {
13334   if (strcmp (".opd", sec->name) == 0)
13335     return 0;
13336
13337   if (strcmp (".toc", sec->name) == 0)
13338     return 0;
13339
13340   if (strcmp (".toc1", sec->name) == 0)
13341     return 0;
13342
13343   return _bfd_elf_default_action_discarded (sec);
13344 }
13345
13346 /* The RELOCATE_SECTION function is called by the ELF backend linker
13347    to handle the relocations for a section.
13348
13349    The relocs are always passed as Rela structures; if the section
13350    actually uses Rel structures, the r_addend field will always be
13351    zero.
13352
13353    This function is responsible for adjust the section contents as
13354    necessary, and (if using Rela relocs and generating a
13355    relocatable output file) adjusting the reloc addend as
13356    necessary.
13357
13358    This function does not have to worry about setting the reloc
13359    address or the reloc symbol index.
13360
13361    LOCAL_SYMS is a pointer to the swapped in local symbols.
13362
13363    LOCAL_SECTIONS is an array giving the section in the input file
13364    corresponding to the st_shndx field of each local symbol.
13365
13366    The global hash table entry for the global symbols can be found
13367    via elf_sym_hashes (input_bfd).
13368
13369    When generating relocatable output, this function must handle
13370    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13371    going to be the section symbol corresponding to the output
13372    section, which means that the addend must be adjusted
13373    accordingly.  */
13374
13375 static bfd_boolean
13376 ppc64_elf_relocate_section (bfd *output_bfd,
13377                             struct bfd_link_info *info,
13378                             bfd *input_bfd,
13379                             asection *input_section,
13380                             bfd_byte *contents,
13381                             Elf_Internal_Rela *relocs,
13382                             Elf_Internal_Sym *local_syms,
13383                             asection **local_sections)
13384 {
13385   struct ppc_link_hash_table *htab;
13386   Elf_Internal_Shdr *symtab_hdr;
13387   struct elf_link_hash_entry **sym_hashes;
13388   Elf_Internal_Rela *rel;
13389   Elf_Internal_Rela *wrel;
13390   Elf_Internal_Rela *relend;
13391   Elf_Internal_Rela outrel;
13392   bfd_byte *loc;
13393   struct got_entry **local_got_ents;
13394   bfd_vma TOCstart;
13395   bfd_boolean ret = TRUE;
13396   bfd_boolean is_opd;
13397   /* Assume 'at' branch hints.  */
13398   bfd_boolean is_isa_v2 = TRUE;
13399   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13400
13401   /* Initialize howto table if needed.  */
13402   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13403     ppc_howto_init ();
13404
13405   htab = ppc_hash_table (info);
13406   if (htab == NULL)
13407     return FALSE;
13408
13409   /* Don't relocate stub sections.  */
13410   if (input_section->owner == htab->params->stub_bfd)
13411     return TRUE;
13412
13413   BFD_ASSERT (is_ppc64_elf (input_bfd));
13414
13415   local_got_ents = elf_local_got_ents (input_bfd);
13416   TOCstart = elf_gp (output_bfd);
13417   symtab_hdr = &elf_symtab_hdr (input_bfd);
13418   sym_hashes = elf_sym_hashes (input_bfd);
13419   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13420
13421   rel = wrel = relocs;
13422   relend = relocs + input_section->reloc_count;
13423   for (; rel < relend; wrel++, rel++)
13424     {
13425       enum elf_ppc64_reloc_type r_type;
13426       bfd_vma addend;
13427       bfd_reloc_status_type r;
13428       Elf_Internal_Sym *sym;
13429       asection *sec;
13430       struct elf_link_hash_entry *h_elf;
13431       struct ppc_link_hash_entry *h;
13432       struct ppc_link_hash_entry *fdh;
13433       const char *sym_name;
13434       unsigned long r_symndx, toc_symndx;
13435       bfd_vma toc_addend;
13436       unsigned char tls_mask, tls_gd, tls_type;
13437       unsigned char sym_type;
13438       bfd_vma relocation;
13439       bfd_boolean unresolved_reloc;
13440       bfd_boolean warned;
13441       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13442       unsigned int insn;
13443       unsigned int mask;
13444       struct ppc_stub_hash_entry *stub_entry;
13445       bfd_vma max_br_offset;
13446       bfd_vma from;
13447       Elf_Internal_Rela orig_rel;
13448       reloc_howto_type *howto;
13449       struct reloc_howto_struct alt_howto;
13450
13451     again:
13452       orig_rel = *rel;
13453
13454       r_type = ELF64_R_TYPE (rel->r_info);
13455       r_symndx = ELF64_R_SYM (rel->r_info);
13456
13457       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13458          symbol of the previous ADDR64 reloc.  The symbol gives us the
13459          proper TOC base to use.  */
13460       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13461           && wrel != relocs
13462           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13463           && is_opd)
13464         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13465
13466       sym = NULL;
13467       sec = NULL;
13468       h_elf = NULL;
13469       sym_name = NULL;
13470       unresolved_reloc = FALSE;
13471       warned = FALSE;
13472
13473       if (r_symndx < symtab_hdr->sh_info)
13474         {
13475           /* It's a local symbol.  */
13476           struct _opd_sec_data *opd;
13477
13478           sym = local_syms + r_symndx;
13479           sec = local_sections[r_symndx];
13480           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13481           sym_type = ELF64_ST_TYPE (sym->st_info);
13482           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13483           opd = get_opd_info (sec);
13484           if (opd != NULL && opd->adjust != NULL)
13485             {
13486               long adjust = opd->adjust[OPD_NDX (sym->st_value
13487                                                  + rel->r_addend)];
13488               if (adjust == -1)
13489                 relocation = 0;
13490               else
13491                 {
13492                   /* If this is a relocation against the opd section sym
13493                      and we have edited .opd, adjust the reloc addend so
13494                      that ld -r and ld --emit-relocs output is correct.
13495                      If it is a reloc against some other .opd symbol,
13496                      then the symbol value will be adjusted later.  */
13497                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13498                     rel->r_addend += adjust;
13499                   else
13500                     relocation += adjust;
13501                 }
13502             }
13503         }
13504       else
13505         {
13506           bfd_boolean ignored;
13507
13508           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13509                                    r_symndx, symtab_hdr, sym_hashes,
13510                                    h_elf, sec, relocation,
13511                                    unresolved_reloc, warned, ignored);
13512           sym_name = h_elf->root.root.string;
13513           sym_type = h_elf->type;
13514           if (sec != NULL
13515               && sec->owner == output_bfd
13516               && strcmp (sec->name, ".opd") == 0)
13517             {
13518               /* This is a symbol defined in a linker script.  All
13519                  such are defined in output sections, even those
13520                  defined by simple assignment from a symbol defined in
13521                  an input section.  Transfer the symbol to an
13522                  appropriate input .opd section, so that a branch to
13523                  this symbol will be mapped to the location specified
13524                  by the opd entry.  */
13525               struct bfd_link_order *lo;
13526               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13527                 if (lo->type == bfd_indirect_link_order)
13528                   {
13529                     asection *isec = lo->u.indirect.section;
13530                     if (h_elf->root.u.def.value >= isec->output_offset
13531                         && h_elf->root.u.def.value < (isec->output_offset
13532                                                       + isec->size))
13533                       {
13534                         h_elf->root.u.def.value -= isec->output_offset;
13535                         h_elf->root.u.def.section = isec;
13536                         sec = isec;
13537                         break;
13538                       }
13539                   }
13540             }
13541         }
13542       h = (struct ppc_link_hash_entry *) h_elf;
13543
13544       if (sec != NULL && discarded_section (sec))
13545         {
13546           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13547                                input_bfd, input_section,
13548                                contents + rel->r_offset);
13549           wrel->r_offset = rel->r_offset;
13550           wrel->r_info = 0;
13551           wrel->r_addend = 0;
13552
13553           /* For ld -r, remove relocations in debug sections against
13554              symbols defined in discarded sections.  Not done for
13555              non-debug to preserve relocs in .eh_frame which the
13556              eh_frame editing code expects to be present.  */
13557           if (bfd_link_relocatable (info)
13558               && (input_section->flags & SEC_DEBUGGING))
13559             wrel--;
13560
13561           continue;
13562         }
13563
13564       if (bfd_link_relocatable (info))
13565         goto copy_reloc;
13566
13567       if (h != NULL && &h->elf == htab->elf.hgot)
13568         {
13569           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13570           sec = bfd_abs_section_ptr;
13571           unresolved_reloc = FALSE;
13572         }
13573
13574       /* TLS optimizations.  Replace instruction sequences and relocs
13575          based on information we collected in tls_optimize.  We edit
13576          RELOCS so that --emit-relocs will output something sensible
13577          for the final instruction stream.  */
13578       tls_mask = 0;
13579       tls_gd = 0;
13580       toc_symndx = 0;
13581       if (h != NULL)
13582         tls_mask = h->tls_mask;
13583       else if (local_got_ents != NULL)
13584         {
13585           struct plt_entry **local_plt = (struct plt_entry **)
13586             (local_got_ents + symtab_hdr->sh_info);
13587           unsigned char *lgot_masks = (unsigned char *)
13588             (local_plt + symtab_hdr->sh_info);
13589           tls_mask = lgot_masks[r_symndx];
13590         }
13591       if (tls_mask == 0
13592           && (r_type == R_PPC64_TLS
13593               || r_type == R_PPC64_TLSGD
13594               || r_type == R_PPC64_TLSLD))
13595         {
13596           /* Check for toc tls entries.  */
13597           unsigned char *toc_tls;
13598
13599           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13600                              &local_syms, rel, input_bfd))
13601             return FALSE;
13602
13603           if (toc_tls)
13604             tls_mask = *toc_tls;
13605         }
13606
13607       /* Check that tls relocs are used with tls syms, and non-tls
13608          relocs are used with non-tls syms.  */
13609       if (r_symndx != STN_UNDEF
13610           && r_type != R_PPC64_NONE
13611           && (h == NULL
13612               || h->elf.root.type == bfd_link_hash_defined
13613               || h->elf.root.type == bfd_link_hash_defweak)
13614           && (IS_PPC64_TLS_RELOC (r_type)
13615               != (sym_type == STT_TLS
13616                   || (sym_type == STT_SECTION
13617                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13618         {
13619           if (tls_mask != 0
13620               && (r_type == R_PPC64_TLS
13621                   || r_type == R_PPC64_TLSGD
13622                   || r_type == R_PPC64_TLSLD))
13623             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13624             ;
13625           else
13626             info->callbacks->einfo
13627               (!IS_PPC64_TLS_RELOC (r_type)
13628                /* xgettext:c-format */
13629                ? _("%H: %s used with TLS symbol `%pT'\n")
13630                /* xgettext:c-format */
13631                : _("%H: %s used with non-TLS symbol `%pT'\n"),
13632                input_bfd, input_section, rel->r_offset,
13633                ppc64_elf_howto_table[r_type]->name,
13634                sym_name);
13635         }
13636
13637       /* Ensure reloc mapping code below stays sane.  */
13638       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13639           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13640           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13641           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13642           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13643           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13644           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13645           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13646           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13647           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13648         abort ();
13649
13650       switch (r_type)
13651         {
13652         default:
13653           break;
13654
13655         case R_PPC64_LO_DS_OPT:
13656           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13657           if ((insn & (0x3f << 26)) != 58u << 26)
13658             abort ();
13659           insn += (14u << 26) - (58u << 26);
13660           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13661           r_type = R_PPC64_TOC16_LO;
13662           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13663           break;
13664
13665         case R_PPC64_TOC16:
13666         case R_PPC64_TOC16_LO:
13667         case R_PPC64_TOC16_DS:
13668         case R_PPC64_TOC16_LO_DS:
13669           {
13670             /* Check for toc tls entries.  */
13671             unsigned char *toc_tls;
13672             int retval;
13673
13674             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13675                                    &local_syms, rel, input_bfd);
13676             if (retval == 0)
13677               return FALSE;
13678
13679             if (toc_tls)
13680               {
13681                 tls_mask = *toc_tls;
13682                 if (r_type == R_PPC64_TOC16_DS
13683                     || r_type == R_PPC64_TOC16_LO_DS)
13684                   {
13685                     if (tls_mask != 0
13686                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13687                       goto toctprel;
13688                   }
13689                 else
13690                   {
13691                     /* If we found a GD reloc pair, then we might be
13692                        doing a GD->IE transition.  */
13693                     if (retval == 2)
13694                       {
13695                         tls_gd = TLS_TPRELGD;
13696                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13697                           goto tls_ldgd_opt;
13698                       }
13699                     else if (retval == 3)
13700                       {
13701                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13702                           goto tls_ldgd_opt;
13703                       }
13704                   }
13705               }
13706           }
13707           break;
13708
13709         case R_PPC64_GOT_TPREL16_HI:
13710         case R_PPC64_GOT_TPREL16_HA:
13711           if (tls_mask != 0
13712               && (tls_mask & TLS_TPREL) == 0)
13713             {
13714               rel->r_offset -= d_offset;
13715               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13716               r_type = R_PPC64_NONE;
13717               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13718             }
13719           break;
13720
13721         case R_PPC64_GOT_TPREL16_DS:
13722         case R_PPC64_GOT_TPREL16_LO_DS:
13723           if (tls_mask != 0
13724               && (tls_mask & TLS_TPREL) == 0)
13725             {
13726             toctprel:
13727               insn = bfd_get_32 (input_bfd,
13728                                  contents + rel->r_offset - d_offset);
13729               insn &= 31 << 21;
13730               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13731               bfd_put_32 (input_bfd, insn,
13732                           contents + rel->r_offset - d_offset);
13733               r_type = R_PPC64_TPREL16_HA;
13734               if (toc_symndx != 0)
13735                 {
13736                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13737                   rel->r_addend = toc_addend;
13738                   /* We changed the symbol.  Start over in order to
13739                      get h, sym, sec etc. right.  */
13740                   goto again;
13741                 }
13742               else
13743                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13744             }
13745           break;
13746
13747         case R_PPC64_TLS:
13748           if (tls_mask != 0
13749               && (tls_mask & TLS_TPREL) == 0)
13750             {
13751               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13752               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13753               if (insn == 0)
13754                 abort ();
13755               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13756               /* Was PPC64_TLS which sits on insn boundary, now
13757                  PPC64_TPREL16_LO which is at low-order half-word.  */
13758               rel->r_offset += d_offset;
13759               r_type = R_PPC64_TPREL16_LO;
13760               if (toc_symndx != 0)
13761                 {
13762                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13763                   rel->r_addend = toc_addend;
13764                   /* We changed the symbol.  Start over in order to
13765                      get h, sym, sec etc. right.  */
13766                   goto again;
13767                 }
13768               else
13769                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13770             }
13771           break;
13772
13773         case R_PPC64_GOT_TLSGD16_HI:
13774         case R_PPC64_GOT_TLSGD16_HA:
13775           tls_gd = TLS_TPRELGD;
13776           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13777             goto tls_gdld_hi;
13778           break;
13779
13780         case R_PPC64_GOT_TLSLD16_HI:
13781         case R_PPC64_GOT_TLSLD16_HA:
13782           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13783             {
13784             tls_gdld_hi:
13785               if ((tls_mask & tls_gd) != 0)
13786                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13787                           + R_PPC64_GOT_TPREL16_DS);
13788               else
13789                 {
13790                   rel->r_offset -= d_offset;
13791                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13792                   r_type = R_PPC64_NONE;
13793                 }
13794               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13795             }
13796           break;
13797
13798         case R_PPC64_GOT_TLSGD16:
13799         case R_PPC64_GOT_TLSGD16_LO:
13800           tls_gd = TLS_TPRELGD;
13801           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13802             goto tls_ldgd_opt;
13803           break;
13804
13805         case R_PPC64_GOT_TLSLD16:
13806         case R_PPC64_GOT_TLSLD16_LO:
13807           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13808             {
13809               unsigned int insn1, insn2;
13810               bfd_vma offset;
13811
13812             tls_ldgd_opt:
13813               offset = (bfd_vma) -1;
13814               /* If not using the newer R_PPC64_TLSGD/LD to mark
13815                  __tls_get_addr calls, we must trust that the call
13816                  stays with its arg setup insns, ie. that the next
13817                  reloc is the __tls_get_addr call associated with
13818                  the current reloc.  Edit both insns.  */
13819               if (input_section->has_tls_get_addr_call
13820                   && rel + 1 < relend
13821                   && branch_reloc_hash_match (input_bfd, rel + 1,
13822                                               htab->tls_get_addr,
13823                                               htab->tls_get_addr_fd))
13824                 offset = rel[1].r_offset;
13825               /* We read the low GOT_TLS (or TOC16) insn because we
13826                  need to keep the destination reg.  It may be
13827                  something other than the usual r3, and moved to r3
13828                  before the call by intervening code.  */
13829               insn1 = bfd_get_32 (input_bfd,
13830                                   contents + rel->r_offset - d_offset);
13831               if ((tls_mask & tls_gd) != 0)
13832                 {
13833                   /* IE */
13834                   insn1 &= (0x1f << 21) | (0x1f << 16);
13835                   insn1 |= 58 << 26;    /* ld */
13836                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13837                   if (offset != (bfd_vma) -1)
13838                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13839                   if ((tls_mask & TLS_EXPLICIT) == 0)
13840                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13841                               + R_PPC64_GOT_TPREL16_DS);
13842                   else
13843                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13844                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13845                 }
13846               else
13847                 {
13848                   /* LE */
13849                   insn1 &= 0x1f << 21;
13850                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13851                   insn2 = 0x38630000;   /* addi 3,3,0 */
13852                   if (tls_gd == 0)
13853                     {
13854                       /* Was an LD reloc.  */
13855                       if (toc_symndx)
13856                         sec = local_sections[toc_symndx];
13857                       for (r_symndx = 0;
13858                            r_symndx < symtab_hdr->sh_info;
13859                            r_symndx++)
13860                         if (local_sections[r_symndx] == sec)
13861                           break;
13862                       if (r_symndx >= symtab_hdr->sh_info)
13863                         r_symndx = STN_UNDEF;
13864                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13865                       if (r_symndx != STN_UNDEF)
13866                         rel->r_addend -= (local_syms[r_symndx].st_value
13867                                           + sec->output_offset
13868                                           + sec->output_section->vma);
13869                     }
13870                   else if (toc_symndx != 0)
13871                     {
13872                       r_symndx = toc_symndx;
13873                       rel->r_addend = toc_addend;
13874                     }
13875                   r_type = R_PPC64_TPREL16_HA;
13876                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13877                   if (offset != (bfd_vma) -1)
13878                     {
13879                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13880                                                     R_PPC64_TPREL16_LO);
13881                       rel[1].r_offset = offset + d_offset;
13882                       rel[1].r_addend = rel->r_addend;
13883                     }
13884                 }
13885               bfd_put_32 (input_bfd, insn1,
13886                           contents + rel->r_offset - d_offset);
13887               if (offset != (bfd_vma) -1)
13888                 bfd_put_32 (input_bfd, insn2, contents + offset);
13889               if ((tls_mask & tls_gd) == 0
13890                   && (tls_gd == 0 || toc_symndx != 0))
13891                 {
13892                   /* We changed the symbol.  Start over in order
13893                      to get h, sym, sec etc. right.  */
13894                   goto again;
13895                 }
13896             }
13897           break;
13898
13899         case R_PPC64_TLSGD:
13900           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0
13901               && rel + 1 < relend)
13902             {
13903               unsigned int insn2;
13904               bfd_vma offset = rel->r_offset;
13905
13906               if ((tls_mask & TLS_TPRELGD) != 0)
13907                 {
13908                   /* IE */
13909                   r_type = R_PPC64_NONE;
13910                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13911                 }
13912               else
13913                 {
13914                   /* LE */
13915                   if (toc_symndx != 0)
13916                     {
13917                       r_symndx = toc_symndx;
13918                       rel->r_addend = toc_addend;
13919                     }
13920                   r_type = R_PPC64_TPREL16_LO;
13921                   rel->r_offset = offset + d_offset;
13922                   insn2 = 0x38630000;   /* addi 3,3,0 */
13923                 }
13924               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13925               /* Zap the reloc on the _tls_get_addr call too.  */
13926               BFD_ASSERT (offset == rel[1].r_offset);
13927               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13928               bfd_put_32 (input_bfd, insn2, contents + offset);
13929               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13930                 goto again;
13931             }
13932           break;
13933
13934         case R_PPC64_TLSLD:
13935           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0
13936               && rel + 1 < relend)
13937             {
13938               unsigned int insn2;
13939               bfd_vma offset = rel->r_offset;
13940
13941               if (toc_symndx)
13942                 sec = local_sections[toc_symndx];
13943               for (r_symndx = 0;
13944                    r_symndx < symtab_hdr->sh_info;
13945                    r_symndx++)
13946                 if (local_sections[r_symndx] == sec)
13947                   break;
13948               if (r_symndx >= symtab_hdr->sh_info)
13949                 r_symndx = STN_UNDEF;
13950               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13951               if (r_symndx != STN_UNDEF)
13952                 rel->r_addend -= (local_syms[r_symndx].st_value
13953                                   + sec->output_offset
13954                                   + sec->output_section->vma);
13955
13956               r_type = R_PPC64_TPREL16_LO;
13957               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13958               rel->r_offset = offset + d_offset;
13959               /* Zap the reloc on the _tls_get_addr call too.  */
13960               BFD_ASSERT (offset == rel[1].r_offset);
13961               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13962               insn2 = 0x38630000;       /* addi 3,3,0 */
13963               bfd_put_32 (input_bfd, insn2, contents + offset);
13964               goto again;
13965             }
13966           break;
13967
13968         case R_PPC64_DTPMOD64:
13969           if (rel + 1 < relend
13970               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13971               && rel[1].r_offset == rel->r_offset + 8)
13972             {
13973               if ((tls_mask & TLS_GD) == 0)
13974                 {
13975                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13976                   if ((tls_mask & TLS_TPRELGD) != 0)
13977                     r_type = R_PPC64_TPREL64;
13978                   else
13979                     {
13980                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13981                       r_type = R_PPC64_NONE;
13982                     }
13983                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13984                 }
13985             }
13986           else
13987             {
13988               if ((tls_mask & TLS_LD) == 0)
13989                 {
13990                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13991                   r_type = R_PPC64_NONE;
13992                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13993                 }
13994             }
13995           break;
13996
13997         case R_PPC64_TPREL64:
13998           if ((tls_mask & TLS_TPREL) == 0)
13999             {
14000               r_type = R_PPC64_NONE;
14001               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14002             }
14003           break;
14004
14005         case R_PPC64_ENTRY:
14006           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14007           if (!bfd_link_pic (info)
14008               && !info->traditional_format
14009               && relocation + 0x80008000 <= 0xffffffff)
14010             {
14011               unsigned int insn1, insn2;
14012
14013               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14014               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14015               if ((insn1 & ~0xfffc) == LD_R2_0R12
14016                   && insn2 == ADD_R2_R2_R12)
14017                 {
14018                   bfd_put_32 (input_bfd,
14019                               LIS_R2 + PPC_HA (relocation),
14020                               contents + rel->r_offset);
14021                   bfd_put_32 (input_bfd,
14022                               ADDI_R2_R2 + PPC_LO (relocation),
14023                               contents + rel->r_offset + 4);
14024                 }
14025             }
14026           else
14027             {
14028               relocation -= (rel->r_offset
14029                              + input_section->output_offset
14030                              + input_section->output_section->vma);
14031               if (relocation + 0x80008000 <= 0xffffffff)
14032                 {
14033                   unsigned int insn1, insn2;
14034
14035                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14036                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14037                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14038                       && insn2 == ADD_R2_R2_R12)
14039                     {
14040                       bfd_put_32 (input_bfd,
14041                                   ADDIS_R2_R12 + PPC_HA (relocation),
14042                                   contents + rel->r_offset);
14043                       bfd_put_32 (input_bfd,
14044                                   ADDI_R2_R2 + PPC_LO (relocation),
14045                                   contents + rel->r_offset + 4);
14046                     }
14047                 }
14048             }
14049           break;
14050
14051         case R_PPC64_REL16_HA:
14052           /* If we are generating a non-PIC executable, edit
14053              .  0:      addis 2,12,.TOC.-0b@ha
14054              .          addi 2,2,.TOC.-0b@l
14055              used by ELFv2 global entry points to set up r2, to
14056              .          lis 2,.TOC.@ha
14057              .          addi 2,2,.TOC.@l
14058              if .TOC. is in range.  */
14059           if (!bfd_link_pic (info)
14060               && !info->traditional_format
14061               && !htab->opd_abi
14062               && rel->r_addend == d_offset
14063               && h != NULL && &h->elf == htab->elf.hgot
14064               && rel + 1 < relend
14065               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14066               && rel[1].r_offset == rel->r_offset + 4
14067               && rel[1].r_addend == rel->r_addend + 4
14068               && relocation + 0x80008000 <= 0xffffffff)
14069             {
14070               unsigned int insn1, insn2;
14071               bfd_vma offset = rel->r_offset - d_offset;
14072               insn1 = bfd_get_32 (input_bfd, contents + offset);
14073               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14074               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14075                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14076                 {
14077                   r_type = R_PPC64_ADDR16_HA;
14078                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14079                   rel->r_addend -= d_offset;
14080                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14081                   rel[1].r_addend -= d_offset + 4;
14082                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14083                 }
14084             }
14085           break;
14086         }
14087
14088       /* Handle other relocations that tweak non-addend part of insn.  */
14089       insn = 0;
14090       max_br_offset = 1 << 25;
14091       addend = rel->r_addend;
14092       reloc_dest = DEST_NORMAL;
14093       switch (r_type)
14094         {
14095         default:
14096           break;
14097
14098         case R_PPC64_TOCSAVE:
14099           if (relocation + addend == (rel->r_offset
14100                                       + input_section->output_offset
14101                                       + input_section->output_section->vma)
14102               && tocsave_find (htab, NO_INSERT,
14103                                &local_syms, rel, input_bfd))
14104             {
14105               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14106               if (insn == NOP
14107                   || insn == CROR_151515 || insn == CROR_313131)
14108                 bfd_put_32 (input_bfd,
14109                             STD_R2_0R1 + STK_TOC (htab),
14110                             contents + rel->r_offset);
14111             }
14112           break;
14113
14114           /* Branch taken prediction relocations.  */
14115         case R_PPC64_ADDR14_BRTAKEN:
14116         case R_PPC64_REL14_BRTAKEN:
14117           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14118           /* Fall through.  */
14119
14120           /* Branch not taken prediction relocations.  */
14121         case R_PPC64_ADDR14_BRNTAKEN:
14122         case R_PPC64_REL14_BRNTAKEN:
14123           insn |= bfd_get_32 (input_bfd,
14124                               contents + rel->r_offset) & ~(0x01 << 21);
14125           /* Fall through.  */
14126
14127         case R_PPC64_REL14:
14128           max_br_offset = 1 << 15;
14129           /* Fall through.  */
14130
14131         case R_PPC64_REL24:
14132           /* Calls to functions with a different TOC, such as calls to
14133              shared objects, need to alter the TOC pointer.  This is
14134              done using a linkage stub.  A REL24 branching to these
14135              linkage stubs needs to be followed by a nop, as the nop
14136              will be replaced with an instruction to restore the TOC
14137              base pointer.  */
14138           fdh = h;
14139           if (h != NULL
14140               && h->oh != NULL
14141               && h->oh->is_func_descriptor)
14142             fdh = ppc_follow_link (h->oh);
14143           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14144                                            htab);
14145           if (stub_entry != NULL
14146               && (stub_entry->stub_type == ppc_stub_plt_call
14147                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14148                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14149                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14150             {
14151               bfd_boolean can_plt_call = FALSE;
14152
14153               if (stub_entry->stub_type == ppc_stub_plt_call
14154                   && !htab->opd_abi
14155                   && htab->params->plt_localentry0 != 0
14156                   && is_elfv2_localentry0 (&h->elf))
14157                 {
14158                   /* The function doesn't use or change r2.  */
14159                   can_plt_call = TRUE;
14160                 }
14161
14162               /* All of these stubs may modify r2, so there must be a
14163                  branch and link followed by a nop.  The nop is
14164                  replaced by an insn to restore r2.  */
14165               else if (rel->r_offset + 8 <= input_section->size)
14166                 {
14167                   unsigned long br;
14168
14169                   br = bfd_get_32 (input_bfd,
14170                                    contents + rel->r_offset);
14171                   if ((br & 1) != 0)
14172                     {
14173                       unsigned long nop;
14174
14175                       nop = bfd_get_32 (input_bfd,
14176                                         contents + rel->r_offset + 4);
14177                       if (nop == NOP
14178                           || nop == CROR_151515 || nop == CROR_313131)
14179                         {
14180                           if (h != NULL
14181                               && (h == htab->tls_get_addr_fd
14182                                   || h == htab->tls_get_addr)
14183                               && htab->params->tls_get_addr_opt)
14184                             {
14185                               /* Special stub used, leave nop alone.  */
14186                             }
14187                           else
14188                             bfd_put_32 (input_bfd,
14189                                         LD_R2_0R1 + STK_TOC (htab),
14190                                         contents + rel->r_offset + 4);
14191                           can_plt_call = TRUE;
14192                         }
14193                     }
14194                 }
14195
14196               if (!can_plt_call && h != NULL)
14197                 {
14198                   const char *name = h->elf.root.root.string;
14199
14200                   if (*name == '.')
14201                     ++name;
14202
14203                   if (strncmp (name, "__libc_start_main", 17) == 0
14204                       && (name[17] == 0 || name[17] == '@'))
14205                     {
14206                       /* Allow crt1 branch to go via a toc adjusting
14207                          stub.  Other calls that never return could do
14208                          the same, if we could detect such.  */
14209                       can_plt_call = TRUE;
14210                     }
14211                 }
14212
14213               if (!can_plt_call)
14214                 {
14215                   /* g++ as of 20130507 emits self-calls without a
14216                      following nop.  This is arguably wrong since we
14217                      have conflicting information.  On the one hand a
14218                      global symbol and on the other a local call
14219                      sequence, but don't error for this special case.
14220                      It isn't possible to cheaply verify we have
14221                      exactly such a call.  Allow all calls to the same
14222                      section.  */
14223                   asection *code_sec = sec;
14224
14225                   if (get_opd_info (sec) != NULL)
14226                     {
14227                       bfd_vma off = (relocation + addend
14228                                      - sec->output_section->vma
14229                                      - sec->output_offset);
14230
14231                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14232                     }
14233                   if (code_sec == input_section)
14234                     can_plt_call = TRUE;
14235                 }
14236
14237               if (!can_plt_call)
14238                 {
14239                   if (stub_entry->stub_type == ppc_stub_plt_call
14240                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14241                     info->callbacks->einfo
14242                       /* xgettext:c-format */
14243                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14244                          "recompile with -fPIC\n"),
14245                        input_bfd, input_section, rel->r_offset, sym_name);
14246                   else
14247                     info->callbacks->einfo
14248                       /* xgettext:c-format */
14249                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14250                          "(-mcmodel=small toc adjust stub)\n"),
14251                        input_bfd, input_section, rel->r_offset, sym_name);
14252
14253                   bfd_set_error (bfd_error_bad_value);
14254                   ret = FALSE;
14255                 }
14256
14257               if (can_plt_call
14258                   && (stub_entry->stub_type == ppc_stub_plt_call
14259                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14260                 unresolved_reloc = FALSE;
14261             }
14262
14263           if ((stub_entry == NULL
14264                || stub_entry->stub_type == ppc_stub_long_branch
14265                || stub_entry->stub_type == ppc_stub_plt_branch)
14266               && get_opd_info (sec) != NULL)
14267             {
14268               /* The branch destination is the value of the opd entry. */
14269               bfd_vma off = (relocation + addend
14270                              - sec->output_section->vma
14271                              - sec->output_offset);
14272               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14273               if (dest != (bfd_vma) -1)
14274                 {
14275                   relocation = dest;
14276                   addend = 0;
14277                   reloc_dest = DEST_OPD;
14278                 }
14279             }
14280
14281           /* If the branch is out of reach we ought to have a long
14282              branch stub.  */
14283           from = (rel->r_offset
14284                   + input_section->output_offset
14285                   + input_section->output_section->vma);
14286
14287           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14288                                                   ? fdh->elf.other
14289                                                   : sym->st_other);
14290
14291           if (stub_entry != NULL
14292               && (stub_entry->stub_type == ppc_stub_long_branch
14293                   || stub_entry->stub_type == ppc_stub_plt_branch)
14294               && (r_type == R_PPC64_ADDR14_BRTAKEN
14295                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14296                   || (relocation + addend - from + max_br_offset
14297                       < 2 * max_br_offset)))
14298             /* Don't use the stub if this branch is in range.  */
14299             stub_entry = NULL;
14300
14301           if (stub_entry != NULL)
14302             {
14303               /* Munge up the value and addend so that we call the stub
14304                  rather than the procedure directly.  */
14305               asection *stub_sec = stub_entry->group->stub_sec;
14306
14307               if (stub_entry->stub_type == ppc_stub_save_res)
14308                 relocation += (stub_sec->output_offset
14309                                + stub_sec->output_section->vma
14310                                + stub_sec->size - htab->sfpr->size
14311                                - htab->sfpr->output_offset
14312                                - htab->sfpr->output_section->vma);
14313               else
14314                 relocation = (stub_entry->stub_offset
14315                               + stub_sec->output_offset
14316                               + stub_sec->output_section->vma);
14317               addend = 0;
14318               reloc_dest = DEST_STUB;
14319
14320               if ((stub_entry->stub_type == ppc_stub_plt_call
14321                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14322                   && (ALWAYS_EMIT_R2SAVE
14323                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14324                   && rel + 1 < relend
14325                   && rel[1].r_offset == rel->r_offset + 4
14326                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14327                 relocation += 4;
14328             }
14329
14330           if (insn != 0)
14331             {
14332               if (is_isa_v2)
14333                 {
14334                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14335                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14336                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14337                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14338                     insn |= 0x02 << 21;
14339                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14340                     insn |= 0x08 << 21;
14341                   else
14342                     break;
14343                 }
14344               else
14345                 {
14346                   /* Invert 'y' bit if not the default.  */
14347                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14348                     insn ^= 0x01 << 21;
14349                 }
14350
14351               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14352             }
14353
14354           /* NOP out calls to undefined weak functions.
14355              We can thus call a weak function without first
14356              checking whether the function is defined.  */
14357           else if (h != NULL
14358                    && h->elf.root.type == bfd_link_hash_undefweak
14359                    && h->elf.dynindx == -1
14360                    && r_type == R_PPC64_REL24
14361                    && relocation == 0
14362                    && addend == 0)
14363             {
14364               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14365               goto copy_reloc;
14366             }
14367           break;
14368         }
14369
14370       /* Set `addend'.  */
14371       tls_type = 0;
14372       switch (r_type)
14373         {
14374         default:
14375           /* xgettext:c-format */
14376           _bfd_error_handler (_("%pB: %s unsupported"),
14377                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14378
14379           bfd_set_error (bfd_error_bad_value);
14380           ret = FALSE;
14381           goto copy_reloc;
14382
14383         case R_PPC64_NONE:
14384         case R_PPC64_TLS:
14385         case R_PPC64_TLSGD:
14386         case R_PPC64_TLSLD:
14387         case R_PPC64_TOCSAVE:
14388         case R_PPC64_GNU_VTINHERIT:
14389         case R_PPC64_GNU_VTENTRY:
14390         case R_PPC64_ENTRY:
14391           goto copy_reloc;
14392
14393           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14394              address in the GOT as relocation value instead of the
14395              symbol's value itself.  Also, create a GOT entry for the
14396              symbol and put the symbol value there.  */
14397         case R_PPC64_GOT_TLSGD16:
14398         case R_PPC64_GOT_TLSGD16_LO:
14399         case R_PPC64_GOT_TLSGD16_HI:
14400         case R_PPC64_GOT_TLSGD16_HA:
14401           tls_type = TLS_TLS | TLS_GD;
14402           goto dogot;
14403
14404         case R_PPC64_GOT_TLSLD16:
14405         case R_PPC64_GOT_TLSLD16_LO:
14406         case R_PPC64_GOT_TLSLD16_HI:
14407         case R_PPC64_GOT_TLSLD16_HA:
14408           tls_type = TLS_TLS | TLS_LD;
14409           goto dogot;
14410
14411         case R_PPC64_GOT_TPREL16_DS:
14412         case R_PPC64_GOT_TPREL16_LO_DS:
14413         case R_PPC64_GOT_TPREL16_HI:
14414         case R_PPC64_GOT_TPREL16_HA:
14415           tls_type = TLS_TLS | TLS_TPREL;
14416           goto dogot;
14417
14418         case R_PPC64_GOT_DTPREL16_DS:
14419         case R_PPC64_GOT_DTPREL16_LO_DS:
14420         case R_PPC64_GOT_DTPREL16_HI:
14421         case R_PPC64_GOT_DTPREL16_HA:
14422           tls_type = TLS_TLS | TLS_DTPREL;
14423           goto dogot;
14424
14425         case R_PPC64_GOT16:
14426         case R_PPC64_GOT16_LO:
14427         case R_PPC64_GOT16_HI:
14428         case R_PPC64_GOT16_HA:
14429         case R_PPC64_GOT16_DS:
14430         case R_PPC64_GOT16_LO_DS:
14431         dogot:
14432           {
14433             /* Relocation is to the entry for this symbol in the global
14434                offset table.  */
14435             asection *got;
14436             bfd_vma *offp;
14437             bfd_vma off;
14438             unsigned long indx = 0;
14439             struct got_entry *ent;
14440
14441             if (tls_type == (TLS_TLS | TLS_LD)
14442                 && (h == NULL
14443                     || !h->elf.def_dynamic))
14444               ent = ppc64_tlsld_got (input_bfd);
14445             else
14446               {
14447                 if (h != NULL)
14448                   {
14449                     if (!htab->elf.dynamic_sections_created
14450                         || h->elf.dynindx == -1
14451                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14452                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14453                       /* This is actually a static link, or it is a
14454                          -Bsymbolic link and the symbol is defined
14455                          locally, or the symbol was forced to be local
14456                          because of a version file.  */
14457                       ;
14458                     else
14459                       {
14460                         indx = h->elf.dynindx;
14461                         unresolved_reloc = FALSE;
14462                       }
14463                     ent = h->elf.got.glist;
14464                   }
14465                 else
14466                   {
14467                     if (local_got_ents == NULL)
14468                       abort ();
14469                     ent = local_got_ents[r_symndx];
14470                   }
14471
14472                 for (; ent != NULL; ent = ent->next)
14473                   if (ent->addend == orig_rel.r_addend
14474                       && ent->owner == input_bfd
14475                       && ent->tls_type == tls_type)
14476                     break;
14477               }
14478
14479             if (ent == NULL)
14480               abort ();
14481             if (ent->is_indirect)
14482               ent = ent->got.ent;
14483             offp = &ent->got.offset;
14484             got = ppc64_elf_tdata (ent->owner)->got;
14485             if (got == NULL)
14486               abort ();
14487
14488             /* The offset must always be a multiple of 8.  We use the
14489                least significant bit to record whether we have already
14490                processed this entry.  */
14491             off = *offp;
14492             if ((off & 1) != 0)
14493               off &= ~1;
14494             else
14495               {
14496                 /* Generate relocs for the dynamic linker, except in
14497                    the case of TLSLD where we'll use one entry per
14498                    module.  */
14499                 asection *relgot;
14500                 bfd_boolean ifunc;
14501
14502                 *offp = off | 1;
14503                 relgot = NULL;
14504                 ifunc = (h != NULL
14505                          ? h->elf.type == STT_GNU_IFUNC
14506                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14507                 if (ifunc)
14508                   {
14509                     relgot = htab->elf.irelplt;
14510                     if (indx == 0)
14511                       htab->local_ifunc_resolver = 1;
14512                     else if (is_static_defined (&h->elf))
14513                       htab->maybe_local_ifunc_resolver = 1;
14514                   }
14515                 else if (indx != 0
14516                          || (bfd_link_pic (info)
14517                              && (h == NULL
14518                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14519                                  || (tls_type == (TLS_TLS | TLS_LD)
14520                                      && !h->elf.def_dynamic))
14521                              && !(tls_type == (TLS_TLS | TLS_TPREL)
14522                                   && bfd_link_executable (info)
14523                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14524                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14525                 if (relgot != NULL)
14526                   {
14527                     outrel.r_offset = (got->output_section->vma
14528                                        + got->output_offset
14529                                        + off);
14530                     outrel.r_addend = addend;
14531                     if (tls_type & (TLS_LD | TLS_GD))
14532                       {
14533                         outrel.r_addend = 0;
14534                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14535                         if (tls_type == (TLS_TLS | TLS_GD))
14536                           {
14537                             loc = relgot->contents;
14538                             loc += (relgot->reloc_count++
14539                                     * sizeof (Elf64_External_Rela));
14540                             bfd_elf64_swap_reloca_out (output_bfd,
14541                                                        &outrel, loc);
14542                             outrel.r_offset += 8;
14543                             outrel.r_addend = addend;
14544                             outrel.r_info
14545                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14546                           }
14547                       }
14548                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14549                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14550                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14551                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14552                     else if (indx != 0)
14553                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14554                     else
14555                       {
14556                         if (ifunc)
14557                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14558                         else
14559                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14560
14561                         /* Write the .got section contents for the sake
14562                            of prelink.  */
14563                         loc = got->contents + off;
14564                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14565                                     loc);
14566                       }
14567
14568                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14569                       {
14570                         outrel.r_addend += relocation;
14571                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14572                           {
14573                             if (htab->elf.tls_sec == NULL)
14574                               outrel.r_addend = 0;
14575                             else
14576                               outrel.r_addend -= htab->elf.tls_sec->vma;
14577                           }
14578                       }
14579                     loc = relgot->contents;
14580                     loc += (relgot->reloc_count++
14581                             * sizeof (Elf64_External_Rela));
14582                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14583                   }
14584
14585                 /* Init the .got section contents here if we're not
14586                    emitting a reloc.  */
14587                 else
14588                   {
14589                     relocation += addend;
14590                     if (tls_type != 0)
14591                       {
14592                         if (htab->elf.tls_sec == NULL)
14593                           relocation = 0;
14594                         else
14595                           {
14596                             if (tls_type & TLS_LD)
14597                               relocation = 0;
14598                             else
14599                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14600                             if (tls_type & TLS_TPREL)
14601                               relocation += DTP_OFFSET - TP_OFFSET;
14602                           }
14603
14604                         if (tls_type & (TLS_GD | TLS_LD))
14605                           {
14606                             bfd_put_64 (output_bfd, relocation,
14607                                         got->contents + off + 8);
14608                             relocation = 1;
14609                           }
14610                       }
14611                     bfd_put_64 (output_bfd, relocation,
14612                                 got->contents + off);
14613                   }
14614               }
14615
14616             if (off >= (bfd_vma) -2)
14617               abort ();
14618
14619             relocation = got->output_section->vma + got->output_offset + off;
14620             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14621           }
14622           break;
14623
14624         case R_PPC64_PLT16_HA:
14625         case R_PPC64_PLT16_HI:
14626         case R_PPC64_PLT16_LO:
14627         case R_PPC64_PLT32:
14628         case R_PPC64_PLT64:
14629           /* Relocation is to the entry for this symbol in the
14630              procedure linkage table.  */
14631           {
14632             struct plt_entry **plt_list = NULL;
14633             if (h != NULL)
14634               plt_list = &h->elf.plt.plist;
14635             else if (local_got_ents != NULL)
14636               {
14637                 struct plt_entry **local_plt = (struct plt_entry **)
14638                   (local_got_ents + symtab_hdr->sh_info);
14639                 unsigned char *local_got_tls_masks = (unsigned char *)
14640                   (local_plt + symtab_hdr->sh_info);
14641                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14642                   plt_list = local_plt + r_symndx;
14643               }
14644             if (plt_list)
14645               {
14646                 struct plt_entry *ent;
14647
14648                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14649                   if (ent->plt.offset != (bfd_vma) -1
14650                       && ent->addend == orig_rel.r_addend)
14651                     {
14652                       asection *plt;
14653
14654                       plt = htab->elf.splt;
14655                       if (!htab->elf.dynamic_sections_created
14656                           || h == NULL
14657                           || h->elf.dynindx == -1)
14658                         plt = htab->elf.iplt;
14659                       relocation = (plt->output_section->vma
14660                                     + plt->output_offset
14661                                     + ent->plt.offset);
14662                       addend = 0;
14663                       unresolved_reloc = FALSE;
14664                       break;
14665                     }
14666               }
14667           }
14668           break;
14669
14670         case R_PPC64_TOC:
14671           /* Relocation value is TOC base.  */
14672           relocation = TOCstart;
14673           if (r_symndx == STN_UNDEF)
14674             relocation += htab->sec_info[input_section->id].toc_off;
14675           else if (unresolved_reloc)
14676             ;
14677           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14678             relocation += htab->sec_info[sec->id].toc_off;
14679           else
14680             unresolved_reloc = TRUE;
14681           goto dodyn;
14682
14683           /* TOC16 relocs.  We want the offset relative to the TOC base,
14684              which is the address of the start of the TOC plus 0x8000.
14685              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14686              in this order.  */
14687         case R_PPC64_TOC16:
14688         case R_PPC64_TOC16_LO:
14689         case R_PPC64_TOC16_HI:
14690         case R_PPC64_TOC16_DS:
14691         case R_PPC64_TOC16_LO_DS:
14692         case R_PPC64_TOC16_HA:
14693           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14694           break;
14695
14696           /* Relocate against the beginning of the section.  */
14697         case R_PPC64_SECTOFF:
14698         case R_PPC64_SECTOFF_LO:
14699         case R_PPC64_SECTOFF_HI:
14700         case R_PPC64_SECTOFF_DS:
14701         case R_PPC64_SECTOFF_LO_DS:
14702         case R_PPC64_SECTOFF_HA:
14703           if (sec != NULL)
14704             addend -= sec->output_section->vma;
14705           break;
14706
14707         case R_PPC64_REL16:
14708         case R_PPC64_REL16_LO:
14709         case R_PPC64_REL16_HI:
14710         case R_PPC64_REL16_HA:
14711         case R_PPC64_REL16DX_HA:
14712           break;
14713
14714         case R_PPC64_REL14:
14715         case R_PPC64_REL14_BRNTAKEN:
14716         case R_PPC64_REL14_BRTAKEN:
14717         case R_PPC64_REL24:
14718           break;
14719
14720         case R_PPC64_TPREL16:
14721         case R_PPC64_TPREL16_LO:
14722         case R_PPC64_TPREL16_HI:
14723         case R_PPC64_TPREL16_HA:
14724         case R_PPC64_TPREL16_DS:
14725         case R_PPC64_TPREL16_LO_DS:
14726         case R_PPC64_TPREL16_HIGH:
14727         case R_PPC64_TPREL16_HIGHA:
14728         case R_PPC64_TPREL16_HIGHER:
14729         case R_PPC64_TPREL16_HIGHERA:
14730         case R_PPC64_TPREL16_HIGHEST:
14731         case R_PPC64_TPREL16_HIGHESTA:
14732           if (h != NULL
14733               && h->elf.root.type == bfd_link_hash_undefweak
14734               && h->elf.dynindx == -1)
14735             {
14736               /* Make this relocation against an undefined weak symbol
14737                  resolve to zero.  This is really just a tweak, since
14738                  code using weak externs ought to check that they are
14739                  defined before using them.  */
14740               bfd_byte *p = contents + rel->r_offset - d_offset;
14741
14742               insn = bfd_get_32 (input_bfd, p);
14743               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14744               if (insn != 0)
14745                 bfd_put_32 (input_bfd, insn, p);
14746               break;
14747             }
14748           if (htab->elf.tls_sec != NULL)
14749             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14750           /* The TPREL16 relocs shouldn't really be used in shared
14751              libs or with non-local symbols as that will result in
14752              DT_TEXTREL being set, but support them anyway.  */
14753           goto dodyn;
14754
14755         case R_PPC64_DTPREL16:
14756         case R_PPC64_DTPREL16_LO:
14757         case R_PPC64_DTPREL16_HI:
14758         case R_PPC64_DTPREL16_HA:
14759         case R_PPC64_DTPREL16_DS:
14760         case R_PPC64_DTPREL16_LO_DS:
14761         case R_PPC64_DTPREL16_HIGH:
14762         case R_PPC64_DTPREL16_HIGHA:
14763         case R_PPC64_DTPREL16_HIGHER:
14764         case R_PPC64_DTPREL16_HIGHERA:
14765         case R_PPC64_DTPREL16_HIGHEST:
14766         case R_PPC64_DTPREL16_HIGHESTA:
14767           if (htab->elf.tls_sec != NULL)
14768             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14769           break;
14770
14771         case R_PPC64_ADDR64_LOCAL:
14772           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14773                                               ? h->elf.other
14774                                               : sym->st_other);
14775           break;
14776
14777         case R_PPC64_DTPMOD64:
14778           relocation = 1;
14779           addend = 0;
14780           goto dodyn;
14781
14782         case R_PPC64_TPREL64:
14783           if (htab->elf.tls_sec != NULL)
14784             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14785           goto dodyn;
14786
14787         case R_PPC64_DTPREL64:
14788           if (htab->elf.tls_sec != NULL)
14789             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14790           /* Fall through.  */
14791
14792           /* Relocations that may need to be propagated if this is a
14793              dynamic object.  */
14794         case R_PPC64_REL30:
14795         case R_PPC64_REL32:
14796         case R_PPC64_REL64:
14797         case R_PPC64_ADDR14:
14798         case R_PPC64_ADDR14_BRNTAKEN:
14799         case R_PPC64_ADDR14_BRTAKEN:
14800         case R_PPC64_ADDR16:
14801         case R_PPC64_ADDR16_DS:
14802         case R_PPC64_ADDR16_HA:
14803         case R_PPC64_ADDR16_HI:
14804         case R_PPC64_ADDR16_HIGH:
14805         case R_PPC64_ADDR16_HIGHA:
14806         case R_PPC64_ADDR16_HIGHER:
14807         case R_PPC64_ADDR16_HIGHERA:
14808         case R_PPC64_ADDR16_HIGHEST:
14809         case R_PPC64_ADDR16_HIGHESTA:
14810         case R_PPC64_ADDR16_LO:
14811         case R_PPC64_ADDR16_LO_DS:
14812         case R_PPC64_ADDR24:
14813         case R_PPC64_ADDR32:
14814         case R_PPC64_ADDR64:
14815         case R_PPC64_UADDR16:
14816         case R_PPC64_UADDR32:
14817         case R_PPC64_UADDR64:
14818         dodyn:
14819           if ((input_section->flags & SEC_ALLOC) == 0)
14820             break;
14821
14822           if (NO_OPD_RELOCS && is_opd)
14823             break;
14824
14825           if (bfd_link_pic (info)
14826               ? ((h == NULL
14827                   || h->dyn_relocs != NULL)
14828                  && ((h != NULL && pc_dynrelocs (h))
14829                      || must_be_dyn_reloc (info, r_type)))
14830               : (h != NULL
14831                  ? h->dyn_relocs != NULL
14832                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14833             {
14834               bfd_boolean skip, relocate;
14835               asection *sreloc;
14836               bfd_vma out_off;
14837               long indx = 0;
14838
14839               /* When generating a dynamic object, these relocations
14840                  are copied into the output file to be resolved at run
14841                  time.  */
14842
14843               skip = FALSE;
14844               relocate = FALSE;
14845
14846               out_off = _bfd_elf_section_offset (output_bfd, info,
14847                                                  input_section, rel->r_offset);
14848               if (out_off == (bfd_vma) -1)
14849                 skip = TRUE;
14850               else if (out_off == (bfd_vma) -2)
14851                 skip = TRUE, relocate = TRUE;
14852               out_off += (input_section->output_section->vma
14853                           + input_section->output_offset);
14854               outrel.r_offset = out_off;
14855               outrel.r_addend = rel->r_addend;
14856
14857               /* Optimize unaligned reloc use.  */
14858               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14859                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14860                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14861               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14862                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14863                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14864               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14865                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14866                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14867
14868               if (skip)
14869                 memset (&outrel, 0, sizeof outrel);
14870               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14871                        && !is_opd
14872                        && r_type != R_PPC64_TOC)
14873                 {
14874                   indx = h->elf.dynindx;
14875                   BFD_ASSERT (indx != -1);
14876                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14877                 }
14878               else
14879                 {
14880                   /* This symbol is local, or marked to become local,
14881                      or this is an opd section reloc which must point
14882                      at a local function.  */
14883                   outrel.r_addend += relocation;
14884                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14885                     {
14886                       if (is_opd && h != NULL)
14887                         {
14888                           /* Lie about opd entries.  This case occurs
14889                              when building shared libraries and we
14890                              reference a function in another shared
14891                              lib.  The same thing happens for a weak
14892                              definition in an application that's
14893                              overridden by a strong definition in a
14894                              shared lib.  (I believe this is a generic
14895                              bug in binutils handling of weak syms.)
14896                              In these cases we won't use the opd
14897                              entry in this lib.  */
14898                           unresolved_reloc = FALSE;
14899                         }
14900                       if (!is_opd
14901                           && r_type == R_PPC64_ADDR64
14902                           && (h != NULL
14903                               ? h->elf.type == STT_GNU_IFUNC
14904                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14905                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14906                       else
14907                         {
14908                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14909
14910                           /* We need to relocate .opd contents for ld.so.
14911                              Prelink also wants simple and consistent rules
14912                              for relocs.  This make all RELATIVE relocs have
14913                              *r_offset equal to r_addend.  */
14914                           relocate = TRUE;
14915                         }
14916                     }
14917                   else
14918                     {
14919                       if (h != NULL
14920                           ? h->elf.type == STT_GNU_IFUNC
14921                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14922                         {
14923                           info->callbacks->einfo
14924                             /* xgettext:c-format */
14925                             (_("%H: %s for indirect "
14926                                "function `%pT' unsupported\n"),
14927                              input_bfd, input_section, rel->r_offset,
14928                              ppc64_elf_howto_table[r_type]->name,
14929                              sym_name);
14930                           ret = FALSE;
14931                         }
14932                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14933                         ;
14934                       else if (sec == NULL || sec->owner == NULL)
14935                         {
14936                           bfd_set_error (bfd_error_bad_value);
14937                           return FALSE;
14938                         }
14939                       else
14940                         {
14941                           asection *osec;
14942
14943                           osec = sec->output_section;
14944                           indx = elf_section_data (osec)->dynindx;
14945
14946                           if (indx == 0)
14947                             {
14948                               if ((osec->flags & SEC_READONLY) == 0
14949                                   && htab->elf.data_index_section != NULL)
14950                                 osec = htab->elf.data_index_section;
14951                               else
14952                                 osec = htab->elf.text_index_section;
14953                               indx = elf_section_data (osec)->dynindx;
14954                             }
14955                           BFD_ASSERT (indx != 0);
14956
14957                           /* We are turning this relocation into one
14958                              against a section symbol, so subtract out
14959                              the output section's address but not the
14960                              offset of the input section in the output
14961                              section.  */
14962                           outrel.r_addend -= osec->vma;
14963                         }
14964
14965                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14966                     }
14967                 }
14968
14969               sreloc = elf_section_data (input_section)->sreloc;
14970               if (h != NULL
14971                   ? h->elf.type == STT_GNU_IFUNC
14972                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14973                 {
14974                   sreloc = htab->elf.irelplt;
14975                   if (indx == 0)
14976                     htab->local_ifunc_resolver = 1;
14977                   else if (is_static_defined (&h->elf))
14978                     htab->maybe_local_ifunc_resolver = 1;
14979                 }
14980               if (sreloc == NULL)
14981                 abort ();
14982
14983               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14984                   >= sreloc->size)
14985                 abort ();
14986               loc = sreloc->contents;
14987               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14988               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14989
14990               /* If this reloc is against an external symbol, it will
14991                  be computed at runtime, so there's no need to do
14992                  anything now.  However, for the sake of prelink ensure
14993                  that the section contents are a known value.  */
14994               if (! relocate)
14995                 {
14996                   unresolved_reloc = FALSE;
14997                   /* The value chosen here is quite arbitrary as ld.so
14998                      ignores section contents except for the special
14999                      case of .opd where the contents might be accessed
15000                      before relocation.  Choose zero, as that won't
15001                      cause reloc overflow.  */
15002                   relocation = 0;
15003                   addend = 0;
15004                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15005                      to improve backward compatibility with older
15006                      versions of ld.  */
15007                   if (r_type == R_PPC64_ADDR64)
15008                     addend = outrel.r_addend;
15009                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15010                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15011                     addend = outrel.r_offset;
15012                 }
15013             }
15014           break;
15015
15016         case R_PPC64_COPY:
15017         case R_PPC64_GLOB_DAT:
15018         case R_PPC64_JMP_SLOT:
15019         case R_PPC64_JMP_IREL:
15020         case R_PPC64_RELATIVE:
15021           /* We shouldn't ever see these dynamic relocs in relocatable
15022              files.  */
15023           /* Fall through.  */
15024
15025         case R_PPC64_PLTGOT16:
15026         case R_PPC64_PLTGOT16_DS:
15027         case R_PPC64_PLTGOT16_HA:
15028         case R_PPC64_PLTGOT16_HI:
15029         case R_PPC64_PLTGOT16_LO:
15030         case R_PPC64_PLTGOT16_LO_DS:
15031         case R_PPC64_PLTREL32:
15032         case R_PPC64_PLTREL64:
15033           /* These ones haven't been implemented yet.  */
15034
15035           info->callbacks->einfo
15036             /* xgettext:c-format */
15037             (_("%P: %pB: %s is not supported for `%pT'\n"),
15038              input_bfd,
15039              ppc64_elf_howto_table[r_type]->name, sym_name);
15040
15041           bfd_set_error (bfd_error_invalid_operation);
15042           ret = FALSE;
15043           goto copy_reloc;
15044         }
15045
15046       /* Multi-instruction sequences that access the TOC can be
15047          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15048          to             nop;           addi rb,r2,x;  */
15049       switch (r_type)
15050         {
15051         default:
15052           break;
15053
15054         case R_PPC64_GOT_TLSLD16_HI:
15055         case R_PPC64_GOT_TLSGD16_HI:
15056         case R_PPC64_GOT_TPREL16_HI:
15057         case R_PPC64_GOT_DTPREL16_HI:
15058         case R_PPC64_GOT16_HI:
15059         case R_PPC64_TOC16_HI:
15060           /* These relocs would only be useful if building up an
15061              offset to later add to r2, perhaps in an indexed
15062              addressing mode instruction.  Don't try to optimize.
15063              Unfortunately, the possibility of someone building up an
15064              offset like this or even with the HA relocs, means that
15065              we need to check the high insn when optimizing the low
15066              insn.  */
15067           break;
15068
15069         case R_PPC64_GOT_TLSLD16_HA:
15070         case R_PPC64_GOT_TLSGD16_HA:
15071         case R_PPC64_GOT_TPREL16_HA:
15072         case R_PPC64_GOT_DTPREL16_HA:
15073         case R_PPC64_GOT16_HA:
15074         case R_PPC64_TOC16_HA:
15075           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15076               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15077             {
15078               bfd_byte *p = contents + (rel->r_offset & ~3);
15079               bfd_put_32 (input_bfd, NOP, p);
15080               goto copy_reloc;
15081             }
15082           break;
15083
15084         case R_PPC64_GOT_TLSLD16_LO:
15085         case R_PPC64_GOT_TLSGD16_LO:
15086         case R_PPC64_GOT_TPREL16_LO_DS:
15087         case R_PPC64_GOT_DTPREL16_LO_DS:
15088         case R_PPC64_GOT16_LO:
15089         case R_PPC64_GOT16_LO_DS:
15090         case R_PPC64_TOC16_LO:
15091         case R_PPC64_TOC16_LO_DS:
15092           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15093               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15094             {
15095               bfd_byte *p = contents + (rel->r_offset & ~3);
15096               insn = bfd_get_32 (input_bfd, p);
15097               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15098                 {
15099                   /* Transform addic to addi when we change reg.  */
15100                   insn &= ~((0x3f << 26) | (0x1f << 16));
15101                   insn |= (14u << 26) | (2 << 16);
15102                 }
15103               else
15104                 {
15105                   insn &= ~(0x1f << 16);
15106                   insn |= 2 << 16;
15107                 }
15108               bfd_put_32 (input_bfd, insn, p);
15109             }
15110           break;
15111
15112         case R_PPC64_TPREL16_HA:
15113           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15114             {
15115               bfd_byte *p = contents + (rel->r_offset & ~3);
15116               insn = bfd_get_32 (input_bfd, p);
15117               if ((insn & ((0x3f << 26) | 0x1f << 16))
15118                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15119                 /* xgettext:c-format */
15120                 info->callbacks->minfo
15121                   (_("%H: warning: %s unexpected insn %#x.\n"),
15122                    input_bfd, input_section, rel->r_offset,
15123                    ppc64_elf_howto_table[r_type]->name, insn);
15124               else
15125                 {
15126                   bfd_put_32 (input_bfd, NOP, p);
15127                   goto copy_reloc;
15128                 }
15129             }
15130           break;
15131
15132         case R_PPC64_TPREL16_LO:
15133         case R_PPC64_TPREL16_LO_DS:
15134           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15135             {
15136               bfd_byte *p = contents + (rel->r_offset & ~3);
15137               insn = bfd_get_32 (input_bfd, p);
15138               insn &= ~(0x1f << 16);
15139               insn |= 13 << 16;
15140               bfd_put_32 (input_bfd, insn, p);
15141             }
15142           break;
15143         }
15144
15145       /* Do any further special processing.  */
15146       switch (r_type)
15147         {
15148         default:
15149           break;
15150
15151         case R_PPC64_REL16_HA:
15152         case R_PPC64_REL16DX_HA:
15153         case R_PPC64_ADDR16_HA:
15154         case R_PPC64_ADDR16_HIGHA:
15155         case R_PPC64_ADDR16_HIGHERA:
15156         case R_PPC64_ADDR16_HIGHESTA:
15157         case R_PPC64_TOC16_HA:
15158         case R_PPC64_SECTOFF_HA:
15159         case R_PPC64_TPREL16_HA:
15160         case R_PPC64_TPREL16_HIGHA:
15161         case R_PPC64_TPREL16_HIGHERA:
15162         case R_PPC64_TPREL16_HIGHESTA:
15163         case R_PPC64_DTPREL16_HA:
15164         case R_PPC64_DTPREL16_HIGHA:
15165         case R_PPC64_DTPREL16_HIGHERA:
15166         case R_PPC64_DTPREL16_HIGHESTA:
15167           /* It's just possible that this symbol is a weak symbol
15168              that's not actually defined anywhere. In that case,
15169              'sec' would be NULL, and we should leave the symbol
15170              alone (it will be set to zero elsewhere in the link).  */
15171           if (sec == NULL)
15172             break;
15173           /* Fall through.  */
15174
15175         case R_PPC64_GOT16_HA:
15176         case R_PPC64_PLTGOT16_HA:
15177         case R_PPC64_PLT16_HA:
15178         case R_PPC64_GOT_TLSGD16_HA:
15179         case R_PPC64_GOT_TLSLD16_HA:
15180         case R_PPC64_GOT_TPREL16_HA:
15181         case R_PPC64_GOT_DTPREL16_HA:
15182           /* Add 0x10000 if sign bit in 0:15 is set.
15183              Bits 0:15 are not used.  */
15184           addend += 0x8000;
15185           break;
15186
15187         case R_PPC64_ADDR16_DS:
15188         case R_PPC64_ADDR16_LO_DS:
15189         case R_PPC64_GOT16_DS:
15190         case R_PPC64_GOT16_LO_DS:
15191         case R_PPC64_PLT16_LO_DS:
15192         case R_PPC64_SECTOFF_DS:
15193         case R_PPC64_SECTOFF_LO_DS:
15194         case R_PPC64_TOC16_DS:
15195         case R_PPC64_TOC16_LO_DS:
15196         case R_PPC64_PLTGOT16_DS:
15197         case R_PPC64_PLTGOT16_LO_DS:
15198         case R_PPC64_GOT_TPREL16_DS:
15199         case R_PPC64_GOT_TPREL16_LO_DS:
15200         case R_PPC64_GOT_DTPREL16_DS:
15201         case R_PPC64_GOT_DTPREL16_LO_DS:
15202         case R_PPC64_TPREL16_DS:
15203         case R_PPC64_TPREL16_LO_DS:
15204         case R_PPC64_DTPREL16_DS:
15205         case R_PPC64_DTPREL16_LO_DS:
15206           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15207           mask = 3;
15208           /* If this reloc is against an lq, lxv, or stxv insn, then
15209              the value must be a multiple of 16.  This is somewhat of
15210              a hack, but the "correct" way to do this by defining _DQ
15211              forms of all the _DS relocs bloats all reloc switches in
15212              this file.  It doesn't make much sense to use these
15213              relocs in data, so testing the insn should be safe.  */
15214           if ((insn & (0x3f << 26)) == (56u << 26)
15215               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15216             mask = 15;
15217           relocation += addend;
15218           addend = insn & (mask ^ 3);
15219           if ((relocation & mask) != 0)
15220             {
15221               relocation ^= relocation & mask;
15222               info->callbacks->einfo
15223                 /* xgettext:c-format */
15224                 (_("%H: error: %s not a multiple of %u\n"),
15225                  input_bfd, input_section, rel->r_offset,
15226                  ppc64_elf_howto_table[r_type]->name,
15227                  mask + 1);
15228               bfd_set_error (bfd_error_bad_value);
15229               ret = FALSE;
15230               goto copy_reloc;
15231             }
15232           break;
15233         }
15234
15235       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15236          because such sections are not SEC_ALLOC and thus ld.so will
15237          not process them.  */
15238       howto = ppc64_elf_howto_table[(int) r_type];
15239       if (unresolved_reloc
15240           && !((input_section->flags & SEC_DEBUGGING) != 0
15241                && h->elf.def_dynamic)
15242           && _bfd_elf_section_offset (output_bfd, info, input_section,
15243                                       rel->r_offset) != (bfd_vma) -1)
15244         {
15245           info->callbacks->einfo
15246             /* xgettext:c-format */
15247             (_("%H: unresolvable %s against `%pT'\n"),
15248              input_bfd, input_section, rel->r_offset,
15249              howto->name,
15250              h->elf.root.root.string);
15251           ret = FALSE;
15252         }
15253
15254       /* 16-bit fields in insns mostly have signed values, but a
15255          few insns have 16-bit unsigned values.  Really, we should
15256          have different reloc types.  */
15257       if (howto->complain_on_overflow != complain_overflow_dont
15258           && howto->dst_mask == 0xffff
15259           && (input_section->flags & SEC_CODE) != 0)
15260         {
15261           enum complain_overflow complain = complain_overflow_signed;
15262
15263           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15264           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15265             complain = complain_overflow_bitfield;
15266           else if (howto->rightshift == 0
15267                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15268                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15269                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15270                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15271                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15272                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15273             complain = complain_overflow_unsigned;
15274           if (howto->complain_on_overflow != complain)
15275             {
15276               alt_howto = *howto;
15277               alt_howto.complain_on_overflow = complain;
15278               howto = &alt_howto;
15279             }
15280         }
15281
15282       if (r_type == R_PPC64_REL16DX_HA)
15283         {
15284           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15285           if (rel->r_offset + 4 > input_section->size)
15286             r = bfd_reloc_outofrange;
15287           else
15288             {
15289               relocation += addend;
15290               relocation -= (rel->r_offset
15291                              + input_section->output_offset
15292                              + input_section->output_section->vma);
15293               relocation = (bfd_signed_vma) relocation >> 16;
15294               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15295               insn &= ~0x1fffc1;
15296               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15297               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15298               r = bfd_reloc_ok;
15299               if (relocation + 0x8000 > 0xffff)
15300                 r = bfd_reloc_overflow;
15301             }
15302         }
15303       else
15304         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15305                                       rel->r_offset, relocation, addend);
15306
15307       if (r != bfd_reloc_ok)
15308         {
15309           char *more_info = NULL;
15310           const char *reloc_name = howto->name;
15311
15312           if (reloc_dest != DEST_NORMAL)
15313             {
15314               more_info = bfd_malloc (strlen (reloc_name) + 8);
15315               if (more_info != NULL)
15316                 {
15317                   strcpy (more_info, reloc_name);
15318                   strcat (more_info, (reloc_dest == DEST_OPD
15319                                       ? " (OPD)" : " (stub)"));
15320                   reloc_name = more_info;
15321                 }
15322             }
15323
15324           if (r == bfd_reloc_overflow)
15325             {
15326               /* On code like "if (foo) foo();" don't report overflow
15327                  on a branch to zero when foo is undefined.  */
15328               if (!warned
15329                   && (reloc_dest == DEST_STUB
15330                       || !(h != NULL
15331                            && (h->elf.root.type == bfd_link_hash_undefweak
15332                                || h->elf.root.type == bfd_link_hash_undefined)
15333                            && is_branch_reloc (r_type))))
15334                 info->callbacks->reloc_overflow (info, &h->elf.root,
15335                                                  sym_name, reloc_name,
15336                                                  orig_rel.r_addend,
15337                                                  input_bfd, input_section,
15338                                                  rel->r_offset);
15339             }
15340           else
15341             {
15342               info->callbacks->einfo
15343                 /* xgettext:c-format */
15344                 (_("%H: %s against `%pT': error %d\n"),
15345                  input_bfd, input_section, rel->r_offset,
15346                  reloc_name, sym_name, (int) r);
15347               ret = FALSE;
15348             }
15349           if (more_info != NULL)
15350             free (more_info);
15351         }
15352     copy_reloc:
15353       if (wrel != rel)
15354         *wrel = *rel;
15355     }
15356
15357   if (wrel != rel)
15358     {
15359       Elf_Internal_Shdr *rel_hdr;
15360       size_t deleted = rel - wrel;
15361
15362       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15363       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15364       if (rel_hdr->sh_size == 0)
15365         {
15366           /* It is too late to remove an empty reloc section.  Leave
15367              one NONE reloc.
15368              ??? What is wrong with an empty section???  */
15369           rel_hdr->sh_size = rel_hdr->sh_entsize;
15370           deleted -= 1;
15371         }
15372       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15373       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15374       input_section->reloc_count -= deleted;
15375     }
15376
15377   /* If we're emitting relocations, then shortly after this function
15378      returns, reloc offsets and addends for this section will be
15379      adjusted.  Worse, reloc symbol indices will be for the output
15380      file rather than the input.  Save a copy of the relocs for
15381      opd_entry_value.  */
15382   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15383     {
15384       bfd_size_type amt;
15385       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15386       rel = bfd_alloc (input_bfd, amt);
15387       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15388       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15389       if (rel == NULL)
15390         return FALSE;
15391       memcpy (rel, relocs, amt);
15392     }
15393   return ret;
15394 }
15395
15396 /* Adjust the value of any local symbols in opd sections.  */
15397
15398 static int
15399 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15400                               const char *name ATTRIBUTE_UNUSED,
15401                               Elf_Internal_Sym *elfsym,
15402                               asection *input_sec,
15403                               struct elf_link_hash_entry *h)
15404 {
15405   struct _opd_sec_data *opd;
15406   long adjust;
15407   bfd_vma value;
15408
15409   if (h != NULL)
15410     return 1;
15411
15412   opd = get_opd_info (input_sec);
15413   if (opd == NULL || opd->adjust == NULL)
15414     return 1;
15415
15416   value = elfsym->st_value - input_sec->output_offset;
15417   if (!bfd_link_relocatable (info))
15418     value -= input_sec->output_section->vma;
15419
15420   adjust = opd->adjust[OPD_NDX (value)];
15421   if (adjust == -1)
15422     return 2;
15423
15424   elfsym->st_value += adjust;
15425   return 1;
15426 }
15427
15428 /* Finish up dynamic symbol handling.  We set the contents of various
15429    dynamic sections here.  */
15430
15431 static bfd_boolean
15432 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15433                                  struct bfd_link_info *info,
15434                                  struct elf_link_hash_entry *h,
15435                                  Elf_Internal_Sym *sym)
15436 {
15437   struct ppc_link_hash_table *htab;
15438   struct plt_entry *ent;
15439   Elf_Internal_Rela rela;
15440   bfd_byte *loc;
15441
15442   htab = ppc_hash_table (info);
15443   if (htab == NULL)
15444     return FALSE;
15445
15446   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15447     if (ent->plt.offset != (bfd_vma) -1)
15448       {
15449         /* This symbol has an entry in the procedure linkage
15450            table.  Set it up.  */
15451         if (!htab->elf.dynamic_sections_created
15452             || h->dynindx == -1)
15453           {
15454             BFD_ASSERT (h->type == STT_GNU_IFUNC
15455                         && h->def_regular
15456                         && (h->root.type == bfd_link_hash_defined
15457                             || h->root.type == bfd_link_hash_defweak));
15458             rela.r_offset = (htab->elf.iplt->output_section->vma
15459                              + htab->elf.iplt->output_offset
15460                              + ent->plt.offset);
15461             if (htab->opd_abi)
15462               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15463             else
15464               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15465             rela.r_addend = (h->root.u.def.value
15466                              + h->root.u.def.section->output_offset
15467                              + h->root.u.def.section->output_section->vma
15468                              + ent->addend);
15469             loc = (htab->elf.irelplt->contents
15470                    + (htab->elf.irelplt->reloc_count++
15471                       * sizeof (Elf64_External_Rela)));
15472             htab->local_ifunc_resolver = 1;
15473           }
15474         else
15475           {
15476             rela.r_offset = (htab->elf.splt->output_section->vma
15477                              + htab->elf.splt->output_offset
15478                              + ent->plt.offset);
15479             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15480             rela.r_addend = ent->addend;
15481             loc = (htab->elf.srelplt->contents
15482                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15483                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15484             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15485               htab->maybe_local_ifunc_resolver = 1;
15486           }
15487         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15488
15489         if (!htab->opd_abi)
15490           {
15491             if (!h->def_regular)
15492               {
15493                 /* Mark the symbol as undefined, rather than as
15494                    defined in glink.  Leave the value if there were
15495                    any relocations where pointer equality matters
15496                    (this is a clue for the dynamic linker, to make
15497                    function pointer comparisons work between an
15498                    application and shared library), otherwise set it
15499                    to zero.  */
15500                 sym->st_shndx = SHN_UNDEF;
15501                 if (!h->pointer_equality_needed)
15502                   sym->st_value = 0;
15503                 else if (!h->ref_regular_nonweak)
15504                   {
15505                     /* This breaks function pointer comparisons, but
15506                        that is better than breaking tests for a NULL
15507                        function pointer.  */
15508                     sym->st_value = 0;
15509                   }
15510               }
15511           }
15512       }
15513
15514   if (h->needs_copy)
15515     {
15516       /* This symbol needs a copy reloc.  Set it up.  */
15517       asection *srel;
15518
15519       if (h->dynindx == -1
15520           || (h->root.type != bfd_link_hash_defined
15521               && h->root.type != bfd_link_hash_defweak)
15522           || htab->elf.srelbss == NULL
15523           || htab->elf.sreldynrelro == NULL)
15524         abort ();
15525
15526       rela.r_offset = (h->root.u.def.value
15527                        + h->root.u.def.section->output_section->vma
15528                        + h->root.u.def.section->output_offset);
15529       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15530       rela.r_addend = 0;
15531       if (h->root.u.def.section == htab->elf.sdynrelro)
15532         srel = htab->elf.sreldynrelro;
15533       else
15534         srel = htab->elf.srelbss;
15535       loc = srel->contents;
15536       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15537       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15538     }
15539
15540   return TRUE;
15541 }
15542
15543 /* Used to decide how to sort relocs in an optimal manner for the
15544    dynamic linker, before writing them out.  */
15545
15546 static enum elf_reloc_type_class
15547 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15548                             const asection *rel_sec,
15549                             const Elf_Internal_Rela *rela)
15550 {
15551   enum elf_ppc64_reloc_type r_type;
15552   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15553
15554   if (rel_sec == htab->elf.irelplt)
15555     return reloc_class_ifunc;
15556
15557   r_type = ELF64_R_TYPE (rela->r_info);
15558   switch (r_type)
15559     {
15560     case R_PPC64_RELATIVE:
15561       return reloc_class_relative;
15562     case R_PPC64_JMP_SLOT:
15563       return reloc_class_plt;
15564     case R_PPC64_COPY:
15565       return reloc_class_copy;
15566     default:
15567       return reloc_class_normal;
15568     }
15569 }
15570
15571 /* Finish up the dynamic sections.  */
15572
15573 static bfd_boolean
15574 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15575                                    struct bfd_link_info *info)
15576 {
15577   struct ppc_link_hash_table *htab;
15578   bfd *dynobj;
15579   asection *sdyn;
15580
15581   htab = ppc_hash_table (info);
15582   if (htab == NULL)
15583     return FALSE;
15584
15585   dynobj = htab->elf.dynobj;
15586   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15587
15588   if (htab->elf.dynamic_sections_created)
15589     {
15590       Elf64_External_Dyn *dyncon, *dynconend;
15591
15592       if (sdyn == NULL || htab->elf.sgot == NULL)
15593         abort ();
15594
15595       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15596       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15597       for (; dyncon < dynconend; dyncon++)
15598         {
15599           Elf_Internal_Dyn dyn;
15600           asection *s;
15601
15602           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15603
15604           switch (dyn.d_tag)
15605             {
15606             default:
15607               continue;
15608
15609             case DT_PPC64_GLINK:
15610               s = htab->glink;
15611               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15612               /* We stupidly defined DT_PPC64_GLINK to be the start
15613                  of glink rather than the first entry point, which is
15614                  what ld.so needs, and now have a bigger stub to
15615                  support automatic multiple TOCs.  */
15616               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
15617               break;
15618
15619             case DT_PPC64_OPD:
15620               s = bfd_get_section_by_name (output_bfd, ".opd");
15621               if (s == NULL)
15622                 continue;
15623               dyn.d_un.d_ptr = s->vma;
15624               break;
15625
15626             case DT_PPC64_OPT:
15627               if (htab->do_multi_toc && htab->multi_toc_needed)
15628                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15629               if (htab->has_plt_localentry0)
15630                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15631               break;
15632
15633             case DT_PPC64_OPDSZ:
15634               s = bfd_get_section_by_name (output_bfd, ".opd");
15635               if (s == NULL)
15636                 continue;
15637               dyn.d_un.d_val = s->size;
15638               break;
15639
15640             case DT_PLTGOT:
15641               s = htab->elf.splt;
15642               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15643               break;
15644
15645             case DT_JMPREL:
15646               s = htab->elf.srelplt;
15647               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15648               break;
15649
15650             case DT_PLTRELSZ:
15651               dyn.d_un.d_val = htab->elf.srelplt->size;
15652               break;
15653
15654             case DT_TEXTREL:
15655               if (htab->local_ifunc_resolver)
15656                 info->callbacks->einfo
15657                   (_("%X%P: text relocations and GNU indirect "
15658                      "functions will result in a segfault at runtime\n"));
15659               else if (htab->maybe_local_ifunc_resolver)
15660                 info->callbacks->einfo
15661                   (_("%P: warning: text relocations and GNU indirect "
15662                      "functions may result in a segfault at runtime\n"));
15663               continue;
15664             }
15665
15666           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15667         }
15668     }
15669
15670   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15671       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15672     {
15673       /* Fill in the first entry in the global offset table.
15674          We use it to hold the link-time TOCbase.  */
15675       bfd_put_64 (output_bfd,
15676                   elf_gp (output_bfd) + TOC_BASE_OFF,
15677                   htab->elf.sgot->contents);
15678
15679       /* Set .got entry size.  */
15680       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15681     }
15682
15683   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15684       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15685     {
15686       /* Set .plt entry size.  */
15687       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15688         = PLT_ENTRY_SIZE (htab);
15689     }
15690
15691   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15692      brlt ourselves if emitrelocations.  */
15693   if (htab->brlt != NULL
15694       && htab->brlt->reloc_count != 0
15695       && !_bfd_elf_link_output_relocs (output_bfd,
15696                                        htab->brlt,
15697                                        elf_section_data (htab->brlt)->rela.hdr,
15698                                        elf_section_data (htab->brlt)->relocs,
15699                                        NULL))
15700     return FALSE;
15701
15702   if (htab->glink != NULL
15703       && htab->glink->reloc_count != 0
15704       && !_bfd_elf_link_output_relocs (output_bfd,
15705                                        htab->glink,
15706                                        elf_section_data (htab->glink)->rela.hdr,
15707                                        elf_section_data (htab->glink)->relocs,
15708                                        NULL))
15709     return FALSE;
15710
15711   if (htab->glink_eh_frame != NULL
15712       && htab->glink_eh_frame->size != 0)
15713     {
15714       bfd_vma val;
15715       bfd_byte *p;
15716       struct map_stub *group;
15717       size_t align = 4;
15718
15719       p = htab->glink_eh_frame->contents;
15720       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15721
15722       for (group = htab->group; group != NULL; group = group->next)
15723         if (group->stub_sec != NULL)
15724           {
15725             /* Offset to stub section.  */
15726             val = (group->stub_sec->output_section->vma
15727                    + group->stub_sec->output_offset);
15728             val -= (htab->glink_eh_frame->output_section->vma
15729                     + htab->glink_eh_frame->output_offset
15730                     + (p + 8 - htab->glink_eh_frame->contents));
15731             if (val + 0x80000000 > 0xffffffff)
15732               {
15733                 _bfd_error_handler
15734                   (_("%s offset too large for .eh_frame sdata4 encoding"),
15735                    group->stub_sec->name);
15736                 return FALSE;
15737               }
15738             bfd_put_32 (dynobj, val, p + 8);
15739             p += stub_eh_frame_size (group, align);
15740           }
15741       if (htab->glink != NULL && htab->glink->size != 0)
15742         {
15743           /* Offset to .glink.  */
15744           val = (htab->glink->output_section->vma
15745                  + htab->glink->output_offset
15746                  + 8);
15747           val -= (htab->glink_eh_frame->output_section->vma
15748                   + htab->glink_eh_frame->output_offset
15749                   + (p + 8 - htab->glink_eh_frame->contents));
15750           if (val + 0x80000000 > 0xffffffff)
15751             {
15752               _bfd_error_handler
15753                 (_("%s offset too large for .eh_frame sdata4 encoding"),
15754                  htab->glink->name);
15755               return FALSE;
15756             }
15757           bfd_put_32 (dynobj, val, p + 8);
15758           p += (24 + align - 1) & -align;
15759         }
15760
15761       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15762           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15763                                                htab->glink_eh_frame,
15764                                                htab->glink_eh_frame->contents))
15765         return FALSE;
15766     }
15767
15768   /* We need to handle writing out multiple GOT sections ourselves,
15769      since we didn't add them to DYNOBJ.  We know dynobj is the first
15770      bfd.  */
15771   while ((dynobj = dynobj->link.next) != NULL)
15772     {
15773       asection *s;
15774
15775       if (!is_ppc64_elf (dynobj))
15776         continue;
15777
15778       s = ppc64_elf_tdata (dynobj)->got;
15779       if (s != NULL
15780           && s->size != 0
15781           && s->output_section != bfd_abs_section_ptr
15782           && !bfd_set_section_contents (output_bfd, s->output_section,
15783                                         s->contents, s->output_offset,
15784                                         s->size))
15785         return FALSE;
15786       s = ppc64_elf_tdata (dynobj)->relgot;
15787       if (s != NULL
15788           && s->size != 0
15789           && s->output_section != bfd_abs_section_ptr
15790           && !bfd_set_section_contents (output_bfd, s->output_section,
15791                                         s->contents, s->output_offset,
15792                                         s->size))
15793         return FALSE;
15794     }
15795
15796   return TRUE;
15797 }
15798
15799 #include "elf64-target.h"
15800
15801 /* FreeBSD support */
15802
15803 #undef  TARGET_LITTLE_SYM
15804 #undef  TARGET_LITTLE_NAME
15805
15806 #undef  TARGET_BIG_SYM
15807 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15808 #undef  TARGET_BIG_NAME
15809 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15810
15811 #undef  ELF_OSABI
15812 #define ELF_OSABI       ELFOSABI_FREEBSD
15813
15814 #undef  elf64_bed
15815 #define elf64_bed       elf64_powerpc_fbsd_bed
15816
15817 #include "elf64-target.h"