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 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
 133
 134 /* The initial size of the plt reserved for the dynamic linker.  */
 135 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 136
 137 /* Offsets to some stack save slots.  */
 138 #define STK_LR 16
 139 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 140 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 141    CR save slot.  Used only by optimised __tls_get_addr call stub,
 142    relying on __tls_get_addr_opt not saving CR..  */
 143 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 144
 145 /* TOC base pointers offset from start of TOC.  */
 146 #define TOC_BASE_OFF    0x8000
 147 /* TOC base alignment.  */
 148 #define TOC_BASE_ALIGN  256
 149
 150 /* Offset of tp and dtp pointers from start of TLS block.  */
 151 #define TP_OFFSET       0x7000
 152 #define DTP_OFFSET      0x8000
 153
 154 /* .plt call stub instructions.  The normal stub is like this, but
 155    sometimes the .plt entry crosses a 64k boundary and we need to
 156    insert an addi to adjust r11.  */
 157 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 158 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 159 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 160 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 161 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 162 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 163 #define BCTR            0x4e800420      /* bctr                      */
 164
 165 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 166 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 167 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 168
 169 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 170 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 171 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 172 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 173 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 174 #define BNECTR          0x4ca20420      /* bnectr+               */
 175 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 176
 177 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 178 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 179 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 180
 181 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 182 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 183 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 184
 185 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 186 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 187 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 188 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 189 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 190
 191 /* __glink_PLTresolve stub instructions.  We enter with the index in R0.  */
 192 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 193   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 194                                         /* 0:                           */
 195                                         /*  .quad plt0-1f               */
 196                                         /* __glink:                     */
 197 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 198 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 199                                         /* 1:                           */
 200 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 201                                         /*  ld %2,(0b-1b)(%11)          */
 202 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 203 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 204                                         /*  ld %12,0(%11)               */
 205                                         /*  ld %2,8(%11)                */
 206                                         /*  mtctr %12                   */
 207                                         /*  ld %11,16(%11)              */
 208                                         /*  bctr                        */
 209 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 210 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 211 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 212 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 213 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 214
 215 /* Pad with this.  */
 216 #define NOP             0x60000000
 217
 218 /* Some other nops.  */
 219 #define CROR_151515     0x4def7b82
 220 #define CROR_313131     0x4ffffb82
 221
 222 /* .glink entries for the first 32k functions are two instructions.  */
 223 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 224 #define B_DOT           0x48000000      /* b     .              */
 225
 226 /* After that, we need two instructions to load the index, followed by
 227    a branch.  */
 228 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 229 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 230
 231 /* Instructions used by the save and restore reg functions.  */
 232 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 233 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 234 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 235 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 236 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 237 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 238 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 239 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 240 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 241 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 242 #define BLR             0x4e800020      /* blr                  */
 243
 244 /* Since .opd is an array of descriptors and each entry will end up
 245    with identical R_PPC64_RELATIVE relocs, there is really no need to
 246    propagate .opd relocs;  The dynamic linker should be taught to
 247    relocate .opd without reloc entries.  */
 248 #ifndef NO_OPD_RELOCS
 249 #define NO_OPD_RELOCS 0
 250 #endif
 251
 252 #ifndef ARRAY_SIZE
 253 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 254 #endif
 255
 256 static inline int
 257 abiversion (bfd *abfd)
 258 {
 259   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 260 }
 261
 262 static inline void
 263 set_abiversion (bfd *abfd, int ver)
 264 {
 265   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 266   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 267 }
 268 \f
 269 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 270
 271 /* Relocation HOWTO's.  */
 272 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 273
 274 static reloc_howto_type ppc64_elf_howto_raw[] =
 275 {
 276   /* This reloc does nothing.  */
 277   HOWTO (R_PPC64_NONE,          /* type */
 278          0,                     /* rightshift */
 279          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          0,                     /* bitsize */
 281          FALSE,                 /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_dont, /* complain_on_overflow */
 284          bfd_elf_generic_reloc, /* special_function */
 285          "R_PPC64_NONE",        /* name */
 286          FALSE,                 /* partial_inplace */
 287          0,                     /* src_mask */
 288          0,                     /* dst_mask */
 289          FALSE),                /* pcrel_offset */
 290
 291   /* A standard 32 bit relocation.  */
 292   HOWTO (R_PPC64_ADDR32,        /* type */
 293          0,                     /* rightshift */
 294          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          32,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_bitfield, /* complain_on_overflow */
 299          bfd_elf_generic_reloc, /* special_function */
 300          "R_PPC64_ADDR32",      /* name */
 301          FALSE,                 /* partial_inplace */
 302          0,                     /* src_mask */
 303          0xffffffff,            /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* An absolute 26 bit branch; the lower two bits must be zero.
 307      FIXME: we don't check that, we just clear them.  */
 308   HOWTO (R_PPC64_ADDR24,        /* type */
 309          0,                     /* rightshift */
 310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          26,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_bitfield, /* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_PPC64_ADDR24",      /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0x03fffffc,            /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   /* A standard 16 bit relocation.  */
 323   HOWTO (R_PPC64_ADDR16,        /* type */
 324          0,                     /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_bitfield, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_PPC64_ADDR16",      /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* A 16 bit relocation without overflow.  */
 338   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 339          0,                     /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_dont,/* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* special_function */
 346          "R_PPC64_ADDR16_LO",   /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0xffff,                /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* Bits 16-31 of an address.  */
 353   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 354          16,                    /* rightshift */
 355          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 356          16,                    /* bitsize */
 357          FALSE,                 /* pc_relative */
 358          0,                     /* bitpos */
 359          complain_overflow_signed, /* complain_on_overflow */
 360          bfd_elf_generic_reloc, /* special_function */
 361          "R_PPC64_ADDR16_HI",   /* name */
 362          FALSE,                 /* partial_inplace */
 363          0,                     /* src_mask */
 364          0xffff,                /* dst_mask */
 365          FALSE),                /* pcrel_offset */
 366
 367   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 368      bits, treated as a signed number, is negative.  */
 369   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 370          16,                    /* rightshift */
 371          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 372          16,                    /* bitsize */
 373          FALSE,                 /* pc_relative */
 374          0,                     /* bitpos */
 375          complain_overflow_signed, /* complain_on_overflow */
 376          ppc64_elf_ha_reloc,    /* special_function */
 377          "R_PPC64_ADDR16_HA",   /* name */
 378          FALSE,                 /* partial_inplace */
 379          0,                     /* src_mask */
 380          0xffff,                /* dst_mask */
 381          FALSE),                /* pcrel_offset */
 382
 383   /* An absolute 16 bit branch; the lower two bits must be zero.
 384      FIXME: we don't check that, we just clear them.  */
 385   HOWTO (R_PPC64_ADDR14,        /* type */
 386          0,                     /* rightshift */
 387          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 388          16,                    /* bitsize */
 389          FALSE,                 /* pc_relative */
 390          0,                     /* bitpos */
 391          complain_overflow_signed, /* complain_on_overflow */
 392          ppc64_elf_branch_reloc, /* special_function */
 393          "R_PPC64_ADDR14",      /* name */
 394          FALSE,                 /* partial_inplace */
 395          0,                     /* src_mask */
 396          0x0000fffc,            /* dst_mask */
 397          FALSE),                /* pcrel_offset */
 398
 399   /* An absolute 16 bit branch, for which bit 10 should be set to
 400      indicate that the branch is expected to be taken.  The lower two
 401      bits must be zero.  */
 402   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 403          0,                     /* rightshift */
 404          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 405          16,                    /* bitsize */
 406          FALSE,                 /* pc_relative */
 407          0,                     /* bitpos */
 408          complain_overflow_signed, /* complain_on_overflow */
 409          ppc64_elf_brtaken_reloc, /* special_function */
 410          "R_PPC64_ADDR14_BRTAKEN",/* name */
 411          FALSE,                 /* partial_inplace */
 412          0,                     /* src_mask */
 413          0x0000fffc,            /* dst_mask */
 414          FALSE),                /* pcrel_offset */
 415
 416   /* An absolute 16 bit branch, for which bit 10 should be set to
 417      indicate that the branch is not expected to be taken.  The lower
 418      two bits must be zero.  */
 419   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          FALSE,                 /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_brtaken_reloc, /* special_function */
 427          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          FALSE),                /* pcrel_offset */
 432
 433   /* A relative 26 bit branch; the lower two bits must be zero.  */
 434   HOWTO (R_PPC64_REL24,         /* type */
 435          0,                     /* rightshift */
 436          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 437          26,                    /* bitsize */
 438          TRUE,                  /* pc_relative */
 439          0,                     /* bitpos */
 440          complain_overflow_signed, /* complain_on_overflow */
 441          ppc64_elf_branch_reloc, /* special_function */
 442          "R_PPC64_REL24",       /* name */
 443          FALSE,                 /* partial_inplace */
 444          0,                     /* src_mask */
 445          0x03fffffc,            /* dst_mask */
 446          TRUE),                 /* pcrel_offset */
 447
 448   /* A relative 16 bit branch; the lower two bits must be zero.  */
 449   HOWTO (R_PPC64_REL14,         /* type */
 450          0,                     /* rightshift */
 451          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 452          16,                    /* bitsize */
 453          TRUE,                  /* pc_relative */
 454          0,                     /* bitpos */
 455          complain_overflow_signed, /* complain_on_overflow */
 456          ppc64_elf_branch_reloc, /* special_function */
 457          "R_PPC64_REL14",       /* name */
 458          FALSE,                 /* partial_inplace */
 459          0,                     /* src_mask */
 460          0x0000fffc,            /* dst_mask */
 461          TRUE),                 /* pcrel_offset */
 462
 463   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 464      the branch is expected to be taken.  The lower two bits must be
 465      zero.  */
 466   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 467          0,                     /* rightshift */
 468          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 469          16,                    /* bitsize */
 470          TRUE,                  /* pc_relative */
 471          0,                     /* bitpos */
 472          complain_overflow_signed, /* complain_on_overflow */
 473          ppc64_elf_brtaken_reloc, /* special_function */
 474          "R_PPC64_REL14_BRTAKEN", /* name */
 475          FALSE,                 /* partial_inplace */
 476          0,                     /* src_mask */
 477          0x0000fffc,            /* dst_mask */
 478          TRUE),                 /* pcrel_offset */
 479
 480   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 481      the branch is not expected to be taken.  The lower two bits must
 482      be zero.  */
 483   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 484          0,                     /* rightshift */
 485          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 486          16,                    /* bitsize */
 487          TRUE,                  /* pc_relative */
 488          0,                     /* bitpos */
 489          complain_overflow_signed, /* complain_on_overflow */
 490          ppc64_elf_brtaken_reloc, /* special_function */
 491          "R_PPC64_REL14_BRNTAKEN",/* name */
 492          FALSE,                 /* partial_inplace */
 493          0,                     /* src_mask */
 494          0x0000fffc,            /* dst_mask */
 495          TRUE),                 /* pcrel_offset */
 496
 497   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 498      symbol.  */
 499   HOWTO (R_PPC64_GOT16,         /* type */
 500          0,                     /* rightshift */
 501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          16,                    /* bitsize */
 503          FALSE,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_signed, /* complain_on_overflow */
 506          ppc64_elf_unhandled_reloc, /* special_function */
 507          "R_PPC64_GOT16",       /* name */
 508          FALSE,                 /* partial_inplace */
 509          0,                     /* src_mask */
 510          0xffff,                /* dst_mask */
 511          FALSE),                /* pcrel_offset */
 512
 513   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 514      the symbol.  */
 515   HOWTO (R_PPC64_GOT16_LO,      /* type */
 516          0,                     /* rightshift */
 517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 518          16,                    /* bitsize */
 519          FALSE,                 /* pc_relative */
 520          0,                     /* bitpos */
 521          complain_overflow_dont, /* complain_on_overflow */
 522          ppc64_elf_unhandled_reloc, /* special_function */
 523          "R_PPC64_GOT16_LO",    /* name */
 524          FALSE,                 /* partial_inplace */
 525          0,                     /* src_mask */
 526          0xffff,                /* dst_mask */
 527          FALSE),                /* pcrel_offset */
 528
 529   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 530      the symbol.  */
 531   HOWTO (R_PPC64_GOT16_HI,      /* type */
 532          16,                    /* rightshift */
 533          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 534          16,                    /* bitsize */
 535          FALSE,                 /* pc_relative */
 536          0,                     /* bitpos */
 537          complain_overflow_signed,/* complain_on_overflow */
 538          ppc64_elf_unhandled_reloc, /* special_function */
 539          "R_PPC64_GOT16_HI",    /* name */
 540          FALSE,                 /* partial_inplace */
 541          0,                     /* src_mask */
 542          0xffff,                /* dst_mask */
 543          FALSE),                /* pcrel_offset */
 544
 545   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 546      the symbol.  */
 547   HOWTO (R_PPC64_GOT16_HA,      /* type */
 548          16,                    /* rightshift */
 549          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 550          16,                    /* bitsize */
 551          FALSE,                 /* pc_relative */
 552          0,                     /* bitpos */
 553          complain_overflow_signed,/* complain_on_overflow */
 554          ppc64_elf_unhandled_reloc, /* special_function */
 555          "R_PPC64_GOT16_HA",    /* name */
 556          FALSE,                 /* partial_inplace */
 557          0,                     /* src_mask */
 558          0xffff,                /* dst_mask */
 559          FALSE),                /* pcrel_offset */
 560
 561   /* This is used only by the dynamic linker.  The symbol should exist
 562      both in the object being run and in some shared library.  The
 563      dynamic linker copies the data addressed by the symbol from the
 564      shared library into the object, because the object being
 565      run has to have the data at some particular address.  */
 566   HOWTO (R_PPC64_COPY,          /* type */
 567          0,                     /* rightshift */
 568          0,                     /* this one is variable size */
 569          0,                     /* bitsize */
 570          FALSE,                 /* pc_relative */
 571          0,                     /* bitpos */
 572          complain_overflow_dont, /* complain_on_overflow */
 573          ppc64_elf_unhandled_reloc, /* special_function */
 574          "R_PPC64_COPY",        /* name */
 575          FALSE,                 /* partial_inplace */
 576          0,                     /* src_mask */
 577          0,                     /* dst_mask */
 578          FALSE),                /* pcrel_offset */
 579
 580   /* Like R_PPC64_ADDR64, but used when setting global offset table
 581      entries.  */
 582   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 583          0,                     /* rightshift */
 584          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 585          64,                    /* bitsize */
 586          FALSE,                 /* pc_relative */
 587          0,                     /* bitpos */
 588          complain_overflow_dont, /* complain_on_overflow */
 589          ppc64_elf_unhandled_reloc,  /* special_function */
 590          "R_PPC64_GLOB_DAT",    /* name */
 591          FALSE,                 /* partial_inplace */
 592          0,                     /* src_mask */
 593          ONES (64),             /* dst_mask */
 594          FALSE),                /* pcrel_offset */
 595
 596   /* Created by the link editor.  Marks a procedure linkage table
 597      entry for a symbol.  */
 598   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 599          0,                     /* rightshift */
 600          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 601          0,                     /* bitsize */
 602          FALSE,                 /* pc_relative */
 603          0,                     /* bitpos */
 604          complain_overflow_dont, /* complain_on_overflow */
 605          ppc64_elf_unhandled_reloc, /* special_function */
 606          "R_PPC64_JMP_SLOT",    /* name */
 607          FALSE,                 /* partial_inplace */
 608          0,                     /* src_mask */
 609          0,                     /* dst_mask */
 610          FALSE),                /* pcrel_offset */
 611
 612   /* Used only by the dynamic linker.  When the object is run, this
 613      doubleword64 is set to the load address of the object, plus the
 614      addend.  */
 615   HOWTO (R_PPC64_RELATIVE,      /* type */
 616          0,                     /* rightshift */
 617          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 618          64,                    /* bitsize */
 619          FALSE,                 /* pc_relative */
 620          0,                     /* bitpos */
 621          complain_overflow_dont, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_RELATIVE",    /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          ONES (64),             /* dst_mask */
 627          FALSE),                /* pcrel_offset */
 628
 629   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 630   HOWTO (R_PPC64_UADDR32,       /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          FALSE,                 /* pc_relative */
 635          0,                     /* bitpos */
 636          complain_overflow_bitfield, /* complain_on_overflow */
 637          bfd_elf_generic_reloc, /* special_function */
 638          "R_PPC64_UADDR32",     /* name */
 639          FALSE,                 /* partial_inplace */
 640          0,                     /* src_mask */
 641          0xffffffff,            /* dst_mask */
 642          FALSE),                /* pcrel_offset */
 643
 644   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 645   HOWTO (R_PPC64_UADDR16,       /* type */
 646          0,                     /* rightshift */
 647          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          16,                    /* bitsize */
 649          FALSE,                 /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_bitfield, /* complain_on_overflow */
 652          bfd_elf_generic_reloc, /* special_function */
 653          "R_PPC64_UADDR16",     /* name */
 654          FALSE,                 /* partial_inplace */
 655          0,                     /* src_mask */
 656          0xffff,                /* dst_mask */
 657          FALSE),                /* pcrel_offset */
 658
 659   /* 32-bit PC relative.  */
 660   HOWTO (R_PPC64_REL32,         /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          32,                    /* bitsize */
 664          TRUE,                  /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_signed, /* complain_on_overflow */
 667          bfd_elf_generic_reloc, /* special_function */
 668          "R_PPC64_REL32",       /* name */
 669          FALSE,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0xffffffff,            /* dst_mask */
 672          TRUE),                 /* pcrel_offset */
 673
 674   /* 32-bit relocation to the symbol's procedure linkage table.  */
 675   HOWTO (R_PPC64_PLT32,         /* type */
 676          0,                     /* rightshift */
 677          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 678          32,                    /* bitsize */
 679          FALSE,                 /* pc_relative */
 680          0,                     /* bitpos */
 681          complain_overflow_bitfield, /* complain_on_overflow */
 682          ppc64_elf_unhandled_reloc, /* special_function */
 683          "R_PPC64_PLT32",       /* name */
 684          FALSE,                 /* partial_inplace */
 685          0,                     /* src_mask */
 686          0xffffffff,            /* dst_mask */
 687          FALSE),                /* pcrel_offset */
 688
 689   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 690      FIXME: R_PPC64_PLTREL32 not supported.  */
 691   HOWTO (R_PPC64_PLTREL32,      /* type */
 692          0,                     /* rightshift */
 693          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 694          32,                    /* bitsize */
 695          TRUE,                  /* pc_relative */
 696          0,                     /* bitpos */
 697          complain_overflow_signed, /* complain_on_overflow */
 698          ppc64_elf_unhandled_reloc, /* special_function */
 699          "R_PPC64_PLTREL32",    /* name */
 700          FALSE,                 /* partial_inplace */
 701          0,                     /* src_mask */
 702          0xffffffff,            /* dst_mask */
 703          TRUE),                 /* pcrel_offset */
 704
 705   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 706      the symbol.  */
 707   HOWTO (R_PPC64_PLT16_LO,      /* type */
 708          0,                     /* rightshift */
 709          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 710          16,                    /* bitsize */
 711          FALSE,                 /* pc_relative */
 712          0,                     /* bitpos */
 713          complain_overflow_dont, /* complain_on_overflow */
 714          ppc64_elf_unhandled_reloc, /* special_function */
 715          "R_PPC64_PLT16_LO",    /* name */
 716          FALSE,                 /* partial_inplace */
 717          0,                     /* src_mask */
 718          0xffff,                /* dst_mask */
 719          FALSE),                /* pcrel_offset */
 720
 721   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 722      the symbol.  */
 723   HOWTO (R_PPC64_PLT16_HI,      /* type */
 724          16,                    /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_signed, /* complain_on_overflow */
 730          ppc64_elf_unhandled_reloc, /* special_function */
 731          "R_PPC64_PLT16_HI",    /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 738      the symbol.  */
 739   HOWTO (R_PPC64_PLT16_HA,      /* type */
 740          16,                    /* rightshift */
 741          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 742          16,                    /* bitsize */
 743          FALSE,                 /* pc_relative */
 744          0,                     /* bitpos */
 745          complain_overflow_signed, /* complain_on_overflow */
 746          ppc64_elf_unhandled_reloc, /* special_function */
 747          "R_PPC64_PLT16_HA",    /* name */
 748          FALSE,                 /* partial_inplace */
 749          0,                     /* src_mask */
 750          0xffff,                /* dst_mask */
 751          FALSE),                /* pcrel_offset */
 752
 753   /* 16-bit section relative relocation.  */
 754   HOWTO (R_PPC64_SECTOFF,       /* type */
 755          0,                     /* rightshift */
 756          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          16,                    /* bitsize */
 758          FALSE,                 /* pc_relative */
 759          0,                     /* bitpos */
 760          complain_overflow_signed, /* complain_on_overflow */
 761          ppc64_elf_sectoff_reloc, /* special_function */
 762          "R_PPC64_SECTOFF",     /* name */
 763          FALSE,                 /* partial_inplace */
 764          0,                     /* src_mask */
 765          0xffff,                /* dst_mask */
 766          FALSE),                /* pcrel_offset */
 767
 768   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 769   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 770          0,                     /* rightshift */
 771          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 772          16,                    /* bitsize */
 773          FALSE,                 /* pc_relative */
 774          0,                     /* bitpos */
 775          complain_overflow_dont, /* complain_on_overflow */
 776          ppc64_elf_sectoff_reloc, /* special_function */
 777          "R_PPC64_SECTOFF_LO",  /* name */
 778          FALSE,                 /* partial_inplace */
 779          0,                     /* src_mask */
 780          0xffff,                /* dst_mask */
 781          FALSE),                /* pcrel_offset */
 782
 783   /* 16-bit upper half section relative relocation.  */
 784   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 785          16,                    /* rightshift */
 786          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 787          16,                    /* bitsize */
 788          FALSE,                 /* pc_relative */
 789          0,                     /* bitpos */
 790          complain_overflow_signed, /* complain_on_overflow */
 791          ppc64_elf_sectoff_reloc, /* special_function */
 792          "R_PPC64_SECTOFF_HI",  /* name */
 793          FALSE,                 /* partial_inplace */
 794          0,                     /* src_mask */
 795          0xffff,                /* dst_mask */
 796          FALSE),                /* pcrel_offset */
 797
 798   /* 16-bit upper half adjusted section relative relocation.  */
 799   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 800          16,                    /* rightshift */
 801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 802          16,                    /* bitsize */
 803          FALSE,                 /* pc_relative */
 804          0,                     /* bitpos */
 805          complain_overflow_signed, /* complain_on_overflow */
 806          ppc64_elf_sectoff_ha_reloc, /* special_function */
 807          "R_PPC64_SECTOFF_HA",  /* name */
 808          FALSE,                 /* partial_inplace */
 809          0,                     /* src_mask */
 810          0xffff,                /* dst_mask */
 811          FALSE),                /* pcrel_offset */
 812
 813   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 814   HOWTO (R_PPC64_REL30,         /* type */
 815          2,                     /* rightshift */
 816          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 817          30,                    /* bitsize */
 818          TRUE,                  /* pc_relative */
 819          0,                     /* bitpos */
 820          complain_overflow_dont, /* complain_on_overflow */
 821          bfd_elf_generic_reloc, /* special_function */
 822          "R_PPC64_REL30",       /* name */
 823          FALSE,                 /* partial_inplace */
 824          0,                     /* src_mask */
 825          0xfffffffc,            /* dst_mask */
 826          TRUE),                 /* pcrel_offset */
 827
 828   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 829
 830   /* A standard 64-bit relocation.  */
 831   HOWTO (R_PPC64_ADDR64,        /* type */
 832          0,                     /* rightshift */
 833          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 834          64,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          bfd_elf_generic_reloc, /* special_function */
 839          "R_PPC64_ADDR64",      /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          ONES (64),             /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 32-47 of an address.  */
 846   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 847          32,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_dont, /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_PPC64_ADDR16_HIGHER", /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* The bits 32-47 of an address, plus 1 if the contents of the low
 861      16 bits, treated as a signed number, is negative.  */
 862   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 863          32,                    /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          ppc64_elf_ha_reloc,    /* special_function */
 870          "R_PPC64_ADDR16_HIGHERA", /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* The bits 48-63 of an address.  */
 877   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 878          48,                    /* rightshift */
 879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          16,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_ADDR16_HIGHEST", /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          0xffff,                /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* The bits 48-63 of an address, plus 1 if the contents of the low
 892      16 bits, treated as a signed number, is negative.  */
 893   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 894          48,                    /* rightshift */
 895          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 896          16,                    /* bitsize */
 897          FALSE,                 /* pc_relative */
 898          0,                     /* bitpos */
 899          complain_overflow_dont, /* complain_on_overflow */
 900          ppc64_elf_ha_reloc,    /* special_function */
 901          "R_PPC64_ADDR16_HIGHESTA", /* name */
 902          FALSE,                 /* partial_inplace */
 903          0,                     /* src_mask */
 904          0xffff,                /* dst_mask */
 905          FALSE),                /* pcrel_offset */
 906
 907   /* Like ADDR64, but may be unaligned.  */
 908   HOWTO (R_PPC64_UADDR64,       /* type */
 909          0,                     /* rightshift */
 910          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 911          64,                    /* bitsize */
 912          FALSE,                 /* pc_relative */
 913          0,                     /* bitpos */
 914          complain_overflow_dont, /* complain_on_overflow */
 915          bfd_elf_generic_reloc, /* special_function */
 916          "R_PPC64_UADDR64",     /* name */
 917          FALSE,                 /* partial_inplace */
 918          0,                     /* src_mask */
 919          ONES (64),             /* dst_mask */
 920          FALSE),                /* pcrel_offset */
 921
 922   /* 64-bit relative relocation.  */
 923   HOWTO (R_PPC64_REL64,         /* type */
 924          0,                     /* rightshift */
 925          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 926          64,                    /* bitsize */
 927          TRUE,                  /* pc_relative */
 928          0,                     /* bitpos */
 929          complain_overflow_dont, /* complain_on_overflow */
 930          bfd_elf_generic_reloc, /* special_function */
 931          "R_PPC64_REL64",       /* name */
 932          FALSE,                 /* partial_inplace */
 933          0,                     /* src_mask */
 934          ONES (64),             /* dst_mask */
 935          TRUE),                 /* pcrel_offset */
 936
 937   /* 64-bit relocation to the symbol's procedure linkage table.  */
 938   HOWTO (R_PPC64_PLT64,         /* type */
 939          0,                     /* rightshift */
 940          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 941          64,                    /* bitsize */
 942          FALSE,                 /* pc_relative */
 943          0,                     /* bitpos */
 944          complain_overflow_dont, /* complain_on_overflow */
 945          ppc64_elf_unhandled_reloc, /* special_function */
 946          "R_PPC64_PLT64",       /* name */
 947          FALSE,                 /* partial_inplace */
 948          0,                     /* src_mask */
 949          ONES (64),             /* dst_mask */
 950          FALSE),                /* pcrel_offset */
 951
 952   /* 64-bit PC relative relocation to the symbol's procedure linkage
 953      table.  */
 954   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 955   HOWTO (R_PPC64_PLTREL64,      /* type */
 956          0,                     /* rightshift */
 957          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 958          64,                    /* bitsize */
 959          TRUE,                  /* pc_relative */
 960          0,                     /* bitpos */
 961          complain_overflow_dont, /* complain_on_overflow */
 962          ppc64_elf_unhandled_reloc, /* special_function */
 963          "R_PPC64_PLTREL64",    /* name */
 964          FALSE,                 /* partial_inplace */
 965          0,                     /* src_mask */
 966          ONES (64),             /* dst_mask */
 967          TRUE),                 /* pcrel_offset */
 968
 969   /* 16 bit TOC-relative relocation.  */
 970
 971   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 972   HOWTO (R_PPC64_TOC16,         /* type */
 973          0,                     /* rightshift */
 974          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 975          16,                    /* bitsize */
 976          FALSE,                 /* pc_relative */
 977          0,                     /* bitpos */
 978          complain_overflow_signed, /* complain_on_overflow */
 979          ppc64_elf_toc_reloc,   /* special_function */
 980          "R_PPC64_TOC16",       /* name */
 981          FALSE,                 /* partial_inplace */
 982          0,                     /* src_mask */
 983          0xffff,                /* dst_mask */
 984          FALSE),                /* pcrel_offset */
 985
 986   /* 16 bit TOC-relative relocation without overflow.  */
 987
 988   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 989   HOWTO (R_PPC64_TOC16_LO,      /* type */
 990          0,                     /* rightshift */
 991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 992          16,                    /* bitsize */
 993          FALSE,                 /* pc_relative */
 994          0,                     /* bitpos */
 995          complain_overflow_dont, /* complain_on_overflow */
 996          ppc64_elf_toc_reloc,   /* special_function */
 997          "R_PPC64_TOC16_LO",    /* name */
 998          FALSE,                 /* partial_inplace */
 999          0,                     /* src_mask */
1000          0xffff,                /* dst_mask */
1001          FALSE),                /* pcrel_offset */
1002
1003   /* 16 bit TOC-relative relocation, high 16 bits.  */
1004
1005   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1006   HOWTO (R_PPC64_TOC16_HI,      /* type */
1007          16,                    /* rightshift */
1008          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1009          16,                    /* bitsize */
1010          FALSE,                 /* pc_relative */
1011          0,                     /* bitpos */
1012          complain_overflow_signed, /* complain_on_overflow */
1013          ppc64_elf_toc_reloc,   /* special_function */
1014          "R_PPC64_TOC16_HI",    /* name */
1015          FALSE,                 /* partial_inplace */
1016          0,                     /* src_mask */
1017          0xffff,                /* dst_mask */
1018          FALSE),                /* pcrel_offset */
1019
1020   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1021      contents of the low 16 bits, treated as a signed number, is
1022      negative.  */
1023
1024   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1025   HOWTO (R_PPC64_TOC16_HA,      /* type */
1026          16,                    /* rightshift */
1027          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1028          16,                    /* bitsize */
1029          FALSE,                 /* pc_relative */
1030          0,                     /* bitpos */
1031          complain_overflow_signed, /* complain_on_overflow */
1032          ppc64_elf_toc_ha_reloc, /* special_function */
1033          "R_PPC64_TOC16_HA",    /* name */
1034          FALSE,                 /* partial_inplace */
1035          0,                     /* src_mask */
1036          0xffff,                /* dst_mask */
1037          FALSE),                /* pcrel_offset */
1038
1039   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1040
1041   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1042   HOWTO (R_PPC64_TOC,           /* type */
1043          0,                     /* rightshift */
1044          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1045          64,                    /* bitsize */
1046          FALSE,                 /* pc_relative */
1047          0,                     /* bitpos */
1048          complain_overflow_dont, /* complain_on_overflow */
1049          ppc64_elf_toc64_reloc, /* special_function */
1050          "R_PPC64_TOC",         /* name */
1051          FALSE,                 /* partial_inplace */
1052          0,                     /* src_mask */
1053          ONES (64),             /* dst_mask */
1054          FALSE),                /* pcrel_offset */
1055
1056   /* Like R_PPC64_GOT16, but also informs the link editor that the
1057      value to relocate may (!) refer to a PLT entry which the link
1058      editor (a) may replace with the symbol value.  If the link editor
1059      is unable to fully resolve the symbol, it may (b) create a PLT
1060      entry and store the address to the new PLT entry in the GOT.
1061      This permits lazy resolution of function symbols at run time.
1062      The link editor may also skip all of this and just (c) emit a
1063      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1064   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1065     HOWTO (R_PPC64_PLTGOT16,    /* type */
1066          0,                     /* rightshift */
1067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1068          16,                    /* bitsize */
1069          FALSE,                 /* pc_relative */
1070          0,                     /* bitpos */
1071          complain_overflow_signed, /* complain_on_overflow */
1072          ppc64_elf_unhandled_reloc, /* special_function */
1073          "R_PPC64_PLTGOT16",    /* name */
1074          FALSE,                 /* partial_inplace */
1075          0,                     /* src_mask */
1076          0xffff,                /* dst_mask */
1077          FALSE),                /* pcrel_offset */
1078
1079   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1080   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1081   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1082          0,                     /* rightshift */
1083          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1084          16,                    /* bitsize */
1085          FALSE,                 /* pc_relative */
1086          0,                     /* bitpos */
1087          complain_overflow_dont, /* complain_on_overflow */
1088          ppc64_elf_unhandled_reloc, /* special_function */
1089          "R_PPC64_PLTGOT16_LO", /* name */
1090          FALSE,                 /* partial_inplace */
1091          0,                     /* src_mask */
1092          0xffff,                /* dst_mask */
1093          FALSE),                /* pcrel_offset */
1094
1095   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1096   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1097   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1098          16,                    /* rightshift */
1099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1100          16,                    /* bitsize */
1101          FALSE,                 /* pc_relative */
1102          0,                     /* bitpos */
1103          complain_overflow_signed, /* complain_on_overflow */
1104          ppc64_elf_unhandled_reloc, /* special_function */
1105          "R_PPC64_PLTGOT16_HI", /* name */
1106          FALSE,                 /* partial_inplace */
1107          0,                     /* src_mask */
1108          0xffff,                /* dst_mask */
1109          FALSE),                /* pcrel_offset */
1110
1111   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1112      1 if the contents of the low 16 bits, treated as a signed number,
1113      is negative.  */
1114   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1115   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1116          16,                    /* rightshift */
1117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1118          16,                    /* bitsize */
1119          FALSE,                 /* pc_relative */
1120          0,                     /* bitpos */
1121          complain_overflow_signed, /* complain_on_overflow */
1122          ppc64_elf_unhandled_reloc, /* special_function */
1123          "R_PPC64_PLTGOT16_HA", /* name */
1124          FALSE,                 /* partial_inplace */
1125          0,                     /* src_mask */
1126          0xffff,                /* dst_mask */
1127          FALSE),                /* pcrel_offset */
1128
1129   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1130   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1131          0,                     /* rightshift */
1132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1133          16,                    /* bitsize */
1134          FALSE,                 /* pc_relative */
1135          0,                     /* bitpos */
1136          complain_overflow_signed, /* complain_on_overflow */
1137          bfd_elf_generic_reloc, /* special_function */
1138          "R_PPC64_ADDR16_DS",   /* name */
1139          FALSE,                 /* partial_inplace */
1140          0,                     /* src_mask */
1141          0xfffc,                /* dst_mask */
1142          FALSE),                /* pcrel_offset */
1143
1144   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1145   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1146          0,                     /* rightshift */
1147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          16,                    /* bitsize */
1149          FALSE,                 /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont,/* complain_on_overflow */
1152          bfd_elf_generic_reloc, /* special_function */
1153          "R_PPC64_ADDR16_LO_DS",/* name */
1154          FALSE,                 /* partial_inplace */
1155          0,                     /* src_mask */
1156          0xfffc,                /* dst_mask */
1157          FALSE),                /* pcrel_offset */
1158
1159   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1160   HOWTO (R_PPC64_GOT16_DS,      /* type */
1161          0,                     /* rightshift */
1162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1163          16,                    /* bitsize */
1164          FALSE,                 /* pc_relative */
1165          0,                     /* bitpos */
1166          complain_overflow_signed, /* complain_on_overflow */
1167          ppc64_elf_unhandled_reloc, /* special_function */
1168          "R_PPC64_GOT16_DS",    /* name */
1169          FALSE,                 /* partial_inplace */
1170          0,                     /* src_mask */
1171          0xfffc,                /* dst_mask */
1172          FALSE),                /* pcrel_offset */
1173
1174   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1175   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1176          0,                     /* rightshift */
1177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1178          16,                    /* bitsize */
1179          FALSE,                 /* pc_relative */
1180          0,                     /* bitpos */
1181          complain_overflow_dont, /* complain_on_overflow */
1182          ppc64_elf_unhandled_reloc, /* special_function */
1183          "R_PPC64_GOT16_LO_DS", /* name */
1184          FALSE,                 /* partial_inplace */
1185          0,                     /* src_mask */
1186          0xfffc,                /* dst_mask */
1187          FALSE),                /* pcrel_offset */
1188
1189   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1190   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1191          0,                     /* rightshift */
1192          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1193          16,                    /* bitsize */
1194          FALSE,                 /* pc_relative */
1195          0,                     /* bitpos */
1196          complain_overflow_dont, /* complain_on_overflow */
1197          ppc64_elf_unhandled_reloc, /* special_function */
1198          "R_PPC64_PLT16_LO_DS", /* name */
1199          FALSE,                 /* partial_inplace */
1200          0,                     /* src_mask */
1201          0xfffc,                /* dst_mask */
1202          FALSE),                /* pcrel_offset */
1203
1204   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1205   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1206          0,                     /* rightshift */
1207          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1208          16,                    /* bitsize */
1209          FALSE,                 /* pc_relative */
1210          0,                     /* bitpos */
1211          complain_overflow_signed, /* complain_on_overflow */
1212          ppc64_elf_sectoff_reloc, /* special_function */
1213          "R_PPC64_SECTOFF_DS",  /* name */
1214          FALSE,                 /* partial_inplace */
1215          0,                     /* src_mask */
1216          0xfffc,                /* dst_mask */
1217          FALSE),                /* pcrel_offset */
1218
1219   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1220   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1221          0,                     /* rightshift */
1222          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1223          16,                    /* bitsize */
1224          FALSE,                 /* pc_relative */
1225          0,                     /* bitpos */
1226          complain_overflow_dont, /* complain_on_overflow */
1227          ppc64_elf_sectoff_reloc, /* special_function */
1228          "R_PPC64_SECTOFF_LO_DS",/* name */
1229          FALSE,                 /* partial_inplace */
1230          0,                     /* src_mask */
1231          0xfffc,                /* dst_mask */
1232          FALSE),                /* pcrel_offset */
1233
1234   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1235   HOWTO (R_PPC64_TOC16_DS,      /* type */
1236          0,                     /* rightshift */
1237          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1238          16,                    /* bitsize */
1239          FALSE,                 /* pc_relative */
1240          0,                     /* bitpos */
1241          complain_overflow_signed, /* complain_on_overflow */
1242          ppc64_elf_toc_reloc,   /* special_function */
1243          "R_PPC64_TOC16_DS",    /* name */
1244          FALSE,                 /* partial_inplace */
1245          0,                     /* src_mask */
1246          0xfffc,                /* dst_mask */
1247          FALSE),                /* pcrel_offset */
1248
1249   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1250   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1251          0,                     /* rightshift */
1252          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1253          16,                    /* bitsize */
1254          FALSE,                 /* pc_relative */
1255          0,                     /* bitpos */
1256          complain_overflow_dont, /* complain_on_overflow */
1257          ppc64_elf_toc_reloc,   /* special_function */
1258          "R_PPC64_TOC16_LO_DS", /* name */
1259          FALSE,                 /* partial_inplace */
1260          0,                     /* src_mask */
1261          0xfffc,                /* dst_mask */
1262          FALSE),                /* pcrel_offset */
1263
1264   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1265   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1266   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1267          0,                     /* rightshift */
1268          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          16,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_signed, /* complain_on_overflow */
1273          ppc64_elf_unhandled_reloc, /* special_function */
1274          "R_PPC64_PLTGOT16_DS", /* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0xfffc,                /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1281   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1282   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1283          0,                     /* rightshift */
1284          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1285          16,                    /* bitsize */
1286          FALSE,                 /* pc_relative */
1287          0,                     /* bitpos */
1288          complain_overflow_dont, /* complain_on_overflow */
1289          ppc64_elf_unhandled_reloc, /* special_function */
1290          "R_PPC64_PLTGOT16_LO_DS",/* name */
1291          FALSE,                 /* partial_inplace */
1292          0,                     /* src_mask */
1293          0xfffc,                /* dst_mask */
1294          FALSE),                /* pcrel_offset */
1295
1296   /* Marker relocs for TLS.  */
1297   HOWTO (R_PPC64_TLS,
1298          0,                     /* rightshift */
1299          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1300          32,                    /* bitsize */
1301          FALSE,                 /* pc_relative */
1302          0,                     /* bitpos */
1303          complain_overflow_dont, /* complain_on_overflow */
1304          bfd_elf_generic_reloc, /* special_function */
1305          "R_PPC64_TLS",         /* name */
1306          FALSE,                 /* partial_inplace */
1307          0,                     /* src_mask */
1308          0,                     /* dst_mask */
1309          FALSE),                /* pcrel_offset */
1310
1311   HOWTO (R_PPC64_TLSGD,
1312          0,                     /* rightshift */
1313          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1314          32,                    /* bitsize */
1315          FALSE,                 /* pc_relative */
1316          0,                     /* bitpos */
1317          complain_overflow_dont, /* complain_on_overflow */
1318          bfd_elf_generic_reloc, /* special_function */
1319          "R_PPC64_TLSGD",       /* name */
1320          FALSE,                 /* partial_inplace */
1321          0,                     /* src_mask */
1322          0,                     /* dst_mask */
1323          FALSE),                /* pcrel_offset */
1324
1325   HOWTO (R_PPC64_TLSLD,
1326          0,                     /* rightshift */
1327          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1328          32,                    /* bitsize */
1329          FALSE,                 /* pc_relative */
1330          0,                     /* bitpos */
1331          complain_overflow_dont, /* complain_on_overflow */
1332          bfd_elf_generic_reloc, /* special_function */
1333          "R_PPC64_TLSLD",       /* name */
1334          FALSE,                 /* partial_inplace */
1335          0,                     /* src_mask */
1336          0,                     /* dst_mask */
1337          FALSE),                /* pcrel_offset */
1338
1339   /* Marker reloc for optimizing r2 save in prologue rather than on
1340      each plt call stub.  */
1341   HOWTO (R_PPC64_TOCSAVE,
1342          0,                     /* rightshift */
1343          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          32,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont, /* complain_on_overflow */
1348          bfd_elf_generic_reloc, /* special_function */
1349          "R_PPC64_TOCSAVE",     /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          0,                     /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* Marker relocs on inline plt call instructions.  */
1356   HOWTO (R_PPC64_PLTSEQ,
1357          0,                     /* rightshift */
1358          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          32,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_dont, /* complain_on_overflow */
1363          bfd_elf_generic_reloc, /* special_function */
1364          "R_PPC64_PLTSEQ",      /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0,                     /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   HOWTO (R_PPC64_PLTCALL,
1371          0,                     /* rightshift */
1372          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1373          32,                    /* bitsize */
1374          FALSE,                 /* pc_relative */
1375          0,                     /* bitpos */
1376          complain_overflow_dont, /* complain_on_overflow */
1377          bfd_elf_generic_reloc, /* special_function */
1378          "R_PPC64_PLTCALL",     /* name */
1379          FALSE,                 /* partial_inplace */
1380          0,                     /* src_mask */
1381          0,                     /* dst_mask */
1382          FALSE),                /* pcrel_offset */
1383
1384   /* Computes the load module index of the load module that contains the
1385      definition of its TLS sym.  */
1386   HOWTO (R_PPC64_DTPMOD64,
1387          0,                     /* rightshift */
1388          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          64,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_dont, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPMOD64",    /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          ONES (64),             /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Computes a dtv-relative displacement, the difference between the value
1401      of sym+add and the base address of the thread-local storage block that
1402      contains the definition of sym, minus 0x8000.  */
1403   HOWTO (R_PPC64_DTPREL64,
1404          0,                     /* rightshift */
1405          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1406          64,                    /* bitsize */
1407          FALSE,                 /* pc_relative */
1408          0,                     /* bitpos */
1409          complain_overflow_dont, /* complain_on_overflow */
1410          ppc64_elf_unhandled_reloc, /* special_function */
1411          "R_PPC64_DTPREL64",    /* name */
1412          FALSE,                 /* partial_inplace */
1413          0,                     /* src_mask */
1414          ONES (64),             /* dst_mask */
1415          FALSE),                /* pcrel_offset */
1416
1417   /* A 16 bit dtprel reloc.  */
1418   HOWTO (R_PPC64_DTPREL16,
1419          0,                     /* rightshift */
1420          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1421          16,                    /* bitsize */
1422          FALSE,                 /* pc_relative */
1423          0,                     /* bitpos */
1424          complain_overflow_signed, /* complain_on_overflow */
1425          ppc64_elf_unhandled_reloc, /* special_function */
1426          "R_PPC64_DTPREL16",    /* name */
1427          FALSE,                 /* partial_inplace */
1428          0,                     /* src_mask */
1429          0xffff,                /* dst_mask */
1430          FALSE),                /* pcrel_offset */
1431
1432   /* Like DTPREL16, but no overflow.  */
1433   HOWTO (R_PPC64_DTPREL16_LO,
1434          0,                     /* rightshift */
1435          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1436          16,                    /* bitsize */
1437          FALSE,                 /* pc_relative */
1438          0,                     /* bitpos */
1439          complain_overflow_dont, /* complain_on_overflow */
1440          ppc64_elf_unhandled_reloc, /* special_function */
1441          "R_PPC64_DTPREL16_LO", /* name */
1442          FALSE,                 /* partial_inplace */
1443          0,                     /* src_mask */
1444          0xffff,                /* dst_mask */
1445          FALSE),                /* pcrel_offset */
1446
1447   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1448   HOWTO (R_PPC64_DTPREL16_HI,
1449          16,                    /* rightshift */
1450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          16,                    /* bitsize */
1452          FALSE,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_signed, /* complain_on_overflow */
1455          ppc64_elf_unhandled_reloc, /* special_function */
1456          "R_PPC64_DTPREL16_HI", /* name */
1457          FALSE,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0xffff,                /* dst_mask */
1460          FALSE),                /* pcrel_offset */
1461
1462   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1463   HOWTO (R_PPC64_DTPREL16_HA,
1464          16,                    /* rightshift */
1465          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1466          16,                    /* bitsize */
1467          FALSE,                 /* pc_relative */
1468          0,                     /* bitpos */
1469          complain_overflow_signed, /* complain_on_overflow */
1470          ppc64_elf_unhandled_reloc, /* special_function */
1471          "R_PPC64_DTPREL16_HA", /* name */
1472          FALSE,                 /* partial_inplace */
1473          0,                     /* src_mask */
1474          0xffff,                /* dst_mask */
1475          FALSE),                /* pcrel_offset */
1476
1477   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1478   HOWTO (R_PPC64_DTPREL16_HIGHER,
1479          32,                    /* rightshift */
1480          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1481          16,                    /* bitsize */
1482          FALSE,                 /* pc_relative */
1483          0,                     /* bitpos */
1484          complain_overflow_dont, /* complain_on_overflow */
1485          ppc64_elf_unhandled_reloc, /* special_function */
1486          "R_PPC64_DTPREL16_HIGHER", /* name */
1487          FALSE,                 /* partial_inplace */
1488          0,                     /* src_mask */
1489          0xffff,                /* dst_mask */
1490          FALSE),                /* pcrel_offset */
1491
1492   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1493   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1494          32,                    /* rightshift */
1495          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          16,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont, /* complain_on_overflow */
1500          ppc64_elf_unhandled_reloc, /* special_function */
1501          "R_PPC64_DTPREL16_HIGHERA", /* name */
1502          FALSE,                 /* partial_inplace */
1503          0,                     /* src_mask */
1504          0xffff,                /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1508   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1509          48,                    /* rightshift */
1510          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1511          16,                    /* bitsize */
1512          FALSE,                 /* pc_relative */
1513          0,                     /* bitpos */
1514          complain_overflow_dont, /* complain_on_overflow */
1515          ppc64_elf_unhandled_reloc, /* special_function */
1516          "R_PPC64_DTPREL16_HIGHEST", /* name */
1517          FALSE,                 /* partial_inplace */
1518          0,                     /* src_mask */
1519          0xffff,                /* dst_mask */
1520          FALSE),                /* pcrel_offset */
1521
1522   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1523   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1524          48,                    /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          FALSE,                 /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_dont, /* complain_on_overflow */
1530          ppc64_elf_unhandled_reloc, /* special_function */
1531          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1532          FALSE,                 /* partial_inplace */
1533          0,                     /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Like DTPREL16, but for insns with a DS field.  */
1538   HOWTO (R_PPC64_DTPREL16_DS,
1539          0,                     /* rightshift */
1540          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          16,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_signed, /* complain_on_overflow */
1545          ppc64_elf_unhandled_reloc, /* special_function */
1546          "R_PPC64_DTPREL16_DS", /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          0xfffc,                /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* Like DTPREL16_DS, but no overflow.  */
1553   HOWTO (R_PPC64_DTPREL16_LO_DS,
1554          0,                     /* rightshift */
1555          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1556          16,                    /* bitsize */
1557          FALSE,                 /* pc_relative */
1558          0,                     /* bitpos */
1559          complain_overflow_dont, /* complain_on_overflow */
1560          ppc64_elf_unhandled_reloc, /* special_function */
1561          "R_PPC64_DTPREL16_LO_DS", /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0xfffc,                /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* Computes a tp-relative displacement, the difference between the value of
1568      sym+add and the value of the thread pointer (r13).  */
1569   HOWTO (R_PPC64_TPREL64,
1570          0,                     /* rightshift */
1571          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          64,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_dont, /* complain_on_overflow */
1576          ppc64_elf_unhandled_reloc, /* special_function */
1577          "R_PPC64_TPREL64",     /* name */
1578          FALSE,                 /* partial_inplace */
1579          0,                     /* src_mask */
1580          ONES (64),             /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582
1583   /* A 16 bit tprel reloc.  */
1584   HOWTO (R_PPC64_TPREL16,
1585          0,                     /* rightshift */
1586          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          16,                    /* bitsize */
1588          FALSE,                 /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_signed, /* complain_on_overflow */
1591          ppc64_elf_unhandled_reloc, /* special_function */
1592          "R_PPC64_TPREL16",     /* name */
1593          FALSE,                 /* partial_inplace */
1594          0,                     /* src_mask */
1595          0xffff,                /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   /* Like TPREL16, but no overflow.  */
1599   HOWTO (R_PPC64_TPREL16_LO,
1600          0,                     /* rightshift */
1601          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1602          16,                    /* bitsize */
1603          FALSE,                 /* pc_relative */
1604          0,                     /* bitpos */
1605          complain_overflow_dont, /* complain_on_overflow */
1606          ppc64_elf_unhandled_reloc, /* special_function */
1607          "R_PPC64_TPREL16_LO",  /* name */
1608          FALSE,                 /* partial_inplace */
1609          0,                     /* src_mask */
1610          0xffff,                /* dst_mask */
1611          FALSE),                /* pcrel_offset */
1612
1613   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1614   HOWTO (R_PPC64_TPREL16_HI,
1615          16,                    /* rightshift */
1616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          16,                    /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_signed, /* complain_on_overflow */
1621          ppc64_elf_unhandled_reloc, /* special_function */
1622          "R_PPC64_TPREL16_HI",  /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0xffff,                /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1629   HOWTO (R_PPC64_TPREL16_HA,
1630          16,                    /* rightshift */
1631          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1632          16,                    /* bitsize */
1633          FALSE,                 /* pc_relative */
1634          0,                     /* bitpos */
1635          complain_overflow_signed, /* complain_on_overflow */
1636          ppc64_elf_unhandled_reloc, /* special_function */
1637          "R_PPC64_TPREL16_HA",  /* name */
1638          FALSE,                 /* partial_inplace */
1639          0,                     /* src_mask */
1640          0xffff,                /* dst_mask */
1641          FALSE),                /* pcrel_offset */
1642
1643   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1644   HOWTO (R_PPC64_TPREL16_HIGHER,
1645          32,                    /* rightshift */
1646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          16,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_dont, /* complain_on_overflow */
1651          ppc64_elf_unhandled_reloc, /* special_function */
1652          "R_PPC64_TPREL16_HIGHER",      /* name */
1653          FALSE,                 /* partial_inplace */
1654          0,                     /* src_mask */
1655          0xffff,                /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1659   HOWTO (R_PPC64_TPREL16_HIGHERA,
1660          32,                    /* rightshift */
1661          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1662          16,                    /* bitsize */
1663          FALSE,                 /* pc_relative */
1664          0,                     /* bitpos */
1665          complain_overflow_dont, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_TPREL16_HIGHERA", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xffff,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1674   HOWTO (R_PPC64_TPREL16_HIGHEST,
1675          48,                    /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_dont, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_TPREL16_HIGHEST", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1689   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1690          48,                    /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_TPREL16_HIGHESTA", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like TPREL16, but for insns with a DS field.  */
1704   HOWTO (R_PPC64_TPREL16_DS,
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_TPREL16_DS",  /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xfffc,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like TPREL16_DS, but no overflow.  */
1719   HOWTO (R_PPC64_TPREL16_LO_DS,
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_TPREL16_LO_DS", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xfffc,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1734      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1735      to the first entry relative to the TOC base (r2).  */
1736   HOWTO (R_PPC64_GOT_TLSGD16,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_signed, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSGD16", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSGD16, but no overflow.  */
1751   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSGD16_LO", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1767          16,                    /* 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_TLSGD16_HI", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1781   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1782          16,                    /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_signed, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSGD16_HA", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1796      with values (sym+add)@dtpmod and zero, and computes the offset to the
1797      first entry relative to the TOC base (r2).  */
1798   HOWTO (R_PPC64_GOT_TLSLD16,
1799          0,                     /* rightshift */
1800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1801          16,                    /* bitsize */
1802          FALSE,                 /* pc_relative */
1803          0,                     /* bitpos */
1804          complain_overflow_signed, /* complain_on_overflow */
1805          ppc64_elf_unhandled_reloc, /* special_function */
1806          "R_PPC64_GOT_TLSLD16", /* name */
1807          FALSE,                 /* partial_inplace */
1808          0,                     /* src_mask */
1809          0xffff,                /* dst_mask */
1810          FALSE),                /* pcrel_offset */
1811
1812   /* Like GOT_TLSLD16, but no overflow.  */
1813   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1814          0,                     /* rightshift */
1815          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1816          16,                    /* bitsize */
1817          FALSE,                 /* pc_relative */
1818          0,                     /* bitpos */
1819          complain_overflow_dont, /* complain_on_overflow */
1820          ppc64_elf_unhandled_reloc, /* special_function */
1821          "R_PPC64_GOT_TLSLD16_LO", /* name */
1822          FALSE,                 /* partial_inplace */
1823          0,                     /* src_mask */
1824          0xffff,                /* dst_mask */
1825          FALSE),                /* pcrel_offset */
1826
1827   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1828   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1829          16,                    /* rightshift */
1830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1831          16,                    /* bitsize */
1832          FALSE,                 /* pc_relative */
1833          0,                     /* bitpos */
1834          complain_overflow_signed, /* complain_on_overflow */
1835          ppc64_elf_unhandled_reloc, /* special_function */
1836          "R_PPC64_GOT_TLSLD16_HI", /* name */
1837          FALSE,                 /* partial_inplace */
1838          0,                     /* src_mask */
1839          0xffff,                /* dst_mask */
1840          FALSE),                /* pcrel_offset */
1841
1842   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1843   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1844          16,                    /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_TLSLD16_HA", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xffff,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1858      the offset to the entry relative to the TOC base (r2).  */
1859   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1860          0,                     /* rightshift */
1861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1862          16,                    /* bitsize */
1863          FALSE,                 /* pc_relative */
1864          0,                     /* bitpos */
1865          complain_overflow_signed, /* complain_on_overflow */
1866          ppc64_elf_unhandled_reloc, /* special_function */
1867          "R_PPC64_GOT_DTPREL16_DS", /* name */
1868          FALSE,                 /* partial_inplace */
1869          0,                     /* src_mask */
1870          0xfffc,                /* dst_mask */
1871          FALSE),                /* pcrel_offset */
1872
1873   /* Like GOT_DTPREL16_DS, but no overflow.  */
1874   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1875          0,                     /* rightshift */
1876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1877          16,                    /* bitsize */
1878          FALSE,                 /* pc_relative */
1879          0,                     /* bitpos */
1880          complain_overflow_dont, /* complain_on_overflow */
1881          ppc64_elf_unhandled_reloc, /* special_function */
1882          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1883          FALSE,                 /* partial_inplace */
1884          0,                     /* src_mask */
1885          0xfffc,                /* dst_mask */
1886          FALSE),                /* pcrel_offset */
1887
1888   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1889   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1890          16,                    /* rightshift */
1891          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1892          16,                    /* bitsize */
1893          FALSE,                 /* pc_relative */
1894          0,                     /* bitpos */
1895          complain_overflow_signed, /* complain_on_overflow */
1896          ppc64_elf_unhandled_reloc, /* special_function */
1897          "R_PPC64_GOT_DTPREL16_HI", /* name */
1898          FALSE,                 /* partial_inplace */
1899          0,                     /* src_mask */
1900          0xffff,                /* dst_mask */
1901          FALSE),                /* pcrel_offset */
1902
1903   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1904   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1905          16,                    /* rightshift */
1906          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1907          16,                    /* bitsize */
1908          FALSE,                 /* pc_relative */
1909          0,                     /* bitpos */
1910          complain_overflow_signed, /* complain_on_overflow */
1911          ppc64_elf_unhandled_reloc, /* special_function */
1912          "R_PPC64_GOT_DTPREL16_HA", /* name */
1913          FALSE,                 /* partial_inplace */
1914          0,                     /* src_mask */
1915          0xffff,                /* dst_mask */
1916          FALSE),                /* pcrel_offset */
1917
1918   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1919      offset to the entry relative to the TOC base (r2).  */
1920   HOWTO (R_PPC64_GOT_TPREL16_DS,
1921          0,                     /* rightshift */
1922          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1923          16,                    /* bitsize */
1924          FALSE,                 /* pc_relative */
1925          0,                     /* bitpos */
1926          complain_overflow_signed, /* complain_on_overflow */
1927          ppc64_elf_unhandled_reloc, /* special_function */
1928          "R_PPC64_GOT_TPREL16_DS", /* name */
1929          FALSE,                 /* partial_inplace */
1930          0,                     /* src_mask */
1931          0xfffc,                /* dst_mask */
1932          FALSE),                /* pcrel_offset */
1933
1934   /* Like GOT_TPREL16_DS, but no overflow.  */
1935   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1936          0,                     /* rightshift */
1937          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1938          16,                    /* bitsize */
1939          FALSE,                 /* pc_relative */
1940          0,                     /* bitpos */
1941          complain_overflow_dont, /* complain_on_overflow */
1942          ppc64_elf_unhandled_reloc, /* special_function */
1943          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1944          FALSE,                 /* partial_inplace */
1945          0,                     /* src_mask */
1946          0xfffc,                /* dst_mask */
1947          FALSE),                /* pcrel_offset */
1948
1949   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1950   HOWTO (R_PPC64_GOT_TPREL16_HI,
1951          16,                    /* rightshift */
1952          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1953          16,                    /* bitsize */
1954          FALSE,                 /* pc_relative */
1955          0,                     /* bitpos */
1956          complain_overflow_signed, /* complain_on_overflow */
1957          ppc64_elf_unhandled_reloc, /* special_function */
1958          "R_PPC64_GOT_TPREL16_HI", /* name */
1959          FALSE,                 /* partial_inplace */
1960          0,                     /* src_mask */
1961          0xffff,                /* dst_mask */
1962          FALSE),                /* pcrel_offset */
1963
1964   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1965   HOWTO (R_PPC64_GOT_TPREL16_HA,
1966          16,                    /* rightshift */
1967          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1968          16,                    /* bitsize */
1969          FALSE,                 /* pc_relative */
1970          0,                     /* bitpos */
1971          complain_overflow_signed, /* complain_on_overflow */
1972          ppc64_elf_unhandled_reloc, /* special_function */
1973          "R_PPC64_GOT_TPREL16_HA", /* name */
1974          FALSE,                 /* partial_inplace */
1975          0,                     /* src_mask */
1976          0xffff,                /* dst_mask */
1977          FALSE),                /* pcrel_offset */
1978
1979   HOWTO (R_PPC64_JMP_IREL,      /* type */
1980          0,                     /* rightshift */
1981          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1982          0,                     /* bitsize */
1983          FALSE,                 /* pc_relative */
1984          0,                     /* bitpos */
1985          complain_overflow_dont, /* complain_on_overflow */
1986          ppc64_elf_unhandled_reloc, /* special_function */
1987          "R_PPC64_JMP_IREL",    /* name */
1988          FALSE,                 /* partial_inplace */
1989          0,                     /* src_mask */
1990          0,                     /* dst_mask */
1991          FALSE),                /* pcrel_offset */
1992
1993   HOWTO (R_PPC64_IRELATIVE,     /* type */
1994          0,                     /* rightshift */
1995          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1996          64,                    /* bitsize */
1997          FALSE,                 /* pc_relative */
1998          0,                     /* bitpos */
1999          complain_overflow_dont, /* complain_on_overflow */
2000          bfd_elf_generic_reloc, /* special_function */
2001          "R_PPC64_IRELATIVE",   /* name */
2002          FALSE,                 /* partial_inplace */
2003          0,                     /* src_mask */
2004          ONES (64),             /* dst_mask */
2005          FALSE),                /* pcrel_offset */
2006
2007   /* A 16 bit relative relocation.  */
2008   HOWTO (R_PPC64_REL16,         /* type */
2009          0,                     /* rightshift */
2010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2011          16,                    /* bitsize */
2012          TRUE,                  /* pc_relative */
2013          0,                     /* bitpos */
2014          complain_overflow_signed, /* complain_on_overflow */
2015          bfd_elf_generic_reloc, /* special_function */
2016          "R_PPC64_REL16",       /* name */
2017          FALSE,                 /* partial_inplace */
2018          0,                     /* src_mask */
2019          0xffff,                /* dst_mask */
2020          TRUE),                 /* pcrel_offset */
2021
2022   /* A 16 bit relative relocation without overflow.  */
2023   HOWTO (R_PPC64_REL16_LO,      /* type */
2024          0,                     /* rightshift */
2025          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2026          16,                    /* bitsize */
2027          TRUE,                  /* pc_relative */
2028          0,                     /* bitpos */
2029          complain_overflow_dont,/* complain_on_overflow */
2030          bfd_elf_generic_reloc, /* special_function */
2031          "R_PPC64_REL16_LO",    /* name */
2032          FALSE,                 /* partial_inplace */
2033          0,                     /* src_mask */
2034          0xffff,                /* dst_mask */
2035          TRUE),                 /* pcrel_offset */
2036
2037   /* The high order 16 bits of a relative address.  */
2038   HOWTO (R_PPC64_REL16_HI,      /* type */
2039          16,                    /* rightshift */
2040          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2041          16,                    /* bitsize */
2042          TRUE,                  /* pc_relative */
2043          0,                     /* bitpos */
2044          complain_overflow_signed, /* complain_on_overflow */
2045          bfd_elf_generic_reloc, /* special_function */
2046          "R_PPC64_REL16_HI",    /* name */
2047          FALSE,                 /* partial_inplace */
2048          0,                     /* src_mask */
2049          0xffff,                /* dst_mask */
2050          TRUE),                 /* pcrel_offset */
2051
2052   /* The high order 16 bits of a relative address, plus 1 if the contents of
2053      the low 16 bits, treated as a signed number, is negative.  */
2054   HOWTO (R_PPC64_REL16_HA,      /* type */
2055          16,                    /* rightshift */
2056          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2057          16,                    /* bitsize */
2058          TRUE,                  /* pc_relative */
2059          0,                     /* bitpos */
2060          complain_overflow_signed, /* complain_on_overflow */
2061          ppc64_elf_ha_reloc,    /* special_function */
2062          "R_PPC64_REL16_HA",    /* name */
2063          FALSE,                 /* partial_inplace */
2064          0,                     /* src_mask */
2065          0xffff,                /* dst_mask */
2066          TRUE),                 /* pcrel_offset */
2067
2068   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2069   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2070          16,                    /* rightshift */
2071          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2072          16,                    /* bitsize */
2073          TRUE,                  /* pc_relative */
2074          0,                     /* bitpos */
2075          complain_overflow_signed, /* complain_on_overflow */
2076          ppc64_elf_ha_reloc,    /* special_function */
2077          "R_PPC64_REL16DX_HA",  /* name */
2078          FALSE,                 /* partial_inplace */
2079          0,                     /* src_mask */
2080          0x1fffc1,              /* dst_mask */
2081          TRUE),                 /* pcrel_offset */
2082
2083   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2084   HOWTO (R_PPC64_16DX_HA,       /* type */
2085          16,                    /* rightshift */
2086          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2087          16,                    /* bitsize */
2088          FALSE,                 /* pc_relative */
2089          0,                     /* bitpos */
2090          complain_overflow_signed, /* complain_on_overflow */
2091          ppc64_elf_ha_reloc,    /* special_function */
2092          "R_PPC64_16DX_HA",     /* name */
2093          FALSE,                 /* partial_inplace */
2094          0,                     /* src_mask */
2095          0x1fffc1,              /* dst_mask */
2096          FALSE),                /* pcrel_offset */
2097
2098   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2099   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2100          16,                    /* rightshift */
2101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2102          16,                    /* bitsize */
2103          FALSE,                 /* pc_relative */
2104          0,                     /* bitpos */
2105          complain_overflow_dont, /* complain_on_overflow */
2106          bfd_elf_generic_reloc, /* special_function */
2107          "R_PPC64_ADDR16_HIGH", /* name */
2108          FALSE,                 /* partial_inplace */
2109          0,                     /* src_mask */
2110          0xffff,                /* dst_mask */
2111          FALSE),                /* pcrel_offset */
2112
2113   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2114   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2115          16,                    /* rightshift */
2116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2117          16,                    /* bitsize */
2118          FALSE,                 /* pc_relative */
2119          0,                     /* bitpos */
2120          complain_overflow_dont, /* complain_on_overflow */
2121          ppc64_elf_ha_reloc,    /* special_function */
2122          "R_PPC64_ADDR16_HIGHA",        /* name */
2123          FALSE,                 /* partial_inplace */
2124          0,                     /* src_mask */
2125          0xffff,                /* dst_mask */
2126          FALSE),                /* pcrel_offset */
2127
2128   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2129   HOWTO (R_PPC64_DTPREL16_HIGH,
2130          16,                    /* rightshift */
2131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2132          16,                    /* bitsize */
2133          FALSE,                 /* pc_relative */
2134          0,                     /* bitpos */
2135          complain_overflow_dont, /* complain_on_overflow */
2136          ppc64_elf_unhandled_reloc, /* special_function */
2137          "R_PPC64_DTPREL16_HIGH", /* name */
2138          FALSE,                 /* partial_inplace */
2139          0,                     /* src_mask */
2140          0xffff,                /* dst_mask */
2141          FALSE),                /* pcrel_offset */
2142
2143   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2144   HOWTO (R_PPC64_DTPREL16_HIGHA,
2145          16,                    /* rightshift */
2146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2147          16,                    /* bitsize */
2148          FALSE,                 /* pc_relative */
2149          0,                     /* bitpos */
2150          complain_overflow_dont, /* complain_on_overflow */
2151          ppc64_elf_unhandled_reloc, /* special_function */
2152          "R_PPC64_DTPREL16_HIGHA", /* name */
2153          FALSE,                 /* partial_inplace */
2154          0,                     /* src_mask */
2155          0xffff,                /* dst_mask */
2156          FALSE),                /* pcrel_offset */
2157
2158   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2159   HOWTO (R_PPC64_TPREL16_HIGH,
2160          16,                    /* rightshift */
2161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2162          16,                    /* bitsize */
2163          FALSE,                 /* pc_relative */
2164          0,                     /* bitpos */
2165          complain_overflow_dont, /* complain_on_overflow */
2166          ppc64_elf_unhandled_reloc, /* special_function */
2167          "R_PPC64_TPREL16_HIGH",        /* name */
2168          FALSE,                 /* partial_inplace */
2169          0,                     /* src_mask */
2170          0xffff,                /* dst_mask */
2171          FALSE),                /* pcrel_offset */
2172
2173   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2174   HOWTO (R_PPC64_TPREL16_HIGHA,
2175          16,                    /* rightshift */
2176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2177          16,                    /* bitsize */
2178          FALSE,                 /* pc_relative */
2179          0,                     /* bitpos */
2180          complain_overflow_dont, /* complain_on_overflow */
2181          ppc64_elf_unhandled_reloc, /* special_function */
2182          "R_PPC64_TPREL16_HIGHA",       /* name */
2183          FALSE,                 /* partial_inplace */
2184          0,                     /* src_mask */
2185          0xffff,                /* dst_mask */
2186          FALSE),                /* pcrel_offset */
2187
2188   /* Marker reloc on ELFv2 large-model function entry.  */
2189   HOWTO (R_PPC64_ENTRY,
2190          0,                     /* rightshift */
2191          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2192          32,                    /* bitsize */
2193          FALSE,                 /* pc_relative */
2194          0,                     /* bitpos */
2195          complain_overflow_dont, /* complain_on_overflow */
2196          bfd_elf_generic_reloc, /* special_function */
2197          "R_PPC64_ENTRY",       /* name */
2198          FALSE,                 /* partial_inplace */
2199          0,                     /* src_mask */
2200          0,                     /* dst_mask */
2201          FALSE),                /* pcrel_offset */
2202
2203   /* Like ADDR64, but use local entry point of function.  */
2204   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2205          0,                     /* rightshift */
2206          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2207          64,                    /* bitsize */
2208          FALSE,                 /* pc_relative */
2209          0,                     /* bitpos */
2210          complain_overflow_dont, /* complain_on_overflow */
2211          bfd_elf_generic_reloc, /* special_function */
2212          "R_PPC64_ADDR64_LOCAL", /* name */
2213          FALSE,                 /* partial_inplace */
2214          0,                     /* src_mask */
2215          ONES (64),             /* dst_mask */
2216          FALSE),                /* pcrel_offset */
2217
2218   /* GNU extension to record C++ vtable hierarchy.  */
2219   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2220          0,                     /* rightshift */
2221          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2222          0,                     /* bitsize */
2223          FALSE,                 /* pc_relative */
2224          0,                     /* bitpos */
2225          complain_overflow_dont, /* complain_on_overflow */
2226          NULL,                  /* special_function */
2227          "R_PPC64_GNU_VTINHERIT", /* name */
2228          FALSE,                 /* partial_inplace */
2229          0,                     /* src_mask */
2230          0,                     /* dst_mask */
2231          FALSE),                /* pcrel_offset */
2232
2233   /* GNU extension to record C++ vtable member usage.  */
2234   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2235          0,                     /* rightshift */
2236          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2237          0,                     /* bitsize */
2238          FALSE,                 /* pc_relative */
2239          0,                     /* bitpos */
2240          complain_overflow_dont, /* complain_on_overflow */
2241          NULL,                  /* special_function */
2242          "R_PPC64_GNU_VTENTRY", /* name */
2243          FALSE,                 /* partial_inplace */
2244          0,                     /* src_mask */
2245          0,                     /* dst_mask */
2246          FALSE),                /* pcrel_offset */
2247 };
2248
2249 \f
2250 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2251    be done.  */
2252
2253 static void
2254 ppc_howto_init (void)
2255 {
2256   unsigned int i, type;
2257
2258   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2259     {
2260       type = ppc64_elf_howto_raw[i].type;
2261       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2262       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2263     }
2264 }
2265
2266 static reloc_howto_type *
2267 ppc64_elf_reloc_type_lookup (bfd *abfd,
2268                              bfd_reloc_code_real_type code)
2269 {
2270   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2271
2272   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2273     /* Initialize howto table if needed.  */
2274     ppc_howto_init ();
2275
2276   switch (code)
2277     {
2278     default:
2279       /* xgettext:c-format */
2280       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2281       bfd_set_error (bfd_error_bad_value);
2282       return NULL;
2283
2284     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2285       break;
2286     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2287       break;
2288     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2289       break;
2290     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2291       break;
2292     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2293       break;
2294     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2295       break;
2296     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2297       break;
2298     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2299       break;
2300     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2301       break;
2302     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2303       break;
2304     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2305       break;
2306     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2307       break;
2308     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2309       break;
2310     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2311       break;
2312     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2313       break;
2314     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2315       break;
2316     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2317       break;
2318     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2319       break;
2320     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2321       break;
2322     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2323       break;
2324     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2325       break;
2326     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2327       break;
2328     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2329       break;
2330     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2331       break;
2332     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2333       break;
2334     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2335       break;
2336     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2337       break;
2338     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2339       break;
2340     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2341       break;
2342     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2343       break;
2344     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2345       break;
2346     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2347       break;
2348     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2349       break;
2350     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2351       break;
2352     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2353       break;
2354     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2355       break;
2356     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2357       break;
2358     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2359       break;
2360     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2361       break;
2362     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2363       break;
2364     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2365       break;
2366     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2367       break;
2368     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2369       break;
2370     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2371       break;
2372     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2373       break;
2374     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2375       break;
2376     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2377       break;
2378     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2379       break;
2380     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2381       break;
2382     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2383       break;
2384     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2385       break;
2386     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2387       break;
2388     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2389       break;
2390     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2391       break;
2392     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2393       break;
2394     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2395       break;
2396     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2397       break;
2398     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2399       break;
2400     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2401       break;
2402     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2403       break;
2404     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2405       break;
2406     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2407       break;
2408     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2409       break;
2410     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2411       break;
2412     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2413       break;
2414     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2415       break;
2416     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2417       break;
2418     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2419       break;
2420     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2421       break;
2422     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2423       break;
2424     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2425       break;
2426     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2427       break;
2428     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2429       break;
2430     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2431       break;
2432     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2433       break;
2434     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2435       break;
2436     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2437       break;
2438     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2439       break;
2440     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2441       break;
2442     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2443       break;
2444     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2445       break;
2446     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2447       break;
2448     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2449       break;
2450     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2451       break;
2452     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2453       break;
2454     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2455       break;
2456     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2457       break;
2458     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2459       break;
2460     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2461       break;
2462     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2463       break;
2464     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2465       break;
2466     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2467       break;
2468     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2469       break;
2470     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2471       break;
2472     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2473       break;
2474     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2475       break;
2476     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2477       break;
2478     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2479       break;
2480     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2481       break;
2482     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2483       break;
2484     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2485       break;
2486     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2487       break;
2488     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2489       break;
2490     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2491       break;
2492     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2493       break;
2494     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2495       break;
2496     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2497       break;
2498     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2499       break;
2500     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2501       break;
2502     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2503       break;
2504     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2505       break;
2506     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2507       break;
2508     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2509       break;
2510     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2511       break;
2512     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2513       break;
2514     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2515       break;
2516     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2517       break;
2518     }
2519
2520   return ppc64_elf_howto_table[r];
2521 };
2522
2523 static reloc_howto_type *
2524 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2525                              const char *r_name)
2526 {
2527   unsigned int i;
2528
2529   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2530     if (ppc64_elf_howto_raw[i].name != NULL
2531         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2532       return &ppc64_elf_howto_raw[i];
2533
2534
2535   return NULL;
2536 }
2537
2538 /* Set the howto pointer for a PowerPC ELF reloc.  */
2539
2540 static bfd_boolean
2541 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2542                          Elf_Internal_Rela *dst)
2543 {
2544   unsigned int type;
2545
2546   /* Initialize howto table if needed.  */
2547   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2548     ppc_howto_init ();
2549
2550   type = ELF64_R_TYPE (dst->r_info);
2551   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2552     {
2553       /* xgettext:c-format */
2554       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2555                           abfd, type);
2556       bfd_set_error (bfd_error_bad_value);
2557       return FALSE;
2558     }
2559   cache_ptr->howto = ppc64_elf_howto_table[type];
2560   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2561     {
2562       /* xgettext:c-format */
2563       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2564                           abfd, type);
2565       bfd_set_error (bfd_error_bad_value);
2566       return FALSE;
2567     }
2568
2569   return TRUE;
2570 }
2571
2572 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2573
2574 static bfd_reloc_status_type
2575 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2576                     void *data, asection *input_section,
2577                     bfd *output_bfd, char **error_message)
2578 {
2579   enum elf_ppc64_reloc_type r_type;
2580   long insn;
2581   bfd_size_type octets;
2582   bfd_vma value;
2583
2584   /* If this is a relocatable link (output_bfd test tells us), just
2585      call the generic function.  Any adjustment will be done at final
2586      link time.  */
2587   if (output_bfd != NULL)
2588     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2589                                   input_section, output_bfd, error_message);
2590
2591   /* Adjust the addend for sign extension of the low 16 bits.
2592      We won't actually be using the low 16 bits, so trashing them
2593      doesn't matter.  */
2594   reloc_entry->addend += 0x8000;
2595   r_type = reloc_entry->howto->type;
2596   if (r_type != R_PPC64_REL16DX_HA)
2597     return bfd_reloc_continue;
2598
2599   value = 0;
2600   if (!bfd_is_com_section (symbol->section))
2601     value = symbol->value;
2602   value += (reloc_entry->addend
2603             + symbol->section->output_offset
2604             + symbol->section->output_section->vma);
2605   value -= (reloc_entry->address
2606             + input_section->output_offset
2607             + input_section->output_section->vma);
2608   value = (bfd_signed_vma) value >> 16;
2609
2610   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2611   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2612   insn &= ~0x1fffc1;
2613   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2614   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2615   if (value + 0x8000 > 0xffff)
2616     return bfd_reloc_overflow;
2617   return bfd_reloc_ok;
2618 }
2619
2620 static bfd_reloc_status_type
2621 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2622                         void *data, asection *input_section,
2623                         bfd *output_bfd, char **error_message)
2624 {
2625   if (output_bfd != NULL)
2626     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2627                                   input_section, output_bfd, error_message);
2628
2629   if (strcmp (symbol->section->name, ".opd") == 0
2630       && (symbol->section->owner->flags & DYNAMIC) == 0)
2631     {
2632       bfd_vma dest = opd_entry_value (symbol->section,
2633                                       symbol->value + reloc_entry->addend,
2634                                       NULL, NULL, FALSE);
2635       if (dest != (bfd_vma) -1)
2636         reloc_entry->addend = dest - (symbol->value
2637                                       + symbol->section->output_section->vma
2638                                       + symbol->section->output_offset);
2639     }
2640   else
2641     {
2642       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2643
2644       if (symbol->section->owner != abfd
2645           && symbol->section->owner != NULL
2646           && abiversion (symbol->section->owner) >= 2)
2647         {
2648           unsigned int i;
2649
2650           for (i = 0; i < symbol->section->owner->symcount; ++i)
2651             {
2652               asymbol *symdef = symbol->section->owner->outsymbols[i];
2653
2654               if (strcmp (symdef->name, symbol->name) == 0)
2655                 {
2656                   elfsym = (elf_symbol_type *) symdef;
2657                   break;
2658                 }
2659             }
2660         }
2661       reloc_entry->addend
2662         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2663     }
2664   return bfd_reloc_continue;
2665 }
2666
2667 static bfd_reloc_status_type
2668 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2669                          void *data, asection *input_section,
2670                          bfd *output_bfd, char **error_message)
2671 {
2672   long insn;
2673   enum elf_ppc64_reloc_type r_type;
2674   bfd_size_type octets;
2675   /* Assume 'at' branch hints.  */
2676   bfd_boolean is_isa_v2 = TRUE;
2677
2678   /* If this is a relocatable link (output_bfd test tells us), just
2679      call the generic function.  Any adjustment will be done at final
2680      link time.  */
2681   if (output_bfd != NULL)
2682     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2683                                   input_section, output_bfd, error_message);
2684
2685   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2686   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2687   insn &= ~(0x01 << 21);
2688   r_type = reloc_entry->howto->type;
2689   if (r_type == R_PPC64_ADDR14_BRTAKEN
2690       || r_type == R_PPC64_REL14_BRTAKEN)
2691     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2692
2693   if (is_isa_v2)
2694     {
2695       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2696          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2697          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2698       if ((insn & (0x14 << 21)) == (0x04 << 21))
2699         insn |= 0x02 << 21;
2700       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2701         insn |= 0x08 << 21;
2702       else
2703         goto out;
2704     }
2705   else
2706     {
2707       bfd_vma target = 0;
2708       bfd_vma from;
2709
2710       if (!bfd_is_com_section (symbol->section))
2711         target = symbol->value;
2712       target += symbol->section->output_section->vma;
2713       target += symbol->section->output_offset;
2714       target += reloc_entry->addend;
2715
2716       from = (reloc_entry->address
2717               + input_section->output_offset
2718               + input_section->output_section->vma);
2719
2720       /* Invert 'y' bit if not the default.  */
2721       if ((bfd_signed_vma) (target - from) < 0)
2722         insn ^= 0x01 << 21;
2723     }
2724   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2725  out:
2726   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2727                                  input_section, output_bfd, error_message);
2728 }
2729
2730 static bfd_reloc_status_type
2731 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2732                          void *data, asection *input_section,
2733                          bfd *output_bfd, char **error_message)
2734 {
2735   /* If this is a relocatable link (output_bfd test tells us), just
2736      call the generic function.  Any adjustment will be done at final
2737      link time.  */
2738   if (output_bfd != NULL)
2739     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2740                                   input_section, output_bfd, error_message);
2741
2742   /* Subtract the symbol section base address.  */
2743   reloc_entry->addend -= symbol->section->output_section->vma;
2744   return bfd_reloc_continue;
2745 }
2746
2747 static bfd_reloc_status_type
2748 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2749                             void *data, asection *input_section,
2750                             bfd *output_bfd, char **error_message)
2751 {
2752   /* If this is a relocatable link (output_bfd test tells us), just
2753      call the generic function.  Any adjustment will be done at final
2754      link time.  */
2755   if (output_bfd != NULL)
2756     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757                                   input_section, output_bfd, error_message);
2758
2759   /* Subtract the symbol section base address.  */
2760   reloc_entry->addend -= symbol->section->output_section->vma;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                      void *data, asection *input_section,
2770                      bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773
2774   /* If this is a relocatable link (output_bfd test tells us), just
2775      call the generic function.  Any adjustment will be done at final
2776      link time.  */
2777   if (output_bfd != NULL)
2778     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779                                   input_section, output_bfd, error_message);
2780
2781   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2782   if (TOCstart == 0)
2783     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2784
2785   /* Subtract the TOC base address.  */
2786   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2787   return bfd_reloc_continue;
2788 }
2789
2790 static bfd_reloc_status_type
2791 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2792                         void *data, asection *input_section,
2793                         bfd *output_bfd, char **error_message)
2794 {
2795   bfd_vma TOCstart;
2796
2797   /* If this is a relocatable link (output_bfd test tells us), just
2798      call the generic function.  Any adjustment will be done at final
2799      link time.  */
2800   if (output_bfd != NULL)
2801     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2802                                   input_section, output_bfd, error_message);
2803
2804   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2805   if (TOCstart == 0)
2806     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2807
2808   /* Subtract the TOC base address.  */
2809   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2810
2811   /* Adjust the addend for sign extension of the low 16 bits.  */
2812   reloc_entry->addend += 0x8000;
2813   return bfd_reloc_continue;
2814 }
2815
2816 static bfd_reloc_status_type
2817 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2818                        void *data, asection *input_section,
2819                        bfd *output_bfd, char **error_message)
2820 {
2821   bfd_vma TOCstart;
2822   bfd_size_type octets;
2823
2824   /* If this is a relocatable link (output_bfd test tells us), just
2825      call the generic function.  Any adjustment will be done at final
2826      link time.  */
2827   if (output_bfd != NULL)
2828     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2829                                   input_section, output_bfd, error_message);
2830
2831   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2832   if (TOCstart == 0)
2833     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2834
2835   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2836   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2837   return bfd_reloc_ok;
2838 }
2839
2840 static bfd_reloc_status_type
2841 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2842                            void *data, asection *input_section,
2843                            bfd *output_bfd, char **error_message)
2844 {
2845   /* If this is a relocatable link (output_bfd test tells us), just
2846      call the generic function.  Any adjustment will be done at final
2847      link time.  */
2848   if (output_bfd != NULL)
2849     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2850                                   input_section, output_bfd, error_message);
2851
2852   if (error_message != NULL)
2853     {
2854       static char buf[60];
2855       sprintf (buf, "generic linker can't handle %s",
2856                reloc_entry->howto->name);
2857       *error_message = buf;
2858     }
2859   return bfd_reloc_dangerous;
2860 }
2861
2862 /* Track GOT entries needed for a given symbol.  We might need more
2863    than one got entry per symbol.  */
2864 struct got_entry
2865 {
2866   struct got_entry *next;
2867
2868   /* The symbol addend that we'll be placing in the GOT.  */
2869   bfd_vma addend;
2870
2871   /* Unlike other ELF targets, we use separate GOT entries for the same
2872      symbol referenced from different input files.  This is to support
2873      automatic multiple TOC/GOT sections, where the TOC base can vary
2874      from one input file to another.  After partitioning into TOC groups
2875      we merge entries within the group.
2876
2877      Point to the BFD owning this GOT entry.  */
2878   bfd *owner;
2879
2880   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2881      TLS_TPREL or TLS_DTPREL for tls entries.  */
2882   unsigned char tls_type;
2883
2884   /* Non-zero if got.ent points to real entry.  */
2885   unsigned char is_indirect;
2886
2887   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2888   union
2889     {
2890       bfd_signed_vma refcount;
2891       bfd_vma offset;
2892       struct got_entry *ent;
2893     } got;
2894 };
2895
2896 /* The same for PLT.  */
2897 struct plt_entry
2898 {
2899   struct plt_entry *next;
2900
2901   bfd_vma addend;
2902
2903   union
2904     {
2905       bfd_signed_vma refcount;
2906       bfd_vma offset;
2907     } plt;
2908 };
2909
2910 struct ppc64_elf_obj_tdata
2911 {
2912   struct elf_obj_tdata elf;
2913
2914   /* Shortcuts to dynamic linker sections.  */
2915   asection *got;
2916   asection *relgot;
2917
2918   /* Used during garbage collection.  We attach global symbols defined
2919      on removed .opd entries to this section so that the sym is removed.  */
2920   asection *deleted_section;
2921
2922   /* TLS local dynamic got entry handling.  Support for multiple GOT
2923      sections means we potentially need one of these for each input bfd.  */
2924   struct got_entry tlsld_got;
2925
2926   union {
2927     /* A copy of relocs before they are modified for --emit-relocs.  */
2928     Elf_Internal_Rela *relocs;
2929
2930     /* Section contents.  */
2931     bfd_byte *contents;
2932   } opd;
2933
2934   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2935      the reloc to be in the range -32768 to 32767.  */
2936   unsigned int has_small_toc_reloc : 1;
2937
2938   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2939      instruction not one we handle.  */
2940   unsigned int unexpected_toc_insn : 1;
2941 };
2942
2943 #define ppc64_elf_tdata(bfd) \
2944   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2945
2946 #define ppc64_tlsld_got(bfd) \
2947   (&ppc64_elf_tdata (bfd)->tlsld_got)
2948
2949 #define is_ppc64_elf(bfd) \
2950   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2951    && elf_object_id (bfd) == PPC64_ELF_DATA)
2952
2953 /* Override the generic function because we store some extras.  */
2954
2955 static bfd_boolean
2956 ppc64_elf_mkobject (bfd *abfd)
2957 {
2958   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2959                                   PPC64_ELF_DATA);
2960 }
2961
2962 /* Fix bad default arch selected for a 64 bit input bfd when the
2963    default is 32 bit.  Also select arch based on apuinfo.  */
2964
2965 static bfd_boolean
2966 ppc64_elf_object_p (bfd *abfd)
2967 {
2968   if (!abfd->arch_info->the_default)
2969     return TRUE;
2970
2971   if (abfd->arch_info->bits_per_word == 32)
2972     {
2973       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2974
2975       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2976         {
2977           /* Relies on arch after 32 bit default being 64 bit default.  */
2978           abfd->arch_info = abfd->arch_info->next;
2979           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2980         }
2981     }
2982   return _bfd_elf_ppc_set_arch (abfd);
2983 }
2984
2985 /* Support for core dump NOTE sections.  */
2986
2987 static bfd_boolean
2988 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2989 {
2990   size_t offset, size;
2991
2992   if (note->descsz != 504)
2993     return FALSE;
2994
2995   /* pr_cursig */
2996   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2997
2998   /* pr_pid */
2999   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3000
3001   /* pr_reg */
3002   offset = 112;
3003   size = 384;
3004
3005   /* Make a ".reg/999" section.  */
3006   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3007                                           size, note->descpos + offset);
3008 }
3009
3010 static bfd_boolean
3011 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3012 {
3013   if (note->descsz != 136)
3014     return FALSE;
3015
3016   elf_tdata (abfd)->core->pid
3017     = bfd_get_32 (abfd, note->descdata + 24);
3018   elf_tdata (abfd)->core->program
3019     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3020   elf_tdata (abfd)->core->command
3021     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3022
3023   return TRUE;
3024 }
3025
3026 static char *
3027 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3028                            ...)
3029 {
3030   switch (note_type)
3031     {
3032     default:
3033       return NULL;
3034
3035     case NT_PRPSINFO:
3036       {
3037         char data[136];
3038         va_list ap;
3039
3040         va_start (ap, note_type);
3041         memset (data, 0, sizeof (data));
3042         strncpy (data + 40, va_arg (ap, const char *), 16);
3043         strncpy (data + 56, va_arg (ap, const char *), 80);
3044         va_end (ap);
3045         return elfcore_write_note (abfd, buf, bufsiz,
3046                                    "CORE", note_type, data, sizeof (data));
3047       }
3048
3049     case NT_PRSTATUS:
3050       {
3051         char data[504];
3052         va_list ap;
3053         long pid;
3054         int cursig;
3055         const void *greg;
3056
3057         va_start (ap, note_type);
3058         memset (data, 0, 112);
3059         pid = va_arg (ap, long);
3060         bfd_put_32 (abfd, pid, data + 32);
3061         cursig = va_arg (ap, int);
3062         bfd_put_16 (abfd, cursig, data + 12);
3063         greg = va_arg (ap, const void *);
3064         memcpy (data + 112, greg, 384);
3065         memset (data + 496, 0, 8);
3066         va_end (ap);
3067         return elfcore_write_note (abfd, buf, bufsiz,
3068                                    "CORE", note_type, data, sizeof (data));
3069       }
3070     }
3071 }
3072
3073 /* Add extra PPC sections.  */
3074
3075 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3076 {
3077   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3078   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3079   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3080   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3081   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3082   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3083   { NULL,                     0,  0, 0,            0 }
3084 };
3085
3086 enum _ppc64_sec_type {
3087   sec_normal = 0,
3088   sec_opd = 1,
3089   sec_toc = 2
3090 };
3091
3092 struct _ppc64_elf_section_data
3093 {
3094   struct bfd_elf_section_data elf;
3095
3096   union
3097   {
3098     /* An array with one entry for each opd function descriptor,
3099        and some spares since opd entries may be either 16 or 24 bytes.  */
3100 #define OPD_NDX(OFF) ((OFF) >> 4)
3101     struct _opd_sec_data
3102     {
3103       /* Points to the function code section for local opd entries.  */
3104       asection **func_sec;
3105
3106       /* After editing .opd, adjust references to opd local syms.  */
3107       long *adjust;
3108     } opd;
3109
3110     /* An array for toc sections, indexed by offset/8.  */
3111     struct _toc_sec_data
3112     {
3113       /* Specifies the relocation symbol index used at a given toc offset.  */
3114       unsigned *symndx;
3115
3116       /* And the relocation addend.  */
3117       bfd_vma *add;
3118     } toc;
3119   } u;
3120
3121   enum _ppc64_sec_type sec_type:2;
3122
3123   /* Flag set when small branches are detected.  Used to
3124      select suitable defaults for the stub group size.  */
3125   unsigned int has_14bit_branch:1;
3126 };
3127
3128 #define ppc64_elf_section_data(sec) \
3129   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3130
3131 static bfd_boolean
3132 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3133 {
3134   if (!sec->used_by_bfd)
3135     {
3136       struct _ppc64_elf_section_data *sdata;
3137       bfd_size_type amt = sizeof (*sdata);
3138
3139       sdata = bfd_zalloc (abfd, amt);
3140       if (sdata == NULL)
3141         return FALSE;
3142       sec->used_by_bfd = sdata;
3143     }
3144
3145   return _bfd_elf_new_section_hook (abfd, sec);
3146 }
3147
3148 static struct _opd_sec_data *
3149 get_opd_info (asection * sec)
3150 {
3151   if (sec != NULL
3152       && ppc64_elf_section_data (sec) != NULL
3153       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3154     return &ppc64_elf_section_data (sec)->u.opd;
3155   return NULL;
3156 }
3157 \f
3158 /* Parameters for the qsort hook.  */
3159 static bfd_boolean synthetic_relocatable;
3160 static asection *synthetic_opd;
3161
3162 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3163
3164 static int
3165 compare_symbols (const void *ap, const void *bp)
3166 {
3167   const asymbol *a = * (const asymbol **) ap;
3168   const asymbol *b = * (const asymbol **) bp;
3169
3170   /* Section symbols first.  */
3171   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3172     return -1;
3173   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3174     return 1;
3175
3176   /* then .opd symbols.  */
3177   if (synthetic_opd != NULL)
3178     {
3179       if (strcmp (a->section->name, ".opd") == 0
3180           && strcmp (b->section->name, ".opd") != 0)
3181         return -1;
3182       if (strcmp (a->section->name, ".opd") != 0
3183           && strcmp (b->section->name, ".opd") == 0)
3184         return 1;
3185     }
3186
3187   /* then other code symbols.  */
3188   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3189       == (SEC_CODE | SEC_ALLOC)
3190       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3191          != (SEC_CODE | SEC_ALLOC))
3192     return -1;
3193
3194   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195       != (SEC_CODE | SEC_ALLOC)
3196       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197          == (SEC_CODE | SEC_ALLOC))
3198     return 1;
3199
3200   if (synthetic_relocatable)
3201     {
3202       if (a->section->id < b->section->id)
3203         return -1;
3204
3205       if (a->section->id > b->section->id)
3206         return 1;
3207     }
3208
3209   if (a->value + a->section->vma < b->value + b->section->vma)
3210     return -1;
3211
3212   if (a->value + a->section->vma > b->value + b->section->vma)
3213     return 1;
3214
3215   /* For syms with the same value, prefer strong dynamic global function
3216      syms over other syms.  */
3217   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3218     return -1;
3219
3220   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3221     return 1;
3222
3223   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3224     return -1;
3225
3226   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3227     return 1;
3228
3229   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3230     return -1;
3231
3232   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3233     return 1;
3234
3235   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3236     return -1;
3237
3238   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3239     return 1;
3240
3241   return a > b;
3242 }
3243
3244 /* Search SYMS for a symbol of the given VALUE.  */
3245
3246 static asymbol *
3247 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3248 {
3249   long mid;
3250
3251   if (id == (unsigned) -1)
3252     {
3253       while (lo < hi)
3254         {
3255           mid = (lo + hi) >> 1;
3256           if (syms[mid]->value + syms[mid]->section->vma < value)
3257             lo = mid + 1;
3258           else if (syms[mid]->value + syms[mid]->section->vma > value)
3259             hi = mid;
3260           else
3261             return syms[mid];
3262         }
3263     }
3264   else
3265     {
3266       while (lo < hi)
3267         {
3268           mid = (lo + hi) >> 1;
3269           if (syms[mid]->section->id < id)
3270             lo = mid + 1;
3271           else if (syms[mid]->section->id > id)
3272             hi = mid;
3273           else if (syms[mid]->value < value)
3274             lo = mid + 1;
3275           else if (syms[mid]->value > value)
3276             hi = mid;
3277           else
3278             return syms[mid];
3279         }
3280     }
3281   return NULL;
3282 }
3283
3284 static bfd_boolean
3285 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3286 {
3287   bfd_vma vma = *(bfd_vma *) ptr;
3288   return ((section->flags & SEC_ALLOC) != 0
3289           && section->vma <= vma
3290           && vma < section->vma + section->size);
3291 }
3292
3293 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3294    entry syms.  Also generate @plt symbols for the glink branch table.
3295    Returns count of synthetic symbols in RET or -1 on error.  */
3296
3297 static long
3298 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3299                                 long static_count, asymbol **static_syms,
3300                                 long dyn_count, asymbol **dyn_syms,
3301                                 asymbol **ret)
3302 {
3303   asymbol *s;
3304   size_t i, j, count;
3305   char *names;
3306   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3307   asection *opd = NULL;
3308   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3309   asymbol **syms;
3310   int abi = abiversion (abfd);
3311
3312   *ret = NULL;
3313
3314   if (abi < 2)
3315     {
3316       opd = bfd_get_section_by_name (abfd, ".opd");
3317       if (opd == NULL && abi == 1)
3318         return 0;
3319     }
3320
3321   syms = NULL;
3322   codesecsym = 0;
3323   codesecsymend = 0;
3324   secsymend = 0;
3325   opdsymend = 0;
3326   symcount = 0;
3327   if (opd != NULL)
3328     {
3329       symcount = static_count;
3330       if (!relocatable)
3331         symcount += dyn_count;
3332       if (symcount == 0)
3333         return 0;
3334
3335       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3336       if (syms == NULL)
3337         return -1;
3338
3339       if (!relocatable && static_count != 0 && dyn_count != 0)
3340         {
3341           /* Use both symbol tables.  */
3342           memcpy (syms, static_syms, static_count * sizeof (*syms));
3343           memcpy (syms + static_count, dyn_syms,
3344                   (dyn_count + 1) * sizeof (*syms));
3345         }
3346       else if (!relocatable && static_count == 0)
3347         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3348       else
3349         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3350
3351       /* Trim uninteresting symbols.  Interesting symbols are section,
3352          function, and notype symbols.  */
3353       for (i = 0, j = 0; i < symcount; ++i)
3354         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3355                                | BSF_RELC | BSF_SRELC)) == 0)
3356           syms[j++] = syms[i];
3357       symcount = j;
3358
3359       synthetic_relocatable = relocatable;
3360       synthetic_opd = opd;
3361       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3362
3363       if (!relocatable && symcount > 1)
3364         {
3365           /* Trim duplicate syms, since we may have merged the normal and
3366              dynamic symbols.  Actually, we only care about syms that have
3367              different values, so trim any with the same value.  */
3368           for (i = 1, j = 1; i < symcount; ++i)
3369             if (syms[i - 1]->value + syms[i - 1]->section->vma
3370                 != syms[i]->value + syms[i]->section->vma)
3371               syms[j++] = syms[i];
3372           symcount = j;
3373         }
3374
3375       i = 0;
3376       /* Note that here and in compare_symbols we can't compare opd and
3377          sym->section directly.  With separate debug info files, the
3378          symbols will be extracted from the debug file while abfd passed
3379          to this function is the real binary.  */
3380       if (strcmp (syms[i]->section->name, ".opd") == 0)
3381         ++i;
3382       codesecsym = i;
3383
3384       for (; i < symcount; ++i)
3385         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3386                                          | SEC_THREAD_LOCAL))
3387              != (SEC_CODE | SEC_ALLOC))
3388             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3389           break;
3390       codesecsymend = i;
3391
3392       for (; i < symcount; ++i)
3393         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3394           break;
3395       secsymend = i;
3396
3397       for (; i < symcount; ++i)
3398         if (strcmp (syms[i]->section->name, ".opd") != 0)
3399           break;
3400       opdsymend = i;
3401
3402       for (; i < symcount; ++i)
3403         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3404             != (SEC_CODE | SEC_ALLOC))
3405           break;
3406       symcount = i;
3407     }
3408   count = 0;
3409
3410   if (relocatable)
3411     {
3412       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3413       arelent *r;
3414       size_t size;
3415       size_t relcount;
3416
3417       if (opdsymend == secsymend)
3418         goto done;
3419
3420       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3421       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3422       if (relcount == 0)
3423         goto done;
3424
3425       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3426         {
3427           count = -1;
3428           goto done;
3429         }
3430
3431       size = 0;
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               ++count;
3454               size += sizeof (asymbol);
3455               size += strlen (syms[i]->name) + 2;
3456             }
3457         }
3458
3459       if (size == 0)
3460         goto done;
3461       s = *ret = bfd_malloc (size);
3462       if (s == NULL)
3463         {
3464           count = -1;
3465           goto done;
3466         }
3467
3468       names = (char *) (s + count);
3469
3470       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3471         {
3472           asymbol *sym;
3473
3474           while (r < opd->relocation + relcount
3475                  && r->address < syms[i]->value + opd->vma)
3476             ++r;
3477
3478           if (r == opd->relocation + relcount)
3479             break;
3480
3481           if (r->address != syms[i]->value + opd->vma)
3482             continue;
3483
3484           if (r->howto->type != R_PPC64_ADDR64)
3485             continue;
3486
3487           sym = *r->sym_ptr_ptr;
3488           if (!sym_exists_at (syms, opdsymend, symcount,
3489                               sym->section->id, sym->value + r->addend))
3490             {
3491               size_t len;
3492
3493               *s = *syms[i];
3494               s->flags |= BSF_SYNTHETIC;
3495               s->section = sym->section;
3496               s->value = sym->value + r->addend;
3497               s->name = names;
3498               *names++ = '.';
3499               len = strlen (syms[i]->name);
3500               memcpy (names, syms[i]->name, len + 1);
3501               names += len + 1;
3502               /* Have udata.p point back to the original symbol this
3503                  synthetic symbol was derived from.  */
3504               s->udata.p = syms[i];
3505               s++;
3506             }
3507         }
3508     }
3509   else
3510     {
3511       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3512       bfd_byte *contents = NULL;
3513       size_t size;
3514       size_t plt_count = 0;
3515       bfd_vma glink_vma = 0, resolv_vma = 0;
3516       asection *dynamic, *glink = NULL, *relplt = NULL;
3517       arelent *p;
3518
3519       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3520         {
3521         free_contents_and_exit_err:
3522           count = -1;
3523         free_contents_and_exit:
3524           if (contents)
3525             free (contents);
3526           goto done;
3527         }
3528
3529       size = 0;
3530       for (i = secsymend; i < opdsymend; ++i)
3531         {
3532           bfd_vma ent;
3533
3534           /* Ignore bogus symbols.  */
3535           if (syms[i]->value > opd->size - 8)
3536             continue;
3537
3538           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3539           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3540             {
3541               ++count;
3542               size += sizeof (asymbol);
3543               size += strlen (syms[i]->name) + 2;
3544             }
3545         }
3546
3547       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3548       if (dyn_count != 0
3549           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3550         {
3551           bfd_byte *dynbuf, *extdyn, *extdynend;
3552           size_t extdynsize;
3553           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3554
3555           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3556             goto free_contents_and_exit_err;
3557
3558           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3559           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3560
3561           extdyn = dynbuf;
3562           extdynend = extdyn + dynamic->size;
3563           for (; extdyn < extdynend; extdyn += extdynsize)
3564             {
3565               Elf_Internal_Dyn dyn;
3566               (*swap_dyn_in) (abfd, extdyn, &dyn);
3567
3568               if (dyn.d_tag == DT_NULL)
3569                 break;
3570
3571               if (dyn.d_tag == DT_PPC64_GLINK)
3572                 {
3573                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3574                      See comment in ppc64_elf_finish_dynamic_sections. */
3575                   glink_vma = dyn.d_un.d_val + 8 * 4;
3576                   /* The .glink section usually does not survive the final
3577                      link; search for the section (usually .text) where the
3578                      glink stubs now reside.  */
3579                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3580                                                 &glink_vma);
3581                   break;
3582                 }
3583             }
3584
3585           free (dynbuf);
3586         }
3587
3588       if (glink != NULL)
3589         {
3590           /* Determine __glink trampoline by reading the relative branch
3591              from the first glink stub.  */
3592           bfd_byte buf[4];
3593           unsigned int off = 0;
3594
3595           while (bfd_get_section_contents (abfd, glink, buf,
3596                                            glink_vma + off - glink->vma, 4))
3597             {
3598               unsigned int insn = bfd_get_32 (abfd, buf);
3599               insn ^= B_DOT;
3600               if ((insn & ~0x3fffffc) == 0)
3601                 {
3602                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3603                   break;
3604                 }
3605               off += 4;
3606               if (off > 4)
3607                 break;
3608             }
3609
3610           if (resolv_vma)
3611             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3612
3613           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3614           if (relplt != NULL)
3615             {
3616               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3617               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3618                 goto free_contents_and_exit_err;
3619
3620               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3621               size += plt_count * sizeof (asymbol);
3622
3623               p = relplt->relocation;
3624               for (i = 0; i < plt_count; i++, p++)
3625                 {
3626                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3627                   if (p->addend != 0)
3628                     size += sizeof ("+0x") - 1 + 16;
3629                 }
3630             }
3631         }
3632
3633       if (size == 0)
3634         goto free_contents_and_exit;
3635       s = *ret = bfd_malloc (size);
3636       if (s == NULL)
3637         goto free_contents_and_exit_err;
3638
3639       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3640
3641       for (i = secsymend; i < opdsymend; ++i)
3642         {
3643           bfd_vma ent;
3644
3645           if (syms[i]->value > opd->size - 8)
3646             continue;
3647
3648           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3649           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3650             {
3651               size_t lo, hi;
3652               size_t len;
3653               asection *sec = abfd->sections;
3654
3655               *s = *syms[i];
3656               lo = codesecsym;
3657               hi = codesecsymend;
3658               while (lo < hi)
3659                 {
3660                   size_t mid = (lo + hi) >> 1;
3661                   if (syms[mid]->section->vma < ent)
3662                     lo = mid + 1;
3663                   else if (syms[mid]->section->vma > ent)
3664                     hi = mid;
3665                   else
3666                     {
3667                       sec = syms[mid]->section;
3668                       break;
3669                     }
3670                 }
3671
3672               if (lo >= hi && lo > codesecsym)
3673                 sec = syms[lo - 1]->section;
3674
3675               for (; sec != NULL; sec = sec->next)
3676                 {
3677                   if (sec->vma > ent)
3678                     break;
3679                   /* SEC_LOAD may not be set if SEC is from a separate debug
3680                      info file.  */
3681                   if ((sec->flags & SEC_ALLOC) == 0)
3682                     break;
3683                   if ((sec->flags & SEC_CODE) != 0)
3684                     s->section = sec;
3685                 }
3686               s->flags |= BSF_SYNTHETIC;
3687               s->value = ent - s->section->vma;
3688               s->name = names;
3689               *names++ = '.';
3690               len = strlen (syms[i]->name);
3691               memcpy (names, syms[i]->name, len + 1);
3692               names += len + 1;
3693               /* Have udata.p point back to the original symbol this
3694                  synthetic symbol was derived from.  */
3695               s->udata.p = syms[i];
3696               s++;
3697             }
3698         }
3699       free (contents);
3700
3701       if (glink != NULL && relplt != NULL)
3702         {
3703           if (resolv_vma)
3704             {
3705               /* Add a symbol for the main glink trampoline.  */
3706               memset (s, 0, sizeof *s);
3707               s->the_bfd = abfd;
3708               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3709               s->section = glink;
3710               s->value = resolv_vma - glink->vma;
3711               s->name = names;
3712               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3713               names += sizeof ("__glink_PLTresolve");
3714               s++;
3715               count++;
3716             }
3717
3718           /* FIXME: It would be very much nicer to put sym@plt on the
3719              stub rather than on the glink branch table entry.  The
3720              objdump disassembler would then use a sensible symbol
3721              name on plt calls.  The difficulty in doing so is
3722              a) finding the stubs, and,
3723              b) matching stubs against plt entries, and,
3724              c) there can be multiple stubs for a given plt entry.
3725
3726              Solving (a) could be done by code scanning, but older
3727              ppc64 binaries used different stubs to current code.
3728              (b) is the tricky one since you need to known the toc
3729              pointer for at least one function that uses a pic stub to
3730              be able to calculate the plt address referenced.
3731              (c) means gdb would need to set multiple breakpoints (or
3732              find the glink branch itself) when setting breakpoints
3733              for pending shared library loads.  */
3734           p = relplt->relocation;
3735           for (i = 0; i < plt_count; i++, p++)
3736             {
3737               size_t len;
3738
3739               *s = **p->sym_ptr_ptr;
3740               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3741                  we are defining a symbol, ensure one of them is set.  */
3742               if ((s->flags & BSF_LOCAL) == 0)
3743                 s->flags |= BSF_GLOBAL;
3744               s->flags |= BSF_SYNTHETIC;
3745               s->section = glink;
3746               s->value = glink_vma - glink->vma;
3747               s->name = names;
3748               s->udata.p = NULL;
3749               len = strlen ((*p->sym_ptr_ptr)->name);
3750               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3751               names += len;
3752               if (p->addend != 0)
3753                 {
3754                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3755                   names += sizeof ("+0x") - 1;
3756                   bfd_sprintf_vma (abfd, names, p->addend);
3757                   names += strlen (names);
3758                 }
3759               memcpy (names, "@plt", sizeof ("@plt"));
3760               names += sizeof ("@plt");
3761               s++;
3762               if (abi < 2)
3763                 {
3764                   glink_vma += 8;
3765                   if (i >= 0x8000)
3766                     glink_vma += 4;
3767                 }
3768               else
3769                 glink_vma += 4;
3770             }
3771           count += plt_count;
3772         }
3773     }
3774
3775  done:
3776   free (syms);
3777   return count;
3778 }
3779 \f
3780 /* The following functions are specific to the ELF linker, while
3781    functions above are used generally.  Those named ppc64_elf_* are
3782    called by the main ELF linker code.  They appear in this file more
3783    or less in the order in which they are called.  eg.
3784    ppc64_elf_check_relocs is called early in the link process,
3785    ppc64_elf_finish_dynamic_sections is one of the last functions
3786    called.
3787
3788    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3789    functions have both a function code symbol and a function descriptor
3790    symbol.  A call to foo in a relocatable object file looks like:
3791
3792    .            .text
3793    .    x:
3794    .            bl      .foo
3795    .            nop
3796
3797    The function definition in another object file might be:
3798
3799    .            .section .opd
3800    .    foo:    .quad   .foo
3801    .            .quad   .TOC.@tocbase
3802    .            .quad   0
3803    .
3804    .            .text
3805    .    .foo:   blr
3806
3807    When the linker resolves the call during a static link, the branch
3808    unsurprisingly just goes to .foo and the .opd information is unused.
3809    If the function definition is in a shared library, things are a little
3810    different:  The call goes via a plt call stub, the opd information gets
3811    copied to the plt, and the linker patches the nop.
3812
3813    .    x:
3814    .            bl      .foo_stub
3815    .            ld      2,40(1)
3816    .
3817    .
3818    .    .foo_stub:
3819    .            std     2,40(1)                 # in practice, the call stub
3820    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3821    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3822    .            ld      12,0(11)
3823    .            ld      2,8(11)
3824    .            mtctr   12
3825    .            ld      11,16(11)
3826    .            bctr
3827    .
3828    .            .section .plt
3829    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3830
3831    The "reloc ()" notation is supposed to indicate that the linker emits
3832    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3833    copying.
3834
3835    What are the difficulties here?  Well, firstly, the relocations
3836    examined by the linker in check_relocs are against the function code
3837    sym .foo, while the dynamic relocation in the plt is emitted against
3838    the function descriptor symbol, foo.  Somewhere along the line, we need
3839    to carefully copy dynamic link information from one symbol to the other.
3840    Secondly, the generic part of the elf linker will make .foo a dynamic
3841    symbol as is normal for most other backends.  We need foo dynamic
3842    instead, at least for an application final link.  However, when
3843    creating a shared library containing foo, we need to have both symbols
3844    dynamic so that references to .foo are satisfied during the early
3845    stages of linking.  Otherwise the linker might decide to pull in a
3846    definition from some other object, eg. a static library.
3847
3848    Update: As of August 2004, we support a new convention.  Function
3849    calls may use the function descriptor symbol, ie. "bl foo".  This
3850    behaves exactly as "bl .foo".  */
3851
3852 /* Of those relocs that might be copied as dynamic relocs, this
3853    function selects those that must be copied when linking a shared
3854    library or PIE, even when the symbol is local.  */
3855
3856 static int
3857 must_be_dyn_reloc (struct bfd_link_info *info,
3858                    enum elf_ppc64_reloc_type r_type)
3859 {
3860   switch (r_type)
3861     {
3862     default:
3863       /* Only relative relocs can be resolved when the object load
3864          address isn't fixed.  DTPREL64 is excluded because the
3865          dynamic linker needs to differentiate global dynamic from
3866          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3867       return 1;
3868
3869     case R_PPC64_REL32:
3870     case R_PPC64_REL64:
3871     case R_PPC64_REL30:
3872       return 0;
3873
3874     case R_PPC64_TPREL16:
3875     case R_PPC64_TPREL16_LO:
3876     case R_PPC64_TPREL16_HI:
3877     case R_PPC64_TPREL16_HA:
3878     case R_PPC64_TPREL16_DS:
3879     case R_PPC64_TPREL16_LO_DS:
3880     case R_PPC64_TPREL16_HIGH:
3881     case R_PPC64_TPREL16_HIGHA:
3882     case R_PPC64_TPREL16_HIGHER:
3883     case R_PPC64_TPREL16_HIGHERA:
3884     case R_PPC64_TPREL16_HIGHEST:
3885     case R_PPC64_TPREL16_HIGHESTA:
3886     case R_PPC64_TPREL64:
3887       /* These relocations are relative but in a shared library the
3888          linker doesn't know the thread pointer base.  */
3889       return bfd_link_dll (info);
3890     }
3891 }
3892
3893 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3894    copying dynamic variables from a shared lib into an app's dynbss
3895    section, and instead use a dynamic relocation to point into the
3896    shared lib.  With code that gcc generates, it's vital that this be
3897    enabled;  In the PowerPC64 ABI, the address of a function is actually
3898    the address of a function descriptor, which resides in the .opd
3899    section.  gcc uses the descriptor directly rather than going via the
3900    GOT as some other ABI's do, which means that initialized function
3901    pointers must reference the descriptor.  Thus, a function pointer
3902    initialized to the address of a function in a shared library will
3903    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3904    redefines the function descriptor symbol to point to the copy.  This
3905    presents a problem as a plt entry for that function is also
3906    initialized from the function descriptor symbol and the copy reloc
3907    may not be initialized first.  */
3908 #define ELIMINATE_COPY_RELOCS 1
3909
3910 /* Section name for stubs is the associated section name plus this
3911    string.  */
3912 #define STUB_SUFFIX ".stub"
3913
3914 /* Linker stubs.
3915    ppc_stub_long_branch:
3916    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3917    destination, but a 24 bit branch in a stub section will reach.
3918    .    b       dest
3919
3920    ppc_stub_plt_branch:
3921    Similar to the above, but a 24 bit branch in the stub section won't
3922    reach its destination.
3923    .    addis   %r11,%r2,xxx@toc@ha
3924    .    ld      %r12,xxx@toc@l(%r11)
3925    .    mtctr   %r12
3926    .    bctr
3927
3928    ppc_stub_plt_call:
3929    Used to call a function in a shared library.  If it so happens that
3930    the plt entry referenced crosses a 64k boundary, then an extra
3931    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3932    .    std     %r2,40(%r1)
3933    .    addis   %r11,%r2,xxx@toc@ha
3934    .    ld      %r12,xxx+0@toc@l(%r11)
3935    .    mtctr   %r12
3936    .    ld      %r2,xxx+8@toc@l(%r11)
3937    .    ld      %r11,xxx+16@toc@l(%r11)
3938    .    bctr
3939
3940    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3941    code to adjust the value and save r2 to support multiple toc sections.
3942    A ppc_stub_long_branch with an r2 offset looks like:
3943    .    std     %r2,40(%r1)
3944    .    addis   %r2,%r2,off@ha
3945    .    addi    %r2,%r2,off@l
3946    .    b       dest
3947
3948    A ppc_stub_plt_branch with an r2 offset looks like:
3949    .    std     %r2,40(%r1)
3950    .    addis   %r11,%r2,xxx@toc@ha
3951    .    ld      %r12,xxx@toc@l(%r11)
3952    .    addis   %r2,%r2,off@ha
3953    .    addi    %r2,%r2,off@l
3954    .    mtctr   %r12
3955    .    bctr
3956
3957    In cases where the "addis" instruction would add zero, the "addis" is
3958    omitted and following instructions modified slightly in some cases.
3959 */
3960
3961 enum ppc_stub_type {
3962   ppc_stub_none,
3963   ppc_stub_long_branch,
3964   ppc_stub_long_branch_r2off,
3965   ppc_stub_plt_branch,
3966   ppc_stub_plt_branch_r2off,
3967   ppc_stub_plt_call,
3968   ppc_stub_plt_call_r2save,
3969   ppc_stub_global_entry,
3970   ppc_stub_save_res
3971 };
3972
3973 /* Information on stub grouping.  */
3974 struct map_stub
3975 {
3976   /* The stub section.  */
3977   asection *stub_sec;
3978   /* This is the section to which stubs in the group will be attached.  */
3979   asection *link_sec;
3980   /* Next group.  */
3981   struct map_stub *next;
3982   /* Whether to emit a copy of register save/restore functions in this
3983      group.  */
3984   int needs_save_res;
3985   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3986      or -1u if no such stub with bctrl exists.  */
3987   unsigned int tls_get_addr_opt_bctrl;
3988 };
3989
3990 struct ppc_stub_hash_entry {
3991
3992   /* Base hash table entry structure.  */
3993   struct bfd_hash_entry root;
3994
3995   enum ppc_stub_type stub_type;
3996
3997   /* Group information.  */
3998   struct map_stub *group;
3999
4000   /* Offset within stub_sec of the beginning of this stub.  */
4001   bfd_vma stub_offset;
4002
4003   /* Given the symbol's value and its section we can determine its final
4004      value when building the stubs (so the stub knows where to jump.  */
4005   bfd_vma target_value;
4006   asection *target_section;
4007
4008   /* The symbol table entry, if any, that this was derived from.  */
4009   struct ppc_link_hash_entry *h;
4010   struct plt_entry *plt_ent;
4011
4012   /* Symbol type.  */
4013   unsigned char symtype;
4014
4015   /* Symbol st_other.  */
4016   unsigned char other;
4017 };
4018
4019 struct ppc_branch_hash_entry {
4020
4021   /* Base hash table entry structure.  */
4022   struct bfd_hash_entry root;
4023
4024   /* Offset within branch lookup table.  */
4025   unsigned int offset;
4026
4027   /* Generation marker.  */
4028   unsigned int iter;
4029 };
4030
4031 /* Used to track dynamic relocations for local symbols.  */
4032 struct ppc_dyn_relocs
4033 {
4034   struct ppc_dyn_relocs *next;
4035
4036   /* The input section of the reloc.  */
4037   asection *sec;
4038
4039   /* Total number of relocs copied for the input section.  */
4040   unsigned int count : 31;
4041
4042   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4043   unsigned int ifunc : 1;
4044 };
4045
4046 struct ppc_link_hash_entry
4047 {
4048   struct elf_link_hash_entry elf;
4049
4050   union {
4051     /* A pointer to the most recently used stub hash entry against this
4052        symbol.  */
4053     struct ppc_stub_hash_entry *stub_cache;
4054
4055     /* A pointer to the next symbol starting with a '.'  */
4056     struct ppc_link_hash_entry *next_dot_sym;
4057   } u;
4058
4059   /* Track dynamic relocs copied for this symbol.  */
4060   struct elf_dyn_relocs *dyn_relocs;
4061
4062   /* Link between function code and descriptor symbols.  */
4063   struct ppc_link_hash_entry *oh;
4064
4065   /* Flag function code and descriptor symbols.  */
4066   unsigned int is_func:1;
4067   unsigned int is_func_descriptor:1;
4068   unsigned int fake:1;
4069
4070   /* Whether global opd/toc sym has been adjusted or not.
4071      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4072      should be set for all globals defined in any opd/toc section.  */
4073   unsigned int adjust_done:1;
4074
4075   /* Set if this is an out-of-line register save/restore function,
4076      with non-standard calling convention.  */
4077   unsigned int save_res:1;
4078
4079   /* Set if a duplicate symbol with non-zero localentry is detected,
4080      even when the duplicate symbol does not provide a definition.  */
4081   unsigned int non_zero_localentry:1;
4082
4083   /* Contexts in which symbol is used in the GOT (or TOC).
4084      Bits are or'd into the mask as the corresponding relocs are
4085      encountered during check_relocs, with TLS_TLS being set when any
4086      of the other TLS bits are set.  tls_optimize clears bits when
4087      optimizing to indicate the corresponding GOT entry type is not
4088      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4089      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4090      separate flag rather than setting TPREL just for convenience in
4091      distinguishing the two cases.
4092      These flags are also kept for local symbols.  */
4093 #define TLS_TLS          1      /* Any TLS reloc.  */
4094 #define TLS_GD           2      /* GD reloc. */
4095 #define TLS_LD           4      /* LD reloc. */
4096 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4097 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4098 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4099 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4100 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4101   unsigned char tls_mask;
4102
4103   /* The above field is also used to mark function symbols.  In which
4104      case TLS_TLS will be 0.  */
4105 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4106 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4107 #define NON_GOT        256      /* local symbol plt, not stored.  */
4108 };
4109
4110 /* ppc64 ELF linker hash table.  */
4111
4112 struct ppc_link_hash_table
4113 {
4114   struct elf_link_hash_table elf;
4115
4116   /* The stub hash table.  */
4117   struct bfd_hash_table stub_hash_table;
4118
4119   /* Another hash table for plt_branch stubs.  */
4120   struct bfd_hash_table branch_hash_table;
4121
4122   /* Hash table for function prologue tocsave.  */
4123   htab_t tocsave_htab;
4124
4125   /* Various options and other info passed from the linker.  */
4126   struct ppc64_elf_params *params;
4127
4128   /* The size of sec_info below.  */
4129   unsigned int sec_info_arr_size;
4130
4131   /* Per-section array of extra section info.  Done this way rather
4132      than as part of ppc64_elf_section_data so we have the info for
4133      non-ppc64 sections.  */
4134   struct
4135   {
4136     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4137     bfd_vma toc_off;
4138
4139     union
4140     {
4141       /* The section group that this section belongs to.  */
4142       struct map_stub *group;
4143       /* A temp section list pointer.  */
4144       asection *list;
4145     } u;
4146   } *sec_info;
4147
4148   /* Linked list of groups.  */
4149   struct map_stub *group;
4150
4151   /* Temp used when calculating TOC pointers.  */
4152   bfd_vma toc_curr;
4153   bfd *toc_bfd;
4154   asection *toc_first_sec;
4155
4156   /* Used when adding symbols.  */
4157   struct ppc_link_hash_entry *dot_syms;
4158
4159   /* Shortcuts to get to dynamic linker sections.  */
4160   asection *glink;
4161   asection *global_entry;
4162   asection *sfpr;
4163   asection *pltlocal;
4164   asection *relpltlocal;
4165   asection *brlt;
4166   asection *relbrlt;
4167   asection *glink_eh_frame;
4168
4169   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4170   struct ppc_link_hash_entry *tls_get_addr;
4171   struct ppc_link_hash_entry *tls_get_addr_fd;
4172
4173   /* The size of reliplt used by got entry relocs.  */
4174   bfd_size_type got_reli_size;
4175
4176   /* Statistics.  */
4177   unsigned long stub_count[ppc_stub_global_entry];
4178
4179   /* Number of stubs against global syms.  */
4180   unsigned long stub_globals;
4181
4182   /* Set if we're linking code with function descriptors.  */
4183   unsigned int opd_abi:1;
4184
4185   /* Support for multiple toc sections.  */
4186   unsigned int do_multi_toc:1;
4187   unsigned int multi_toc_needed:1;
4188   unsigned int second_toc_pass:1;
4189   unsigned int do_toc_opt:1;
4190
4191   /* Set if tls optimization is enabled.  */
4192   unsigned int do_tls_opt:1;
4193
4194   /* Set on error.  */
4195   unsigned int stub_error:1;
4196
4197   /* Whether func_desc_adjust needs to be run over symbols.  */
4198   unsigned int need_func_desc_adj:1;
4199
4200   /* Whether there exist local gnu indirect function resolvers,
4201      referenced by dynamic relocations.  */
4202   unsigned int local_ifunc_resolver:1;
4203   unsigned int maybe_local_ifunc_resolver:1;
4204
4205   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4206   unsigned int has_plt_localentry0:1;
4207
4208   /* Incremented every time we size stubs.  */
4209   unsigned int stub_iteration;
4210
4211   /* Small local sym cache.  */
4212   struct sym_cache sym_cache;
4213 };
4214
4215 /* Rename some of the generic section flags to better document how they
4216    are used here.  */
4217
4218 /* Nonzero if this section has TLS related relocations.  */
4219 #define has_tls_reloc sec_flg0
4220
4221 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4222 #define has_tls_get_addr_call sec_flg1
4223
4224 /* Nonzero if this section has any toc or got relocs.  */
4225 #define has_toc_reloc sec_flg2
4226
4227 /* Nonzero if this section has a call to another section that uses
4228    the toc or got.  */
4229 #define makes_toc_func_call sec_flg3
4230
4231 /* Recursion protection when determining above flag.  */
4232 #define call_check_in_progress sec_flg4
4233 #define call_check_done sec_flg5
4234
4235 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4236
4237 #define ppc_hash_table(p) \
4238   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4239   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4240
4241 #define ppc_stub_hash_lookup(table, string, create, copy) \
4242   ((struct ppc_stub_hash_entry *) \
4243    bfd_hash_lookup ((table), (string), (create), (copy)))
4244
4245 #define ppc_branch_hash_lookup(table, string, create, copy) \
4246   ((struct ppc_branch_hash_entry *) \
4247    bfd_hash_lookup ((table), (string), (create), (copy)))
4248
4249 /* Create an entry in the stub hash table.  */
4250
4251 static struct bfd_hash_entry *
4252 stub_hash_newfunc (struct bfd_hash_entry *entry,
4253                    struct bfd_hash_table *table,
4254                    const char *string)
4255 {
4256   /* Allocate the structure if it has not already been allocated by a
4257      subclass.  */
4258   if (entry == NULL)
4259     {
4260       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4261       if (entry == NULL)
4262         return entry;
4263     }
4264
4265   /* Call the allocation method of the superclass.  */
4266   entry = bfd_hash_newfunc (entry, table, string);
4267   if (entry != NULL)
4268     {
4269       struct ppc_stub_hash_entry *eh;
4270
4271       /* Initialize the local fields.  */
4272       eh = (struct ppc_stub_hash_entry *) entry;
4273       eh->stub_type = ppc_stub_none;
4274       eh->group = NULL;
4275       eh->stub_offset = 0;
4276       eh->target_value = 0;
4277       eh->target_section = NULL;
4278       eh->h = NULL;
4279       eh->plt_ent = NULL;
4280       eh->other = 0;
4281     }
4282
4283   return entry;
4284 }
4285
4286 /* Create an entry in the branch hash table.  */
4287
4288 static struct bfd_hash_entry *
4289 branch_hash_newfunc (struct bfd_hash_entry *entry,
4290                      struct bfd_hash_table *table,
4291                      const char *string)
4292 {
4293   /* Allocate the structure if it has not already been allocated by a
4294      subclass.  */
4295   if (entry == NULL)
4296     {
4297       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4298       if (entry == NULL)
4299         return entry;
4300     }
4301
4302   /* Call the allocation method of the superclass.  */
4303   entry = bfd_hash_newfunc (entry, table, string);
4304   if (entry != NULL)
4305     {
4306       struct ppc_branch_hash_entry *eh;
4307
4308       /* Initialize the local fields.  */
4309       eh = (struct ppc_branch_hash_entry *) entry;
4310       eh->offset = 0;
4311       eh->iter = 0;
4312     }
4313
4314   return entry;
4315 }
4316
4317 /* Create an entry in a ppc64 ELF linker hash table.  */
4318
4319 static struct bfd_hash_entry *
4320 link_hash_newfunc (struct bfd_hash_entry *entry,
4321                    struct bfd_hash_table *table,
4322                    const char *string)
4323 {
4324   /* Allocate the structure if it has not already been allocated by a
4325      subclass.  */
4326   if (entry == NULL)
4327     {
4328       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4329       if (entry == NULL)
4330         return entry;
4331     }
4332
4333   /* Call the allocation method of the superclass.  */
4334   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4335   if (entry != NULL)
4336     {
4337       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4338
4339       memset (&eh->u.stub_cache, 0,
4340               (sizeof (struct ppc_link_hash_entry)
4341                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4342
4343       /* When making function calls, old ABI code references function entry
4344          points (dot symbols), while new ABI code references the function
4345          descriptor symbol.  We need to make any combination of reference and
4346          definition work together, without breaking archive linking.
4347
4348          For a defined function "foo" and an undefined call to "bar":
4349          An old object defines "foo" and ".foo", references ".bar" (possibly
4350          "bar" too).
4351          A new object defines "foo" and references "bar".
4352
4353          A new object thus has no problem with its undefined symbols being
4354          satisfied by definitions in an old object.  On the other hand, the
4355          old object won't have ".bar" satisfied by a new object.
4356
4357          Keep a list of newly added dot-symbols.  */
4358
4359       if (string[0] == '.')
4360         {
4361           struct ppc_link_hash_table *htab;
4362
4363           htab = (struct ppc_link_hash_table *) table;
4364           eh->u.next_dot_sym = htab->dot_syms;
4365           htab->dot_syms = eh;
4366         }
4367     }
4368
4369   return entry;
4370 }
4371
4372 struct tocsave_entry {
4373   asection *sec;
4374   bfd_vma offset;
4375 };
4376
4377 static hashval_t
4378 tocsave_htab_hash (const void *p)
4379 {
4380   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4381   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4382 }
4383
4384 static int
4385 tocsave_htab_eq (const void *p1, const void *p2)
4386 {
4387   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4388   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4389   return e1->sec == e2->sec && e1->offset == e2->offset;
4390 }
4391
4392 /* Destroy a ppc64 ELF linker hash table.  */
4393
4394 static void
4395 ppc64_elf_link_hash_table_free (bfd *obfd)
4396 {
4397   struct ppc_link_hash_table *htab;
4398
4399   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4400   if (htab->tocsave_htab)
4401     htab_delete (htab->tocsave_htab);
4402   bfd_hash_table_free (&htab->branch_hash_table);
4403   bfd_hash_table_free (&htab->stub_hash_table);
4404   _bfd_elf_link_hash_table_free (obfd);
4405 }
4406
4407 /* Create a ppc64 ELF linker hash table.  */
4408
4409 static struct bfd_link_hash_table *
4410 ppc64_elf_link_hash_table_create (bfd *abfd)
4411 {
4412   struct ppc_link_hash_table *htab;
4413   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4414
4415   htab = bfd_zmalloc (amt);
4416   if (htab == NULL)
4417     return NULL;
4418
4419   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4420                                       sizeof (struct ppc_link_hash_entry),
4421                                       PPC64_ELF_DATA))
4422     {
4423       free (htab);
4424       return NULL;
4425     }
4426
4427   /* Init the stub hash table too.  */
4428   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4429                             sizeof (struct ppc_stub_hash_entry)))
4430     {
4431       _bfd_elf_link_hash_table_free (abfd);
4432       return NULL;
4433     }
4434
4435   /* And the branch hash table.  */
4436   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4437                             sizeof (struct ppc_branch_hash_entry)))
4438     {
4439       bfd_hash_table_free (&htab->stub_hash_table);
4440       _bfd_elf_link_hash_table_free (abfd);
4441       return NULL;
4442     }
4443
4444   htab->tocsave_htab = htab_try_create (1024,
4445                                         tocsave_htab_hash,
4446                                         tocsave_htab_eq,
4447                                         NULL);
4448   if (htab->tocsave_htab == NULL)
4449     {
4450       ppc64_elf_link_hash_table_free (abfd);
4451       return NULL;
4452     }
4453   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4454
4455   /* Initializing two fields of the union is just cosmetic.  We really
4456      only care about glist, but when compiled on a 32-bit host the
4457      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4458      debugger inspection of these fields look nicer.  */
4459   htab->elf.init_got_refcount.refcount = 0;
4460   htab->elf.init_got_refcount.glist = NULL;
4461   htab->elf.init_plt_refcount.refcount = 0;
4462   htab->elf.init_plt_refcount.glist = NULL;
4463   htab->elf.init_got_offset.offset = 0;
4464   htab->elf.init_got_offset.glist = NULL;
4465   htab->elf.init_plt_offset.offset = 0;
4466   htab->elf.init_plt_offset.glist = NULL;
4467
4468   return &htab->elf.root;
4469 }
4470
4471 /* Create sections for linker generated code.  */
4472
4473 static bfd_boolean
4474 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4475 {
4476   struct ppc_link_hash_table *htab;
4477   flagword flags;
4478
4479   htab = ppc_hash_table (info);
4480
4481   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4482            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4483   if (htab->params->save_restore_funcs)
4484     {
4485       /* Create .sfpr for code to save and restore fp regs.  */
4486       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4487                                                        flags);
4488       if (htab->sfpr == NULL
4489           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4490         return FALSE;
4491     }
4492
4493   if (bfd_link_relocatable (info))
4494     return TRUE;
4495
4496   /* Create .glink for lazy dynamic linking support.  */
4497   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4498                                                     flags);
4499   if (htab->glink == NULL
4500       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4501     return FALSE;
4502
4503   /* The part of .glink used by global entry stubs, separate so that
4504      it can be aligned appropriately without affecting htab->glink.  */
4505   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4506                                                            flags);
4507   if (htab->global_entry == NULL
4508       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4509     return FALSE;
4510
4511   if (!info->no_ld_generated_unwind_info)
4512     {
4513       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4514                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4515       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4516                                                                  ".eh_frame",
4517                                                                  flags);
4518       if (htab->glink_eh_frame == NULL
4519           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4520         return FALSE;
4521     }
4522
4523   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4524   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4525   if (htab->elf.iplt == NULL
4526       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4527     return FALSE;
4528
4529   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4530            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4531   htab->elf.irelplt
4532     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4533   if (htab->elf.irelplt == NULL
4534       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4535     return FALSE;
4536
4537   /* Create branch lookup table for plt_branch stubs.  */
4538   flags = (SEC_ALLOC | SEC_LOAD
4539            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4540   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4541                                                    flags);
4542   if (htab->brlt == NULL
4543       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4544     return FALSE;
4545
4546   /* Local plt entries, put in .branch_lt but a separate section for
4547      convenience.  */
4548   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4549                                                        flags);
4550   if (htab->pltlocal == NULL
4551       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4552     return FALSE;
4553
4554   if (!bfd_link_pic (info))
4555     return TRUE;
4556
4557   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4558            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4559   htab->relbrlt
4560     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4561   if (htab->relbrlt == NULL
4562       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4563     return FALSE;
4564
4565   htab->relpltlocal
4566     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4567   if (htab->relpltlocal == NULL
4568       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4569     return FALSE;
4570
4571   return TRUE;
4572 }
4573
4574 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4575
4576 bfd_boolean
4577 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4578                          struct ppc64_elf_params *params)
4579 {
4580   struct ppc_link_hash_table *htab;
4581
4582   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4583
4584 /* Always hook our dynamic sections into the first bfd, which is the
4585    linker created stub bfd.  This ensures that the GOT header is at
4586    the start of the output TOC section.  */
4587   htab = ppc_hash_table (info);
4588   htab->elf.dynobj = params->stub_bfd;
4589   htab->params = params;
4590
4591   return create_linkage_sections (htab->elf.dynobj, info);
4592 }
4593
4594 /* Build a name for an entry in the stub hash table.  */
4595
4596 static char *
4597 ppc_stub_name (const asection *input_section,
4598                const asection *sym_sec,
4599                const struct ppc_link_hash_entry *h,
4600                const Elf_Internal_Rela *rel)
4601 {
4602   char *stub_name;
4603   ssize_t len;
4604
4605   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4606      offsets from a sym as a branch target?  In fact, we could
4607      probably assume the addend is always zero.  */
4608   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4609
4610   if (h)
4611     {
4612       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4613       stub_name = bfd_malloc (len);
4614       if (stub_name == NULL)
4615         return stub_name;
4616
4617       len = sprintf (stub_name, "%08x.%s+%x",
4618                      input_section->id & 0xffffffff,
4619                      h->elf.root.root.string,
4620                      (int) rel->r_addend & 0xffffffff);
4621     }
4622   else
4623     {
4624       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4625       stub_name = bfd_malloc (len);
4626       if (stub_name == NULL)
4627         return stub_name;
4628
4629       len = sprintf (stub_name, "%08x.%x:%x+%x",
4630                      input_section->id & 0xffffffff,
4631                      sym_sec->id & 0xffffffff,
4632                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4633                      (int) rel->r_addend & 0xffffffff);
4634     }
4635   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4636     stub_name[len - 2] = 0;
4637   return stub_name;
4638 }
4639
4640 /* Look up an entry in the stub hash.  Stub entries are cached because
4641    creating the stub name takes a bit of time.  */
4642
4643 static struct ppc_stub_hash_entry *
4644 ppc_get_stub_entry (const asection *input_section,
4645                     const asection *sym_sec,
4646                     struct ppc_link_hash_entry *h,
4647                     const Elf_Internal_Rela *rel,
4648                     struct ppc_link_hash_table *htab)
4649 {
4650   struct ppc_stub_hash_entry *stub_entry;
4651   struct map_stub *group;
4652
4653   /* If this input section is part of a group of sections sharing one
4654      stub section, then use the id of the first section in the group.
4655      Stub names need to include a section id, as there may well be
4656      more than one stub used to reach say, printf, and we need to
4657      distinguish between them.  */
4658   group = htab->sec_info[input_section->id].u.group;
4659   if (group == NULL)
4660     return NULL;
4661
4662   if (h != NULL && h->u.stub_cache != NULL
4663       && h->u.stub_cache->h == h
4664       && h->u.stub_cache->group == group)
4665     {
4666       stub_entry = h->u.stub_cache;
4667     }
4668   else
4669     {
4670       char *stub_name;
4671
4672       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4673       if (stub_name == NULL)
4674         return NULL;
4675
4676       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4677                                          stub_name, FALSE, FALSE);
4678       if (h != NULL)
4679         h->u.stub_cache = stub_entry;
4680
4681       free (stub_name);
4682     }
4683
4684   return stub_entry;
4685 }
4686
4687 /* Add a new stub entry to the stub hash.  Not all fields of the new
4688    stub entry are initialised.  */
4689
4690 static struct ppc_stub_hash_entry *
4691 ppc_add_stub (const char *stub_name,
4692               asection *section,
4693               struct bfd_link_info *info)
4694 {
4695   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4696   struct map_stub *group;
4697   asection *link_sec;
4698   asection *stub_sec;
4699   struct ppc_stub_hash_entry *stub_entry;
4700
4701   group = htab->sec_info[section->id].u.group;
4702   link_sec = group->link_sec;
4703   stub_sec = group->stub_sec;
4704   if (stub_sec == NULL)
4705     {
4706       size_t namelen;
4707       bfd_size_type len;
4708       char *s_name;
4709
4710       namelen = strlen (link_sec->name);
4711       len = namelen + sizeof (STUB_SUFFIX);
4712       s_name = bfd_alloc (htab->params->stub_bfd, len);
4713       if (s_name == NULL)
4714         return NULL;
4715
4716       memcpy (s_name, link_sec->name, namelen);
4717       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4718       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4719       if (stub_sec == NULL)
4720         return NULL;
4721       group->stub_sec = stub_sec;
4722     }
4723
4724   /* Enter this entry into the linker stub hash table.  */
4725   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4726                                      TRUE, FALSE);
4727   if (stub_entry == NULL)
4728     {
4729       /* xgettext:c-format */
4730       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4731                           section->owner, stub_name);
4732       return NULL;
4733     }
4734
4735   stub_entry->group = group;
4736   stub_entry->stub_offset = 0;
4737   return stub_entry;
4738 }
4739
4740 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4741    not already done.  */
4742
4743 static bfd_boolean
4744 create_got_section (bfd *abfd, struct bfd_link_info *info)
4745 {
4746   asection *got, *relgot;
4747   flagword flags;
4748   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4749
4750   if (!is_ppc64_elf (abfd))
4751     return FALSE;
4752   if (htab == NULL)
4753     return FALSE;
4754
4755   if (!htab->elf.sgot
4756       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4757     return FALSE;
4758
4759   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4760            | SEC_LINKER_CREATED);
4761
4762   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4763   if (!got
4764       || !bfd_set_section_alignment (abfd, got, 3))
4765     return FALSE;
4766
4767   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4768                                                flags | SEC_READONLY);
4769   if (!relgot
4770       || ! bfd_set_section_alignment (abfd, relgot, 3))
4771     return FALSE;
4772
4773   ppc64_elf_tdata (abfd)->got = got;
4774   ppc64_elf_tdata (abfd)->relgot = relgot;
4775   return TRUE;
4776 }
4777
4778 /* Follow indirect and warning symbol links.  */
4779
4780 static inline struct bfd_link_hash_entry *
4781 follow_link (struct bfd_link_hash_entry *h)
4782 {
4783   while (h->type == bfd_link_hash_indirect
4784          || h->type == bfd_link_hash_warning)
4785     h = h->u.i.link;
4786   return h;
4787 }
4788
4789 static inline struct elf_link_hash_entry *
4790 elf_follow_link (struct elf_link_hash_entry *h)
4791 {
4792   return (struct elf_link_hash_entry *) follow_link (&h->root);
4793 }
4794
4795 static inline struct ppc_link_hash_entry *
4796 ppc_follow_link (struct ppc_link_hash_entry *h)
4797 {
4798   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4799 }
4800
4801 /* Merge PLT info on FROM with that on TO.  */
4802
4803 static void
4804 move_plt_plist (struct ppc_link_hash_entry *from,
4805                 struct ppc_link_hash_entry *to)
4806 {
4807   if (from->elf.plt.plist != NULL)
4808     {
4809       if (to->elf.plt.plist != NULL)
4810         {
4811           struct plt_entry **entp;
4812           struct plt_entry *ent;
4813
4814           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4815             {
4816               struct plt_entry *dent;
4817
4818               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4819                 if (dent->addend == ent->addend)
4820                   {
4821                     dent->plt.refcount += ent->plt.refcount;
4822                     *entp = ent->next;
4823                     break;
4824                   }
4825               if (dent == NULL)
4826                 entp = &ent->next;
4827             }
4828           *entp = to->elf.plt.plist;
4829         }
4830
4831       to->elf.plt.plist = from->elf.plt.plist;
4832       from->elf.plt.plist = NULL;
4833     }
4834 }
4835
4836 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4837
4838 static void
4839 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4840                                 struct elf_link_hash_entry *dir,
4841                                 struct elf_link_hash_entry *ind)
4842 {
4843   struct ppc_link_hash_entry *edir, *eind;
4844
4845   edir = (struct ppc_link_hash_entry *) dir;
4846   eind = (struct ppc_link_hash_entry *) ind;
4847
4848   edir->is_func |= eind->is_func;
4849   edir->is_func_descriptor |= eind->is_func_descriptor;
4850   edir->tls_mask |= eind->tls_mask;
4851   if (eind->oh != NULL)
4852     edir->oh = ppc_follow_link (eind->oh);
4853
4854   if (edir->elf.versioned != versioned_hidden)
4855     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4856   edir->elf.ref_regular |= eind->elf.ref_regular;
4857   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4858   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4859   edir->elf.needs_plt |= eind->elf.needs_plt;
4860   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4861
4862   /* If we were called to copy over info for a weak sym, don't copy
4863      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4864      in order to simplify readonly_dynrelocs and save a field in the
4865      symbol hash entry, but that means dyn_relocs can't be used in any
4866      tests about a specific symbol, or affect other symbol flags which
4867      are then tested.  */
4868   if (eind->elf.root.type != bfd_link_hash_indirect)
4869     return;
4870
4871   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4872   if (eind->dyn_relocs != NULL)
4873     {
4874       if (edir->dyn_relocs != NULL)
4875         {
4876           struct elf_dyn_relocs **pp;
4877           struct elf_dyn_relocs *p;
4878
4879           /* Add reloc counts against the indirect sym to the direct sym
4880              list.  Merge any entries against the same section.  */
4881           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4882             {
4883               struct elf_dyn_relocs *q;
4884
4885               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4886                 if (q->sec == p->sec)
4887                   {
4888                     q->pc_count += p->pc_count;
4889                     q->count += p->count;
4890                     *pp = p->next;
4891                     break;
4892                   }
4893               if (q == NULL)
4894                 pp = &p->next;
4895             }
4896           *pp = edir->dyn_relocs;
4897         }
4898
4899       edir->dyn_relocs = eind->dyn_relocs;
4900       eind->dyn_relocs = NULL;
4901     }
4902
4903   /* Copy over got entries that we may have already seen to the
4904      symbol which just became indirect.  */
4905   if (eind->elf.got.glist != NULL)
4906     {
4907       if (edir->elf.got.glist != NULL)
4908         {
4909           struct got_entry **entp;
4910           struct got_entry *ent;
4911
4912           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4913             {
4914               struct got_entry *dent;
4915
4916               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4917                 if (dent->addend == ent->addend
4918                     && dent->owner == ent->owner
4919                     && dent->tls_type == ent->tls_type)
4920                   {
4921                     dent->got.refcount += ent->got.refcount;
4922                     *entp = ent->next;
4923                     break;
4924                   }
4925               if (dent == NULL)
4926                 entp = &ent->next;
4927             }
4928           *entp = edir->elf.got.glist;
4929         }
4930
4931       edir->elf.got.glist = eind->elf.got.glist;
4932       eind->elf.got.glist = NULL;
4933     }
4934
4935   /* And plt entries.  */
4936   move_plt_plist (eind, edir);
4937
4938   if (eind->elf.dynindx != -1)
4939     {
4940       if (edir->elf.dynindx != -1)
4941         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4942                                 edir->elf.dynstr_index);
4943       edir->elf.dynindx = eind->elf.dynindx;
4944       edir->elf.dynstr_index = eind->elf.dynstr_index;
4945       eind->elf.dynindx = -1;
4946       eind->elf.dynstr_index = 0;
4947     }
4948 }
4949
4950 /* Find the function descriptor hash entry from the given function code
4951    hash entry FH.  Link the entries via their OH fields.  */
4952
4953 static struct ppc_link_hash_entry *
4954 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4955 {
4956   struct ppc_link_hash_entry *fdh = fh->oh;
4957
4958   if (fdh == NULL)
4959     {
4960       const char *fd_name = fh->elf.root.root.string + 1;
4961
4962       fdh = (struct ppc_link_hash_entry *)
4963         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4964       if (fdh == NULL)
4965         return fdh;
4966
4967       fdh->is_func_descriptor = 1;
4968       fdh->oh = fh;
4969       fh->is_func = 1;
4970       fh->oh = fdh;
4971     }
4972
4973   fdh = ppc_follow_link (fdh);
4974   fdh->is_func_descriptor = 1;
4975   fdh->oh = fh;
4976   return fdh;
4977 }
4978
4979 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4980
4981 static struct ppc_link_hash_entry *
4982 make_fdh (struct bfd_link_info *info,
4983           struct ppc_link_hash_entry *fh)
4984 {
4985   bfd *abfd = fh->elf.root.u.undef.abfd;
4986   struct bfd_link_hash_entry *bh = NULL;
4987   struct ppc_link_hash_entry *fdh;
4988   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4989                     ? BSF_WEAK
4990                     : BSF_GLOBAL);
4991
4992   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4993                                          fh->elf.root.root.string + 1,
4994                                          flags, bfd_und_section_ptr, 0,
4995                                          NULL, FALSE, FALSE, &bh))
4996     return NULL;
4997
4998   fdh = (struct ppc_link_hash_entry *) bh;
4999   fdh->elf.non_elf = 0;
5000   fdh->fake = 1;
5001   fdh->is_func_descriptor = 1;
5002   fdh->oh = fh;
5003   fh->is_func = 1;
5004   fh->oh = fdh;
5005   return fdh;
5006 }
5007
5008 /* Fix function descriptor symbols defined in .opd sections to be
5009    function type.  */
5010
5011 static bfd_boolean
5012 ppc64_elf_add_symbol_hook (bfd *ibfd,
5013                            struct bfd_link_info *info,
5014                            Elf_Internal_Sym *isym,
5015                            const char **name,
5016                            flagword *flags ATTRIBUTE_UNUSED,
5017                            asection **sec,
5018                            bfd_vma *value)
5019 {
5020   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5021       && (ibfd->flags & DYNAMIC) == 0
5022       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5023     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
5024
5025   if (*sec != NULL
5026       && strcmp ((*sec)->name, ".opd") == 0)
5027     {
5028       asection *code_sec;
5029
5030       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5031             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5032         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5033
5034       /* If the symbol is a function defined in .opd, and the function
5035          code is in a discarded group, let it appear to be undefined.  */
5036       if (!bfd_link_relocatable (info)
5037           && (*sec)->reloc_count != 0
5038           && opd_entry_value (*sec, *value, &code_sec, NULL,
5039                               FALSE) != (bfd_vma) -1
5040           && discarded_section (code_sec))
5041         {
5042           *sec = bfd_und_section_ptr;
5043           isym->st_shndx = SHN_UNDEF;
5044         }
5045     }
5046   else if (*sec != NULL
5047            && strcmp ((*sec)->name, ".toc") == 0
5048            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5049     {
5050       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5051       if (htab != NULL)
5052         htab->params->object_in_toc = 1;
5053     }
5054
5055   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5056     {
5057       if (abiversion (ibfd) == 0)
5058         set_abiversion (ibfd, 2);
5059       else if (abiversion (ibfd) == 1)
5060         {
5061           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5062                                 " for ABI version 1"), *name);
5063           bfd_set_error (bfd_error_bad_value);
5064           return FALSE;
5065         }
5066     }
5067
5068   return TRUE;
5069 }
5070
5071 /* Merge non-visibility st_other attributes: local entry point.  */
5072
5073 static void
5074 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5075                                   const Elf_Internal_Sym *isym,
5076                                   bfd_boolean definition,
5077                                   bfd_boolean dynamic)
5078 {
5079   if (definition && (!dynamic || !h->def_regular))
5080     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5081                 | ELF_ST_VISIBILITY (h->other));
5082 }
5083
5084 /* Hook called on merging a symbol.  We use this to clear "fake" since
5085    we now have a real symbol.  */
5086
5087 static bfd_boolean
5088 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5089                         const Elf_Internal_Sym *isym,
5090                         asection **psec ATTRIBUTE_UNUSED,
5091                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5092                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5093                         bfd *oldbfd ATTRIBUTE_UNUSED,
5094                         const asection *oldsec ATTRIBUTE_UNUSED)
5095 {
5096   ((struct ppc_link_hash_entry *) h)->fake = 0;
5097   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5098     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5099   return TRUE;
5100 }
5101
5102 /* This function makes an old ABI object reference to ".bar" cause the
5103    inclusion of a new ABI object archive that defines "bar".
5104    NAME is a symbol defined in an archive.  Return a symbol in the hash
5105    table that might be satisfied by the archive symbols.  */
5106
5107 static struct elf_link_hash_entry *
5108 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5109                                  struct bfd_link_info *info,
5110                                  const char *name)
5111 {
5112   struct elf_link_hash_entry *h;
5113   char *dot_name;
5114   size_t len;
5115
5116   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5117   if (h != NULL
5118       /* Don't return this sym if it is a fake function descriptor
5119          created by add_symbol_adjust.  */
5120       && !((struct ppc_link_hash_entry *) h)->fake)
5121     return h;
5122
5123   if (name[0] == '.')
5124     return h;
5125
5126   len = strlen (name);
5127   dot_name = bfd_alloc (abfd, len + 2);
5128   if (dot_name == NULL)
5129     return (struct elf_link_hash_entry *) -1;
5130   dot_name[0] = '.';
5131   memcpy (dot_name + 1, name, len + 1);
5132   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5133   bfd_release (abfd, dot_name);
5134   return h;
5135 }
5136
5137 /* This function satisfies all old ABI object references to ".bar" if a
5138    new ABI object defines "bar".  Well, at least, undefined dot symbols
5139    are made weak.  This stops later archive searches from including an
5140    object if we already have a function descriptor definition.  It also
5141    prevents the linker complaining about undefined symbols.
5142    We also check and correct mismatched symbol visibility here.  The
5143    most restrictive visibility of the function descriptor and the
5144    function entry symbol is used.  */
5145
5146 static bfd_boolean
5147 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5148 {
5149   struct ppc_link_hash_table *htab;
5150   struct ppc_link_hash_entry *fdh;
5151
5152   if (eh->elf.root.type == bfd_link_hash_warning)
5153     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5154
5155   if (eh->elf.root.type == bfd_link_hash_indirect)
5156     return TRUE;
5157
5158   if (eh->elf.root.root.string[0] != '.')
5159     abort ();
5160
5161   htab = ppc_hash_table (info);
5162   if (htab == NULL)
5163     return FALSE;
5164
5165   fdh = lookup_fdh (eh, htab);
5166   if (fdh == NULL
5167       && !bfd_link_relocatable (info)
5168       && (eh->elf.root.type == bfd_link_hash_undefined
5169           || eh->elf.root.type == bfd_link_hash_undefweak)
5170       && eh->elf.ref_regular)
5171     {
5172       /* Make an undefined function descriptor sym, in order to
5173          pull in an --as-needed shared lib.  Archives are handled
5174          elsewhere.  */
5175       fdh = make_fdh (info, eh);
5176       if (fdh == NULL)
5177         return FALSE;
5178     }
5179
5180   if (fdh != NULL)
5181     {
5182       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5183       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5184
5185       /* Make both descriptor and entry symbol have the most
5186          constraining visibility of either symbol.  */
5187       if (entry_vis < descr_vis)
5188         fdh->elf.other += entry_vis - descr_vis;
5189       else if (entry_vis > descr_vis)
5190         eh->elf.other += descr_vis - entry_vis;
5191
5192       /* Propagate reference flags from entry symbol to function
5193          descriptor symbol.  */
5194       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5195       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5196       fdh->elf.ref_regular |= eh->elf.ref_regular;
5197       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5198
5199       if (!fdh->elf.forced_local
5200           && fdh->elf.dynindx == -1
5201           && fdh->elf.versioned != versioned_hidden
5202           && (bfd_link_dll (info)
5203               || fdh->elf.def_dynamic
5204               || fdh->elf.ref_dynamic)
5205           && (eh->elf.ref_regular
5206               || eh->elf.def_regular))
5207         {
5208           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5209             return FALSE;
5210         }
5211     }
5212
5213   return TRUE;
5214 }
5215
5216 /* Set up opd section info and abiversion for IBFD, and process list
5217    of dot-symbols we made in link_hash_newfunc.  */
5218
5219 static bfd_boolean
5220 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5221 {
5222   struct ppc_link_hash_table *htab;
5223   struct ppc_link_hash_entry **p, *eh;
5224   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5225
5226   if (opd != NULL && opd->size != 0)
5227     {
5228       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5229       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5230
5231       if (abiversion (ibfd) == 0)
5232         set_abiversion (ibfd, 1);
5233       else if (abiversion (ibfd) >= 2)
5234         {
5235           /* xgettext:c-format */
5236           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5237                               ibfd, abiversion (ibfd));
5238           bfd_set_error (bfd_error_bad_value);
5239           return FALSE;
5240         }
5241     }
5242
5243   if (is_ppc64_elf (info->output_bfd))
5244     {
5245       /* For input files without an explicit abiversion in e_flags
5246          we should have flagged any with symbol st_other bits set
5247          as ELFv1 and above flagged those with .opd as ELFv2.
5248          Set the output abiversion if not yet set, and for any input
5249          still ambiguous, take its abiversion from the output.
5250          Differences in ABI are reported later.  */
5251       if (abiversion (info->output_bfd) == 0)
5252         set_abiversion (info->output_bfd, abiversion (ibfd));
5253       else if (abiversion (ibfd) == 0)
5254         set_abiversion (ibfd, abiversion (info->output_bfd));
5255     }
5256
5257   htab = ppc_hash_table (info);
5258   if (htab == NULL)
5259     return TRUE;
5260
5261   if (opd != NULL && opd->size != 0
5262       && (ibfd->flags & DYNAMIC) == 0
5263       && (opd->flags & SEC_RELOC) != 0
5264       && opd->reloc_count != 0
5265       && !bfd_is_abs_section (opd->output_section)
5266       && info->gc_sections)
5267     {
5268       /* Garbage collection needs some extra help with .opd sections.
5269          We don't want to necessarily keep everything referenced by
5270          relocs in .opd, as that would keep all functions.  Instead,
5271          if we reference an .opd symbol (a function descriptor), we
5272          want to keep the function code symbol's section.  This is
5273          easy for global symbols, but for local syms we need to keep
5274          information about the associated function section.  */
5275       bfd_size_type amt;
5276       asection **opd_sym_map;
5277       Elf_Internal_Shdr *symtab_hdr;
5278       Elf_Internal_Rela *relocs, *rel_end, *rel;
5279
5280       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5281       opd_sym_map = bfd_zalloc (ibfd, amt);
5282       if (opd_sym_map == NULL)
5283         return FALSE;
5284       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5285       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5286                                           info->keep_memory);
5287       if (relocs == NULL)
5288         return FALSE;
5289       symtab_hdr = &elf_symtab_hdr (ibfd);
5290       rel_end = relocs + opd->reloc_count - 1;
5291       for (rel = relocs; rel < rel_end; rel++)
5292         {
5293           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5294           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5295
5296           if (r_type == R_PPC64_ADDR64
5297               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5298               && r_symndx < symtab_hdr->sh_info)
5299             {
5300               Elf_Internal_Sym *isym;
5301               asection *s;
5302
5303               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5304               if (isym == NULL)
5305                 {
5306                   if (elf_section_data (opd)->relocs != relocs)
5307                     free (relocs);
5308                   return FALSE;
5309                 }
5310
5311               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5312               if (s != NULL && s != opd)
5313                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5314             }
5315         }
5316       if (elf_section_data (opd)->relocs != relocs)
5317         free (relocs);
5318     }
5319
5320   p = &htab->dot_syms;
5321   while ((eh = *p) != NULL)
5322     {
5323       *p = NULL;
5324       if (&eh->elf == htab->elf.hgot)
5325         ;
5326       else if (htab->elf.hgot == NULL
5327                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5328         htab->elf.hgot = &eh->elf;
5329       else if (abiversion (ibfd) <= 1)
5330         {
5331           htab->need_func_desc_adj = 1;
5332           if (!add_symbol_adjust (eh, info))
5333             return FALSE;
5334         }
5335       p = &eh->u.next_dot_sym;
5336     }
5337   return TRUE;
5338 }
5339
5340 /* Undo hash table changes when an --as-needed input file is determined
5341    not to be needed.  */
5342
5343 static bfd_boolean
5344 ppc64_elf_notice_as_needed (bfd *ibfd,
5345                             struct bfd_link_info *info,
5346                             enum notice_asneeded_action act)
5347 {
5348   if (act == notice_not_needed)
5349     {
5350       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5351
5352       if (htab == NULL)
5353         return FALSE;
5354
5355       htab->dot_syms = NULL;
5356     }
5357   return _bfd_elf_notice_as_needed (ibfd, info, act);
5358 }
5359
5360 /* If --just-symbols against a final linked binary, then assume we need
5361    toc adjusting stubs when calling functions defined there.  */
5362
5363 static void
5364 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5365 {
5366   if ((sec->flags & SEC_CODE) != 0
5367       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5368       && is_ppc64_elf (sec->owner))
5369     {
5370       if (abiversion (sec->owner) >= 2
5371           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5372         sec->has_toc_reloc = 1;
5373     }
5374   _bfd_elf_link_just_syms (sec, info);
5375 }
5376
5377 static struct plt_entry **
5378 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5379                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5380 {
5381   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5382   struct plt_entry **local_plt;
5383   unsigned char *local_got_tls_masks;
5384
5385   if (local_got_ents == NULL)
5386     {
5387       bfd_size_type size = symtab_hdr->sh_info;
5388
5389       size *= (sizeof (*local_got_ents)
5390                + sizeof (*local_plt)
5391                + sizeof (*local_got_tls_masks));
5392       local_got_ents = bfd_zalloc (abfd, size);
5393       if (local_got_ents == NULL)
5394         return NULL;
5395       elf_local_got_ents (abfd) = local_got_ents;
5396     }
5397
5398   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5399     {
5400       struct got_entry *ent;
5401
5402       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5403         if (ent->addend == r_addend
5404             && ent->owner == abfd
5405             && ent->tls_type == tls_type)
5406           break;
5407       if (ent == NULL)
5408         {
5409           bfd_size_type amt = sizeof (*ent);
5410           ent = bfd_alloc (abfd, amt);
5411           if (ent == NULL)
5412             return FALSE;
5413           ent->next = local_got_ents[r_symndx];
5414           ent->addend = r_addend;
5415           ent->owner = abfd;
5416           ent->tls_type = tls_type;
5417           ent->is_indirect = FALSE;
5418           ent->got.refcount = 0;
5419           local_got_ents[r_symndx] = ent;
5420         }
5421       ent->got.refcount += 1;
5422     }
5423
5424   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5425   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5426   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5427
5428   return local_plt + r_symndx;
5429 }
5430
5431 static bfd_boolean
5432 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5433 {
5434   struct plt_entry *ent;
5435
5436   for (ent = *plist; ent != NULL; ent = ent->next)
5437     if (ent->addend == addend)
5438       break;
5439   if (ent == NULL)
5440     {
5441       bfd_size_type amt = sizeof (*ent);
5442       ent = bfd_alloc (abfd, amt);
5443       if (ent == NULL)
5444         return FALSE;
5445       ent->next = *plist;
5446       ent->addend = addend;
5447       ent->plt.refcount = 0;
5448       *plist = ent;
5449     }
5450   ent->plt.refcount += 1;
5451   return TRUE;
5452 }
5453
5454 static bfd_boolean
5455 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5456 {
5457   return (r_type == R_PPC64_REL24
5458           || r_type == R_PPC64_REL14
5459           || r_type == R_PPC64_REL14_BRTAKEN
5460           || r_type == R_PPC64_REL14_BRNTAKEN
5461           || r_type == R_PPC64_ADDR24
5462           || r_type == R_PPC64_ADDR14
5463           || r_type == R_PPC64_ADDR14_BRTAKEN
5464           || r_type == R_PPC64_ADDR14_BRNTAKEN
5465           || r_type == R_PPC64_PLTCALL);
5466 }
5467
5468 /* Relocs on inline plt call sequence insns prior to the call.  */
5469
5470 static bfd_boolean
5471 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5472 {
5473   return (r_type == R_PPC64_PLT16_HA
5474           || r_type == R_PPC64_PLT16_HI
5475           || r_type == R_PPC64_PLT16_LO
5476           || r_type == R_PPC64_PLT16_LO_DS
5477           || r_type == R_PPC64_PLTSEQ);
5478 }
5479
5480 /* Look through the relocs for a section during the first phase, and
5481    calculate needed space in the global offset table, procedure
5482    linkage table, and dynamic reloc sections.  */
5483
5484 static bfd_boolean
5485 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5486                         asection *sec, const Elf_Internal_Rela *relocs)
5487 {
5488   struct ppc_link_hash_table *htab;
5489   Elf_Internal_Shdr *symtab_hdr;
5490   struct elf_link_hash_entry **sym_hashes;
5491   const Elf_Internal_Rela *rel;
5492   const Elf_Internal_Rela *rel_end;
5493   asection *sreloc;
5494   struct elf_link_hash_entry *tga, *dottga;
5495   bfd_boolean is_opd;
5496
5497   if (bfd_link_relocatable (info))
5498     return TRUE;
5499
5500   /* Don't do anything special with non-loaded, non-alloced sections.
5501      In particular, any relocs in such sections should not affect GOT
5502      and PLT reference counting (ie. we don't allow them to create GOT
5503      or PLT entries), there's no possibility or desire to optimize TLS
5504      relocs, and there's not much point in propagating relocs to shared
5505      libs that the dynamic linker won't relocate.  */
5506   if ((sec->flags & SEC_ALLOC) == 0)
5507     return TRUE;
5508
5509   BFD_ASSERT (is_ppc64_elf (abfd));
5510
5511   htab = ppc_hash_table (info);
5512   if (htab == NULL)
5513     return FALSE;
5514
5515   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5516                               FALSE, FALSE, TRUE);
5517   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5518                                  FALSE, FALSE, TRUE);
5519   symtab_hdr = &elf_symtab_hdr (abfd);
5520   sym_hashes = elf_sym_hashes (abfd);
5521   sreloc = NULL;
5522   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5523   rel_end = relocs + sec->reloc_count;
5524   for (rel = relocs; rel < rel_end; rel++)
5525     {
5526       unsigned long r_symndx;
5527       struct elf_link_hash_entry *h;
5528       enum elf_ppc64_reloc_type r_type;
5529       int tls_type;
5530       struct _ppc64_elf_section_data *ppc64_sec;
5531       struct plt_entry **ifunc, **plt_list;
5532
5533       r_symndx = ELF64_R_SYM (rel->r_info);
5534       if (r_symndx < symtab_hdr->sh_info)
5535         h = NULL;
5536       else
5537         {
5538           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5539           h = elf_follow_link (h);
5540
5541           if (h == htab->elf.hgot)
5542             sec->has_toc_reloc = 1;
5543         }
5544
5545       tls_type = 0;
5546       ifunc = NULL;
5547       if (h != NULL)
5548         {
5549           if (h->type == STT_GNU_IFUNC)
5550             {
5551               h->needs_plt = 1;
5552               ifunc = &h->plt.plist;
5553             }
5554         }
5555       else
5556         {
5557           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5558                                                           abfd, r_symndx);
5559           if (isym == NULL)
5560             return FALSE;
5561
5562           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5563             {
5564               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5565                                              rel->r_addend,
5566                                              NON_GOT | PLT_IFUNC);
5567               if (ifunc == NULL)
5568                 return FALSE;
5569             }
5570         }
5571
5572       r_type = ELF64_R_TYPE (rel->r_info);
5573       switch (r_type)
5574         {
5575         case R_PPC64_TLSGD:
5576         case R_PPC64_TLSLD:
5577           /* These special tls relocs tie a call to __tls_get_addr with
5578              its parameter symbol.  */
5579           if (h != NULL)
5580             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5581           else
5582             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5583                                         rel->r_addend,
5584                                         NON_GOT | TLS_TLS | TLS_MARK))
5585               return FALSE;
5586           sec->has_tls_reloc = 1;
5587           break;
5588
5589         case R_PPC64_GOT_TLSLD16:
5590         case R_PPC64_GOT_TLSLD16_LO:
5591         case R_PPC64_GOT_TLSLD16_HI:
5592         case R_PPC64_GOT_TLSLD16_HA:
5593           tls_type = TLS_TLS | TLS_LD;
5594           goto dogottls;
5595
5596         case R_PPC64_GOT_TLSGD16:
5597         case R_PPC64_GOT_TLSGD16_LO:
5598         case R_PPC64_GOT_TLSGD16_HI:
5599         case R_PPC64_GOT_TLSGD16_HA:
5600           tls_type = TLS_TLS | TLS_GD;
5601           goto dogottls;
5602
5603         case R_PPC64_GOT_TPREL16_DS:
5604         case R_PPC64_GOT_TPREL16_LO_DS:
5605         case R_PPC64_GOT_TPREL16_HI:
5606         case R_PPC64_GOT_TPREL16_HA:
5607           if (bfd_link_dll (info))
5608             info->flags |= DF_STATIC_TLS;
5609           tls_type = TLS_TLS | TLS_TPREL;
5610           goto dogottls;
5611
5612         case R_PPC64_GOT_DTPREL16_DS:
5613         case R_PPC64_GOT_DTPREL16_LO_DS:
5614         case R_PPC64_GOT_DTPREL16_HI:
5615         case R_PPC64_GOT_DTPREL16_HA:
5616           tls_type = TLS_TLS | TLS_DTPREL;
5617         dogottls:
5618           sec->has_tls_reloc = 1;
5619           /* Fall through */
5620
5621         case R_PPC64_GOT16:
5622         case R_PPC64_GOT16_DS:
5623         case R_PPC64_GOT16_HA:
5624         case R_PPC64_GOT16_HI:
5625         case R_PPC64_GOT16_LO:
5626         case R_PPC64_GOT16_LO_DS:
5627           /* This symbol requires a global offset table entry.  */
5628           sec->has_toc_reloc = 1;
5629           if (r_type == R_PPC64_GOT_TLSLD16
5630               || r_type == R_PPC64_GOT_TLSGD16
5631               || r_type == R_PPC64_GOT_TPREL16_DS
5632               || r_type == R_PPC64_GOT_DTPREL16_DS
5633               || r_type == R_PPC64_GOT16
5634               || r_type == R_PPC64_GOT16_DS)
5635             {
5636               htab->do_multi_toc = 1;
5637               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5638             }
5639
5640           if (ppc64_elf_tdata (abfd)->got == NULL
5641               && !create_got_section (abfd, info))
5642             return FALSE;
5643
5644           if (h != NULL)
5645             {
5646               struct ppc_link_hash_entry *eh;
5647               struct got_entry *ent;
5648
5649               eh = (struct ppc_link_hash_entry *) h;
5650               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5651                 if (ent->addend == rel->r_addend
5652                     && ent->owner == abfd
5653                     && ent->tls_type == tls_type)
5654                   break;
5655               if (ent == NULL)
5656                 {
5657                   bfd_size_type amt = sizeof (*ent);
5658                   ent = bfd_alloc (abfd, amt);
5659                   if (ent == NULL)
5660                     return FALSE;
5661                   ent->next = eh->elf.got.glist;
5662                   ent->addend = rel->r_addend;
5663                   ent->owner = abfd;
5664                   ent->tls_type = tls_type;
5665                   ent->is_indirect = FALSE;
5666                   ent->got.refcount = 0;
5667                   eh->elf.got.glist = ent;
5668                 }
5669               ent->got.refcount += 1;
5670               eh->tls_mask |= tls_type;
5671             }
5672           else
5673             /* This is a global offset table entry for a local symbol.  */
5674             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5675                                         rel->r_addend, tls_type))
5676               return FALSE;
5677
5678           /* We may also need a plt entry if the symbol turns out to be
5679              an ifunc.  */
5680           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5681             {
5682               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5683                 return FALSE;
5684             }
5685           break;
5686
5687         case R_PPC64_PLT16_HA:
5688         case R_PPC64_PLT16_HI:
5689         case R_PPC64_PLT16_LO:
5690         case R_PPC64_PLT16_LO_DS:
5691         case R_PPC64_PLT32:
5692         case R_PPC64_PLT64:
5693           /* This symbol requires a procedure linkage table entry.  */
5694           plt_list = ifunc;
5695           if (h != NULL)
5696             {
5697               h->needs_plt = 1;
5698               if (h->root.root.string[0] == '.'
5699                   && h->root.root.string[1] != '\0')
5700                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5701               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5702               plt_list = &h->plt.plist;
5703             }
5704           if (plt_list == NULL)
5705             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5706                                               rel->r_addend,
5707                                               NON_GOT | PLT_KEEP);
5708           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5709             return FALSE;
5710           break;
5711
5712           /* The following relocations don't need to propagate the
5713              relocation if linking a shared object since they are
5714              section relative.  */
5715         case R_PPC64_SECTOFF:
5716         case R_PPC64_SECTOFF_LO:
5717         case R_PPC64_SECTOFF_HI:
5718         case R_PPC64_SECTOFF_HA:
5719         case R_PPC64_SECTOFF_DS:
5720         case R_PPC64_SECTOFF_LO_DS:
5721         case R_PPC64_DTPREL16:
5722         case R_PPC64_DTPREL16_LO:
5723         case R_PPC64_DTPREL16_HI:
5724         case R_PPC64_DTPREL16_HA:
5725         case R_PPC64_DTPREL16_DS:
5726         case R_PPC64_DTPREL16_LO_DS:
5727         case R_PPC64_DTPREL16_HIGH:
5728         case R_PPC64_DTPREL16_HIGHA:
5729         case R_PPC64_DTPREL16_HIGHER:
5730         case R_PPC64_DTPREL16_HIGHERA:
5731         case R_PPC64_DTPREL16_HIGHEST:
5732         case R_PPC64_DTPREL16_HIGHESTA:
5733           break;
5734
5735           /* Nor do these.  */
5736         case R_PPC64_REL16:
5737         case R_PPC64_REL16_LO:
5738         case R_PPC64_REL16_HI:
5739         case R_PPC64_REL16_HA:
5740         case R_PPC64_REL16DX_HA:
5741           break;
5742
5743           /* Not supported as a dynamic relocation.  */
5744         case R_PPC64_ADDR64_LOCAL:
5745           if (bfd_link_pic (info))
5746             {
5747               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5748                 ppc_howto_init ();
5749               /* xgettext:c-format */
5750               info->callbacks->einfo (_("%H: %s reloc unsupported "
5751                                         "in shared libraries and PIEs\n"),
5752                                       abfd, sec, rel->r_offset,
5753                                       ppc64_elf_howto_table[r_type]->name);
5754               bfd_set_error (bfd_error_bad_value);
5755               return FALSE;
5756             }
5757           break;
5758
5759         case R_PPC64_TOC16:
5760         case R_PPC64_TOC16_DS:
5761           htab->do_multi_toc = 1;
5762           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5763           /* Fall through.  */
5764         case R_PPC64_TOC16_LO:
5765         case R_PPC64_TOC16_HI:
5766         case R_PPC64_TOC16_HA:
5767         case R_PPC64_TOC16_LO_DS:
5768           sec->has_toc_reloc = 1;
5769           break;
5770
5771           /* Marker reloc.  */
5772         case R_PPC64_ENTRY:
5773           break;
5774
5775           /* This relocation describes the C++ object vtable hierarchy.
5776              Reconstruct it for later use during GC.  */
5777         case R_PPC64_GNU_VTINHERIT:
5778           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5779             return FALSE;
5780           break;
5781
5782           /* This relocation describes which C++ vtable entries are actually
5783              used.  Record for later use during GC.  */
5784         case R_PPC64_GNU_VTENTRY:
5785           BFD_ASSERT (h != NULL);
5786           if (h != NULL
5787               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5788             return FALSE;
5789           break;
5790
5791         case R_PPC64_REL14:
5792         case R_PPC64_REL14_BRTAKEN:
5793         case R_PPC64_REL14_BRNTAKEN:
5794           {
5795             asection *dest = NULL;
5796
5797             /* Heuristic: If jumping outside our section, chances are
5798                we are going to need a stub.  */
5799             if (h != NULL)
5800               {
5801                 /* If the sym is weak it may be overridden later, so
5802                    don't assume we know where a weak sym lives.  */
5803                 if (h->root.type == bfd_link_hash_defined)
5804                   dest = h->root.u.def.section;
5805               }
5806             else
5807               {
5808                 Elf_Internal_Sym *isym;
5809
5810                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5811                                               abfd, r_symndx);
5812                 if (isym == NULL)
5813                   return FALSE;
5814
5815                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5816               }
5817
5818             if (dest != sec)
5819               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5820           }
5821           /* Fall through.  */
5822
5823         case R_PPC64_REL24:
5824         case R_PPC64_PLTCALL:
5825           plt_list = ifunc;
5826           if (h != NULL)
5827             {
5828               h->needs_plt = 1;
5829               if (h->root.root.string[0] == '.'
5830                   && h->root.root.string[1] != '\0')
5831                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5832
5833               if (h == tga || h == dottga)
5834                 {
5835                   sec->has_tls_reloc = 1;
5836                   if (rel != relocs
5837                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5838                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5839                     /* We have a new-style __tls_get_addr call with
5840                        a marker reloc.  */
5841                     ;
5842                   else
5843                     /* Mark this section as having an old-style call.  */
5844                     sec->has_tls_get_addr_call = 1;
5845                 }
5846               plt_list = &h->plt.plist;
5847             }
5848
5849           /* We may need a .plt entry if the function this reloc
5850              refers to is in a shared lib.  */
5851           if (plt_list
5852               && !update_plt_info (abfd, plt_list, rel->r_addend))
5853             return FALSE;
5854           break;
5855
5856         case R_PPC64_ADDR14:
5857         case R_PPC64_ADDR14_BRNTAKEN:
5858         case R_PPC64_ADDR14_BRTAKEN:
5859         case R_PPC64_ADDR24:
5860           goto dodyn;
5861
5862         case R_PPC64_TPREL64:
5863           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5864           if (bfd_link_dll (info))
5865             info->flags |= DF_STATIC_TLS;
5866           goto dotlstoc;
5867
5868         case R_PPC64_DTPMOD64:
5869           if (rel + 1 < rel_end
5870               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5871               && rel[1].r_offset == rel->r_offset + 8)
5872             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5873           else
5874             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5875           goto dotlstoc;
5876
5877         case R_PPC64_DTPREL64:
5878           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5879           if (rel != relocs
5880               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5881               && rel[-1].r_offset == rel->r_offset - 8)
5882             /* This is the second reloc of a dtpmod, dtprel pair.
5883                Don't mark with TLS_DTPREL.  */
5884             goto dodyn;
5885
5886         dotlstoc:
5887           sec->has_tls_reloc = 1;
5888           if (h != NULL)
5889             {
5890               struct ppc_link_hash_entry *eh;
5891               eh = (struct ppc_link_hash_entry *) h;
5892               eh->tls_mask |= tls_type;
5893             }
5894           else
5895             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5896                                         rel->r_addend, tls_type))
5897               return FALSE;
5898
5899           ppc64_sec = ppc64_elf_section_data (sec);
5900           if (ppc64_sec->sec_type != sec_toc)
5901             {
5902               bfd_size_type amt;
5903
5904               /* One extra to simplify get_tls_mask.  */
5905               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5906               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5907               if (ppc64_sec->u.toc.symndx == NULL)
5908                 return FALSE;
5909               amt = sec->size * sizeof (bfd_vma) / 8;
5910               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5911               if (ppc64_sec->u.toc.add == NULL)
5912                 return FALSE;
5913               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5914               ppc64_sec->sec_type = sec_toc;
5915             }
5916           BFD_ASSERT (rel->r_offset % 8 == 0);
5917           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5918           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5919
5920           /* Mark the second slot of a GD or LD entry.
5921              -1 to indicate GD and -2 to indicate LD.  */
5922           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5923             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5924           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5925             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5926           goto dodyn;
5927
5928         case R_PPC64_TPREL16:
5929         case R_PPC64_TPREL16_LO:
5930         case R_PPC64_TPREL16_HI:
5931         case R_PPC64_TPREL16_HA:
5932         case R_PPC64_TPREL16_DS:
5933         case R_PPC64_TPREL16_LO_DS:
5934         case R_PPC64_TPREL16_HIGH:
5935         case R_PPC64_TPREL16_HIGHA:
5936         case R_PPC64_TPREL16_HIGHER:
5937         case R_PPC64_TPREL16_HIGHERA:
5938         case R_PPC64_TPREL16_HIGHEST:
5939         case R_PPC64_TPREL16_HIGHESTA:
5940           if (bfd_link_dll (info))
5941             info->flags |= DF_STATIC_TLS;
5942           goto dodyn;
5943
5944         case R_PPC64_ADDR64:
5945           if (is_opd
5946               && rel + 1 < rel_end
5947               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5948             {
5949               if (h != NULL)
5950                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5951             }
5952           /* Fall through.  */
5953
5954         case R_PPC64_ADDR16:
5955         case R_PPC64_ADDR16_DS:
5956         case R_PPC64_ADDR16_HA:
5957         case R_PPC64_ADDR16_HI:
5958         case R_PPC64_ADDR16_HIGH:
5959         case R_PPC64_ADDR16_HIGHA:
5960         case R_PPC64_ADDR16_HIGHER:
5961         case R_PPC64_ADDR16_HIGHERA:
5962         case R_PPC64_ADDR16_HIGHEST:
5963         case R_PPC64_ADDR16_HIGHESTA:
5964         case R_PPC64_ADDR16_LO:
5965         case R_PPC64_ADDR16_LO_DS:
5966           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5967               && rel->r_addend == 0)
5968             {
5969               /* We may need a .plt entry if this reloc refers to a
5970                  function in a shared lib.  */
5971               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5972                 return FALSE;
5973               h->pointer_equality_needed = 1;
5974             }
5975           /* Fall through.  */
5976
5977         case R_PPC64_REL30:
5978         case R_PPC64_REL32:
5979         case R_PPC64_REL64:
5980         case R_PPC64_ADDR32:
5981         case R_PPC64_UADDR16:
5982         case R_PPC64_UADDR32:
5983         case R_PPC64_UADDR64:
5984         case R_PPC64_TOC:
5985           if (h != NULL && !bfd_link_pic (info))
5986             /* We may need a copy reloc.  */
5987             h->non_got_ref = 1;
5988
5989           /* Don't propagate .opd relocs.  */
5990           if (NO_OPD_RELOCS && is_opd)
5991             break;
5992
5993           /* If we are creating a shared library, and this is a reloc
5994              against a global symbol, or a non PC relative reloc
5995              against a local symbol, then we need to copy the reloc
5996              into the shared library.  However, if we are linking with
5997              -Bsymbolic, we do not need to copy a reloc against a
5998              global symbol which is defined in an object we are
5999              including in the link (i.e., DEF_REGULAR is set).  At
6000              this point we have not seen all the input files, so it is
6001              possible that DEF_REGULAR is not set now but will be set
6002              later (it is never cleared).  In case of a weak definition,
6003              DEF_REGULAR may be cleared later by a strong definition in
6004              a shared library.  We account for that possibility below by
6005              storing information in the dyn_relocs field of the hash
6006              table entry.  A similar situation occurs when creating
6007              shared libraries and symbol visibility changes render the
6008              symbol local.
6009
6010              If on the other hand, we are creating an executable, we
6011              may need to keep relocations for symbols satisfied by a
6012              dynamic library if we manage to avoid copy relocs for the
6013              symbol.  */
6014         dodyn:
6015           if ((bfd_link_pic (info)
6016                && (must_be_dyn_reloc (info, r_type)
6017                    || (h != NULL
6018                        && (!SYMBOLIC_BIND (info, h)
6019                            || h->root.type == bfd_link_hash_defweak
6020                            || !h->def_regular))))
6021               || (ELIMINATE_COPY_RELOCS
6022                   && !bfd_link_pic (info)
6023                   && h != NULL
6024                   && (h->root.type == bfd_link_hash_defweak
6025                       || !h->def_regular))
6026               || (!bfd_link_pic (info)
6027                   && ifunc != NULL))
6028             {
6029               /* We must copy these reloc types into the output file.
6030                  Create a reloc section in dynobj and make room for
6031                  this reloc.  */
6032               if (sreloc == NULL)
6033                 {
6034                   sreloc = _bfd_elf_make_dynamic_reloc_section
6035                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6036
6037                   if (sreloc == NULL)
6038                     return FALSE;
6039                 }
6040
6041               /* If this is a global symbol, we count the number of
6042                  relocations we need for this symbol.  */
6043               if (h != NULL)
6044                 {
6045                   struct elf_dyn_relocs *p;
6046                   struct elf_dyn_relocs **head;
6047
6048                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6049                   p = *head;
6050                   if (p == NULL || p->sec != sec)
6051                     {
6052                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6053                       if (p == NULL)
6054                         return FALSE;
6055                       p->next = *head;
6056                       *head = p;
6057                       p->sec = sec;
6058                       p->count = 0;
6059                       p->pc_count = 0;
6060                     }
6061                   p->count += 1;
6062                   if (!must_be_dyn_reloc (info, r_type))
6063                     p->pc_count += 1;
6064                 }
6065               else
6066                 {
6067                   /* Track dynamic relocs needed for local syms too.
6068                      We really need local syms available to do this
6069                      easily.  Oh well.  */
6070                   struct ppc_dyn_relocs *p;
6071                   struct ppc_dyn_relocs **head;
6072                   bfd_boolean is_ifunc;
6073                   asection *s;
6074                   void *vpp;
6075                   Elf_Internal_Sym *isym;
6076
6077                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6078                                                 abfd, r_symndx);
6079                   if (isym == NULL)
6080                     return FALSE;
6081
6082                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6083                   if (s == NULL)
6084                     s = sec;
6085
6086                   vpp = &elf_section_data (s)->local_dynrel;
6087                   head = (struct ppc_dyn_relocs **) vpp;
6088                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6089                   p = *head;
6090                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6091                     p = p->next;
6092                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6093                     {
6094                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6095                       if (p == NULL)
6096                         return FALSE;
6097                       p->next = *head;
6098                       *head = p;
6099                       p->sec = sec;
6100                       p->ifunc = is_ifunc;
6101                       p->count = 0;
6102                     }
6103                   p->count += 1;
6104                 }
6105             }
6106           break;
6107
6108         default:
6109           break;
6110         }
6111     }
6112
6113   return TRUE;
6114 }
6115
6116 /* Merge backend specific data from an object file to the output
6117    object file when linking.  */
6118
6119 static bfd_boolean
6120 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6121 {
6122   bfd *obfd = info->output_bfd;
6123   unsigned long iflags, oflags;
6124
6125   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6126     return TRUE;
6127
6128   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6129     return TRUE;
6130
6131   if (!_bfd_generic_verify_endian_match (ibfd, info))
6132     return FALSE;
6133
6134   iflags = elf_elfheader (ibfd)->e_flags;
6135   oflags = elf_elfheader (obfd)->e_flags;
6136
6137   if (iflags & ~EF_PPC64_ABI)
6138     {
6139       _bfd_error_handler
6140         /* xgettext:c-format */
6141         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6142       bfd_set_error (bfd_error_bad_value);
6143       return FALSE;
6144     }
6145   else if (iflags != oflags && iflags != 0)
6146     {
6147       _bfd_error_handler
6148         /* xgettext:c-format */
6149         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6150          ibfd, iflags, oflags);
6151       bfd_set_error (bfd_error_bad_value);
6152       return FALSE;
6153     }
6154
6155   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6156
6157   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6158   _bfd_elf_merge_object_attributes (ibfd, info);
6159
6160   return TRUE;
6161 }
6162
6163 static bfd_boolean
6164 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6165 {
6166   /* Print normal ELF private data.  */
6167   _bfd_elf_print_private_bfd_data (abfd, ptr);
6168
6169   if (elf_elfheader (abfd)->e_flags != 0)
6170     {
6171       FILE *file = ptr;
6172
6173       fprintf (file, _("private flags = 0x%lx:"),
6174                elf_elfheader (abfd)->e_flags);
6175
6176       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6177         fprintf (file, _(" [abiv%ld]"),
6178                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6179       fputc ('\n', file);
6180     }
6181
6182   return TRUE;
6183 }
6184
6185 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6186    of the code entry point, and its section, which must be in the same
6187    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6188
6189 static bfd_vma
6190 opd_entry_value (asection *opd_sec,
6191                  bfd_vma offset,
6192                  asection **code_sec,
6193                  bfd_vma *code_off,
6194                  bfd_boolean in_code_sec)
6195 {
6196   bfd *opd_bfd = opd_sec->owner;
6197   Elf_Internal_Rela *relocs;
6198   Elf_Internal_Rela *lo, *hi, *look;
6199   bfd_vma val;
6200
6201   /* No relocs implies we are linking a --just-symbols object, or looking
6202      at a final linked executable with addr2line or somesuch.  */
6203   if (opd_sec->reloc_count == 0)
6204     {
6205       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6206
6207       if (contents == NULL)
6208         {
6209           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6210             return (bfd_vma) -1;
6211           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6212         }
6213
6214       /* PR 17512: file: 64b9dfbb.  */
6215       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6216         return (bfd_vma) -1;
6217
6218       val = bfd_get_64 (opd_bfd, contents + offset);
6219       if (code_sec != NULL)
6220         {
6221           asection *sec, *likely = NULL;
6222
6223           if (in_code_sec)
6224             {
6225               sec = *code_sec;
6226               if (sec->vma <= val
6227                   && val < sec->vma + sec->size)
6228                 likely = sec;
6229               else
6230                 val = -1;
6231             }
6232           else
6233             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6234               if (sec->vma <= val
6235                   && (sec->flags & SEC_LOAD) != 0
6236                   && (sec->flags & SEC_ALLOC) != 0)
6237                 likely = sec;
6238           if (likely != NULL)
6239             {
6240               *code_sec = likely;
6241               if (code_off != NULL)
6242                 *code_off = val - likely->vma;
6243             }
6244         }
6245       return val;
6246     }
6247
6248   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6249
6250   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6251   if (relocs == NULL)
6252     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6253   /* PR 17512: file: df8e1fd6.  */
6254   if (relocs == NULL)
6255     return (bfd_vma) -1;
6256
6257   /* Go find the opd reloc at the sym address.  */
6258   lo = relocs;
6259   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6260   val = (bfd_vma) -1;
6261   while (lo < hi)
6262     {
6263       look = lo + (hi - lo) / 2;
6264       if (look->r_offset < offset)
6265         lo = look + 1;
6266       else if (look->r_offset > offset)
6267         hi = look;
6268       else
6269         {
6270           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6271
6272           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6273               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6274             {
6275               unsigned long symndx = ELF64_R_SYM (look->r_info);
6276               asection *sec = NULL;
6277
6278               if (symndx >= symtab_hdr->sh_info
6279                   && elf_sym_hashes (opd_bfd) != NULL)
6280                 {
6281                   struct elf_link_hash_entry **sym_hashes;
6282                   struct elf_link_hash_entry *rh;
6283
6284                   sym_hashes = elf_sym_hashes (opd_bfd);
6285                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6286                   if (rh != NULL)
6287                     {
6288                       rh = elf_follow_link (rh);
6289                       if (rh->root.type != bfd_link_hash_defined
6290                           && rh->root.type != bfd_link_hash_defweak)
6291                         break;
6292                       if (rh->root.u.def.section->owner == opd_bfd)
6293                         {
6294                           val = rh->root.u.def.value;
6295                           sec = rh->root.u.def.section;
6296                         }
6297                     }
6298                 }
6299
6300               if (sec == NULL)
6301                 {
6302                   Elf_Internal_Sym *sym;
6303
6304                   if (symndx < symtab_hdr->sh_info)
6305                     {
6306                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6307                       if (sym == NULL)
6308                         {
6309                           size_t symcnt = symtab_hdr->sh_info;
6310                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6311                                                       symcnt, 0,
6312                                                       NULL, NULL, NULL);
6313                           if (sym == NULL)
6314                             break;
6315                           symtab_hdr->contents = (bfd_byte *) sym;
6316                         }
6317                       sym += symndx;
6318                     }
6319                   else
6320                     {
6321                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6322                                                   1, symndx,
6323                                                   NULL, NULL, NULL);
6324                       if (sym == NULL)
6325                         break;
6326                     }
6327                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6328                   if (sec == NULL)
6329                     break;
6330                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6331                   val = sym->st_value;
6332                 }
6333
6334               val += look->r_addend;
6335               if (code_off != NULL)
6336                 *code_off = val;
6337               if (code_sec != NULL)
6338                 {
6339                   if (in_code_sec && *code_sec != sec)
6340                     return -1;
6341                   else
6342                     *code_sec = sec;
6343                 }
6344               if (sec->output_section != NULL)
6345                 val += sec->output_section->vma + sec->output_offset;
6346             }
6347           break;
6348         }
6349     }
6350
6351   return val;
6352 }
6353
6354 /* If the ELF symbol SYM might be a function in SEC, return the
6355    function size and set *CODE_OFF to the function's entry point,
6356    otherwise return zero.  */
6357
6358 static bfd_size_type
6359 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6360                               bfd_vma *code_off)
6361 {
6362   bfd_size_type size;
6363
6364   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6365                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6366     return 0;
6367
6368   size = 0;
6369   if (!(sym->flags & BSF_SYNTHETIC))
6370     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6371
6372   if (strcmp (sym->section->name, ".opd") == 0)
6373     {
6374       struct _opd_sec_data *opd = get_opd_info (sym->section);
6375       bfd_vma symval = sym->value;
6376
6377       if (opd != NULL
6378           && opd->adjust != NULL
6379           && elf_section_data (sym->section)->relocs != NULL)
6380         {
6381           /* opd_entry_value will use cached relocs that have been
6382              adjusted, but with raw symbols.  That means both local
6383              and global symbols need adjusting.  */
6384           long adjust = opd->adjust[OPD_NDX (symval)];
6385           if (adjust == -1)
6386             return 0;
6387           symval += adjust;
6388         }
6389
6390       if (opd_entry_value (sym->section, symval,
6391                            &sec, code_off, TRUE) == (bfd_vma) -1)
6392         return 0;
6393       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6394          symbol.  This size has nothing to do with the code size of the
6395          function, which is what we're supposed to return, but the
6396          code size isn't available without looking up the dot-sym.
6397          However, doing that would be a waste of time particularly
6398          since elf_find_function will look at the dot-sym anyway.
6399          Now, elf_find_function will keep the largest size of any
6400          function sym found at the code address of interest, so return
6401          1 here to avoid it incorrectly caching a larger function size
6402          for a small function.  This does mean we return the wrong
6403          size for a new-ABI function of size 24, but all that does is
6404          disable caching for such functions.  */
6405       if (size == 24)
6406         size = 1;
6407     }
6408   else
6409     {
6410       if (sym->section != sec)
6411         return 0;
6412       *code_off = sym->value;
6413     }
6414   if (size == 0)
6415     size = 1;
6416   return size;
6417 }
6418
6419 /* Return true if symbol is a strong function defined in an ELFv2
6420    object with st_other localentry bits of zero, ie. its local entry
6421    point coincides with its global entry point.  */
6422
6423 static bfd_boolean
6424 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6425 {
6426   return (h != NULL
6427           && h->type == STT_FUNC
6428           && h->root.type == bfd_link_hash_defined
6429           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6430           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6431           && is_ppc64_elf (h->root.u.def.section->owner)
6432           && abiversion (h->root.u.def.section->owner) >= 2);
6433 }
6434
6435 /* Return true if symbol is defined in a regular object file.  */
6436
6437 static bfd_boolean
6438 is_static_defined (struct elf_link_hash_entry *h)
6439 {
6440   return ((h->root.type == bfd_link_hash_defined
6441            || h->root.type == bfd_link_hash_defweak)
6442           && h->root.u.def.section != NULL
6443           && h->root.u.def.section->output_section != NULL);
6444 }
6445
6446 /* If FDH is a function descriptor symbol, return the associated code
6447    entry symbol if it is defined.  Return NULL otherwise.  */
6448
6449 static struct ppc_link_hash_entry *
6450 defined_code_entry (struct ppc_link_hash_entry *fdh)
6451 {
6452   if (fdh->is_func_descriptor)
6453     {
6454       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6455       if (fh->elf.root.type == bfd_link_hash_defined
6456           || fh->elf.root.type == bfd_link_hash_defweak)
6457         return fh;
6458     }
6459   return NULL;
6460 }
6461
6462 /* If FH is a function code entry symbol, return the associated
6463    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6464
6465 static struct ppc_link_hash_entry *
6466 defined_func_desc (struct ppc_link_hash_entry *fh)
6467 {
6468   if (fh->oh != NULL
6469       && fh->oh->is_func_descriptor)
6470     {
6471       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6472       if (fdh->elf.root.type == bfd_link_hash_defined
6473           || fdh->elf.root.type == bfd_link_hash_defweak)
6474         return fdh;
6475     }
6476   return NULL;
6477 }
6478
6479 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6480
6481 /* Garbage collect sections, after first dealing with dot-symbols.  */
6482
6483 static bfd_boolean
6484 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6485 {
6486   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6487
6488   if (htab != NULL && htab->need_func_desc_adj)
6489     {
6490       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6491       htab->need_func_desc_adj = 0;
6492     }
6493   return bfd_elf_gc_sections (abfd, info);
6494 }
6495
6496 /* Mark all our entry sym sections, both opd and code section.  */
6497
6498 static void
6499 ppc64_elf_gc_keep (struct bfd_link_info *info)
6500 {
6501   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6502   struct bfd_sym_chain *sym;
6503
6504   if (htab == NULL)
6505     return;
6506
6507   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6508     {
6509       struct ppc_link_hash_entry *eh, *fh;
6510       asection *sec;
6511
6512       eh = (struct ppc_link_hash_entry *)
6513         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6514       if (eh == NULL)
6515         continue;
6516       if (eh->elf.root.type != bfd_link_hash_defined
6517           && eh->elf.root.type != bfd_link_hash_defweak)
6518         continue;
6519
6520       fh = defined_code_entry (eh);
6521       if (fh != NULL)
6522         {
6523           sec = fh->elf.root.u.def.section;
6524           sec->flags |= SEC_KEEP;
6525         }
6526       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6527                && opd_entry_value (eh->elf.root.u.def.section,
6528                                    eh->elf.root.u.def.value,
6529                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6530         sec->flags |= SEC_KEEP;
6531
6532       sec = eh->elf.root.u.def.section;
6533       sec->flags |= SEC_KEEP;
6534     }
6535 }
6536
6537 /* Mark sections containing dynamically referenced symbols.  When
6538    building shared libraries, we must assume that any visible symbol is
6539    referenced.  */
6540
6541 static bfd_boolean
6542 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6543 {
6544   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6545   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6546   struct ppc_link_hash_entry *fdh;
6547   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6548
6549   /* Dynamic linking info is on the func descriptor sym.  */
6550   fdh = defined_func_desc (eh);
6551   if (fdh != NULL)
6552     eh = fdh;
6553
6554   if ((eh->elf.root.type == bfd_link_hash_defined
6555        || eh->elf.root.type == bfd_link_hash_defweak)
6556       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6557           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6558               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6559               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6560               && (!bfd_link_executable (info)
6561                   || info->gc_keep_exported
6562                   || info->export_dynamic
6563                   || (eh->elf.dynamic
6564                       && d != NULL
6565                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6566               && (eh->elf.versioned >= versioned
6567                   || !bfd_hide_sym_by_version (info->version_info,
6568                                                eh->elf.root.root.string)))))
6569     {
6570       asection *code_sec;
6571       struct ppc_link_hash_entry *fh;
6572
6573       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6574
6575       /* Function descriptor syms cause the associated
6576          function code sym section to be marked.  */
6577       fh = defined_code_entry (eh);
6578       if (fh != NULL)
6579         {
6580           code_sec = fh->elf.root.u.def.section;
6581           code_sec->flags |= SEC_KEEP;
6582         }
6583       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6584                && opd_entry_value (eh->elf.root.u.def.section,
6585                                    eh->elf.root.u.def.value,
6586                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6587         code_sec->flags |= SEC_KEEP;
6588     }
6589
6590   return TRUE;
6591 }
6592
6593 /* Return the section that should be marked against GC for a given
6594    relocation.  */
6595
6596 static asection *
6597 ppc64_elf_gc_mark_hook (asection *sec,
6598                         struct bfd_link_info *info,
6599                         Elf_Internal_Rela *rel,
6600                         struct elf_link_hash_entry *h,
6601                         Elf_Internal_Sym *sym)
6602 {
6603   asection *rsec;
6604
6605   /* Syms return NULL if we're marking .opd, so we avoid marking all
6606      function sections, as all functions are referenced in .opd.  */
6607   rsec = NULL;
6608   if (get_opd_info (sec) != NULL)
6609     return rsec;
6610
6611   if (h != NULL)
6612     {
6613       enum elf_ppc64_reloc_type r_type;
6614       struct ppc_link_hash_entry *eh, *fh, *fdh;
6615
6616       r_type = ELF64_R_TYPE (rel->r_info);
6617       switch (r_type)
6618         {
6619         case R_PPC64_GNU_VTINHERIT:
6620         case R_PPC64_GNU_VTENTRY:
6621           break;
6622
6623         default:
6624           switch (h->root.type)
6625             {
6626             case bfd_link_hash_defined:
6627             case bfd_link_hash_defweak:
6628               eh = (struct ppc_link_hash_entry *) h;
6629               fdh = defined_func_desc (eh);
6630               if (fdh != NULL)
6631                 {
6632                   /* -mcall-aixdesc code references the dot-symbol on
6633                      a call reloc.  Mark the function descriptor too
6634                      against garbage collection.  */
6635                   fdh->elf.mark = 1;
6636                   if (fdh->elf.is_weakalias)
6637                     weakdef (&fdh->elf)->mark = 1;
6638                   eh = fdh;
6639                 }
6640
6641               /* Function descriptor syms cause the associated
6642                  function code sym section to be marked.  */
6643               fh = defined_code_entry (eh);
6644               if (fh != NULL)
6645                 {
6646                   /* They also mark their opd section.  */
6647                   eh->elf.root.u.def.section->gc_mark = 1;
6648
6649                   rsec = fh->elf.root.u.def.section;
6650                 }
6651               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6652                        && opd_entry_value (eh->elf.root.u.def.section,
6653                                            eh->elf.root.u.def.value,
6654                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6655                 eh->elf.root.u.def.section->gc_mark = 1;
6656               else
6657                 rsec = h->root.u.def.section;
6658               break;
6659
6660             case bfd_link_hash_common:
6661               rsec = h->root.u.c.p->section;
6662               break;
6663
6664             default:
6665               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6666             }
6667         }
6668     }
6669   else
6670     {
6671       struct _opd_sec_data *opd;
6672
6673       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6674       opd = get_opd_info (rsec);
6675       if (opd != NULL && opd->func_sec != NULL)
6676         {
6677           rsec->gc_mark = 1;
6678
6679           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6680         }
6681     }
6682
6683   return rsec;
6684 }
6685
6686 /* The maximum size of .sfpr.  */
6687 #define SFPR_MAX (218*4)
6688
6689 struct sfpr_def_parms
6690 {
6691   const char name[12];
6692   unsigned char lo, hi;
6693   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6694   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6695 };
6696
6697 /* Auto-generate _save*, _rest* functions in .sfpr.
6698    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6699    instead.  */
6700
6701 static bfd_boolean
6702 sfpr_define (struct bfd_link_info *info,
6703              const struct sfpr_def_parms *parm,
6704              asection *stub_sec)
6705 {
6706   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6707   unsigned int i;
6708   size_t len = strlen (parm->name);
6709   bfd_boolean writing = FALSE;
6710   char sym[16];
6711
6712   if (htab == NULL)
6713     return FALSE;
6714
6715   memcpy (sym, parm->name, len);
6716   sym[len + 2] = 0;
6717
6718   for (i = parm->lo; i <= parm->hi; i++)
6719     {
6720       struct ppc_link_hash_entry *h;
6721
6722       sym[len + 0] = i / 10 + '0';
6723       sym[len + 1] = i % 10 + '0';
6724       h = (struct ppc_link_hash_entry *)
6725         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6726       if (stub_sec != NULL)
6727         {
6728           if (h != NULL
6729               && h->elf.root.type == bfd_link_hash_defined
6730               && h->elf.root.u.def.section == htab->sfpr)
6731             {
6732               struct elf_link_hash_entry *s;
6733               char buf[32];
6734               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6735               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6736               if (s == NULL)
6737                 return FALSE;
6738               if (s->root.type == bfd_link_hash_new
6739                   || (s->root.type = bfd_link_hash_defined
6740                       && s->root.u.def.section == stub_sec))
6741                 {
6742                   s->root.type = bfd_link_hash_defined;
6743                   s->root.u.def.section = stub_sec;
6744                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6745                                          + h->elf.root.u.def.value);
6746                   s->ref_regular = 1;
6747                   s->def_regular = 1;
6748                   s->ref_regular_nonweak = 1;
6749                   s->forced_local = 1;
6750                   s->non_elf = 0;
6751                   s->root.linker_def = 1;
6752                 }
6753             }
6754           continue;
6755         }
6756       if (h != NULL)
6757         {
6758           h->save_res = 1;
6759           if (!h->elf.def_regular)
6760             {
6761               h->elf.root.type = bfd_link_hash_defined;
6762               h->elf.root.u.def.section = htab->sfpr;
6763               h->elf.root.u.def.value = htab->sfpr->size;
6764               h->elf.type = STT_FUNC;
6765               h->elf.def_regular = 1;
6766               h->elf.non_elf = 0;
6767               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6768               writing = TRUE;
6769               if (htab->sfpr->contents == NULL)
6770                 {
6771                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6772                   if (htab->sfpr->contents == NULL)
6773                     return FALSE;
6774                 }
6775             }
6776         }
6777       if (writing)
6778         {
6779           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6780           if (i != parm->hi)
6781             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6782           else
6783             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6784           htab->sfpr->size = p - htab->sfpr->contents;
6785         }
6786     }
6787
6788   return TRUE;
6789 }
6790
6791 static bfd_byte *
6792 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6793 {
6794   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6795   return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6800 {
6801   p = savegpr0 (abfd, p, r);
6802   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6803   p = p + 4;
6804   bfd_put_32 (abfd, BLR, p);
6805   return p + 4;
6806 }
6807
6808 static bfd_byte *
6809 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6810 {
6811   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6812   return p + 4;
6813 }
6814
6815 static bfd_byte *
6816 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6817 {
6818   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6819   p = p + 4;
6820   p = restgpr0 (abfd, p, r);
6821   bfd_put_32 (abfd, MTLR_R0, p);
6822   p = p + 4;
6823   if (r == 29)
6824     {
6825       p = restgpr0 (abfd, p, 30);
6826       p = restgpr0 (abfd, p, 31);
6827     }
6828   bfd_put_32 (abfd, BLR, p);
6829   return p + 4;
6830 }
6831
6832 static bfd_byte *
6833 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6834 {
6835   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6836   return p + 4;
6837 }
6838
6839 static bfd_byte *
6840 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6841 {
6842   p = savegpr1 (abfd, p, r);
6843   bfd_put_32 (abfd, BLR, p);
6844   return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6849 {
6850   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6851   return p + 4;
6852 }
6853
6854 static bfd_byte *
6855 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6856 {
6857   p = restgpr1 (abfd, p, r);
6858   bfd_put_32 (abfd, BLR, p);
6859   return p + 4;
6860 }
6861
6862 static bfd_byte *
6863 savefpr (bfd *abfd, bfd_byte *p, int r)
6864 {
6865   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6866   return p + 4;
6867 }
6868
6869 static bfd_byte *
6870 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6871 {
6872   p = savefpr (abfd, p, r);
6873   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6874   p = p + 4;
6875   bfd_put_32 (abfd, BLR, p);
6876   return p + 4;
6877 }
6878
6879 static bfd_byte *
6880 restfpr (bfd *abfd, bfd_byte *p, int r)
6881 {
6882   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6883   return p + 4;
6884 }
6885
6886 static bfd_byte *
6887 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6888 {
6889   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6890   p = p + 4;
6891   p = restfpr (abfd, p, r);
6892   bfd_put_32 (abfd, MTLR_R0, p);
6893   p = p + 4;
6894   if (r == 29)
6895     {
6896       p = restfpr (abfd, p, 30);
6897       p = restfpr (abfd, p, 31);
6898     }
6899   bfd_put_32 (abfd, BLR, p);
6900   return p + 4;
6901 }
6902
6903 static bfd_byte *
6904 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6905 {
6906   p = savefpr (abfd, p, r);
6907   bfd_put_32 (abfd, BLR, p);
6908   return p + 4;
6909 }
6910
6911 static bfd_byte *
6912 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6913 {
6914   p = restfpr (abfd, p, r);
6915   bfd_put_32 (abfd, BLR, p);
6916   return p + 4;
6917 }
6918
6919 static bfd_byte *
6920 savevr (bfd *abfd, bfd_byte *p, int r)
6921 {
6922   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6923   p = p + 4;
6924   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6925   return p + 4;
6926 }
6927
6928 static bfd_byte *
6929 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6930 {
6931   p = savevr (abfd, p, r);
6932   bfd_put_32 (abfd, BLR, p);
6933   return p + 4;
6934 }
6935
6936 static bfd_byte *
6937 restvr (bfd *abfd, bfd_byte *p, int r)
6938 {
6939   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6940   p = p + 4;
6941   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6942   return p + 4;
6943 }
6944
6945 static bfd_byte *
6946 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6947 {
6948   p = restvr (abfd, p, r);
6949   bfd_put_32 (abfd, BLR, p);
6950   return p + 4;
6951 }
6952
6953 /* Called via elf_link_hash_traverse to transfer dynamic linking
6954    information on function code symbol entries to their corresponding
6955    function descriptor symbol entries.  */
6956
6957 static bfd_boolean
6958 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6959 {
6960   struct bfd_link_info *info;
6961   struct ppc_link_hash_table *htab;
6962   struct ppc_link_hash_entry *fh;
6963   struct ppc_link_hash_entry *fdh;
6964   bfd_boolean force_local;
6965
6966   fh = (struct ppc_link_hash_entry *) h;
6967   if (fh->elf.root.type == bfd_link_hash_indirect)
6968     return TRUE;
6969
6970   if (!fh->is_func)
6971     return TRUE;
6972
6973   if (fh->elf.root.root.string[0] != '.'
6974       || fh->elf.root.root.string[1] == '\0')
6975     return TRUE;
6976
6977   info = inf;
6978   htab = ppc_hash_table (info);
6979   if (htab == NULL)
6980     return FALSE;
6981
6982   /* Find the corresponding function descriptor symbol.  */
6983   fdh = lookup_fdh (fh, htab);
6984
6985   /* Resolve undefined references to dot-symbols as the value
6986      in the function descriptor, if we have one in a regular object.
6987      This is to satisfy cases like ".quad .foo".  Calls to functions
6988      in dynamic objects are handled elsewhere.  */
6989   if ((fh->elf.root.type == bfd_link_hash_undefined
6990        || fh->elf.root.type == bfd_link_hash_undefweak)
6991       && (fdh->elf.root.type == bfd_link_hash_defined
6992           || fdh->elf.root.type == bfd_link_hash_defweak)
6993       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6994       && opd_entry_value (fdh->elf.root.u.def.section,
6995                           fdh->elf.root.u.def.value,
6996                           &fh->elf.root.u.def.section,
6997                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6998     {
6999       fh->elf.root.type = fdh->elf.root.type;
7000       fh->elf.forced_local = 1;
7001       fh->elf.def_regular = fdh->elf.def_regular;
7002       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7003     }
7004
7005   if (!fh->elf.dynamic)
7006     {
7007       struct plt_entry *ent;
7008
7009       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7010         if (ent->plt.refcount > 0)
7011           break;
7012       if (ent == NULL)
7013         return TRUE;
7014     }
7015
7016   /* Create a descriptor as undefined if necessary.  */
7017   if (fdh == NULL
7018       && !bfd_link_executable (info)
7019       && (fh->elf.root.type == bfd_link_hash_undefined
7020           || fh->elf.root.type == bfd_link_hash_undefweak))
7021     {
7022       fdh = make_fdh (info, fh);
7023       if (fdh == NULL)
7024         return FALSE;
7025     }
7026
7027   /* We can't support overriding of symbols on a fake descriptor.  */
7028   if (fdh != NULL
7029       && fdh->fake
7030       && (fh->elf.root.type == bfd_link_hash_defined
7031           || fh->elf.root.type == bfd_link_hash_defweak))
7032     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7033
7034   /* Transfer dynamic linking information to the function descriptor.  */
7035   if (fdh != NULL)
7036     {
7037       fdh->elf.ref_regular |= fh->elf.ref_regular;
7038       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7039       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7040       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7041       fdh->elf.dynamic |= fh->elf.dynamic;
7042       fdh->elf.needs_plt |= (fh->elf.needs_plt
7043                              || fh->elf.type == STT_FUNC
7044                              || fh->elf.type == STT_GNU_IFUNC);
7045       move_plt_plist (fh, fdh);
7046
7047       if (!fdh->elf.forced_local
7048           && fh->elf.dynindx != -1)
7049         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7050           return FALSE;
7051     }
7052
7053   /* Now that the info is on the function descriptor, clear the
7054      function code sym info.  Any function code syms for which we
7055      don't have a definition in a regular file, we force local.
7056      This prevents a shared library from exporting syms that have
7057      been imported from another library.  Function code syms that
7058      are really in the library we must leave global to prevent the
7059      linker dragging in a definition from a static library.  */
7060   force_local = (!fh->elf.def_regular
7061                  || fdh == NULL
7062                  || !fdh->elf.def_regular
7063                  || fdh->elf.forced_local);
7064   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7065
7066   return TRUE;
7067 }
7068
7069 static const struct sfpr_def_parms save_res_funcs[] =
7070   {
7071     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7072     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7073     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7074     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7075     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7076     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7077     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7078     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7079     { "._savef", 14, 31, savefpr, savefpr1_tail },
7080     { "._restf", 14, 31, restfpr, restfpr1_tail },
7081     { "_savevr_", 20, 31, savevr, savevr_tail },
7082     { "_restvr_", 20, 31, restvr, restvr_tail }
7083   };
7084
7085 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7086    this hook to a) provide some gcc support functions, and b) transfer
7087    dynamic linking information gathered so far on function code symbol
7088    entries, to their corresponding function descriptor symbol entries.  */
7089
7090 static bfd_boolean
7091 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7092                             struct bfd_link_info *info)
7093 {
7094   struct ppc_link_hash_table *htab;
7095
7096   htab = ppc_hash_table (info);
7097   if (htab == NULL)
7098     return FALSE;
7099
7100   /* Provide any missing _save* and _rest* functions.  */
7101   if (htab->sfpr != NULL)
7102     {
7103       unsigned int i;
7104
7105       htab->sfpr->size = 0;
7106       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7107         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7108           return FALSE;
7109       if (htab->sfpr->size == 0)
7110         htab->sfpr->flags |= SEC_EXCLUDE;
7111     }
7112
7113   if (bfd_link_relocatable (info))
7114     return TRUE;
7115
7116   if (htab->elf.hgot != NULL)
7117     {
7118       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7119       /* Make .TOC. defined so as to prevent it being made dynamic.
7120          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7121       if (!htab->elf.hgot->def_regular
7122           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7123         {
7124           htab->elf.hgot->root.type = bfd_link_hash_defined;
7125           htab->elf.hgot->root.u.def.value = 0;
7126           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7127           htab->elf.hgot->def_regular = 1;
7128           htab->elf.hgot->root.linker_def = 1;
7129         }
7130       htab->elf.hgot->type = STT_OBJECT;
7131       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7132                                | STV_HIDDEN);
7133     }
7134
7135   if (htab->need_func_desc_adj)
7136     {
7137       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7138       htab->need_func_desc_adj = 0;
7139     }
7140
7141   return TRUE;
7142 }
7143
7144 /* Find dynamic relocs for H that apply to read-only sections.  */
7145
7146 static asection *
7147 readonly_dynrelocs (struct elf_link_hash_entry *h)
7148 {
7149   struct ppc_link_hash_entry *eh;
7150   struct elf_dyn_relocs *p;
7151
7152   eh = (struct ppc_link_hash_entry *) h;
7153   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7154     {
7155       asection *s = p->sec->output_section;
7156
7157       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7158         return p->sec;
7159     }
7160   return NULL;
7161 }
7162
7163 /* Return true if we have dynamic relocs against H or any of its weak
7164    aliases, that apply to read-only sections.  Cannot be used after
7165    size_dynamic_sections.  */
7166
7167 static bfd_boolean
7168 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7169 {
7170   struct ppc_link_hash_entry *eh;
7171
7172   eh = (struct ppc_link_hash_entry *) h;
7173   do
7174     {
7175       if (readonly_dynrelocs (&eh->elf))
7176         return TRUE;
7177       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7178     } while (eh != NULL && &eh->elf != h);
7179
7180   return FALSE;
7181 }
7182
7183 /* Return whether EH has pc-relative dynamic relocs.  */
7184
7185 static bfd_boolean
7186 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7187 {
7188   struct elf_dyn_relocs *p;
7189
7190   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7191     if (p->pc_count != 0)
7192       return TRUE;
7193   return FALSE;
7194 }
7195
7196 /* Return true if a global entry stub will be created for H.  Valid
7197    for ELFv2 before plt entries have been allocated.  */
7198
7199 static bfd_boolean
7200 global_entry_stub (struct elf_link_hash_entry *h)
7201 {
7202   struct plt_entry *pent;
7203
7204   if (!h->pointer_equality_needed
7205       || h->def_regular)
7206     return FALSE;
7207
7208   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7209     if (pent->plt.refcount > 0
7210         && pent->addend == 0)
7211       return TRUE;
7212
7213   return FALSE;
7214 }
7215
7216 /* Adjust a symbol defined by a dynamic object and referenced by a
7217    regular object.  The current definition is in some section of the
7218    dynamic object, but we're not including those sections.  We have to
7219    change the definition to something the rest of the link can
7220    understand.  */
7221
7222 static bfd_boolean
7223 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7224                                  struct elf_link_hash_entry *h)
7225 {
7226   struct ppc_link_hash_table *htab;
7227   asection *s, *srel;
7228
7229   htab = ppc_hash_table (info);
7230   if (htab == NULL)
7231     return FALSE;
7232
7233   /* Deal with function syms.  */
7234   if (h->type == STT_FUNC
7235       || h->type == STT_GNU_IFUNC
7236       || h->needs_plt)
7237     {
7238       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7239                            || SYMBOL_CALLS_LOCAL (info, h)
7240                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7241       /* Discard dyn_relocs when non-pic if we've decided that a
7242          function symbol is local and not an ifunc.  We keep dynamic
7243          relocs for ifuncs when local rather than always emitting a
7244          plt call stub for them and defining the symbol on the call
7245          stub.  We can't do that for ELFv1 anyway (a function symbol
7246          is defined on a descriptor, not code) and it can be faster at
7247          run-time due to not needing to bounce through a stub.  The
7248          dyn_relocs for ifuncs will be applied even in a static
7249          executable.  */
7250       if (!bfd_link_pic (info)
7251           && h->type != STT_GNU_IFUNC
7252           && local)
7253         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7254
7255       /* Clear procedure linkage table information for any symbol that
7256          won't need a .plt entry.  */
7257       struct plt_entry *ent;
7258       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7259         if (ent->plt.refcount > 0)
7260           break;
7261       if (ent == NULL
7262           || (h->type != STT_GNU_IFUNC
7263               && local
7264               && (((struct ppc_link_hash_entry *) h)->tls_mask
7265                   & (TLS_TLS | PLT_KEEP)) != PLT_KEEP))
7266         {
7267           h->plt.plist = NULL;
7268           h->needs_plt = 0;
7269           h->pointer_equality_needed = 0;
7270         }
7271       else if (abiversion (info->output_bfd) >= 2)
7272         {
7273           /* Taking a function's address in a read/write section
7274              doesn't require us to define the function symbol in the
7275              executable on a global entry stub.  A dynamic reloc can
7276              be used instead.  The reason we prefer a few more dynamic
7277              relocs is that calling via a global entry stub costs a
7278              few more instructions, and pointer_equality_needed causes
7279              extra work in ld.so when resolving these symbols.  */
7280           if (global_entry_stub (h))
7281             {
7282               if (!readonly_dynrelocs (h))
7283                 {
7284                   h->pointer_equality_needed = 0;
7285                   /* If we haven't seen a branch reloc then we don't need
7286                      a plt entry.  */
7287                   if (!h->needs_plt)
7288                     h->plt.plist = NULL;
7289                 }
7290               else if (!bfd_link_pic (info))
7291                 /* We are going to be defining the function symbol on the
7292                    plt stub, so no dyn_relocs needed when non-pic.  */
7293                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7294             }
7295
7296           /* ELFv2 function symbols can't have copy relocs.  */
7297           return TRUE;
7298         }
7299       else if (!h->needs_plt
7300                && !readonly_dynrelocs (h))
7301         {
7302           /* If we haven't seen a branch reloc then we don't need a
7303              plt entry.  */
7304           h->plt.plist = NULL;
7305           h->pointer_equality_needed = 0;
7306           return TRUE;
7307         }
7308     }
7309   else
7310     h->plt.plist = NULL;
7311
7312   /* If this is a weak symbol, and there is a real definition, the
7313      processor independent code will have arranged for us to see the
7314      real definition first, and we can just use the same value.  */
7315   if (h->is_weakalias)
7316     {
7317       struct elf_link_hash_entry *def = weakdef (h);
7318       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7319       h->root.u.def.section = def->root.u.def.section;
7320       h->root.u.def.value = def->root.u.def.value;
7321       if (def->root.u.def.section == htab->elf.sdynbss
7322           || def->root.u.def.section == htab->elf.sdynrelro)
7323         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7324       return TRUE;
7325     }
7326
7327   /* If we are creating a shared library, we must presume that the
7328      only references to the symbol are via the global offset table.
7329      For such cases we need not do anything here; the relocations will
7330      be handled correctly by relocate_section.  */
7331   if (bfd_link_pic (info))
7332     return TRUE;
7333
7334   /* If there are no references to this symbol that do not use the
7335      GOT, we don't need to generate a copy reloc.  */
7336   if (!h->non_got_ref)
7337     return TRUE;
7338
7339   /* Don't generate a copy reloc for symbols defined in the executable.  */
7340   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7341
7342       /* If -z nocopyreloc was given, don't generate them either.  */
7343       || info->nocopyreloc
7344
7345       /* If we don't find any dynamic relocs in read-only sections, then
7346          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7347       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7348
7349       /* Protected variables do not work with .dynbss.  The copy in
7350          .dynbss won't be used by the shared library with the protected
7351          definition for the variable.  Text relocations are preferable
7352          to an incorrect program.  */
7353       || h->protected_def)
7354     return TRUE;
7355
7356   if (h->plt.plist != NULL)
7357     {
7358       /* We should never get here, but unfortunately there are versions
7359          of gcc out there that improperly (for this ABI) put initialized
7360          function pointers, vtable refs and suchlike in read-only
7361          sections.  Allow them to proceed, but warn that this might
7362          break at runtime.  */
7363       info->callbacks->einfo
7364         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7365            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7366          h->root.root.string);
7367     }
7368
7369   /* This is a reference to a symbol defined by a dynamic object which
7370      is not a function.  */
7371
7372   /* We must allocate the symbol in our .dynbss section, which will
7373      become part of the .bss section of the executable.  There will be
7374      an entry for this symbol in the .dynsym section.  The dynamic
7375      object will contain position independent code, so all references
7376      from the dynamic object to this symbol will go through the global
7377      offset table.  The dynamic linker will use the .dynsym entry to
7378      determine the address it must put in the global offset table, so
7379      both the dynamic object and the regular object will refer to the
7380      same memory location for the variable.  */
7381   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7382     {
7383       s = htab->elf.sdynrelro;
7384       srel = htab->elf.sreldynrelro;
7385     }
7386   else
7387     {
7388       s = htab->elf.sdynbss;
7389       srel = htab->elf.srelbss;
7390     }
7391   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7392     {
7393       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7394          linker to copy the initial value out of the dynamic object
7395          and into the runtime process image.  */
7396       srel->size += sizeof (Elf64_External_Rela);
7397       h->needs_copy = 1;
7398     }
7399
7400   /* We no longer want dyn_relocs.  */
7401   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7402   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7403 }
7404
7405 /* If given a function descriptor symbol, hide both the function code
7406    sym and the descriptor.  */
7407 static void
7408 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7409                        struct elf_link_hash_entry *h,
7410                        bfd_boolean force_local)
7411 {
7412   struct ppc_link_hash_entry *eh;
7413   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7414
7415   eh = (struct ppc_link_hash_entry *) h;
7416   if (eh->is_func_descriptor)
7417     {
7418       struct ppc_link_hash_entry *fh = eh->oh;
7419
7420       if (fh == NULL)
7421         {
7422           const char *p, *q;
7423           struct elf_link_hash_table *htab = elf_hash_table (info);
7424           char save;
7425
7426           /* We aren't supposed to use alloca in BFD because on
7427              systems which do not have alloca the version in libiberty
7428              calls xmalloc, which might cause the program to crash
7429              when it runs out of memory.  This function doesn't have a
7430              return status, so there's no way to gracefully return an
7431              error.  So cheat.  We know that string[-1] can be safely
7432              accessed;  It's either a string in an ELF string table,
7433              or allocated in an objalloc structure.  */
7434
7435           p = eh->elf.root.root.string - 1;
7436           save = *p;
7437           *(char *) p = '.';
7438           fh = (struct ppc_link_hash_entry *)
7439             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7440           *(char *) p = save;
7441
7442           /* Unfortunately, if it so happens that the string we were
7443              looking for was allocated immediately before this string,
7444              then we overwrote the string terminator.  That's the only
7445              reason the lookup should fail.  */
7446           if (fh == NULL)
7447             {
7448               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7449               while (q >= eh->elf.root.root.string && *q == *p)
7450                 --q, --p;
7451               if (q < eh->elf.root.root.string && *p == '.')
7452                 fh = (struct ppc_link_hash_entry *)
7453                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7454             }
7455           if (fh != NULL)
7456             {
7457               eh->oh = fh;
7458               fh->oh = eh;
7459             }
7460         }
7461       if (fh != NULL)
7462         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7463     }
7464 }
7465
7466 static bfd_boolean
7467 get_sym_h (struct elf_link_hash_entry **hp,
7468            Elf_Internal_Sym **symp,
7469            asection **symsecp,
7470            unsigned char **tls_maskp,
7471            Elf_Internal_Sym **locsymsp,
7472            unsigned long r_symndx,
7473            bfd *ibfd)
7474 {
7475   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7476
7477   if (r_symndx >= symtab_hdr->sh_info)
7478     {
7479       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7480       struct elf_link_hash_entry *h;
7481
7482       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7483       h = elf_follow_link (h);
7484
7485       if (hp != NULL)
7486         *hp = h;
7487
7488       if (symp != NULL)
7489         *symp = NULL;
7490
7491       if (symsecp != NULL)
7492         {
7493           asection *symsec = NULL;
7494           if (h->root.type == bfd_link_hash_defined
7495               || h->root.type == bfd_link_hash_defweak)
7496             symsec = h->root.u.def.section;
7497           *symsecp = symsec;
7498         }
7499
7500       if (tls_maskp != NULL)
7501         {
7502           struct ppc_link_hash_entry *eh;
7503
7504           eh = (struct ppc_link_hash_entry *) h;
7505           *tls_maskp = &eh->tls_mask;
7506         }
7507     }
7508   else
7509     {
7510       Elf_Internal_Sym *sym;
7511       Elf_Internal_Sym *locsyms = *locsymsp;
7512
7513       if (locsyms == NULL)
7514         {
7515           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7516           if (locsyms == NULL)
7517             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7518                                             symtab_hdr->sh_info,
7519                                             0, NULL, NULL, NULL);
7520           if (locsyms == NULL)
7521             return FALSE;
7522           *locsymsp = locsyms;
7523         }
7524       sym = locsyms + r_symndx;
7525
7526       if (hp != NULL)
7527         *hp = NULL;
7528
7529       if (symp != NULL)
7530         *symp = sym;
7531
7532       if (symsecp != NULL)
7533         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7534
7535       if (tls_maskp != NULL)
7536         {
7537           struct got_entry **lgot_ents;
7538           unsigned char *tls_mask;
7539
7540           tls_mask = NULL;
7541           lgot_ents = elf_local_got_ents (ibfd);
7542           if (lgot_ents != NULL)
7543             {
7544               struct plt_entry **local_plt = (struct plt_entry **)
7545                 (lgot_ents + symtab_hdr->sh_info);
7546               unsigned char *lgot_masks = (unsigned char *)
7547                 (local_plt + symtab_hdr->sh_info);
7548               tls_mask = &lgot_masks[r_symndx];
7549             }
7550           *tls_maskp = tls_mask;
7551         }
7552     }
7553   return TRUE;
7554 }
7555
7556 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7557    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7558    type suitable for optimization, and 1 otherwise.  */
7559
7560 static int
7561 get_tls_mask (unsigned char **tls_maskp,
7562               unsigned long *toc_symndx,
7563               bfd_vma *toc_addend,
7564               Elf_Internal_Sym **locsymsp,
7565               const Elf_Internal_Rela *rel,
7566               bfd *ibfd)
7567 {
7568   unsigned long r_symndx;
7569   int next_r;
7570   struct elf_link_hash_entry *h;
7571   Elf_Internal_Sym *sym;
7572   asection *sec;
7573   bfd_vma off;
7574
7575   r_symndx = ELF64_R_SYM (rel->r_info);
7576   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7577     return 0;
7578
7579   if ((*tls_maskp != NULL
7580        && (**tls_maskp & TLS_TLS) != 0
7581        && **tls_maskp != (TLS_TLS | TLS_MARK))
7582       || sec == NULL
7583       || ppc64_elf_section_data (sec) == NULL
7584       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7585     return 1;
7586
7587   /* Look inside a TOC section too.  */
7588   if (h != NULL)
7589     {
7590       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7591       off = h->root.u.def.value;
7592     }
7593   else
7594     off = sym->st_value;
7595   off += rel->r_addend;
7596   BFD_ASSERT (off % 8 == 0);
7597   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7598   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7599   if (toc_symndx != NULL)
7600     *toc_symndx = r_symndx;
7601   if (toc_addend != NULL)
7602     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7603   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7604     return 0;
7605   if ((h == NULL || is_static_defined (h))
7606       && (next_r == -1 || next_r == -2))
7607     return 1 - next_r;
7608   return 1;
7609 }
7610
7611 /* Find (or create) an entry in the tocsave hash table.  */
7612
7613 static struct tocsave_entry *
7614 tocsave_find (struct ppc_link_hash_table *htab,
7615               enum insert_option insert,
7616               Elf_Internal_Sym **local_syms,
7617               const Elf_Internal_Rela *irela,
7618               bfd *ibfd)
7619 {
7620   unsigned long r_indx;
7621   struct elf_link_hash_entry *h;
7622   Elf_Internal_Sym *sym;
7623   struct tocsave_entry ent, *p;
7624   hashval_t hash;
7625   struct tocsave_entry **slot;
7626
7627   r_indx = ELF64_R_SYM (irela->r_info);
7628   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7629     return NULL;
7630   if (ent.sec == NULL || ent.sec->output_section == NULL)
7631     {
7632       _bfd_error_handler
7633         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7634       return NULL;
7635     }
7636
7637   if (h != NULL)
7638     ent.offset = h->root.u.def.value;
7639   else
7640     ent.offset = sym->st_value;
7641   ent.offset += irela->r_addend;
7642
7643   hash = tocsave_htab_hash (&ent);
7644   slot = ((struct tocsave_entry **)
7645           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7646   if (slot == NULL)
7647     return NULL;
7648
7649   if (*slot == NULL)
7650     {
7651       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7652       if (p == NULL)
7653         return NULL;
7654       *p = ent;
7655       *slot = p;
7656     }
7657   return *slot;
7658 }
7659
7660 /* Adjust all global syms defined in opd sections.  In gcc generated
7661    code for the old ABI, these will already have been done.  */
7662
7663 static bfd_boolean
7664 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7665 {
7666   struct ppc_link_hash_entry *eh;
7667   asection *sym_sec;
7668   struct _opd_sec_data *opd;
7669
7670   if (h->root.type == bfd_link_hash_indirect)
7671     return TRUE;
7672
7673   if (h->root.type != bfd_link_hash_defined
7674       && h->root.type != bfd_link_hash_defweak)
7675     return TRUE;
7676
7677   eh = (struct ppc_link_hash_entry *) h;
7678   if (eh->adjust_done)
7679     return TRUE;
7680
7681   sym_sec = eh->elf.root.u.def.section;
7682   opd = get_opd_info (sym_sec);
7683   if (opd != NULL && opd->adjust != NULL)
7684     {
7685       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7686       if (adjust == -1)
7687         {
7688           /* This entry has been deleted.  */
7689           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7690           if (dsec == NULL)
7691             {
7692               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7693                 if (discarded_section (dsec))
7694                   {
7695                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7696                     break;
7697                   }
7698             }
7699           eh->elf.root.u.def.value = 0;
7700           eh->elf.root.u.def.section = dsec;
7701         }
7702       else
7703         eh->elf.root.u.def.value += adjust;
7704       eh->adjust_done = 1;
7705     }
7706   return TRUE;
7707 }
7708
7709 /* Handles decrementing dynamic reloc counts for the reloc specified by
7710    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7711    have already been determined.  */
7712
7713 static bfd_boolean
7714 dec_dynrel_count (bfd_vma r_info,
7715                   asection *sec,
7716                   struct bfd_link_info *info,
7717                   Elf_Internal_Sym **local_syms,
7718                   struct elf_link_hash_entry *h,
7719                   Elf_Internal_Sym *sym)
7720 {
7721   enum elf_ppc64_reloc_type r_type;
7722   asection *sym_sec = NULL;
7723
7724   /* Can this reloc be dynamic?  This switch, and later tests here
7725      should be kept in sync with the code in check_relocs.  */
7726   r_type = ELF64_R_TYPE (r_info);
7727   switch (r_type)
7728     {
7729     default:
7730       return TRUE;
7731
7732     case R_PPC64_TPREL16:
7733     case R_PPC64_TPREL16_LO:
7734     case R_PPC64_TPREL16_HI:
7735     case R_PPC64_TPREL16_HA:
7736     case R_PPC64_TPREL16_DS:
7737     case R_PPC64_TPREL16_LO_DS:
7738     case R_PPC64_TPREL16_HIGH:
7739     case R_PPC64_TPREL16_HIGHA:
7740     case R_PPC64_TPREL16_HIGHER:
7741     case R_PPC64_TPREL16_HIGHERA:
7742     case R_PPC64_TPREL16_HIGHEST:
7743     case R_PPC64_TPREL16_HIGHESTA:
7744     case R_PPC64_TPREL64:
7745     case R_PPC64_DTPMOD64:
7746     case R_PPC64_DTPREL64:
7747     case R_PPC64_ADDR64:
7748     case R_PPC64_REL30:
7749     case R_PPC64_REL32:
7750     case R_PPC64_REL64:
7751     case R_PPC64_ADDR14:
7752     case R_PPC64_ADDR14_BRNTAKEN:
7753     case R_PPC64_ADDR14_BRTAKEN:
7754     case R_PPC64_ADDR16:
7755     case R_PPC64_ADDR16_DS:
7756     case R_PPC64_ADDR16_HA:
7757     case R_PPC64_ADDR16_HI:
7758     case R_PPC64_ADDR16_HIGH:
7759     case R_PPC64_ADDR16_HIGHA:
7760     case R_PPC64_ADDR16_HIGHER:
7761     case R_PPC64_ADDR16_HIGHERA:
7762     case R_PPC64_ADDR16_HIGHEST:
7763     case R_PPC64_ADDR16_HIGHESTA:
7764     case R_PPC64_ADDR16_LO:
7765     case R_PPC64_ADDR16_LO_DS:
7766     case R_PPC64_ADDR24:
7767     case R_PPC64_ADDR32:
7768     case R_PPC64_UADDR16:
7769     case R_PPC64_UADDR32:
7770     case R_PPC64_UADDR64:
7771     case R_PPC64_TOC:
7772       break;
7773     }
7774
7775   if (local_syms != NULL)
7776     {
7777       unsigned long r_symndx;
7778       bfd *ibfd = sec->owner;
7779
7780       r_symndx = ELF64_R_SYM (r_info);
7781       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7782         return FALSE;
7783     }
7784
7785   if ((bfd_link_pic (info)
7786        && (must_be_dyn_reloc (info, r_type)
7787            || (h != NULL
7788                && (!SYMBOLIC_BIND (info, h)
7789                    || h->root.type == bfd_link_hash_defweak
7790                    || !h->def_regular))))
7791       || (ELIMINATE_COPY_RELOCS
7792           && !bfd_link_pic (info)
7793           && h != NULL
7794           && (h->root.type == bfd_link_hash_defweak
7795               || !h->def_regular)))
7796     ;
7797   else
7798     return TRUE;
7799
7800   if (h != NULL)
7801     {
7802       struct elf_dyn_relocs *p;
7803       struct elf_dyn_relocs **pp;
7804       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7805
7806       /* elf_gc_sweep may have already removed all dyn relocs associated
7807          with local syms for a given section.  Also, symbol flags are
7808          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7809          report a dynreloc miscount.  */
7810       if (*pp == NULL && info->gc_sections)
7811         return TRUE;
7812
7813       while ((p = *pp) != NULL)
7814         {
7815           if (p->sec == sec)
7816             {
7817               if (!must_be_dyn_reloc (info, r_type))
7818                 p->pc_count -= 1;
7819               p->count -= 1;
7820               if (p->count == 0)
7821                 *pp = p->next;
7822               return TRUE;
7823             }
7824           pp = &p->next;
7825         }
7826     }
7827   else
7828     {
7829       struct ppc_dyn_relocs *p;
7830       struct ppc_dyn_relocs **pp;
7831       void *vpp;
7832       bfd_boolean is_ifunc;
7833
7834       if (local_syms == NULL)
7835         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7836       if (sym_sec == NULL)
7837         sym_sec = sec;
7838
7839       vpp = &elf_section_data (sym_sec)->local_dynrel;
7840       pp = (struct ppc_dyn_relocs **) vpp;
7841
7842       if (*pp == NULL && info->gc_sections)
7843         return TRUE;
7844
7845       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7846       while ((p = *pp) != NULL)
7847         {
7848           if (p->sec == sec && p->ifunc == is_ifunc)
7849             {
7850               p->count -= 1;
7851               if (p->count == 0)
7852                 *pp = p->next;
7853               return TRUE;
7854             }
7855           pp = &p->next;
7856         }
7857     }
7858
7859   /* xgettext:c-format */
7860   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7861                       sec->owner, sec);
7862   bfd_set_error (bfd_error_bad_value);
7863   return FALSE;
7864 }
7865
7866 /* Remove unused Official Procedure Descriptor entries.  Currently we
7867    only remove those associated with functions in discarded link-once
7868    sections, or weakly defined functions that have been overridden.  It
7869    would be possible to remove many more entries for statically linked
7870    applications.  */
7871
7872 bfd_boolean
7873 ppc64_elf_edit_opd (struct bfd_link_info *info)
7874 {
7875   bfd *ibfd;
7876   bfd_boolean some_edited = FALSE;
7877   asection *need_pad = NULL;
7878   struct ppc_link_hash_table *htab;
7879
7880   htab = ppc_hash_table (info);
7881   if (htab == NULL)
7882     return FALSE;
7883
7884   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7885     {
7886       asection *sec;
7887       Elf_Internal_Rela *relstart, *rel, *relend;
7888       Elf_Internal_Shdr *symtab_hdr;
7889       Elf_Internal_Sym *local_syms;
7890       struct _opd_sec_data *opd;
7891       bfd_boolean need_edit, add_aux_fields, broken;
7892       bfd_size_type cnt_16b = 0;
7893
7894       if (!is_ppc64_elf (ibfd))
7895         continue;
7896
7897       sec = bfd_get_section_by_name (ibfd, ".opd");
7898       if (sec == NULL || sec->size == 0)
7899         continue;
7900
7901       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7902         continue;
7903
7904       if (sec->output_section == bfd_abs_section_ptr)
7905         continue;
7906
7907       /* Look through the section relocs.  */
7908       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7909         continue;
7910
7911       local_syms = NULL;
7912       symtab_hdr = &elf_symtab_hdr (ibfd);
7913
7914       /* Read the relocations.  */
7915       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7916                                             info->keep_memory);
7917       if (relstart == NULL)
7918         return FALSE;
7919
7920       /* First run through the relocs to check they are sane, and to
7921          determine whether we need to edit this opd section.  */
7922       need_edit = FALSE;
7923       broken = FALSE;
7924       need_pad = sec;
7925       relend = relstart + sec->reloc_count;
7926       for (rel = relstart; rel < relend; )
7927         {
7928           enum elf_ppc64_reloc_type r_type;
7929           unsigned long r_symndx;
7930           asection *sym_sec;
7931           struct elf_link_hash_entry *h;
7932           Elf_Internal_Sym *sym;
7933           bfd_vma offset;
7934
7935           /* .opd contains an array of 16 or 24 byte entries.  We're
7936              only interested in the reloc pointing to a function entry
7937              point.  */
7938           offset = rel->r_offset;
7939           if (rel + 1 == relend
7940               || rel[1].r_offset != offset + 8)
7941             {
7942               /* If someone messes with .opd alignment then after a
7943                  "ld -r" we might have padding in the middle of .opd.
7944                  Also, there's nothing to prevent someone putting
7945                  something silly in .opd with the assembler.  No .opd
7946                  optimization for them!  */
7947             broken_opd:
7948               _bfd_error_handler
7949                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7950               broken = TRUE;
7951               break;
7952             }
7953
7954           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7955               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7956             {
7957               _bfd_error_handler
7958                 /* xgettext:c-format */
7959                 (_("%pB: unexpected reloc type %u in .opd section"),
7960                  ibfd, r_type);
7961               broken = TRUE;
7962               break;
7963             }
7964
7965           r_symndx = ELF64_R_SYM (rel->r_info);
7966           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7967                           r_symndx, ibfd))
7968             goto error_ret;
7969
7970           if (sym_sec == NULL || sym_sec->owner == NULL)
7971             {
7972               const char *sym_name;
7973               if (h != NULL)
7974                 sym_name = h->root.root.string;
7975               else
7976                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7977                                              sym_sec);
7978
7979               _bfd_error_handler
7980                 /* xgettext:c-format */
7981                 (_("%pB: undefined sym `%s' in .opd section"),
7982                  ibfd, sym_name);
7983               broken = TRUE;
7984               break;
7985             }
7986
7987           /* opd entries are always for functions defined in the
7988              current input bfd.  If the symbol isn't defined in the
7989              input bfd, then we won't be using the function in this
7990              bfd;  It must be defined in a linkonce section in another
7991              bfd, or is weak.  It's also possible that we are
7992              discarding the function due to a linker script /DISCARD/,
7993              which we test for via the output_section.  */
7994           if (sym_sec->owner != ibfd
7995               || sym_sec->output_section == bfd_abs_section_ptr)
7996             need_edit = TRUE;
7997
7998           rel += 2;
7999           if (rel + 1 == relend
8000               || (rel + 2 < relend
8001                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8002             ++rel;
8003
8004           if (rel == relend)
8005             {
8006               if (sec->size == offset + 24)
8007                 {
8008                   need_pad = NULL;
8009                   break;
8010                 }
8011               if (sec->size == offset + 16)
8012                 {
8013                   cnt_16b++;
8014                   break;
8015                 }
8016               goto broken_opd;
8017             }
8018           else if (rel + 1 < relend
8019                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8020                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8021             {
8022               if (rel[0].r_offset == offset + 16)
8023                 cnt_16b++;
8024               else if (rel[0].r_offset != offset + 24)
8025                 goto broken_opd;
8026             }
8027           else
8028             goto broken_opd;
8029         }
8030
8031       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8032
8033       if (!broken && (need_edit || add_aux_fields))
8034         {
8035           Elf_Internal_Rela *write_rel;
8036           Elf_Internal_Shdr *rel_hdr;
8037           bfd_byte *rptr, *wptr;
8038           bfd_byte *new_contents;
8039           bfd_size_type amt;
8040
8041           new_contents = NULL;
8042           amt = OPD_NDX (sec->size) * sizeof (long);
8043           opd = &ppc64_elf_section_data (sec)->u.opd;
8044           opd->adjust = bfd_zalloc (sec->owner, amt);
8045           if (opd->adjust == NULL)
8046             return FALSE;
8047
8048           /* This seems a waste of time as input .opd sections are all
8049              zeros as generated by gcc, but I suppose there's no reason
8050              this will always be so.  We might start putting something in
8051              the third word of .opd entries.  */
8052           if ((sec->flags & SEC_IN_MEMORY) == 0)
8053             {
8054               bfd_byte *loc;
8055               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8056                 {
8057                   if (loc != NULL)
8058                     free (loc);
8059                 error_ret:
8060                   if (local_syms != NULL
8061                       && symtab_hdr->contents != (unsigned char *) local_syms)
8062                     free (local_syms);
8063                   if (elf_section_data (sec)->relocs != relstart)
8064                     free (relstart);
8065                   return FALSE;
8066                 }
8067               sec->contents = loc;
8068               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8069             }
8070
8071           elf_section_data (sec)->relocs = relstart;
8072
8073           new_contents = sec->contents;
8074           if (add_aux_fields)
8075             {
8076               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8077               if (new_contents == NULL)
8078                 return FALSE;
8079               need_pad = NULL;
8080             }
8081           wptr = new_contents;
8082           rptr = sec->contents;
8083           write_rel = relstart;
8084           for (rel = relstart; rel < relend; )
8085             {
8086               unsigned long r_symndx;
8087               asection *sym_sec;
8088               struct elf_link_hash_entry *h;
8089               struct ppc_link_hash_entry *fdh = NULL;
8090               Elf_Internal_Sym *sym;
8091               long opd_ent_size;
8092               Elf_Internal_Rela *next_rel;
8093               bfd_boolean skip;
8094
8095               r_symndx = ELF64_R_SYM (rel->r_info);
8096               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8097                               r_symndx, ibfd))
8098                 goto error_ret;
8099
8100               next_rel = rel + 2;
8101               if (next_rel + 1 == relend
8102                   || (next_rel + 2 < relend
8103                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8104                 ++next_rel;
8105
8106               /* See if the .opd entry is full 24 byte or
8107                  16 byte (with fd_aux entry overlapped with next
8108                  fd_func).  */
8109               opd_ent_size = 24;
8110               if (next_rel == relend)
8111                 {
8112                   if (sec->size == rel->r_offset + 16)
8113                     opd_ent_size = 16;
8114                 }
8115               else if (next_rel->r_offset == rel->r_offset + 16)
8116                 opd_ent_size = 16;
8117
8118               if (h != NULL
8119                   && h->root.root.string[0] == '.')
8120                 {
8121                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8122                   if (fdh != NULL)
8123                     {
8124                       fdh = ppc_follow_link (fdh);
8125                       if (fdh->elf.root.type != bfd_link_hash_defined
8126                           && fdh->elf.root.type != bfd_link_hash_defweak)
8127                         fdh = NULL;
8128                     }
8129                 }
8130
8131               skip = (sym_sec->owner != ibfd
8132                       || sym_sec->output_section == bfd_abs_section_ptr);
8133               if (skip)
8134                 {
8135                   if (fdh != NULL && sym_sec->owner == ibfd)
8136                     {
8137                       /* Arrange for the function descriptor sym
8138                          to be dropped.  */
8139                       fdh->elf.root.u.def.value = 0;
8140                       fdh->elf.root.u.def.section = sym_sec;
8141                     }
8142                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8143
8144                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8145                     rel = next_rel;
8146                   else
8147                     while (1)
8148                       {
8149                         if (!dec_dynrel_count (rel->r_info, sec, info,
8150                                                NULL, h, sym))
8151                           goto error_ret;
8152
8153                         if (++rel == next_rel)
8154                           break;
8155
8156                         r_symndx = ELF64_R_SYM (rel->r_info);
8157                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8158                                         r_symndx, ibfd))
8159                           goto error_ret;
8160                       }
8161                 }
8162               else
8163                 {
8164                   /* We'll be keeping this opd entry.  */
8165                   long adjust;
8166
8167                   if (fdh != NULL)
8168                     {
8169                       /* Redefine the function descriptor symbol to
8170                          this location in the opd section.  It is
8171                          necessary to update the value here rather
8172                          than using an array of adjustments as we do
8173                          for local symbols, because various places
8174                          in the generic ELF code use the value
8175                          stored in u.def.value.  */
8176                       fdh->elf.root.u.def.value = wptr - new_contents;
8177                       fdh->adjust_done = 1;
8178                     }
8179
8180                   /* Local syms are a bit tricky.  We could
8181                      tweak them as they can be cached, but
8182                      we'd need to look through the local syms
8183                      for the function descriptor sym which we
8184                      don't have at the moment.  So keep an
8185                      array of adjustments.  */
8186                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8187                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8188
8189                   if (wptr != rptr)
8190                     memcpy (wptr, rptr, opd_ent_size);
8191                   wptr += opd_ent_size;
8192                   if (add_aux_fields && opd_ent_size == 16)
8193                     {
8194                       memset (wptr, '\0', 8);
8195                       wptr += 8;
8196                     }
8197
8198                   /* We need to adjust any reloc offsets to point to the
8199                      new opd entries.  */
8200                   for ( ; rel != next_rel; ++rel)
8201                     {
8202                       rel->r_offset += adjust;
8203                       if (write_rel != rel)
8204                         memcpy (write_rel, rel, sizeof (*rel));
8205                       ++write_rel;
8206                     }
8207                 }
8208
8209               rptr += opd_ent_size;
8210             }
8211
8212           sec->size = wptr - new_contents;
8213           sec->reloc_count = write_rel - relstart;
8214           if (add_aux_fields)
8215             {
8216               free (sec->contents);
8217               sec->contents = new_contents;
8218             }
8219
8220           /* Fudge the header size too, as this is used later in
8221              elf_bfd_final_link if we are emitting relocs.  */
8222           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8223           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8224           some_edited = TRUE;
8225         }
8226       else if (elf_section_data (sec)->relocs != relstart)
8227         free (relstart);
8228
8229       if (local_syms != NULL
8230           && symtab_hdr->contents != (unsigned char *) local_syms)
8231         {
8232           if (!info->keep_memory)
8233             free (local_syms);
8234           else
8235             symtab_hdr->contents = (unsigned char *) local_syms;
8236         }
8237     }
8238
8239   if (some_edited)
8240     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8241
8242   /* If we are doing a final link and the last .opd entry is just 16 byte
8243      long, add a 8 byte padding after it.  */
8244   if (need_pad != NULL && !bfd_link_relocatable (info))
8245     {
8246       bfd_byte *p;
8247
8248       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8249         {
8250           BFD_ASSERT (need_pad->size > 0);
8251
8252           p = bfd_malloc (need_pad->size + 8);
8253           if (p == NULL)
8254             return FALSE;
8255
8256           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8257                                           p, 0, need_pad->size))
8258             return FALSE;
8259
8260           need_pad->contents = p;
8261           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8262         }
8263       else
8264         {
8265           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8266           if (p == NULL)
8267             return FALSE;
8268
8269           need_pad->contents = p;
8270         }
8271
8272       memset (need_pad->contents + need_pad->size, 0, 8);
8273       need_pad->size += 8;
8274     }
8275
8276   return TRUE;
8277 }
8278
8279 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8280
8281 asection *
8282 ppc64_elf_tls_setup (struct bfd_link_info *info)
8283 {
8284   struct ppc_link_hash_table *htab;
8285
8286   htab = ppc_hash_table (info);
8287   if (htab == NULL)
8288     return NULL;
8289
8290   if (abiversion (info->output_bfd) == 1)
8291     htab->opd_abi = 1;
8292
8293   if (htab->params->no_multi_toc)
8294     htab->do_multi_toc = 0;
8295   else if (!htab->do_multi_toc)
8296     htab->params->no_multi_toc = 1;
8297
8298   /* Default to --no-plt-localentry, as this option can cause problems
8299      with symbol interposition.  For example, glibc libpthread.so and
8300      libc.so duplicate many pthread symbols, with a fallback
8301      implementation in libc.so.  In some cases the fallback does more
8302      work than the pthread implementation.  __pthread_condattr_destroy
8303      is one such symbol: the libpthread.so implementation is
8304      localentry:0 while the libc.so implementation is localentry:8.
8305      An app that "cleverly" uses dlopen to only load necessary
8306      libraries at runtime may omit loading libpthread.so when not
8307      running multi-threaded, which then results in the libc.so
8308      fallback symbols being used and ld.so complaining.  Now there
8309      are workarounds in ld (see non_zero_localentry) to detect the
8310      pthread situation, but that may not be the only case where
8311      --plt-localentry can cause trouble.  */
8312   if (htab->params->plt_localentry0 < 0)
8313     htab->params->plt_localentry0 = 0;
8314   if (htab->params->plt_localentry0
8315       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8316                                FALSE, FALSE, FALSE) == NULL)
8317     _bfd_error_handler
8318       (_("warning: --plt-localentry is especially dangerous without "
8319          "ld.so support to detect ABI violations"));
8320
8321   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8322                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8323                                               FALSE, FALSE, TRUE));
8324   /* Move dynamic linking info to the function descriptor sym.  */
8325   if (htab->tls_get_addr != NULL)
8326     func_desc_adjust (&htab->tls_get_addr->elf, info);
8327   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8328                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8329                                                  FALSE, FALSE, TRUE));
8330   if (htab->params->tls_get_addr_opt)
8331     {
8332       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8333
8334       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8335                                   FALSE, FALSE, TRUE);
8336       if (opt != NULL)
8337         func_desc_adjust (opt, info);
8338       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8339                                      FALSE, FALSE, TRUE);
8340       if (opt_fd != NULL
8341           && (opt_fd->root.type == bfd_link_hash_defined
8342               || opt_fd->root.type == bfd_link_hash_defweak))
8343         {
8344           /* If glibc supports an optimized __tls_get_addr call stub,
8345              signalled by the presence of __tls_get_addr_opt, and we'll
8346              be calling __tls_get_addr via a plt call stub, then
8347              make __tls_get_addr point to __tls_get_addr_opt.  */
8348           tga_fd = &htab->tls_get_addr_fd->elf;
8349           if (htab->elf.dynamic_sections_created
8350               && tga_fd != NULL
8351               && (tga_fd->type == STT_FUNC
8352                   || tga_fd->needs_plt)
8353               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8354                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8355             {
8356               struct plt_entry *ent;
8357
8358               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8359                 if (ent->plt.refcount > 0)
8360                   break;
8361               if (ent != NULL)
8362                 {
8363                   tga_fd->root.type = bfd_link_hash_indirect;
8364                   tga_fd->root.u.i.link = &opt_fd->root;
8365                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8366                   opt_fd->mark = 1;
8367                   if (opt_fd->dynindx != -1)
8368                     {
8369                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8370                       opt_fd->dynindx = -1;
8371                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8372                                               opt_fd->dynstr_index);
8373                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8374                         return NULL;
8375                     }
8376                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8377                   tga = &htab->tls_get_addr->elf;
8378                   if (opt != NULL && tga != NULL)
8379                     {
8380                       tga->root.type = bfd_link_hash_indirect;
8381                       tga->root.u.i.link = &opt->root;
8382                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8383                       opt->mark = 1;
8384                       _bfd_elf_link_hash_hide_symbol (info, opt,
8385                                                       tga->forced_local);
8386                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8387                     }
8388                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8389                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8390                   if (htab->tls_get_addr != NULL)
8391                     {
8392                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8393                       htab->tls_get_addr->is_func = 1;
8394                     }
8395                 }
8396             }
8397         }
8398       else if (htab->params->tls_get_addr_opt < 0)
8399         htab->params->tls_get_addr_opt = 0;
8400     }
8401   return _bfd_elf_tls_setup (info->output_bfd, info);
8402 }
8403
8404 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8405    HASH1 or HASH2.  */
8406
8407 static bfd_boolean
8408 branch_reloc_hash_match (const bfd *ibfd,
8409                          const Elf_Internal_Rela *rel,
8410                          const struct ppc_link_hash_entry *hash1,
8411                          const struct ppc_link_hash_entry *hash2)
8412 {
8413   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8414   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8415   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8416
8417   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8418     {
8419       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8420       struct elf_link_hash_entry *h;
8421
8422       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8423       h = elf_follow_link (h);
8424       if (h == &hash1->elf || h == &hash2->elf)
8425         return TRUE;
8426     }
8427   return FALSE;
8428 }
8429
8430 /* Run through all the TLS relocs looking for optimization
8431    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8432    a preliminary section layout so that we know the TLS segment
8433    offsets.  We can't optimize earlier because some optimizations need
8434    to know the tp offset, and we need to optimize before allocating
8435    dynamic relocations.  */
8436
8437 bfd_boolean
8438 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8439 {
8440   bfd *ibfd;
8441   asection *sec;
8442   struct ppc_link_hash_table *htab;
8443   unsigned char *toc_ref;
8444   int pass;
8445
8446   if (!bfd_link_executable (info))
8447     return TRUE;
8448
8449   htab = ppc_hash_table (info);
8450   if (htab == NULL)
8451     return FALSE;
8452
8453   /* Make two passes over the relocs.  On the first pass, mark toc
8454      entries involved with tls relocs, and check that tls relocs
8455      involved in setting up a tls_get_addr call are indeed followed by
8456      such a call.  If they are not, we can't do any tls optimization.
8457      On the second pass twiddle tls_mask flags to notify
8458      relocate_section that optimization can be done, and adjust got
8459      and plt refcounts.  */
8460   toc_ref = NULL;
8461   for (pass = 0; pass < 2; ++pass)
8462     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8463       {
8464         Elf_Internal_Sym *locsyms = NULL;
8465         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8466
8467         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8468           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8469             {
8470               Elf_Internal_Rela *relstart, *rel, *relend;
8471               bfd_boolean found_tls_get_addr_arg = 0;
8472
8473               /* Read the relocations.  */
8474               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8475                                                     info->keep_memory);
8476               if (relstart == NULL)
8477                 {
8478                   free (toc_ref);
8479                   return FALSE;
8480                 }
8481
8482               relend = relstart + sec->reloc_count;
8483               for (rel = relstart; rel < relend; rel++)
8484                 {
8485                   enum elf_ppc64_reloc_type r_type;
8486                   unsigned long r_symndx;
8487                   struct elf_link_hash_entry *h;
8488                   Elf_Internal_Sym *sym;
8489                   asection *sym_sec;
8490                   unsigned char *tls_mask;
8491                   unsigned char tls_set, tls_clear, tls_type = 0;
8492                   bfd_vma value;
8493                   bfd_boolean ok_tprel, is_local;
8494                   long toc_ref_index = 0;
8495                   int expecting_tls_get_addr = 0;
8496                   bfd_boolean ret = FALSE;
8497
8498                   r_symndx = ELF64_R_SYM (rel->r_info);
8499                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8500                                   r_symndx, ibfd))
8501                     {
8502                     err_free_rel:
8503                       if (elf_section_data (sec)->relocs != relstart)
8504                         free (relstart);
8505                       if (toc_ref != NULL)
8506                         free (toc_ref);
8507                       if (locsyms != NULL
8508                           && (elf_symtab_hdr (ibfd).contents
8509                               != (unsigned char *) locsyms))
8510                         free (locsyms);
8511                       return ret;
8512                     }
8513
8514                   if (h != NULL)
8515                     {
8516                       if (h->root.type == bfd_link_hash_defined
8517                           || h->root.type == bfd_link_hash_defweak)
8518                         value = h->root.u.def.value;
8519                       else if (h->root.type == bfd_link_hash_undefweak)
8520                         value = 0;
8521                       else
8522                         {
8523                           found_tls_get_addr_arg = 0;
8524                           continue;
8525                         }
8526                     }
8527                   else
8528                     /* Symbols referenced by TLS relocs must be of type
8529                        STT_TLS.  So no need for .opd local sym adjust.  */
8530                     value = sym->st_value;
8531
8532                   ok_tprel = FALSE;
8533                   is_local = FALSE;
8534                   if (h == NULL
8535                       || !h->def_dynamic)
8536                     {
8537                       is_local = TRUE;
8538                       if (h != NULL
8539                           && h->root.type == bfd_link_hash_undefweak)
8540                         ok_tprel = TRUE;
8541                       else if (sym_sec != NULL
8542                                && sym_sec->output_section != NULL)
8543                         {
8544                           value += sym_sec->output_offset;
8545                           value += sym_sec->output_section->vma;
8546                           value -= htab->elf.tls_sec->vma;
8547                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8548                                       < (bfd_vma) 1 << 32);
8549                         }
8550                     }
8551
8552                   r_type = ELF64_R_TYPE (rel->r_info);
8553                   /* If this section has old-style __tls_get_addr calls
8554                      without marker relocs, then check that each
8555                      __tls_get_addr call reloc is preceded by a reloc
8556                      that conceivably belongs to the __tls_get_addr arg
8557                      setup insn.  If we don't find matching arg setup
8558                      relocs, don't do any tls optimization.  */
8559                   if (pass == 0
8560                       && sec->has_tls_get_addr_call
8561                       && h != NULL
8562                       && (h == &htab->tls_get_addr->elf
8563                           || h == &htab->tls_get_addr_fd->elf)
8564                       && !found_tls_get_addr_arg
8565                       && is_branch_reloc (r_type))
8566                     {
8567                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8568                                                 "TLS optimization disabled\n"),
8569                                               ibfd, sec, rel->r_offset);
8570                       ret = TRUE;
8571                       goto err_free_rel;
8572                     }
8573
8574                   found_tls_get_addr_arg = 0;
8575                   switch (r_type)
8576                     {
8577                     case R_PPC64_GOT_TLSLD16:
8578                     case R_PPC64_GOT_TLSLD16_LO:
8579                       expecting_tls_get_addr = 1;
8580                       found_tls_get_addr_arg = 1;
8581                       /* Fall through.  */
8582
8583                     case R_PPC64_GOT_TLSLD16_HI:
8584                     case R_PPC64_GOT_TLSLD16_HA:
8585                       /* These relocs should never be against a symbol
8586                          defined in a shared lib.  Leave them alone if
8587                          that turns out to be the case.  */
8588                       if (!is_local)
8589                         continue;
8590
8591                       /* LD -> LE */
8592                       tls_set = 0;
8593                       tls_clear = TLS_LD;
8594                       tls_type = TLS_TLS | TLS_LD;
8595                       break;
8596
8597                     case R_PPC64_GOT_TLSGD16:
8598                     case R_PPC64_GOT_TLSGD16_LO:
8599                       expecting_tls_get_addr = 1;
8600                       found_tls_get_addr_arg = 1;
8601                       /* Fall through. */
8602
8603                     case R_PPC64_GOT_TLSGD16_HI:
8604                     case R_PPC64_GOT_TLSGD16_HA:
8605                       if (ok_tprel)
8606                         /* GD -> LE */
8607                         tls_set = 0;
8608                       else
8609                         /* GD -> IE */
8610                         tls_set = TLS_TLS | TLS_TPRELGD;
8611                       tls_clear = TLS_GD;
8612                       tls_type = TLS_TLS | TLS_GD;
8613                       break;
8614
8615                     case R_PPC64_GOT_TPREL16_DS:
8616                     case R_PPC64_GOT_TPREL16_LO_DS:
8617                     case R_PPC64_GOT_TPREL16_HI:
8618                     case R_PPC64_GOT_TPREL16_HA:
8619                       if (ok_tprel)
8620                         {
8621                           /* IE -> LE */
8622                           tls_set = 0;
8623                           tls_clear = TLS_TPREL;
8624                           tls_type = TLS_TLS | TLS_TPREL;
8625                           break;
8626                         }
8627                       continue;
8628
8629                     case R_PPC64_TLSGD:
8630                     case R_PPC64_TLSLD:
8631                       if (rel + 1 < relend
8632                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8633                         {
8634                           if (pass != 0
8635                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8636                             {
8637                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8638                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8639                                   r_symndx, ibfd))
8640                                 goto err_free_rel;
8641                               if (h != NULL)
8642                                 {
8643                                   struct plt_entry *ent = NULL;
8644
8645                                   for (ent = h->plt.plist;
8646                                        ent != NULL;
8647                                        ent = ent->next)
8648                                     if (ent->addend == rel[1].r_addend)
8649                                       break;
8650
8651                                   if (ent != NULL
8652                                       && ent->plt.refcount > 0)
8653                                     ent->plt.refcount -= 1;
8654                                 }
8655                             }
8656                           continue;
8657                         }
8658                       found_tls_get_addr_arg = 1;
8659                       /* Fall through.  */
8660
8661                     case R_PPC64_TLS:
8662                     case R_PPC64_TOC16:
8663                     case R_PPC64_TOC16_LO:
8664                       if (sym_sec == NULL || sym_sec != toc)
8665                         continue;
8666
8667                       /* Mark this toc entry as referenced by a TLS
8668                          code sequence.  We can do that now in the
8669                          case of R_PPC64_TLS, and after checking for
8670                          tls_get_addr for the TOC16 relocs.  */
8671                       if (toc_ref == NULL)
8672                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8673                       if (toc_ref == NULL)
8674                         goto err_free_rel;
8675
8676                       if (h != NULL)
8677                         value = h->root.u.def.value;
8678                       else
8679                         value = sym->st_value;
8680                       value += rel->r_addend;
8681                       if (value % 8 != 0)
8682                         continue;
8683                       BFD_ASSERT (value < toc->size
8684                                   && toc->output_offset % 8 == 0);
8685                       toc_ref_index = (value + toc->output_offset) / 8;
8686                       if (r_type == R_PPC64_TLS
8687                           || r_type == R_PPC64_TLSGD
8688                           || r_type == R_PPC64_TLSLD)
8689                         {
8690                           toc_ref[toc_ref_index] = 1;
8691                           continue;
8692                         }
8693
8694                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8695                         continue;
8696
8697                       tls_set = 0;
8698                       tls_clear = 0;
8699                       expecting_tls_get_addr = 2;
8700                       break;
8701
8702                     case R_PPC64_TPREL64:
8703                       if (pass == 0
8704                           || sec != toc
8705                           || toc_ref == NULL
8706                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8707                         continue;
8708                       if (ok_tprel)
8709                         {
8710                           /* IE -> LE */
8711                           tls_set = TLS_EXPLICIT;
8712                           tls_clear = TLS_TPREL;
8713                           break;
8714                         }
8715                       continue;
8716
8717                     case R_PPC64_DTPMOD64:
8718                       if (pass == 0
8719                           || sec != toc
8720                           || toc_ref == NULL
8721                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8722                         continue;
8723                       if (rel + 1 < relend
8724                           && (rel[1].r_info
8725                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8726                           && rel[1].r_offset == rel->r_offset + 8)
8727                         {
8728                           if (ok_tprel)
8729                             /* GD -> LE */
8730                             tls_set = TLS_EXPLICIT | TLS_GD;
8731                           else
8732                             /* GD -> IE */
8733                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8734                           tls_clear = TLS_GD;
8735                         }
8736                       else
8737                         {
8738                           if (!is_local)
8739                             continue;
8740
8741                           /* LD -> LE */
8742                           tls_set = TLS_EXPLICIT;
8743                           tls_clear = TLS_LD;
8744                         }
8745                       break;
8746
8747                     default:
8748                       continue;
8749                     }
8750
8751                   if (pass == 0)
8752                     {
8753                       if (!expecting_tls_get_addr
8754                           || !sec->has_tls_get_addr_call)
8755                         continue;
8756
8757                       if (rel + 1 < relend
8758                           && branch_reloc_hash_match (ibfd, rel + 1,
8759                                                       htab->tls_get_addr,
8760                                                       htab->tls_get_addr_fd))
8761                         {
8762                           if (expecting_tls_get_addr == 2)
8763                             {
8764                               /* Check for toc tls entries.  */
8765                               unsigned char *toc_tls;
8766                               int retval;
8767
8768                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8769                                                      &locsyms,
8770                                                      rel, ibfd);
8771                               if (retval == 0)
8772                                 goto err_free_rel;
8773                               if (toc_tls != NULL)
8774                                 {
8775                                   if ((*toc_tls & TLS_TLS) != 0
8776                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8777                                     found_tls_get_addr_arg = 1;
8778                                   if (retval > 1)
8779                                     toc_ref[toc_ref_index] = 1;
8780                                 }
8781                             }
8782                           continue;
8783                         }
8784
8785                       /* Uh oh, we didn't find the expected call.  We
8786                          could just mark this symbol to exclude it
8787                          from tls optimization but it's safer to skip
8788                          the entire optimization.  */
8789                       /* xgettext:c-format */
8790                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8791                                                 "TLS optimization disabled\n"),
8792                                               ibfd, sec, rel->r_offset);
8793                       ret = TRUE;
8794                       goto err_free_rel;
8795                     }
8796
8797                   /* If we don't have old-style __tls_get_addr calls
8798                      without TLSGD/TLSLD marker relocs, and we haven't
8799                      found a new-style __tls_get_addr call with a
8800                      marker for this symbol, then we either have a
8801                      broken object file or an -mlongcall style
8802                      indirect call to __tls_get_addr without a marker.
8803                      Disable optimization in this case.  */
8804                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8805                       && (tls_set & TLS_EXPLICIT) == 0
8806                       && !sec->has_tls_get_addr_call
8807                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8808                           != (TLS_TLS | TLS_MARK)))
8809                     continue;
8810
8811                   if (expecting_tls_get_addr)
8812                     {
8813                       struct plt_entry *ent = NULL;
8814
8815                       if (htab->tls_get_addr != NULL)
8816                         for (ent = htab->tls_get_addr->elf.plt.plist;
8817                              ent != NULL;
8818                              ent = ent->next)
8819                           if (ent->addend == 0)
8820                             break;
8821
8822                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
8823                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8824                              ent != NULL;
8825                              ent = ent->next)
8826                           if (ent->addend == 0)
8827                             break;
8828
8829                       if (ent != NULL
8830                           && ent->plt.refcount > 0)
8831                         ent->plt.refcount -= 1;
8832                     }
8833
8834                   if (tls_clear == 0)
8835                     continue;
8836
8837                   if ((tls_set & TLS_EXPLICIT) == 0)
8838                     {
8839                       struct got_entry *ent;
8840
8841                       /* Adjust got entry for this reloc.  */
8842                       if (h != NULL)
8843                         ent = h->got.glist;
8844                       else
8845                         ent = elf_local_got_ents (ibfd)[r_symndx];
8846
8847                       for (; ent != NULL; ent = ent->next)
8848                         if (ent->addend == rel->r_addend
8849                             && ent->owner == ibfd
8850                             && ent->tls_type == tls_type)
8851                           break;
8852                       if (ent == NULL)
8853                         abort ();
8854
8855                       if (tls_set == 0)
8856                         {
8857                           /* We managed to get rid of a got entry.  */
8858                           if (ent->got.refcount > 0)
8859                             ent->got.refcount -= 1;
8860                         }
8861                     }
8862                   else
8863                     {
8864                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8865                          we'll lose one or two dyn relocs.  */
8866                       if (!dec_dynrel_count (rel->r_info, sec, info,
8867                                              NULL, h, sym))
8868                         return FALSE;
8869
8870                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8871                         {
8872                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8873                                                  NULL, h, sym))
8874                             return FALSE;
8875                         }
8876                     }
8877
8878                   *tls_mask |= tls_set;
8879                   *tls_mask &= ~tls_clear;
8880                 }
8881
8882               if (elf_section_data (sec)->relocs != relstart)
8883                 free (relstart);
8884             }
8885
8886         if (locsyms != NULL
8887             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8888           {
8889             if (!info->keep_memory)
8890               free (locsyms);
8891             else
8892               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8893           }
8894       }
8895
8896   if (toc_ref != NULL)
8897     free (toc_ref);
8898   htab->do_tls_opt = 1;
8899   return TRUE;
8900 }
8901
8902 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8903    the values of any global symbols in a toc section that has been
8904    edited.  Globals in toc sections should be a rarity, so this function
8905    sets a flag if any are found in toc sections other than the one just
8906    edited, so that further hash table traversals can be avoided.  */
8907
8908 struct adjust_toc_info
8909 {
8910   asection *toc;
8911   unsigned long *skip;
8912   bfd_boolean global_toc_syms;
8913 };
8914
8915 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8916
8917 static bfd_boolean
8918 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8919 {
8920   struct ppc_link_hash_entry *eh;
8921   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8922   unsigned long i;
8923
8924   if (h->root.type != bfd_link_hash_defined
8925       && h->root.type != bfd_link_hash_defweak)
8926     return TRUE;
8927
8928   eh = (struct ppc_link_hash_entry *) h;
8929   if (eh->adjust_done)
8930     return TRUE;
8931
8932   if (eh->elf.root.u.def.section == toc_inf->toc)
8933     {
8934       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8935         i = toc_inf->toc->rawsize >> 3;
8936       else
8937         i = eh->elf.root.u.def.value >> 3;
8938
8939       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8940         {
8941           _bfd_error_handler
8942             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8943           do
8944             ++i;
8945           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8946           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8947         }
8948
8949       eh->elf.root.u.def.value -= toc_inf->skip[i];
8950       eh->adjust_done = 1;
8951     }
8952   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8953     toc_inf->global_toc_syms = TRUE;
8954
8955   return TRUE;
8956 }
8957
8958 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8959    on a _LO variety toc/got reloc.  */
8960
8961 static bfd_boolean
8962 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8963 {
8964   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8965           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8966           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8967           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8968           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8969           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8970           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8971           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8972           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8973           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8974           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8975           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8976           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8977           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8978           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8979           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8980           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8981               /* Exclude lfqu by testing reloc.  If relocs are ever
8982                  defined for the reduced D field in psq_lu then those
8983                  will need testing too.  */
8984               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8985           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8986               && (insn & 1) == 0)
8987           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8988           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8989               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8990               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8991           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8992               && (insn & 1) == 0));
8993 }
8994
8995 /* Examine all relocs referencing .toc sections in order to remove
8996    unused .toc entries.  */
8997
8998 bfd_boolean
8999 ppc64_elf_edit_toc (struct bfd_link_info *info)
9000 {
9001   bfd *ibfd;
9002   struct adjust_toc_info toc_inf;
9003   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9004
9005   htab->do_toc_opt = 1;
9006   toc_inf.global_toc_syms = TRUE;
9007   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9008     {
9009       asection *toc, *sec;
9010       Elf_Internal_Shdr *symtab_hdr;
9011       Elf_Internal_Sym *local_syms;
9012       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9013       unsigned long *skip, *drop;
9014       unsigned char *used;
9015       unsigned char *keep, last, some_unused;
9016
9017       if (!is_ppc64_elf (ibfd))
9018         continue;
9019
9020       toc = bfd_get_section_by_name (ibfd, ".toc");
9021       if (toc == NULL
9022           || toc->size == 0
9023           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9024           || discarded_section (toc))
9025         continue;
9026
9027       toc_relocs = NULL;
9028       local_syms = NULL;
9029       symtab_hdr = &elf_symtab_hdr (ibfd);
9030
9031       /* Look at sections dropped from the final link.  */
9032       skip = NULL;
9033       relstart = NULL;
9034       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9035         {
9036           if (sec->reloc_count == 0
9037               || !discarded_section (sec)
9038               || get_opd_info (sec)
9039               || (sec->flags & SEC_ALLOC) == 0
9040               || (sec->flags & SEC_DEBUGGING) != 0)
9041             continue;
9042
9043           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9044           if (relstart == NULL)
9045             goto error_ret;
9046
9047           /* Run through the relocs to see which toc entries might be
9048              unused.  */
9049           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9050             {
9051               enum elf_ppc64_reloc_type r_type;
9052               unsigned long r_symndx;
9053               asection *sym_sec;
9054               struct elf_link_hash_entry *h;
9055               Elf_Internal_Sym *sym;
9056               bfd_vma val;
9057
9058               r_type = ELF64_R_TYPE (rel->r_info);
9059               switch (r_type)
9060                 {
9061                 default:
9062                   continue;
9063
9064                 case R_PPC64_TOC16:
9065                 case R_PPC64_TOC16_LO:
9066                 case R_PPC64_TOC16_HI:
9067                 case R_PPC64_TOC16_HA:
9068                 case R_PPC64_TOC16_DS:
9069                 case R_PPC64_TOC16_LO_DS:
9070                   break;
9071                 }
9072
9073               r_symndx = ELF64_R_SYM (rel->r_info);
9074               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9075                               r_symndx, ibfd))
9076                 goto error_ret;
9077
9078               if (sym_sec != toc)
9079                 continue;
9080
9081               if (h != NULL)
9082                 val = h->root.u.def.value;
9083               else
9084                 val = sym->st_value;
9085               val += rel->r_addend;
9086
9087               if (val >= toc->size)
9088                 continue;
9089
9090               /* Anything in the toc ought to be aligned to 8 bytes.
9091                  If not, don't mark as unused.  */
9092               if (val & 7)
9093                 continue;
9094
9095               if (skip == NULL)
9096                 {
9097                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9098                   if (skip == NULL)
9099                     goto error_ret;
9100                 }
9101
9102               skip[val >> 3] = ref_from_discarded;
9103             }
9104
9105           if (elf_section_data (sec)->relocs != relstart)
9106             free (relstart);
9107         }
9108
9109       /* For largetoc loads of address constants, we can convert
9110          .  addis rx,2,addr@got@ha
9111          .  ld ry,addr@got@l(rx)
9112          to
9113          .  addis rx,2,addr@toc@ha
9114          .  addi ry,rx,addr@toc@l
9115          when addr is within 2G of the toc pointer.  This then means
9116          that the word storing "addr" in the toc is no longer needed.  */
9117
9118       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9119           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9120           && toc->reloc_count != 0)
9121         {
9122           /* Read toc relocs.  */
9123           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9124                                                   info->keep_memory);
9125           if (toc_relocs == NULL)
9126             goto error_ret;
9127
9128           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9129             {
9130               enum elf_ppc64_reloc_type r_type;
9131               unsigned long r_symndx;
9132               asection *sym_sec;
9133               struct elf_link_hash_entry *h;
9134               Elf_Internal_Sym *sym;
9135               bfd_vma val, addr;
9136
9137               r_type = ELF64_R_TYPE (rel->r_info);
9138               if (r_type != R_PPC64_ADDR64)
9139                 continue;
9140
9141               r_symndx = ELF64_R_SYM (rel->r_info);
9142               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9143                               r_symndx, ibfd))
9144                 goto error_ret;
9145
9146               if (sym_sec == NULL
9147                   || sym_sec->output_section == NULL
9148                   || discarded_section (sym_sec))
9149                 continue;
9150
9151               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9152                 continue;
9153
9154               if (h != NULL)
9155                 {
9156                   if (h->type == STT_GNU_IFUNC)
9157                     continue;
9158                   val = h->root.u.def.value;
9159                 }
9160               else
9161                 {
9162                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9163                     continue;
9164                   val = sym->st_value;
9165                 }
9166               val += rel->r_addend;
9167               val += sym_sec->output_section->vma + sym_sec->output_offset;
9168
9169               /* We don't yet know the exact toc pointer value, but we
9170                  know it will be somewhere in the toc section.  Don't
9171                  optimize if the difference from any possible toc
9172                  pointer is outside [ff..f80008000, 7fff7fff].  */
9173               addr = toc->output_section->vma + TOC_BASE_OFF;
9174               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9175                 continue;
9176
9177               addr = toc->output_section->vma + toc->output_section->rawsize;
9178               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9179                 continue;
9180
9181               if (skip == NULL)
9182                 {
9183                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9184                   if (skip == NULL)
9185                     goto error_ret;
9186                 }
9187
9188               skip[rel->r_offset >> 3]
9189                 |= can_optimize | ((rel - toc_relocs) << 2);
9190             }
9191         }
9192
9193       if (skip == NULL)
9194         continue;
9195
9196       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9197       if (used == NULL)
9198         {
9199         error_ret:
9200           if (local_syms != NULL
9201               && symtab_hdr->contents != (unsigned char *) local_syms)
9202             free (local_syms);
9203           if (sec != NULL
9204               && relstart != NULL
9205               && elf_section_data (sec)->relocs != relstart)
9206             free (relstart);
9207           if (toc_relocs != NULL
9208               && elf_section_data (toc)->relocs != toc_relocs)
9209             free (toc_relocs);
9210           if (skip != NULL)
9211             free (skip);
9212           return FALSE;
9213         }
9214
9215       /* Now check all kept sections that might reference the toc.
9216          Check the toc itself last.  */
9217       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9218                   : ibfd->sections);
9219            sec != NULL;
9220            sec = (sec == toc ? NULL
9221                   : sec->next == NULL ? toc
9222                   : sec->next == toc && toc->next ? toc->next
9223                   : sec->next))
9224         {
9225           int repeat;
9226
9227           if (sec->reloc_count == 0
9228               || discarded_section (sec)
9229               || get_opd_info (sec)
9230               || (sec->flags & SEC_ALLOC) == 0
9231               || (sec->flags & SEC_DEBUGGING) != 0)
9232             continue;
9233
9234           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9235                                                 info->keep_memory);
9236           if (relstart == NULL)
9237             {
9238               free (used);
9239               goto error_ret;
9240             }
9241
9242           /* Mark toc entries referenced as used.  */
9243           do
9244             {
9245               repeat = 0;
9246               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9247                 {
9248                   enum elf_ppc64_reloc_type r_type;
9249                   unsigned long r_symndx;
9250                   asection *sym_sec;
9251                   struct elf_link_hash_entry *h;
9252                   Elf_Internal_Sym *sym;
9253                   bfd_vma val;
9254                   enum {no_check, check_lo, check_ha} insn_check;
9255
9256                   r_type = ELF64_R_TYPE (rel->r_info);
9257                   switch (r_type)
9258                     {
9259                     default:
9260                       insn_check = no_check;
9261                       break;
9262
9263                     case R_PPC64_GOT_TLSLD16_HA:
9264                     case R_PPC64_GOT_TLSGD16_HA:
9265                     case R_PPC64_GOT_TPREL16_HA:
9266                     case R_PPC64_GOT_DTPREL16_HA:
9267                     case R_PPC64_GOT16_HA:
9268                     case R_PPC64_TOC16_HA:
9269                       insn_check = check_ha;
9270                       break;
9271
9272                     case R_PPC64_GOT_TLSLD16_LO:
9273                     case R_PPC64_GOT_TLSGD16_LO:
9274                     case R_PPC64_GOT_TPREL16_LO_DS:
9275                     case R_PPC64_GOT_DTPREL16_LO_DS:
9276                     case R_PPC64_GOT16_LO:
9277                     case R_PPC64_GOT16_LO_DS:
9278                     case R_PPC64_TOC16_LO:
9279                     case R_PPC64_TOC16_LO_DS:
9280                       insn_check = check_lo;
9281                       break;
9282                     }
9283
9284                   if (insn_check != no_check)
9285                     {
9286                       bfd_vma off = rel->r_offset & ~3;
9287                       unsigned char buf[4];
9288                       unsigned int insn;
9289
9290                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9291                         {
9292                           free (used);
9293                           goto error_ret;
9294                         }
9295                       insn = bfd_get_32 (ibfd, buf);
9296                       if (insn_check == check_lo
9297                           ? !ok_lo_toc_insn (insn, r_type)
9298                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9299                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9300                         {
9301                           char str[12];
9302
9303                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9304                           sprintf (str, "%#08x", insn);
9305                           info->callbacks->einfo
9306                             /* xgettext:c-format */
9307                             (_("%H: toc optimization is not supported for"
9308                                " %s instruction\n"),
9309                              ibfd, sec, rel->r_offset & ~3, str);
9310                         }
9311                     }
9312
9313                   switch (r_type)
9314                     {
9315                     case R_PPC64_TOC16:
9316                     case R_PPC64_TOC16_LO:
9317                     case R_PPC64_TOC16_HI:
9318                     case R_PPC64_TOC16_HA:
9319                     case R_PPC64_TOC16_DS:
9320                     case R_PPC64_TOC16_LO_DS:
9321                       /* In case we're taking addresses of toc entries.  */
9322                     case R_PPC64_ADDR64:
9323                       break;
9324
9325                     default:
9326                       continue;
9327                     }
9328
9329                   r_symndx = ELF64_R_SYM (rel->r_info);
9330                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9331                                   r_symndx, ibfd))
9332                     {
9333                       free (used);
9334                       goto error_ret;
9335                     }
9336
9337                   if (sym_sec != toc)
9338                     continue;
9339
9340                   if (h != NULL)
9341                     val = h->root.u.def.value;
9342                   else
9343                     val = sym->st_value;
9344                   val += rel->r_addend;
9345
9346                   if (val >= toc->size)
9347                     continue;
9348
9349                   if ((skip[val >> 3] & can_optimize) != 0)
9350                     {
9351                       bfd_vma off;
9352                       unsigned char opc;
9353
9354                       switch (r_type)
9355                         {
9356                         case R_PPC64_TOC16_HA:
9357                           break;
9358
9359                         case R_PPC64_TOC16_LO_DS:
9360                           off = rel->r_offset;
9361                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9362                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9363                                                          off, 1))
9364                             {
9365                               free (used);
9366                               goto error_ret;
9367                             }
9368                           if ((opc & (0x3f << 2)) == (58u << 2))
9369                             break;
9370                           /* Fall through.  */
9371
9372                         default:
9373                           /* Wrong sort of reloc, or not a ld.  We may
9374                              as well clear ref_from_discarded too.  */
9375                           skip[val >> 3] = 0;
9376                         }
9377                     }
9378
9379                   if (sec != toc)
9380                     used[val >> 3] = 1;
9381                   /* For the toc section, we only mark as used if this
9382                      entry itself isn't unused.  */
9383                   else if ((used[rel->r_offset >> 3]
9384                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9385                            && !used[val >> 3])
9386                     {
9387                       /* Do all the relocs again, to catch reference
9388                          chains.  */
9389                       repeat = 1;
9390                       used[val >> 3] = 1;
9391                     }
9392                 }
9393             }
9394           while (repeat);
9395
9396           if (elf_section_data (sec)->relocs != relstart)
9397             free (relstart);
9398         }
9399
9400       /* Merge the used and skip arrays.  Assume that TOC
9401          doublewords not appearing as either used or unused belong
9402          to an entry more than one doubleword in size.  */
9403       for (drop = skip, keep = used, last = 0, some_unused = 0;
9404            drop < skip + (toc->size + 7) / 8;
9405            ++drop, ++keep)
9406         {
9407           if (*keep)
9408             {
9409               *drop &= ~ref_from_discarded;
9410               if ((*drop & can_optimize) != 0)
9411                 some_unused = 1;
9412               last = 0;
9413             }
9414           else if ((*drop & ref_from_discarded) != 0)
9415             {
9416               some_unused = 1;
9417               last = ref_from_discarded;
9418             }
9419           else
9420             *drop = last;
9421         }
9422
9423       free (used);
9424
9425       if (some_unused)
9426         {
9427           bfd_byte *contents, *src;
9428           unsigned long off;
9429           Elf_Internal_Sym *sym;
9430           bfd_boolean local_toc_syms = FALSE;
9431
9432           /* Shuffle the toc contents, and at the same time convert the
9433              skip array from booleans into offsets.  */
9434           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9435             goto error_ret;
9436
9437           elf_section_data (toc)->this_hdr.contents = contents;
9438
9439           for (src = contents, off = 0, drop = skip;
9440                src < contents + toc->size;
9441                src += 8, ++drop)
9442             {
9443               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9444                 off += 8;
9445               else if (off != 0)
9446                 {
9447                   *drop = off;
9448                   memcpy (src - off, src, 8);
9449                 }
9450             }
9451           *drop = off;
9452           toc->rawsize = toc->size;
9453           toc->size = src - contents - off;
9454
9455           /* Adjust addends for relocs against the toc section sym,
9456              and optimize any accesses we can.  */
9457           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9458             {
9459               if (sec->reloc_count == 0
9460                   || discarded_section (sec))
9461                 continue;
9462
9463               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9464                                                     info->keep_memory);
9465               if (relstart == NULL)
9466                 goto error_ret;
9467
9468               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9469                 {
9470                   enum elf_ppc64_reloc_type r_type;
9471                   unsigned long r_symndx;
9472                   asection *sym_sec;
9473                   struct elf_link_hash_entry *h;
9474                   bfd_vma val;
9475
9476                   r_type = ELF64_R_TYPE (rel->r_info);
9477                   switch (r_type)
9478                     {
9479                     default:
9480                       continue;
9481
9482                     case R_PPC64_TOC16:
9483                     case R_PPC64_TOC16_LO:
9484                     case R_PPC64_TOC16_HI:
9485                     case R_PPC64_TOC16_HA:
9486                     case R_PPC64_TOC16_DS:
9487                     case R_PPC64_TOC16_LO_DS:
9488                     case R_PPC64_ADDR64:
9489                       break;
9490                     }
9491
9492                   r_symndx = ELF64_R_SYM (rel->r_info);
9493                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9494                                   r_symndx, ibfd))
9495                     goto error_ret;
9496
9497                   if (sym_sec != toc)
9498                     continue;
9499
9500                   if (h != NULL)
9501                     val = h->root.u.def.value;
9502                   else
9503                     {
9504                       val = sym->st_value;
9505                       if (val != 0)
9506                         local_toc_syms = TRUE;
9507                     }
9508
9509                   val += rel->r_addend;
9510
9511                   if (val > toc->rawsize)
9512                     val = toc->rawsize;
9513                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9514                     continue;
9515                   else if ((skip[val >> 3] & can_optimize) != 0)
9516                     {
9517                       Elf_Internal_Rela *tocrel
9518                         = toc_relocs + (skip[val >> 3] >> 2);
9519                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9520
9521                       switch (r_type)
9522                         {
9523                         case R_PPC64_TOC16_HA:
9524                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9525                           break;
9526
9527                         case R_PPC64_TOC16_LO_DS:
9528                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9529                           break;
9530
9531                         default:
9532                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9533                             ppc_howto_init ();
9534                           info->callbacks->einfo
9535                             /* xgettext:c-format */
9536                             (_("%H: %s references "
9537                                "optimized away TOC entry\n"),
9538                              ibfd, sec, rel->r_offset,
9539                              ppc64_elf_howto_table[r_type]->name);
9540                           bfd_set_error (bfd_error_bad_value);
9541                           goto error_ret;
9542                         }
9543                       rel->r_addend = tocrel->r_addend;
9544                       elf_section_data (sec)->relocs = relstart;
9545                       continue;
9546                     }
9547
9548                   if (h != NULL || sym->st_value != 0)
9549                     continue;
9550
9551                   rel->r_addend -= skip[val >> 3];
9552                   elf_section_data (sec)->relocs = relstart;
9553                 }
9554
9555               if (elf_section_data (sec)->relocs != relstart)
9556                 free (relstart);
9557             }
9558
9559           /* We shouldn't have local or global symbols defined in the TOC,
9560              but handle them anyway.  */
9561           if (local_syms != NULL)
9562             for (sym = local_syms;
9563                  sym < local_syms + symtab_hdr->sh_info;
9564                  ++sym)
9565               if (sym->st_value != 0
9566                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9567                 {
9568                   unsigned long i;
9569
9570                   if (sym->st_value > toc->rawsize)
9571                     i = toc->rawsize >> 3;
9572                   else
9573                     i = sym->st_value >> 3;
9574
9575                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9576                     {
9577                       if (local_toc_syms)
9578                         _bfd_error_handler
9579                           (_("%s defined on removed toc entry"),
9580                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9581                       do
9582                         ++i;
9583                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9584                       sym->st_value = (bfd_vma) i << 3;
9585                     }
9586
9587                   sym->st_value -= skip[i];
9588                   symtab_hdr->contents = (unsigned char *) local_syms;
9589                 }
9590
9591           /* Adjust any global syms defined in this toc input section.  */
9592           if (toc_inf.global_toc_syms)
9593             {
9594               toc_inf.toc = toc;
9595               toc_inf.skip = skip;
9596               toc_inf.global_toc_syms = FALSE;
9597               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9598                                       &toc_inf);
9599             }
9600
9601           if (toc->reloc_count != 0)
9602             {
9603               Elf_Internal_Shdr *rel_hdr;
9604               Elf_Internal_Rela *wrel;
9605               bfd_size_type sz;
9606
9607               /* Remove unused toc relocs, and adjust those we keep.  */
9608               if (toc_relocs == NULL)
9609                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9610                                                         info->keep_memory);
9611               if (toc_relocs == NULL)
9612                 goto error_ret;
9613
9614               wrel = toc_relocs;
9615               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9616                 if ((skip[rel->r_offset >> 3]
9617                      & (ref_from_discarded | can_optimize)) == 0)
9618                   {
9619                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9620                     wrel->r_info = rel->r_info;
9621                     wrel->r_addend = rel->r_addend;
9622                     ++wrel;
9623                   }
9624                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9625                                             &local_syms, NULL, NULL))
9626                   goto error_ret;
9627
9628               elf_section_data (toc)->relocs = toc_relocs;
9629               toc->reloc_count = wrel - toc_relocs;
9630               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9631               sz = rel_hdr->sh_entsize;
9632               rel_hdr->sh_size = toc->reloc_count * sz;
9633             }
9634         }
9635       else if (toc_relocs != NULL
9636                && elf_section_data (toc)->relocs != toc_relocs)
9637         free (toc_relocs);
9638
9639       if (local_syms != NULL
9640           && symtab_hdr->contents != (unsigned char *) local_syms)
9641         {
9642           if (!info->keep_memory)
9643             free (local_syms);
9644           else
9645             symtab_hdr->contents = (unsigned char *) local_syms;
9646         }
9647       free (skip);
9648     }
9649
9650   return TRUE;
9651 }
9652
9653 /* Return true iff input section I references the TOC using
9654    instructions limited to +/-32k offsets.  */
9655
9656 bfd_boolean
9657 ppc64_elf_has_small_toc_reloc (asection *i)
9658 {
9659   return (is_ppc64_elf (i->owner)
9660           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9661 }
9662
9663 /* Allocate space for one GOT entry.  */
9664
9665 static void
9666 allocate_got (struct elf_link_hash_entry *h,
9667               struct bfd_link_info *info,
9668               struct got_entry *gent)
9669 {
9670   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9671   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9672   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9673                  ? 16 : 8);
9674   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9675                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9676   asection *got = ppc64_elf_tdata (gent->owner)->got;
9677
9678   gent->got.offset = got->size;
9679   got->size += entsize;
9680
9681   if (h->type == STT_GNU_IFUNC)
9682     {
9683       htab->elf.irelplt->size += rentsize;
9684       htab->got_reli_size += rentsize;
9685     }
9686   else if (((bfd_link_pic (info)
9687              && !((gent->tls_type & TLS_TPREL) != 0
9688                   && bfd_link_executable (info)
9689                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9690             || (htab->elf.dynamic_sections_created
9691                 && h->dynindx != -1
9692                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9693            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9694     {
9695       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9696       relgot->size += rentsize;
9697     }
9698 }
9699
9700 /* This function merges got entries in the same toc group.  */
9701
9702 static void
9703 merge_got_entries (struct got_entry **pent)
9704 {
9705   struct got_entry *ent, *ent2;
9706
9707   for (ent = *pent; ent != NULL; ent = ent->next)
9708     if (!ent->is_indirect)
9709       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9710         if (!ent2->is_indirect
9711             && ent2->addend == ent->addend
9712             && ent2->tls_type == ent->tls_type
9713             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9714           {
9715             ent2->is_indirect = TRUE;
9716             ent2->got.ent = ent;
9717           }
9718 }
9719
9720 /* If H is undefined, make it dynamic if that makes sense.  */
9721
9722 static bfd_boolean
9723 ensure_undef_dynamic (struct bfd_link_info *info,
9724                       struct elf_link_hash_entry *h)
9725 {
9726   struct elf_link_hash_table *htab = elf_hash_table (info);
9727
9728   if (htab->dynamic_sections_created
9729       && ((info->dynamic_undefined_weak != 0
9730            && h->root.type == bfd_link_hash_undefweak)
9731           || h->root.type == bfd_link_hash_undefined)
9732       && h->dynindx == -1
9733       && !h->forced_local
9734       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9735     return bfd_elf_link_record_dynamic_symbol (info, h);
9736   return TRUE;
9737 }
9738
9739 /* Allocate space in .plt, .got and associated reloc sections for
9740    dynamic relocs.  */
9741
9742 static bfd_boolean
9743 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9744 {
9745   struct bfd_link_info *info;
9746   struct ppc_link_hash_table *htab;
9747   asection *s;
9748   struct ppc_link_hash_entry *eh;
9749   struct got_entry **pgent, *gent;
9750
9751   if (h->root.type == bfd_link_hash_indirect)
9752     return TRUE;
9753
9754   info = (struct bfd_link_info *) inf;
9755   htab = ppc_hash_table (info);
9756   if (htab == NULL)
9757     return FALSE;
9758
9759   eh = (struct ppc_link_hash_entry *) h;
9760   /* Run through the TLS GD got entries first if we're changing them
9761      to TPREL.  */
9762   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9763     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9764       if (gent->got.refcount > 0
9765           && (gent->tls_type & TLS_GD) != 0)
9766         {
9767           /* This was a GD entry that has been converted to TPREL.  If
9768              there happens to be a TPREL entry we can use that one.  */
9769           struct got_entry *ent;
9770           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9771             if (ent->got.refcount > 0
9772                 && (ent->tls_type & TLS_TPREL) != 0
9773                 && ent->addend == gent->addend
9774                 && ent->owner == gent->owner)
9775               {
9776                 gent->got.refcount = 0;
9777                 break;
9778               }
9779
9780           /* If not, then we'll be using our own TPREL entry.  */
9781           if (gent->got.refcount != 0)
9782             gent->tls_type = TLS_TLS | TLS_TPREL;
9783         }
9784
9785   /* Remove any list entry that won't generate a word in the GOT before
9786      we call merge_got_entries.  Otherwise we risk merging to empty
9787      entries.  */
9788   pgent = &h->got.glist;
9789   while ((gent = *pgent) != NULL)
9790     if (gent->got.refcount > 0)
9791       {
9792         if ((gent->tls_type & TLS_LD) != 0
9793             && !h->def_dynamic)
9794           {
9795             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9796             *pgent = gent->next;
9797           }
9798         else
9799           pgent = &gent->next;
9800       }
9801     else
9802       *pgent = gent->next;
9803
9804   if (!htab->do_multi_toc)
9805     merge_got_entries (&h->got.glist);
9806
9807   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9808     if (!gent->is_indirect)
9809       {
9810         /* Make sure this symbol is output as a dynamic symbol.  */
9811         if (!ensure_undef_dynamic (info, h))
9812           return FALSE;
9813
9814         if (!is_ppc64_elf (gent->owner))
9815           abort ();
9816
9817         allocate_got (h, info, gent);
9818       }
9819
9820   /* If no dynamic sections we can't have dynamic relocs, except for
9821      IFUNCs which are handled even in static executables.  */
9822   if (!htab->elf.dynamic_sections_created
9823       && h->type != STT_GNU_IFUNC)
9824     eh->dyn_relocs = NULL;
9825
9826   /* Discard relocs on undefined symbols that must be local.  */
9827   else if (h->root.type == bfd_link_hash_undefined
9828            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9829     eh->dyn_relocs = NULL;
9830
9831   /* Also discard relocs on undefined weak syms with non-default
9832      visibility, or when dynamic_undefined_weak says so.  */
9833   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9834     eh->dyn_relocs = NULL;
9835
9836   if (eh->dyn_relocs != NULL)
9837     {
9838       struct elf_dyn_relocs *p, **pp;
9839
9840       /* In the shared -Bsymbolic case, discard space allocated for
9841          dynamic pc-relative relocs against symbols which turn out to
9842          be defined in regular objects.  For the normal shared case,
9843          discard space for relocs that have become local due to symbol
9844          visibility changes.  */
9845
9846       if (bfd_link_pic (info))
9847         {
9848           /* Relocs that use pc_count are those that appear on a call
9849              insn, or certain REL relocs (see must_be_dyn_reloc) that
9850              can be generated via assembly.  We want calls to
9851              protected symbols to resolve directly to the function
9852              rather than going via the plt.  If people want function
9853              pointer comparisons to work as expected then they should
9854              avoid writing weird assembly.  */
9855           if (SYMBOL_CALLS_LOCAL (info, h))
9856             {
9857               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9858                 {
9859                   p->count -= p->pc_count;
9860                   p->pc_count = 0;
9861                   if (p->count == 0)
9862                     *pp = p->next;
9863                   else
9864                     pp = &p->next;
9865                 }
9866             }
9867
9868           if (eh->dyn_relocs != NULL)
9869             {
9870               /* Make sure this symbol is output as a dynamic symbol.  */
9871               if (!ensure_undef_dynamic (info, h))
9872                 return FALSE;
9873             }
9874         }
9875       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9876         {
9877           /* For the non-pic case, discard space for relocs against
9878              symbols which turn out to need copy relocs or are not
9879              dynamic.  */
9880           if (h->dynamic_adjusted
9881               && !h->def_regular
9882               && !ELF_COMMON_DEF_P (h))
9883             {
9884               /* Make sure this symbol is output as a dynamic symbol.  */
9885               if (!ensure_undef_dynamic (info, h))
9886                 return FALSE;
9887
9888               if (h->dynindx == -1)
9889                 eh->dyn_relocs = NULL;
9890             }
9891           else
9892             eh->dyn_relocs = NULL;
9893         }
9894
9895       /* Finally, allocate space.  */
9896       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9897         {
9898           asection *sreloc = elf_section_data (p->sec)->sreloc;
9899           if (eh->elf.type == STT_GNU_IFUNC)
9900             sreloc = htab->elf.irelplt;
9901           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9902         }
9903     }
9904
9905   /* We might need a PLT entry when the symbol
9906      a) is dynamic, or
9907      b) is an ifunc, or
9908      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9909      d) has plt16 relocs and we are linking statically.  */
9910   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
9911       || h->type == STT_GNU_IFUNC
9912       || (h->needs_plt && h->dynamic_adjusted)
9913       || (h->needs_plt
9914           && h->def_regular
9915           && !htab->elf.dynamic_sections_created
9916           && (((struct ppc_link_hash_entry *) h)->tls_mask
9917               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
9918     {
9919       struct plt_entry *pent;
9920       bfd_boolean doneone = FALSE;
9921       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9922         if (pent->plt.refcount > 0)
9923           {
9924             if (!htab->elf.dynamic_sections_created
9925                 || h->dynindx == -1)
9926               {
9927                 if (h->type == STT_GNU_IFUNC)
9928                   {
9929                     s = htab->elf.iplt;
9930                     pent->plt.offset = s->size;
9931                     s->size += PLT_ENTRY_SIZE (htab);
9932                     s = htab->elf.irelplt;
9933                   }
9934                 else
9935                   {
9936                     s = htab->pltlocal;
9937                     pent->plt.offset = s->size;
9938                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9939                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9940                   }
9941               }
9942             else
9943               {
9944                 /* If this is the first .plt entry, make room for the special
9945                    first entry.  */
9946                 s = htab->elf.splt;
9947                 if (s->size == 0)
9948                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9949
9950                 pent->plt.offset = s->size;
9951
9952                 /* Make room for this entry.  */
9953                 s->size += PLT_ENTRY_SIZE (htab);
9954
9955                 /* Make room for the .glink code.  */
9956                 s = htab->glink;
9957                 if (s->size == 0)
9958                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
9959                 if (htab->opd_abi)
9960                   {
9961                     /* We need bigger stubs past index 32767.  */
9962                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9963                       s->size += 4;
9964                     s->size += 2*4;
9965                   }
9966                 else
9967                   s->size += 4;
9968
9969                 /* We also need to make an entry in the .rela.plt section.  */
9970                 s = htab->elf.srelplt;
9971               }
9972             if (s != NULL)
9973               s->size += sizeof (Elf64_External_Rela);
9974             doneone = TRUE;
9975           }
9976         else
9977           pent->plt.offset = (bfd_vma) -1;
9978       if (!doneone)
9979         {
9980           h->plt.plist = NULL;
9981           h->needs_plt = 0;
9982         }
9983     }
9984   else
9985     {
9986       h->plt.plist = NULL;
9987       h->needs_plt = 0;
9988     }
9989
9990   return TRUE;
9991 }
9992
9993 #define PPC_LO(v) ((v) & 0xffff)
9994 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9995 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9996
9997 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9998    to set up space for global entry stubs.  These are put in glink,
9999    after the branch table.  */
10000
10001 static bfd_boolean
10002 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10003 {
10004   struct bfd_link_info *info;
10005   struct ppc_link_hash_table *htab;
10006   struct plt_entry *pent;
10007   asection *s, *plt;
10008
10009   if (h->root.type == bfd_link_hash_indirect)
10010     return TRUE;
10011
10012   if (!h->pointer_equality_needed)
10013     return TRUE;
10014
10015   if (h->def_regular)
10016     return TRUE;
10017
10018   info = inf;
10019   htab = ppc_hash_table (info);
10020   if (htab == NULL)
10021     return FALSE;
10022
10023   s = htab->global_entry;
10024   plt = htab->elf.splt;
10025   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10026     if (pent->plt.offset != (bfd_vma) -1
10027         && pent->addend == 0)
10028       {
10029         /* For ELFv2, if this symbol is not defined in a regular file
10030            and we are not generating a shared library or pie, then we
10031            need to define the symbol in the executable on a call stub.
10032            This is to avoid text relocations.  */
10033         bfd_vma off, stub_align, stub_off, stub_size;
10034         unsigned int align_power;
10035
10036         stub_size = 16;
10037         stub_off = s->size;
10038         if (htab->params->plt_stub_align >= 0)
10039           align_power = htab->params->plt_stub_align;
10040         else
10041           align_power = -htab->params->plt_stub_align;
10042         /* Setting section alignment is delayed until we know it is
10043            non-empty.  Otherwise the .text output section will be
10044            aligned at least to plt_stub_align even when no global
10045            entry stubs are needed.  */
10046         if (s->alignment_power < align_power)
10047           s->alignment_power = align_power;
10048         stub_align = (bfd_vma) 1 << align_power;
10049         if (htab->params->plt_stub_align >= 0
10050             || ((((stub_off + stub_size - 1) & -stub_align)
10051                  - (stub_off & -stub_align))
10052                 > ((stub_size - 1) & -stub_align)))
10053           stub_off = (stub_off + stub_align - 1) & -stub_align;
10054         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10055         off -= stub_off + s->output_offset + s->output_section->vma;
10056         /* Note that for --plt-stub-align negative we have a possible
10057            dependency between stub offset and size.  Break that
10058            dependency by assuming the max stub size when calculating
10059            the stub offset.  */
10060         if (PPC_HA (off) == 0)
10061           stub_size -= 4;
10062         h->root.type = bfd_link_hash_defined;
10063         h->root.u.def.section = s;
10064         h->root.u.def.value = stub_off;
10065         s->size = stub_off + stub_size;
10066         break;
10067       }
10068   return TRUE;
10069 }
10070
10071 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10072    read-only sections.  */
10073
10074 static bfd_boolean
10075 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10076 {
10077   asection *sec;
10078
10079   if (h->root.type == bfd_link_hash_indirect)
10080     return TRUE;
10081
10082   sec = readonly_dynrelocs (h);
10083   if (sec != NULL)
10084     {
10085       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10086
10087       info->flags |= DF_TEXTREL;
10088       info->callbacks->minfo
10089         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10090          sec->owner, h->root.root.string, sec);
10091
10092       /* Not an error, just cut short the traversal.  */
10093       return FALSE;
10094     }
10095   return TRUE;
10096 }
10097
10098 /* Set the sizes of the dynamic sections.  */
10099
10100 static bfd_boolean
10101 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10102                                  struct bfd_link_info *info)
10103 {
10104   struct ppc_link_hash_table *htab;
10105   bfd *dynobj;
10106   asection *s;
10107   bfd_boolean relocs;
10108   bfd *ibfd;
10109   struct got_entry *first_tlsld;
10110
10111   htab = ppc_hash_table (info);
10112   if (htab == NULL)
10113     return FALSE;
10114
10115   dynobj = htab->elf.dynobj;
10116   if (dynobj == NULL)
10117     abort ();
10118
10119   if (htab->elf.dynamic_sections_created)
10120     {
10121       /* Set the contents of the .interp section to the interpreter.  */
10122       if (bfd_link_executable (info) && !info->nointerp)
10123         {
10124           s = bfd_get_linker_section (dynobj, ".interp");
10125           if (s == NULL)
10126             abort ();
10127           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10128           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10129         }
10130     }
10131
10132   /* Set up .got offsets for local syms, and space for local dynamic
10133      relocs.  */
10134   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10135     {
10136       struct got_entry **lgot_ents;
10137       struct got_entry **end_lgot_ents;
10138       struct plt_entry **local_plt;
10139       struct plt_entry **end_local_plt;
10140       unsigned char *lgot_masks;
10141       bfd_size_type locsymcount;
10142       Elf_Internal_Shdr *symtab_hdr;
10143
10144       if (!is_ppc64_elf (ibfd))
10145         continue;
10146
10147       for (s = ibfd->sections; s != NULL; s = s->next)
10148         {
10149           struct ppc_dyn_relocs *p;
10150
10151           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10152             {
10153               if (!bfd_is_abs_section (p->sec)
10154                   && bfd_is_abs_section (p->sec->output_section))
10155                 {
10156                   /* Input section has been discarded, either because
10157                      it is a copy of a linkonce section or due to
10158                      linker script /DISCARD/, so we'll be discarding
10159                      the relocs too.  */
10160                 }
10161               else if (p->count != 0)
10162                 {
10163                   asection *srel = elf_section_data (p->sec)->sreloc;
10164                   if (p->ifunc)
10165                     srel = htab->elf.irelplt;
10166                   srel->size += p->count * sizeof (Elf64_External_Rela);
10167                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10168                     info->flags |= DF_TEXTREL;
10169                 }
10170             }
10171         }
10172
10173       lgot_ents = elf_local_got_ents (ibfd);
10174       if (!lgot_ents)
10175         continue;
10176
10177       symtab_hdr = &elf_symtab_hdr (ibfd);
10178       locsymcount = symtab_hdr->sh_info;
10179       end_lgot_ents = lgot_ents + locsymcount;
10180       local_plt = (struct plt_entry **) end_lgot_ents;
10181       end_local_plt = local_plt + locsymcount;
10182       lgot_masks = (unsigned char *) end_local_plt;
10183       s = ppc64_elf_tdata (ibfd)->got;
10184       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10185         {
10186           struct got_entry **pent, *ent;
10187
10188           pent = lgot_ents;
10189           while ((ent = *pent) != NULL)
10190             if (ent->got.refcount > 0)
10191               {
10192                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10193                   {
10194                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10195                     *pent = ent->next;
10196                   }
10197                 else
10198                   {
10199                     unsigned int ent_size = 8;
10200                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10201
10202                     ent->got.offset = s->size;
10203                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10204                       {
10205                         ent_size *= 2;
10206                         rel_size *= 2;
10207                       }
10208                     s->size += ent_size;
10209                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10210                       {
10211                         htab->elf.irelplt->size += rel_size;
10212                         htab->got_reli_size += rel_size;
10213                       }
10214                     else if (bfd_link_pic (info)
10215                              && !((ent->tls_type & TLS_TPREL) != 0
10216                                   && bfd_link_executable (info)))
10217                       {
10218                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10219                         srel->size += rel_size;
10220                       }
10221                     pent = &ent->next;
10222                   }
10223               }
10224             else
10225               *pent = ent->next;
10226         }
10227
10228       /* Allocate space for plt calls to local syms.  */
10229       lgot_masks = (unsigned char *) end_local_plt;
10230       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10231         {
10232           struct plt_entry *ent;
10233
10234           for (ent = *local_plt; ent != NULL; ent = ent->next)
10235             if (ent->plt.refcount > 0)
10236               {
10237                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10238                   {
10239                     s = htab->elf.iplt;
10240                     ent->plt.offset = s->size;
10241                     s->size += PLT_ENTRY_SIZE (htab);
10242                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10243                   }
10244                 else if ((*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10245                   ent->plt.offset = (bfd_vma) -1;
10246                 else
10247                   {
10248                     s = htab->pltlocal;
10249                     ent->plt.offset = s->size;
10250                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10251                     if (bfd_link_pic (info))
10252                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10253                   }
10254               }
10255             else
10256               ent->plt.offset = (bfd_vma) -1;
10257         }
10258     }
10259
10260   /* Allocate global sym .plt and .got entries, and space for global
10261      sym dynamic relocs.  */
10262   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10263
10264   if (!htab->opd_abi && !bfd_link_pic (info))
10265     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10266
10267   first_tlsld = NULL;
10268   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10269     {
10270       struct got_entry *ent;
10271
10272       if (!is_ppc64_elf (ibfd))
10273         continue;
10274
10275       ent = ppc64_tlsld_got (ibfd);
10276       if (ent->got.refcount > 0)
10277         {
10278           if (!htab->do_multi_toc && first_tlsld != NULL)
10279             {
10280               ent->is_indirect = TRUE;
10281               ent->got.ent = first_tlsld;
10282             }
10283           else
10284             {
10285               if (first_tlsld == NULL)
10286                 first_tlsld = ent;
10287               s = ppc64_elf_tdata (ibfd)->got;
10288               ent->got.offset = s->size;
10289               ent->owner = ibfd;
10290               s->size += 16;
10291               if (bfd_link_pic (info))
10292                 {
10293                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10294                   srel->size += sizeof (Elf64_External_Rela);
10295                 }
10296             }
10297         }
10298       else
10299         ent->got.offset = (bfd_vma) -1;
10300     }
10301
10302   /* We now have determined the sizes of the various dynamic sections.
10303      Allocate memory for them.  */
10304   relocs = FALSE;
10305   for (s = dynobj->sections; s != NULL; s = s->next)
10306     {
10307       if ((s->flags & SEC_LINKER_CREATED) == 0)
10308         continue;
10309
10310       if (s == htab->brlt || s == htab->relbrlt)
10311         /* These haven't been allocated yet;  don't strip.  */
10312         continue;
10313       else if (s == htab->elf.sgot
10314                || s == htab->elf.splt
10315                || s == htab->elf.iplt
10316                || s == htab->pltlocal
10317                || s == htab->glink
10318                || s == htab->global_entry
10319                || s == htab->elf.sdynbss
10320                || s == htab->elf.sdynrelro)
10321         {
10322           /* Strip this section if we don't need it; see the
10323              comment below.  */
10324         }
10325       else if (s == htab->glink_eh_frame)
10326         {
10327           if (!bfd_is_abs_section (s->output_section))
10328             /* Not sized yet.  */
10329             continue;
10330         }
10331       else if (CONST_STRNEQ (s->name, ".rela"))
10332         {
10333           if (s->size != 0)
10334             {
10335               if (s != htab->elf.srelplt)
10336                 relocs = TRUE;
10337
10338               /* We use the reloc_count field as a counter if we need
10339                  to copy relocs into the output file.  */
10340               s->reloc_count = 0;
10341             }
10342         }
10343       else
10344         {
10345           /* It's not one of our sections, so don't allocate space.  */
10346           continue;
10347         }
10348
10349       if (s->size == 0)
10350         {
10351           /* If we don't need this section, strip it from the
10352              output file.  This is mostly to handle .rela.bss and
10353              .rela.plt.  We must create both sections in
10354              create_dynamic_sections, because they must be created
10355              before the linker maps input sections to output
10356              sections.  The linker does that before
10357              adjust_dynamic_symbol is called, and it is that
10358              function which decides whether anything needs to go
10359              into these sections.  */
10360           s->flags |= SEC_EXCLUDE;
10361           continue;
10362         }
10363
10364       if (bfd_is_abs_section (s->output_section))
10365         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10366                             s->name);
10367
10368       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10369         continue;
10370
10371       /* Allocate memory for the section contents.  We use bfd_zalloc
10372          here in case unused entries are not reclaimed before the
10373          section's contents are written out.  This should not happen,
10374          but this way if it does we get a R_PPC64_NONE reloc in .rela
10375          sections instead of garbage.
10376          We also rely on the section contents being zero when writing
10377          the GOT and .dynrelro.  */
10378       s->contents = bfd_zalloc (dynobj, s->size);
10379       if (s->contents == NULL)
10380         return FALSE;
10381     }
10382
10383   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10384     {
10385       if (!is_ppc64_elf (ibfd))
10386         continue;
10387
10388       s = ppc64_elf_tdata (ibfd)->got;
10389       if (s != NULL && s != htab->elf.sgot)
10390         {
10391           if (s->size == 0)
10392             s->flags |= SEC_EXCLUDE;
10393           else
10394             {
10395               s->contents = bfd_zalloc (ibfd, s->size);
10396               if (s->contents == NULL)
10397                 return FALSE;
10398             }
10399         }
10400       s = ppc64_elf_tdata (ibfd)->relgot;
10401       if (s != NULL)
10402         {
10403           if (s->size == 0)
10404             s->flags |= SEC_EXCLUDE;
10405           else
10406             {
10407               s->contents = bfd_zalloc (ibfd, s->size);
10408               if (s->contents == NULL)
10409                 return FALSE;
10410               relocs = TRUE;
10411               s->reloc_count = 0;
10412             }
10413         }
10414     }
10415
10416   if (htab->elf.dynamic_sections_created)
10417     {
10418       bfd_boolean tls_opt;
10419
10420       /* Add some entries to the .dynamic section.  We fill in the
10421          values later, in ppc64_elf_finish_dynamic_sections, but we
10422          must add the entries now so that we get the correct size for
10423          the .dynamic section.  The DT_DEBUG entry is filled in by the
10424          dynamic linker and used by the debugger.  */
10425 #define add_dynamic_entry(TAG, VAL) \
10426   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10427
10428       if (bfd_link_executable (info))
10429         {
10430           if (!add_dynamic_entry (DT_DEBUG, 0))
10431             return FALSE;
10432         }
10433
10434       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10435         {
10436           if (!add_dynamic_entry (DT_PLTGOT, 0)
10437               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10438               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10439               || !add_dynamic_entry (DT_JMPREL, 0)
10440               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10441             return FALSE;
10442         }
10443
10444       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10445         {
10446           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10447               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10448             return FALSE;
10449         }
10450
10451       tls_opt = (htab->params->tls_get_addr_opt
10452                  && htab->tls_get_addr_fd != NULL
10453                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10454       if (tls_opt || !htab->opd_abi)
10455         {
10456           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10457             return FALSE;
10458         }
10459
10460       if (relocs)
10461         {
10462           if (!add_dynamic_entry (DT_RELA, 0)
10463               || !add_dynamic_entry (DT_RELASZ, 0)
10464               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10465             return FALSE;
10466
10467           /* If any dynamic relocs apply to a read-only section,
10468              then we need a DT_TEXTREL entry.  */
10469           if ((info->flags & DF_TEXTREL) == 0)
10470             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10471
10472           if ((info->flags & DF_TEXTREL) != 0)
10473             {
10474               if (!add_dynamic_entry (DT_TEXTREL, 0))
10475                 return FALSE;
10476             }
10477         }
10478     }
10479 #undef add_dynamic_entry
10480
10481   return TRUE;
10482 }
10483
10484 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10485
10486 static bfd_boolean
10487 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10488 {
10489   if (h->plt.plist != NULL
10490       && !h->def_regular
10491       && !h->pointer_equality_needed)
10492     return FALSE;
10493
10494   return _bfd_elf_hash_symbol (h);
10495 }
10496
10497 /* Determine the type of stub needed, if any, for a call.  */
10498
10499 static inline enum ppc_stub_type
10500 ppc_type_of_stub (asection *input_sec,
10501                   const Elf_Internal_Rela *rel,
10502                   struct ppc_link_hash_entry **hash,
10503                   struct plt_entry **plt_ent,
10504                   bfd_vma destination,
10505                   unsigned long local_off)
10506 {
10507   struct ppc_link_hash_entry *h = *hash;
10508   bfd_vma location;
10509   bfd_vma branch_offset;
10510   bfd_vma max_branch_offset;
10511   enum elf_ppc64_reloc_type r_type;
10512
10513   if (h != NULL)
10514     {
10515       struct plt_entry *ent;
10516       struct ppc_link_hash_entry *fdh = h;
10517       if (h->oh != NULL
10518           && h->oh->is_func_descriptor)
10519         {
10520           fdh = ppc_follow_link (h->oh);
10521           *hash = fdh;
10522         }
10523
10524       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10525         if (ent->addend == rel->r_addend
10526             && ent->plt.offset != (bfd_vma) -1)
10527           {
10528             *plt_ent = ent;
10529             return ppc_stub_plt_call;
10530           }
10531
10532       /* Here, we know we don't have a plt entry.  If we don't have a
10533          either a defined function descriptor or a defined entry symbol
10534          in a regular object file, then it is pointless trying to make
10535          any other type of stub.  */
10536       if (!is_static_defined (&fdh->elf)
10537           && !is_static_defined (&h->elf))
10538         return ppc_stub_none;
10539     }
10540   else if (elf_local_got_ents (input_sec->owner) != NULL)
10541     {
10542       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10543       struct plt_entry **local_plt = (struct plt_entry **)
10544         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10545       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10546
10547       if (local_plt[r_symndx] != NULL)
10548         {
10549           struct plt_entry *ent;
10550
10551           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10552             if (ent->addend == rel->r_addend
10553                 && ent->plt.offset != (bfd_vma) -1)
10554               {
10555                 *plt_ent = ent;
10556                 return ppc_stub_plt_call;
10557               }
10558         }
10559     }
10560
10561   /* Determine where the call point is.  */
10562   location = (input_sec->output_offset
10563               + input_sec->output_section->vma
10564               + rel->r_offset);
10565
10566   branch_offset = destination - location;
10567   r_type = ELF64_R_TYPE (rel->r_info);
10568
10569   /* Determine if a long branch stub is needed.  */
10570   max_branch_offset = 1 << 25;
10571   if (r_type == R_PPC64_REL14
10572       || r_type == R_PPC64_REL14_BRTAKEN
10573       || r_type == R_PPC64_REL14_BRNTAKEN)
10574     max_branch_offset = 1 << 15;
10575
10576   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10577     /* We need a stub.  Figure out whether a long_branch or plt_branch
10578        is needed later.  */
10579     return ppc_stub_long_branch;
10580
10581   return ppc_stub_none;
10582 }
10583
10584 /* With power7 weakly ordered memory model, it is possible for ld.so
10585    to update a plt entry in one thread and have another thread see a
10586    stale zero toc entry.  To avoid this we need some sort of acquire
10587    barrier in the call stub.  One solution is to make the load of the
10588    toc word seem to appear to depend on the load of the function entry
10589    word.  Another solution is to test for r2 being zero, and branch to
10590    the appropriate glink entry if so.
10591
10592    .    fake dep barrier        compare
10593    .    ld 12,xxx(2)            ld 12,xxx(2)
10594    .    mtctr 12                mtctr 12
10595    .    xor 11,12,12            ld 2,xxx+8(2)
10596    .    add 2,2,11              cmpldi 2,0
10597    .    ld 2,xxx+8(2)           bnectr+
10598    .    bctr                    b <glink_entry>
10599
10600    The solution involving the compare turns out to be faster, so
10601    that's what we use unless the branch won't reach.  */
10602
10603 #define ALWAYS_USE_FAKE_DEP 0
10604 #define ALWAYS_EMIT_R2SAVE 0
10605
10606 static inline unsigned int
10607 plt_stub_size (struct ppc_link_hash_table *htab,
10608                struct ppc_stub_hash_entry *stub_entry,
10609                bfd_vma off)
10610 {
10611   unsigned size = 12;
10612
10613   if (ALWAYS_EMIT_R2SAVE
10614       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10615     size += 4;
10616   if (PPC_HA (off) != 0)
10617     size += 4;
10618   if (htab->opd_abi)
10619     {
10620       size += 4;
10621       if (htab->params->plt_static_chain)
10622         size += 4;
10623       if (htab->params->plt_thread_safe
10624           && htab->elf.dynamic_sections_created
10625           && stub_entry->h != NULL
10626           && stub_entry->h->elf.dynindx != -1)
10627         size += 8;
10628       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10629         size += 4;
10630     }
10631   if (stub_entry->h != NULL
10632       && (stub_entry->h == htab->tls_get_addr_fd
10633           || stub_entry->h == htab->tls_get_addr)
10634       && htab->params->tls_get_addr_opt)
10635     {
10636       size += 7 * 4;
10637       if (ALWAYS_EMIT_R2SAVE
10638           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10639         size += 6 * 4;
10640     }
10641   return size;
10642 }
10643
10644 /* Depending on the sign of plt_stub_align:
10645    If positive, return the padding to align to a 2**plt_stub_align
10646    boundary.
10647    If negative, if this stub would cross fewer 2**plt_stub_align
10648    boundaries if we align, then return the padding needed to do so.  */
10649
10650 static inline unsigned int
10651 plt_stub_pad (struct ppc_link_hash_table *htab,
10652               struct ppc_stub_hash_entry *stub_entry,
10653               bfd_vma plt_off)
10654 {
10655   int stub_align;
10656   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10657   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10658
10659   if (htab->params->plt_stub_align >= 0)
10660     {
10661       stub_align = 1 << htab->params->plt_stub_align;
10662       if ((stub_off & (stub_align - 1)) != 0)
10663         return stub_align - (stub_off & (stub_align - 1));
10664       return 0;
10665     }
10666
10667   stub_align = 1 << -htab->params->plt_stub_align;
10668   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10669       > ((stub_size - 1) & -stub_align))
10670     return stub_align - (stub_off & (stub_align - 1));
10671   return 0;
10672 }
10673
10674 /* Build a .plt call stub.  */
10675
10676 static inline bfd_byte *
10677 build_plt_stub (struct ppc_link_hash_table *htab,
10678                 struct ppc_stub_hash_entry *stub_entry,
10679                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10680 {
10681   bfd *obfd = htab->params->stub_bfd;
10682   bfd_boolean plt_load_toc = htab->opd_abi;
10683   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10684   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10685                                  && htab->elf.dynamic_sections_created
10686                                  && stub_entry->h != NULL
10687                                  && stub_entry->h->elf.dynindx != -1);
10688   bfd_boolean use_fake_dep = plt_thread_safe;
10689   bfd_vma cmp_branch_off = 0;
10690
10691   if (!ALWAYS_USE_FAKE_DEP
10692       && plt_load_toc
10693       && plt_thread_safe
10694       && !((stub_entry->h == htab->tls_get_addr_fd
10695             || stub_entry->h == htab->tls_get_addr)
10696            && htab->params->tls_get_addr_opt))
10697     {
10698       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10699       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10700                           / PLT_ENTRY_SIZE (htab));
10701       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10702       bfd_vma to, from;
10703
10704       if (pltindex > 32768)
10705         glinkoff += (pltindex - 32768) * 4;
10706       to = (glinkoff
10707             + htab->glink->output_offset
10708             + htab->glink->output_section->vma);
10709       from = (p - stub_entry->group->stub_sec->contents
10710               + 4 * (ALWAYS_EMIT_R2SAVE
10711                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10712               + 4 * (PPC_HA (offset) != 0)
10713               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10714                      != PPC_HA (offset))
10715               + 4 * (plt_static_chain != 0)
10716               + 20
10717               + stub_entry->group->stub_sec->output_offset
10718               + stub_entry->group->stub_sec->output_section->vma);
10719       cmp_branch_off = to - from;
10720       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10721     }
10722
10723   if (PPC_HA (offset) != 0)
10724     {
10725       if (r != NULL)
10726         {
10727           if (ALWAYS_EMIT_R2SAVE
10728               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10729             r[0].r_offset += 4;
10730           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10731           r[1].r_offset = r[0].r_offset + 4;
10732           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10733           r[1].r_addend = r[0].r_addend;
10734           if (plt_load_toc)
10735             {
10736               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10737                 {
10738                   r[2].r_offset = r[1].r_offset + 4;
10739                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10740                   r[2].r_addend = r[0].r_addend;
10741                 }
10742               else
10743                 {
10744                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10745                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10746                   r[2].r_addend = r[0].r_addend + 8;
10747                   if (plt_static_chain)
10748                     {
10749                       r[3].r_offset = r[2].r_offset + 4;
10750                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10751                       r[3].r_addend = r[0].r_addend + 16;
10752                     }
10753                 }
10754             }
10755         }
10756       if (ALWAYS_EMIT_R2SAVE
10757           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10758         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10759       if (plt_load_toc)
10760         {
10761           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10762           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10763         }
10764       else
10765         {
10766           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10767           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10768         }
10769       if (plt_load_toc
10770           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10771         {
10772           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10773           offset = 0;
10774         }
10775       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10776       if (plt_load_toc)
10777         {
10778           if (use_fake_dep)
10779             {
10780               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10781               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10782             }
10783           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10784           if (plt_static_chain)
10785             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10786         }
10787     }
10788   else
10789     {
10790       if (r != NULL)
10791         {
10792           if (ALWAYS_EMIT_R2SAVE
10793               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10794             r[0].r_offset += 4;
10795           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10796           if (plt_load_toc)
10797             {
10798               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10799                 {
10800                   r[1].r_offset = r[0].r_offset + 4;
10801                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10802                   r[1].r_addend = r[0].r_addend;
10803                 }
10804               else
10805                 {
10806                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10807                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10808                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10809                   if (plt_static_chain)
10810                     {
10811                       r[2].r_offset = r[1].r_offset + 4;
10812                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10813                       r[2].r_addend = r[0].r_addend + 8;
10814                     }
10815                 }
10816             }
10817         }
10818       if (ALWAYS_EMIT_R2SAVE
10819           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10820         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10821       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10822       if (plt_load_toc
10823           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10824         {
10825           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10826           offset = 0;
10827         }
10828       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10829       if (plt_load_toc)
10830         {
10831           if (use_fake_dep)
10832             {
10833               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10834               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10835             }
10836           if (plt_static_chain)
10837             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10838           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10839         }
10840     }
10841   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10842     {
10843       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10844       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10845       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10846     }
10847   else
10848     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10849   return p;
10850 }
10851
10852 /* Build a special .plt call stub for __tls_get_addr.  */
10853
10854 #define LD_R11_0R3      0xe9630000
10855 #define LD_R12_0R3      0xe9830000
10856 #define MR_R0_R3        0x7c601b78
10857 #define CMPDI_R11_0     0x2c2b0000
10858 #define ADD_R3_R12_R13  0x7c6c6a14
10859 #define BEQLR           0x4d820020
10860 #define MR_R3_R0        0x7c030378
10861 #define STD_R11_0R1     0xf9610000
10862 #define BCTRL           0x4e800421
10863 #define LD_R11_0R1      0xe9610000
10864 #define MTLR_R11        0x7d6803a6
10865
10866 static inline bfd_byte *
10867 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10868                          struct ppc_stub_hash_entry *stub_entry,
10869                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10870 {
10871   bfd *obfd = htab->params->stub_bfd;
10872
10873   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10874   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10875   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10876   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10877   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10878   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10879   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10880   if (r != NULL)
10881     r[0].r_offset += 7 * 4;
10882   if (!ALWAYS_EMIT_R2SAVE
10883       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10884     return build_plt_stub (htab, stub_entry, p, offset, r);
10885
10886   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10887   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10888
10889   if (r != NULL)
10890     r[0].r_offset += 2 * 4;
10891   p = build_plt_stub (htab, stub_entry, p, offset, r);
10892   bfd_put_32 (obfd, BCTRL, p - 4);
10893
10894   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10895   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10896   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10897   bfd_put_32 (obfd, BLR, p),                    p += 4;
10898
10899   return p;
10900 }
10901
10902 static Elf_Internal_Rela *
10903 get_relocs (asection *sec, int count)
10904 {
10905   Elf_Internal_Rela *relocs;
10906   struct bfd_elf_section_data *elfsec_data;
10907
10908   elfsec_data = elf_section_data (sec);
10909   relocs = elfsec_data->relocs;
10910   if (relocs == NULL)
10911     {
10912       bfd_size_type relsize;
10913       relsize = sec->reloc_count * sizeof (*relocs);
10914       relocs = bfd_alloc (sec->owner, relsize);
10915       if (relocs == NULL)
10916         return NULL;
10917       elfsec_data->relocs = relocs;
10918       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10919                                           sizeof (Elf_Internal_Shdr));
10920       if (elfsec_data->rela.hdr == NULL)
10921         return NULL;
10922       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10923                                         * sizeof (Elf64_External_Rela));
10924       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10925       sec->reloc_count = 0;
10926     }
10927   relocs += sec->reloc_count;
10928   sec->reloc_count += count;
10929   return relocs;
10930 }
10931
10932 static bfd_vma
10933 get_r2off (struct bfd_link_info *info,
10934            struct ppc_stub_hash_entry *stub_entry)
10935 {
10936   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10937   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10938
10939   if (r2off == 0)
10940     {
10941       /* Support linking -R objects.  Get the toc pointer from the
10942          opd entry.  */
10943       char buf[8];
10944       if (!htab->opd_abi)
10945         return r2off;
10946       asection *opd = stub_entry->h->elf.root.u.def.section;
10947       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10948
10949       if (strcmp (opd->name, ".opd") != 0
10950           || opd->reloc_count != 0)
10951         {
10952           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
10953                                   stub_entry->h->elf.root.root.string);
10954           bfd_set_error (bfd_error_bad_value);
10955           return (bfd_vma) -1;
10956         }
10957       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10958         return (bfd_vma) -1;
10959       r2off = bfd_get_64 (opd->owner, buf);
10960       r2off -= elf_gp (info->output_bfd);
10961     }
10962   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10963   return r2off;
10964 }
10965
10966 static bfd_boolean
10967 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10968 {
10969   struct ppc_stub_hash_entry *stub_entry;
10970   struct ppc_branch_hash_entry *br_entry;
10971   struct bfd_link_info *info;
10972   struct ppc_link_hash_table *htab;
10973   bfd_byte *loc;
10974   bfd_byte *p;
10975   bfd_vma dest, off;
10976   Elf_Internal_Rela *r;
10977   asection *plt;
10978
10979   /* Massage our args to the form they really have.  */
10980   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10981   info = in_arg;
10982
10983   htab = ppc_hash_table (info);
10984   if (htab == NULL)
10985     return FALSE;
10986
10987   /* Make a note of the offset within the stubs for this entry.  */
10988   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10989   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10990
10991   htab->stub_count[stub_entry->stub_type - 1] += 1;
10992   switch (stub_entry->stub_type)
10993     {
10994     case ppc_stub_long_branch:
10995     case ppc_stub_long_branch_r2off:
10996       /* Branches are relative.  This is where we are going to.  */
10997       dest = (stub_entry->target_value
10998               + stub_entry->target_section->output_offset
10999               + stub_entry->target_section->output_section->vma);
11000       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11001       off = dest;
11002
11003       /* And this is where we are coming from.  */
11004       off -= (stub_entry->stub_offset
11005               + stub_entry->group->stub_sec->output_offset
11006               + stub_entry->group->stub_sec->output_section->vma);
11007
11008       p = loc;
11009       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11010         {
11011           bfd_vma r2off = get_r2off (info, stub_entry);
11012
11013           if (r2off == (bfd_vma) -1)
11014             {
11015               htab->stub_error = TRUE;
11016               return FALSE;
11017             }
11018           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11019           p += 4;
11020           if (PPC_HA (r2off) != 0)
11021             {
11022               bfd_put_32 (htab->params->stub_bfd,
11023                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11024               p += 4;
11025             }
11026           if (PPC_LO (r2off) != 0)
11027             {
11028               bfd_put_32 (htab->params->stub_bfd,
11029                           ADDI_R2_R2 | PPC_LO (r2off), p);
11030               p += 4;
11031             }
11032           off -= p - loc;
11033         }
11034       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11035       p += 4;
11036
11037       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11038         {
11039           _bfd_error_handler
11040             (_("long branch stub `%s' offset overflow"),
11041              stub_entry->root.string);
11042           htab->stub_error = TRUE;
11043           return FALSE;
11044         }
11045
11046       if (info->emitrelocations)
11047         {
11048           r = get_relocs (stub_entry->group->stub_sec, 1);
11049           if (r == NULL)
11050             return FALSE;
11051           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11052           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11053           r->r_addend = dest;
11054           if (stub_entry->h != NULL)
11055             {
11056               struct elf_link_hash_entry **hashes;
11057               unsigned long symndx;
11058               struct ppc_link_hash_entry *h;
11059
11060               hashes = elf_sym_hashes (htab->params->stub_bfd);
11061               if (hashes == NULL)
11062                 {
11063                   bfd_size_type hsize;
11064
11065                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11066                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11067                   if (hashes == NULL)
11068                     return FALSE;
11069                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11070                   htab->stub_globals = 1;
11071                 }
11072               symndx = htab->stub_globals++;
11073               h = stub_entry->h;
11074               hashes[symndx] = &h->elf;
11075               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11076               if (h->oh != NULL && h->oh->is_func)
11077                 h = ppc_follow_link (h->oh);
11078               if (h->elf.root.u.def.section != stub_entry->target_section)
11079                 /* H is an opd symbol.  The addend must be zero.  */
11080                 r->r_addend = 0;
11081               else
11082                 {
11083                   off = (h->elf.root.u.def.value
11084                          + h->elf.root.u.def.section->output_offset
11085                          + h->elf.root.u.def.section->output_section->vma);
11086                   r->r_addend -= off;
11087                 }
11088             }
11089         }
11090       break;
11091
11092     case ppc_stub_plt_branch:
11093     case ppc_stub_plt_branch_r2off:
11094       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11095                                          stub_entry->root.string + 9,
11096                                          FALSE, FALSE);
11097       if (br_entry == NULL)
11098         {
11099           _bfd_error_handler (_("can't find branch stub `%s'"),
11100                               stub_entry->root.string);
11101           htab->stub_error = TRUE;
11102           return FALSE;
11103         }
11104
11105       dest = (stub_entry->target_value
11106               + stub_entry->target_section->output_offset
11107               + stub_entry->target_section->output_section->vma);
11108       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11109         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11110
11111       bfd_put_64 (htab->brlt->owner, dest,
11112                   htab->brlt->contents + br_entry->offset);
11113
11114       if (br_entry->iter == htab->stub_iteration)
11115         {
11116           br_entry->iter = 0;
11117
11118           if (htab->relbrlt != NULL)
11119             {
11120               /* Create a reloc for the branch lookup table entry.  */
11121               Elf_Internal_Rela rela;
11122               bfd_byte *rl;
11123
11124               rela.r_offset = (br_entry->offset
11125                                + htab->brlt->output_offset
11126                                + htab->brlt->output_section->vma);
11127               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11128               rela.r_addend = dest;
11129
11130               rl = htab->relbrlt->contents;
11131               rl += (htab->relbrlt->reloc_count++
11132                      * sizeof (Elf64_External_Rela));
11133               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11134             }
11135           else if (info->emitrelocations)
11136             {
11137               r = get_relocs (htab->brlt, 1);
11138               if (r == NULL)
11139                 return FALSE;
11140               /* brlt, being SEC_LINKER_CREATED does not go through the
11141                  normal reloc processing.  Symbols and offsets are not
11142                  translated from input file to output file form, so
11143                  set up the offset per the output file.  */
11144               r->r_offset = (br_entry->offset
11145                              + htab->brlt->output_offset
11146                              + htab->brlt->output_section->vma);
11147               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11148               r->r_addend = dest;
11149             }
11150         }
11151
11152       dest = (br_entry->offset
11153               + htab->brlt->output_offset
11154               + htab->brlt->output_section->vma);
11155
11156       off = (dest
11157              - elf_gp (info->output_bfd)
11158              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11159
11160       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11161         {
11162           info->callbacks->einfo
11163             (_("%P: linkage table error against `%pT'\n"),
11164              stub_entry->root.string);
11165           bfd_set_error (bfd_error_bad_value);
11166           htab->stub_error = TRUE;
11167           return FALSE;
11168         }
11169
11170       if (info->emitrelocations)
11171         {
11172           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11173           if (r == NULL)
11174             return FALSE;
11175           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11176           if (bfd_big_endian (info->output_bfd))
11177             r[0].r_offset += 2;
11178           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11179             r[0].r_offset += 4;
11180           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11181           r[0].r_addend = dest;
11182           if (PPC_HA (off) != 0)
11183             {
11184               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11185               r[1].r_offset = r[0].r_offset + 4;
11186               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11187               r[1].r_addend = r[0].r_addend;
11188             }
11189         }
11190
11191       p = loc;
11192       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11193         {
11194           if (PPC_HA (off) != 0)
11195             {
11196               bfd_put_32 (htab->params->stub_bfd,
11197                           ADDIS_R12_R2 | PPC_HA (off), p);
11198               p += 4;
11199               bfd_put_32 (htab->params->stub_bfd,
11200                           LD_R12_0R12 | PPC_LO (off), p);
11201             }
11202           else
11203             bfd_put_32 (htab->params->stub_bfd,
11204                         LD_R12_0R2 | PPC_LO (off), p);
11205         }
11206       else
11207         {
11208           bfd_vma r2off = get_r2off (info, stub_entry);
11209
11210           if (r2off == (bfd_vma) -1)
11211             {
11212               htab->stub_error = TRUE;
11213               return FALSE;
11214             }
11215
11216           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11217           p += 4;
11218           if (PPC_HA (off) != 0)
11219             {
11220               bfd_put_32 (htab->params->stub_bfd,
11221                           ADDIS_R12_R2 | PPC_HA (off), p);
11222               p += 4;
11223               bfd_put_32 (htab->params->stub_bfd,
11224                           LD_R12_0R12 | PPC_LO (off), p);
11225             }
11226           else
11227             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11228
11229           if (PPC_HA (r2off) != 0)
11230             {
11231               p += 4;
11232               bfd_put_32 (htab->params->stub_bfd,
11233                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11234             }
11235           if (PPC_LO (r2off) != 0)
11236             {
11237               p += 4;
11238               bfd_put_32 (htab->params->stub_bfd,
11239                           ADDI_R2_R2 | PPC_LO (r2off), p);
11240             }
11241         }
11242       p += 4;
11243       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11244       p += 4;
11245       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11246       p += 4;
11247       break;
11248
11249     case ppc_stub_plt_call:
11250     case ppc_stub_plt_call_r2save:
11251       if (stub_entry->h != NULL
11252           && stub_entry->h->is_func_descriptor
11253           && stub_entry->h->oh != NULL)
11254         {
11255           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11256
11257           /* If the old-ABI "dot-symbol" is undefined make it weak so
11258              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11259           if (fh->elf.root.type == bfd_link_hash_undefined
11260               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11261                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11262             fh->elf.root.type = bfd_link_hash_undefweak;
11263         }
11264
11265       /* Now build the stub.  */
11266       dest = stub_entry->plt_ent->plt.offset & ~1;
11267       if (dest >= (bfd_vma) -2)
11268         abort ();
11269
11270       plt = htab->elf.splt;
11271       if (!htab->elf.dynamic_sections_created
11272           || stub_entry->h == NULL
11273           || stub_entry->h->elf.dynindx == -1)
11274         {
11275           if (stub_entry->symtype == STT_GNU_IFUNC)
11276             plt = htab->elf.iplt;
11277           else
11278             plt = htab->pltlocal;
11279         }
11280
11281       dest += plt->output_offset + plt->output_section->vma;
11282
11283       off = (dest
11284              - elf_gp (info->output_bfd)
11285              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11286
11287       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11288         {
11289           info->callbacks->einfo
11290             /* xgettext:c-format */
11291             (_("%P: linkage table error against `%pT'\n"),
11292              stub_entry->h != NULL
11293              ? stub_entry->h->elf.root.root.string
11294              : "<local sym>");
11295           bfd_set_error (bfd_error_bad_value);
11296           htab->stub_error = TRUE;
11297           return FALSE;
11298         }
11299
11300       if (htab->params->plt_stub_align != 0)
11301         {
11302           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11303
11304           stub_entry->group->stub_sec->size += pad;
11305           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11306           loc += pad;
11307         }
11308
11309       r = NULL;
11310       if (info->emitrelocations)
11311         {
11312           r = get_relocs (stub_entry->group->stub_sec,
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           if (r == NULL)
11319             return FALSE;
11320           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11321           if (bfd_big_endian (info->output_bfd))
11322             r[0].r_offset += 2;
11323           r[0].r_addend = dest;
11324         }
11325       if (stub_entry->h != NULL
11326           && (stub_entry->h == htab->tls_get_addr_fd
11327               || stub_entry->h == htab->tls_get_addr)
11328           && htab->params->tls_get_addr_opt)
11329         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11330       else
11331         p = build_plt_stub (htab, stub_entry, loc, off, r);
11332       break;
11333
11334     case ppc_stub_save_res:
11335       return TRUE;
11336
11337     default:
11338       BFD_FAIL ();
11339       return FALSE;
11340     }
11341
11342   stub_entry->group->stub_sec->size += p - loc;
11343
11344   if (htab->params->emit_stub_syms)
11345     {
11346       struct elf_link_hash_entry *h;
11347       size_t len1, len2;
11348       char *name;
11349       const char *const stub_str[] = { "long_branch",
11350                                        "long_branch_r2off",
11351                                        "plt_branch",
11352                                        "plt_branch_r2off",
11353                                        "plt_call",
11354                                        "plt_call" };
11355
11356       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11357       len2 = strlen (stub_entry->root.string);
11358       name = bfd_malloc (len1 + len2 + 2);
11359       if (name == NULL)
11360         return FALSE;
11361       memcpy (name, stub_entry->root.string, 9);
11362       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11363       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11364       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11365       if (h == NULL)
11366         return FALSE;
11367       if (h->root.type == bfd_link_hash_new)
11368         {
11369           h->root.type = bfd_link_hash_defined;
11370           h->root.u.def.section = stub_entry->group->stub_sec;
11371           h->root.u.def.value = stub_entry->stub_offset;
11372           h->ref_regular = 1;
11373           h->def_regular = 1;
11374           h->ref_regular_nonweak = 1;
11375           h->forced_local = 1;
11376           h->non_elf = 0;
11377           h->root.linker_def = 1;
11378         }
11379     }
11380
11381   return TRUE;
11382 }
11383
11384 /* As above, but don't actually build the stub.  Just bump offset so
11385    we know stub section sizes, and select plt_branch stubs where
11386    long_branch stubs won't do.  */
11387
11388 static bfd_boolean
11389 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11390 {
11391   struct ppc_stub_hash_entry *stub_entry;
11392   struct bfd_link_info *info;
11393   struct ppc_link_hash_table *htab;
11394   bfd_vma off;
11395   int size;
11396
11397   /* Massage our args to the form they really have.  */
11398   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11399   info = in_arg;
11400
11401   htab = ppc_hash_table (info);
11402   if (htab == NULL)
11403     return FALSE;
11404
11405   if (stub_entry->h != NULL
11406       && stub_entry->h->save_res
11407       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11408       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11409     {
11410       /* Don't make stubs to out-of-line register save/restore
11411          functions.  Instead, emit copies of the functions.  */
11412       stub_entry->group->needs_save_res = 1;
11413       stub_entry->stub_type = ppc_stub_save_res;
11414       return TRUE;
11415     }
11416
11417   if (stub_entry->stub_type == ppc_stub_plt_call
11418       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11419     {
11420       asection *plt;
11421       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11422       if (off >= (bfd_vma) -2)
11423         abort ();
11424       plt = htab->elf.splt;
11425       if (!htab->elf.dynamic_sections_created
11426           || stub_entry->h == NULL
11427           || stub_entry->h->elf.dynindx == -1)
11428         {
11429           if (stub_entry->symtype == STT_GNU_IFUNC)
11430             plt = htab->elf.iplt;
11431           else
11432             plt = htab->pltlocal;
11433         }
11434       off += (plt->output_offset
11435               + plt->output_section->vma
11436               - elf_gp (info->output_bfd)
11437               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11438
11439       size = plt_stub_size (htab, stub_entry, off);
11440       if (stub_entry->h != NULL
11441           && (stub_entry->h == htab->tls_get_addr_fd
11442               || stub_entry->h == htab->tls_get_addr)
11443           && htab->params->tls_get_addr_opt
11444           && (ALWAYS_EMIT_R2SAVE
11445               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11446         stub_entry->group->tls_get_addr_opt_bctrl
11447           = stub_entry->group->stub_sec->size + size - 5 * 4;
11448
11449       if (htab->params->plt_stub_align)
11450         size += plt_stub_pad (htab, stub_entry, off);
11451       if (info->emitrelocations)
11452         {
11453           stub_entry->group->stub_sec->reloc_count
11454             += ((PPC_HA (off) != 0)
11455                 + (htab->opd_abi
11456                    ? 2 + (htab->params->plt_static_chain
11457                           && PPC_HA (off + 16) == PPC_HA (off))
11458                    : 1));
11459           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11460         }
11461     }
11462   else
11463     {
11464       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11465          variants.  */
11466       bfd_vma r2off = 0;
11467       bfd_vma local_off = 0;
11468
11469       off = (stub_entry->target_value
11470              + stub_entry->target_section->output_offset
11471              + stub_entry->target_section->output_section->vma);
11472       off -= (stub_entry->group->stub_sec->size
11473               + stub_entry->group->stub_sec->output_offset
11474               + stub_entry->group->stub_sec->output_section->vma);
11475
11476       /* Reset the stub type from the plt variant in case we now
11477          can reach with a shorter stub.  */
11478       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11479         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11480
11481       size = 4;
11482       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11483         {
11484           r2off = get_r2off (info, stub_entry);
11485           if (r2off == (bfd_vma) -1)
11486             {
11487               htab->stub_error = TRUE;
11488               return FALSE;
11489             }
11490           size = 8;
11491           if (PPC_HA (r2off) != 0)
11492             size += 4;
11493           if (PPC_LO (r2off) != 0)
11494             size += 4;
11495           off -= size - 4;
11496         }
11497
11498       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11499
11500       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11501          Do the same for -R objects without function descriptors.  */
11502       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11503           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11504               && r2off == 0
11505               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11506         {
11507           struct ppc_branch_hash_entry *br_entry;
11508
11509           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11510                                              stub_entry->root.string + 9,
11511                                              TRUE, FALSE);
11512           if (br_entry == NULL)
11513             {
11514               _bfd_error_handler (_("can't build branch stub `%s'"),
11515                                   stub_entry->root.string);
11516               htab->stub_error = TRUE;
11517               return FALSE;
11518             }
11519
11520           if (br_entry->iter != htab->stub_iteration)
11521             {
11522               br_entry->iter = htab->stub_iteration;
11523               br_entry->offset = htab->brlt->size;
11524               htab->brlt->size += 8;
11525
11526               if (htab->relbrlt != NULL)
11527                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11528               else if (info->emitrelocations)
11529                 {
11530                   htab->brlt->reloc_count += 1;
11531                   htab->brlt->flags |= SEC_RELOC;
11532                 }
11533             }
11534
11535           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11536           off = (br_entry->offset
11537                  + htab->brlt->output_offset
11538                  + htab->brlt->output_section->vma
11539                  - elf_gp (info->output_bfd)
11540                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11541
11542           if (info->emitrelocations)
11543             {
11544               stub_entry->group->stub_sec->reloc_count
11545                 += 1 + (PPC_HA (off) != 0);
11546               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11547             }
11548
11549           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11550             {
11551               size = 12;
11552               if (PPC_HA (off) != 0)
11553                 size = 16;
11554             }
11555           else
11556             {
11557               size = 16;
11558               if (PPC_HA (off) != 0)
11559                 size += 4;
11560
11561               if (PPC_HA (r2off) != 0)
11562                 size += 4;
11563               if (PPC_LO (r2off) != 0)
11564                 size += 4;
11565             }
11566         }
11567       else if (info->emitrelocations)
11568         {
11569           stub_entry->group->stub_sec->reloc_count += 1;
11570           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11571         }
11572     }
11573
11574   stub_entry->group->stub_sec->size += size;
11575   return TRUE;
11576 }
11577
11578 /* Set up various things so that we can make a list of input sections
11579    for each output section included in the link.  Returns -1 on error,
11580    0 when no stubs will be needed, and 1 on success.  */
11581
11582 int
11583 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11584 {
11585   unsigned int id;
11586   bfd_size_type amt;
11587   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11588
11589   if (htab == NULL)
11590     return -1;
11591
11592   htab->sec_info_arr_size = bfd_get_next_section_id ();
11593   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11594   htab->sec_info = bfd_zmalloc (amt);
11595   if (htab->sec_info == NULL)
11596     return -1;
11597
11598   /* Set toc_off for com, und, abs and ind sections.  */
11599   for (id = 0; id < 3; id++)
11600     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11601
11602   return 1;
11603 }
11604
11605 /* Set up for first pass at multitoc partitioning.  */
11606
11607 void
11608 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11609 {
11610   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11611
11612   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11613   htab->toc_bfd = NULL;
11614   htab->toc_first_sec = NULL;
11615 }
11616
11617 /* The linker repeatedly calls this function for each TOC input section
11618    and linker generated GOT section.  Group input bfds such that the toc
11619    within a group is less than 64k in size.  */
11620
11621 bfd_boolean
11622 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11623 {
11624   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11625   bfd_vma addr, off, limit;
11626
11627   if (htab == NULL)
11628     return FALSE;
11629
11630   if (!htab->second_toc_pass)
11631     {
11632       /* Keep track of the first .toc or .got section for this input bfd.  */
11633       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11634
11635       if (new_bfd)
11636         {
11637           htab->toc_bfd = isec->owner;
11638           htab->toc_first_sec = isec;
11639         }
11640
11641       addr = isec->output_offset + isec->output_section->vma;
11642       off = addr - htab->toc_curr;
11643       limit = 0x80008000;
11644       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11645         limit = 0x10000;
11646       if (off + isec->size > limit)
11647         {
11648           addr = (htab->toc_first_sec->output_offset
11649                   + htab->toc_first_sec->output_section->vma);
11650           htab->toc_curr = addr;
11651           htab->toc_curr &= -TOC_BASE_ALIGN;
11652         }
11653
11654       /* toc_curr is the base address of this toc group.  Set elf_gp
11655          for the input section to be the offset relative to the
11656          output toc base plus 0x8000.  Making the input elf_gp an
11657          offset allows us to move the toc as a whole without
11658          recalculating input elf_gp.  */
11659       off = htab->toc_curr - elf_gp (info->output_bfd);
11660       off += TOC_BASE_OFF;
11661
11662       /* Die if someone uses a linker script that doesn't keep input
11663          file .toc and .got together.  */
11664       if (new_bfd
11665           && elf_gp (isec->owner) != 0
11666           && elf_gp (isec->owner) != off)
11667         return FALSE;
11668
11669       elf_gp (isec->owner) = off;
11670       return TRUE;
11671     }
11672
11673   /* During the second pass toc_first_sec points to the start of
11674      a toc group, and toc_curr is used to track the old elf_gp.
11675      We use toc_bfd to ensure we only look at each bfd once.  */
11676   if (htab->toc_bfd == isec->owner)
11677     return TRUE;
11678   htab->toc_bfd = isec->owner;
11679
11680   if (htab->toc_first_sec == NULL
11681       || htab->toc_curr != elf_gp (isec->owner))
11682     {
11683       htab->toc_curr = elf_gp (isec->owner);
11684       htab->toc_first_sec = isec;
11685     }
11686   addr = (htab->toc_first_sec->output_offset
11687           + htab->toc_first_sec->output_section->vma);
11688   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11689   elf_gp (isec->owner) = off;
11690
11691   return TRUE;
11692 }
11693
11694 /* Called via elf_link_hash_traverse to merge GOT entries for global
11695    symbol H.  */
11696
11697 static bfd_boolean
11698 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11699 {
11700   if (h->root.type == bfd_link_hash_indirect)
11701     return TRUE;
11702
11703   merge_got_entries (&h->got.glist);
11704
11705   return TRUE;
11706 }
11707
11708 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11709    symbol H.  */
11710
11711 static bfd_boolean
11712 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11713 {
11714   struct got_entry *gent;
11715
11716   if (h->root.type == bfd_link_hash_indirect)
11717     return TRUE;
11718
11719   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11720     if (!gent->is_indirect)
11721       allocate_got (h, (struct bfd_link_info *) inf, gent);
11722   return TRUE;
11723 }
11724
11725 /* Called on the first multitoc pass after the last call to
11726    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11727    entries.  */
11728
11729 bfd_boolean
11730 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11731 {
11732   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11733   struct bfd *ibfd, *ibfd2;
11734   bfd_boolean done_something;
11735
11736   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11737
11738   if (!htab->do_multi_toc)
11739     return FALSE;
11740
11741   /* Merge global sym got entries within a toc group.  */
11742   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11743
11744   /* And tlsld_got.  */
11745   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11746     {
11747       struct got_entry *ent, *ent2;
11748
11749       if (!is_ppc64_elf (ibfd))
11750         continue;
11751
11752       ent = ppc64_tlsld_got (ibfd);
11753       if (!ent->is_indirect
11754           && ent->got.offset != (bfd_vma) -1)
11755         {
11756           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11757             {
11758               if (!is_ppc64_elf (ibfd2))
11759                 continue;
11760
11761               ent2 = ppc64_tlsld_got (ibfd2);
11762               if (!ent2->is_indirect
11763                   && ent2->got.offset != (bfd_vma) -1
11764                   && elf_gp (ibfd2) == elf_gp (ibfd))
11765                 {
11766                   ent2->is_indirect = TRUE;
11767                   ent2->got.ent = ent;
11768                 }
11769             }
11770         }
11771     }
11772
11773   /* Zap sizes of got sections.  */
11774   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11775   htab->elf.irelplt->size -= htab->got_reli_size;
11776   htab->got_reli_size = 0;
11777
11778   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11779     {
11780       asection *got, *relgot;
11781
11782       if (!is_ppc64_elf (ibfd))
11783         continue;
11784
11785       got = ppc64_elf_tdata (ibfd)->got;
11786       if (got != NULL)
11787         {
11788           got->rawsize = got->size;
11789           got->size = 0;
11790           relgot = ppc64_elf_tdata (ibfd)->relgot;
11791           relgot->rawsize = relgot->size;
11792           relgot->size = 0;
11793         }
11794     }
11795
11796   /* Now reallocate the got, local syms first.  We don't need to
11797      allocate section contents again since we never increase size.  */
11798   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11799     {
11800       struct got_entry **lgot_ents;
11801       struct got_entry **end_lgot_ents;
11802       struct plt_entry **local_plt;
11803       struct plt_entry **end_local_plt;
11804       unsigned char *lgot_masks;
11805       bfd_size_type locsymcount;
11806       Elf_Internal_Shdr *symtab_hdr;
11807       asection *s;
11808
11809       if (!is_ppc64_elf (ibfd))
11810         continue;
11811
11812       lgot_ents = elf_local_got_ents (ibfd);
11813       if (!lgot_ents)
11814         continue;
11815
11816       symtab_hdr = &elf_symtab_hdr (ibfd);
11817       locsymcount = symtab_hdr->sh_info;
11818       end_lgot_ents = lgot_ents + locsymcount;
11819       local_plt = (struct plt_entry **) end_lgot_ents;
11820       end_local_plt = local_plt + locsymcount;
11821       lgot_masks = (unsigned char *) end_local_plt;
11822       s = ppc64_elf_tdata (ibfd)->got;
11823       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11824         {
11825           struct got_entry *ent;
11826
11827           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11828             {
11829               unsigned int ent_size = 8;
11830               unsigned int rel_size = sizeof (Elf64_External_Rela);
11831
11832               ent->got.offset = s->size;
11833               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11834                 {
11835                   ent_size *= 2;
11836                   rel_size *= 2;
11837                 }
11838               s->size += ent_size;
11839               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
11840                 {
11841                   htab->elf.irelplt->size += rel_size;
11842                   htab->got_reli_size += rel_size;
11843                 }
11844               else if (bfd_link_pic (info)
11845                        && !((ent->tls_type & TLS_TPREL) != 0
11846                             && bfd_link_executable (info)))
11847                 {
11848                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11849                   srel->size += rel_size;
11850                 }
11851             }
11852         }
11853     }
11854
11855   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11856
11857   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11858     {
11859       struct got_entry *ent;
11860
11861       if (!is_ppc64_elf (ibfd))
11862         continue;
11863
11864       ent = ppc64_tlsld_got (ibfd);
11865       if (!ent->is_indirect
11866           && ent->got.offset != (bfd_vma) -1)
11867         {
11868           asection *s = ppc64_elf_tdata (ibfd)->got;
11869           ent->got.offset = s->size;
11870           s->size += 16;
11871           if (bfd_link_pic (info))
11872             {
11873               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11874               srel->size += sizeof (Elf64_External_Rela);
11875             }
11876         }
11877     }
11878
11879   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11880   if (!done_something)
11881     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11882       {
11883         asection *got;
11884
11885         if (!is_ppc64_elf (ibfd))
11886           continue;
11887
11888         got = ppc64_elf_tdata (ibfd)->got;
11889         if (got != NULL)
11890           {
11891             done_something = got->rawsize != got->size;
11892             if (done_something)
11893               break;
11894           }
11895       }
11896
11897   if (done_something)
11898     (*htab->params->layout_sections_again) ();
11899
11900   /* Set up for second pass over toc sections to recalculate elf_gp
11901      on input sections.  */
11902   htab->toc_bfd = NULL;
11903   htab->toc_first_sec = NULL;
11904   htab->second_toc_pass = TRUE;
11905   return done_something;
11906 }
11907
11908 /* Called after second pass of multitoc partitioning.  */
11909
11910 void
11911 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11912 {
11913   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11914
11915   /* After the second pass, toc_curr tracks the TOC offset used
11916      for code sections below in ppc64_elf_next_input_section.  */
11917   htab->toc_curr = TOC_BASE_OFF;
11918 }
11919
11920 /* No toc references were found in ISEC.  If the code in ISEC makes no
11921    calls, then there's no need to use toc adjusting stubs when branching
11922    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11923    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11924    needed, and 2 if a cyclical call-graph was found but no other reason
11925    for a stub was detected.  If called from the top level, a return of
11926    2 means the same as a return of 0.  */
11927
11928 static int
11929 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11930 {
11931   int ret;
11932
11933   /* Mark this section as checked.  */
11934   isec->call_check_done = 1;
11935
11936   /* We know none of our code bearing sections will need toc stubs.  */
11937   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11938     return 0;
11939
11940   if (isec->size == 0)
11941     return 0;
11942
11943   if (isec->output_section == NULL)
11944     return 0;
11945
11946   ret = 0;
11947   if (isec->reloc_count != 0)
11948     {
11949       Elf_Internal_Rela *relstart, *rel;
11950       Elf_Internal_Sym *local_syms;
11951       struct ppc_link_hash_table *htab;
11952
11953       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11954                                             info->keep_memory);
11955       if (relstart == NULL)
11956         return -1;
11957
11958       /* Look for branches to outside of this section.  */
11959       local_syms = NULL;
11960       htab = ppc_hash_table (info);
11961       if (htab == NULL)
11962         return -1;
11963
11964       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11965         {
11966           enum elf_ppc64_reloc_type r_type;
11967           unsigned long r_symndx;
11968           struct elf_link_hash_entry *h;
11969           struct ppc_link_hash_entry *eh;
11970           Elf_Internal_Sym *sym;
11971           asection *sym_sec;
11972           struct _opd_sec_data *opd;
11973           bfd_vma sym_value;
11974           bfd_vma dest;
11975
11976           r_type = ELF64_R_TYPE (rel->r_info);
11977           if (r_type != R_PPC64_REL24
11978               && r_type != R_PPC64_REL14
11979               && r_type != R_PPC64_REL14_BRTAKEN
11980               && r_type != R_PPC64_REL14_BRNTAKEN
11981               && r_type != R_PPC64_PLTCALL)
11982             continue;
11983
11984           r_symndx = ELF64_R_SYM (rel->r_info);
11985           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11986                           isec->owner))
11987             {
11988               ret = -1;
11989               break;
11990             }
11991
11992           /* Calls to dynamic lib functions go through a plt call stub
11993              that uses r2.  */
11994           eh = (struct ppc_link_hash_entry *) h;
11995           if (eh != NULL
11996               && (eh->elf.plt.plist != NULL
11997                   || (eh->oh != NULL
11998                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11999             {
12000               ret = 1;
12001               break;
12002             }
12003
12004           if (sym_sec == NULL)
12005             /* Ignore other undefined symbols.  */
12006             continue;
12007
12008           /* Assume branches to other sections not included in the
12009              link need stubs too, to cover -R and absolute syms.  */
12010           if (sym_sec->output_section == NULL)
12011             {
12012               ret = 1;
12013               break;
12014             }
12015
12016           if (h == NULL)
12017             sym_value = sym->st_value;
12018           else
12019             {
12020               if (h->root.type != bfd_link_hash_defined
12021                   && h->root.type != bfd_link_hash_defweak)
12022                 abort ();
12023               sym_value = h->root.u.def.value;
12024             }
12025           sym_value += rel->r_addend;
12026
12027           /* If this branch reloc uses an opd sym, find the code section.  */
12028           opd = get_opd_info (sym_sec);
12029           if (opd != NULL)
12030             {
12031               if (h == NULL && opd->adjust != NULL)
12032                 {
12033                   long adjust;
12034
12035                   adjust = opd->adjust[OPD_NDX (sym_value)];
12036                   if (adjust == -1)
12037                     /* Assume deleted functions won't ever be called.  */
12038                     continue;
12039                   sym_value += adjust;
12040                 }
12041
12042               dest = opd_entry_value (sym_sec, sym_value,
12043                                       &sym_sec, NULL, FALSE);
12044               if (dest == (bfd_vma) -1)
12045                 continue;
12046             }
12047           else
12048             dest = (sym_value
12049                     + sym_sec->output_offset
12050                     + sym_sec->output_section->vma);
12051
12052           /* Ignore branch to self.  */
12053           if (sym_sec == isec)
12054             continue;
12055
12056           /* If the called function uses the toc, we need a stub.  */
12057           if (sym_sec->has_toc_reloc
12058               || sym_sec->makes_toc_func_call)
12059             {
12060               ret = 1;
12061               break;
12062             }
12063
12064           /* Assume any branch that needs a long branch stub might in fact
12065              need a plt_branch stub.  A plt_branch stub uses r2.  */
12066           else if (dest - (isec->output_offset
12067                            + isec->output_section->vma
12068                            + rel->r_offset) + (1 << 25)
12069                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12070                                                              ? h->other
12071                                                              : sym->st_other))
12072             {
12073               ret = 1;
12074               break;
12075             }
12076
12077           /* If calling back to a section in the process of being
12078              tested, we can't say for sure that no toc adjusting stubs
12079              are needed, so don't return zero.  */
12080           else if (sym_sec->call_check_in_progress)
12081             ret = 2;
12082
12083           /* Branches to another section that itself doesn't have any TOC
12084              references are OK.  Recursively call ourselves to check.  */
12085           else if (!sym_sec->call_check_done)
12086             {
12087               int recur;
12088
12089               /* Mark current section as indeterminate, so that other
12090                  sections that call back to current won't be marked as
12091                  known.  */
12092               isec->call_check_in_progress = 1;
12093               recur = toc_adjusting_stub_needed (info, sym_sec);
12094               isec->call_check_in_progress = 0;
12095
12096               if (recur != 0)
12097                 {
12098                   ret = recur;
12099                   if (recur != 2)
12100                     break;
12101                 }
12102             }
12103         }
12104
12105       if (local_syms != NULL
12106           && (elf_symtab_hdr (isec->owner).contents
12107               != (unsigned char *) local_syms))
12108         free (local_syms);
12109       if (elf_section_data (isec)->relocs != relstart)
12110         free (relstart);
12111     }
12112
12113   if ((ret & 1) == 0
12114       && isec->map_head.s != NULL
12115       && (strcmp (isec->output_section->name, ".init") == 0
12116           || strcmp (isec->output_section->name, ".fini") == 0))
12117     {
12118       if (isec->map_head.s->has_toc_reloc
12119           || isec->map_head.s->makes_toc_func_call)
12120         ret = 1;
12121       else if (!isec->map_head.s->call_check_done)
12122         {
12123           int recur;
12124           isec->call_check_in_progress = 1;
12125           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12126           isec->call_check_in_progress = 0;
12127           if (recur != 0)
12128             ret = recur;
12129         }
12130     }
12131
12132   if (ret == 1)
12133     isec->makes_toc_func_call = 1;
12134
12135   return ret;
12136 }
12137
12138 /* The linker repeatedly calls this function for each input section,
12139    in the order that input sections are linked into output sections.
12140    Build lists of input sections to determine groupings between which
12141    we may insert linker stubs.  */
12142
12143 bfd_boolean
12144 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12145 {
12146   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12147
12148   if (htab == NULL)
12149     return FALSE;
12150
12151   if ((isec->output_section->flags & SEC_CODE) != 0
12152       && isec->output_section->id < htab->sec_info_arr_size)
12153     {
12154       /* This happens to make the list in reverse order,
12155          which is what we want.  */
12156       htab->sec_info[isec->id].u.list
12157         = htab->sec_info[isec->output_section->id].u.list;
12158       htab->sec_info[isec->output_section->id].u.list = isec;
12159     }
12160
12161   if (htab->multi_toc_needed)
12162     {
12163       /* Analyse sections that aren't already flagged as needing a
12164          valid toc pointer.  Exclude .fixup for the linux kernel.
12165          .fixup contains branches, but only back to the function that
12166          hit an exception.  */
12167       if (!(isec->has_toc_reloc
12168             || (isec->flags & SEC_CODE) == 0
12169             || strcmp (isec->name, ".fixup") == 0
12170             || isec->call_check_done))
12171         {
12172           if (toc_adjusting_stub_needed (info, isec) < 0)
12173             return FALSE;
12174         }
12175       /* Make all sections use the TOC assigned for this object file.
12176          This will be wrong for pasted sections;  We fix that in
12177          check_pasted_section().  */
12178       if (elf_gp (isec->owner) != 0)
12179         htab->toc_curr = elf_gp (isec->owner);
12180     }
12181
12182   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12183   return TRUE;
12184 }
12185
12186 /* Check that all .init and .fini sections use the same toc, if they
12187    have toc relocs.  */
12188
12189 static bfd_boolean
12190 check_pasted_section (struct bfd_link_info *info, const char *name)
12191 {
12192   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12193
12194   if (o != NULL)
12195     {
12196       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12197       bfd_vma toc_off = 0;
12198       asection *i;
12199
12200       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12201         if (i->has_toc_reloc)
12202           {
12203             if (toc_off == 0)
12204               toc_off = htab->sec_info[i->id].toc_off;
12205             else if (toc_off != htab->sec_info[i->id].toc_off)
12206               return FALSE;
12207           }
12208
12209       if (toc_off == 0)
12210         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12211           if (i->makes_toc_func_call)
12212             {
12213               toc_off = htab->sec_info[i->id].toc_off;
12214               break;
12215             }
12216
12217       /* Make sure the whole pasted function uses the same toc offset.  */
12218       if (toc_off != 0)
12219         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12220           htab->sec_info[i->id].toc_off = toc_off;
12221     }
12222   return TRUE;
12223 }
12224
12225 bfd_boolean
12226 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12227 {
12228   return (check_pasted_section (info, ".init")
12229           & check_pasted_section (info, ".fini"));
12230 }
12231
12232 /* See whether we can group stub sections together.  Grouping stub
12233    sections may result in fewer stubs.  More importantly, we need to
12234    put all .init* and .fini* stubs at the beginning of the .init or
12235    .fini output sections respectively, because glibc splits the
12236    _init and _fini functions into multiple parts.  Putting a stub in
12237    the middle of a function is not a good idea.  */
12238
12239 static bfd_boolean
12240 group_sections (struct bfd_link_info *info,
12241                 bfd_size_type stub_group_size,
12242                 bfd_boolean stubs_always_before_branch)
12243 {
12244   struct ppc_link_hash_table *htab;
12245   asection *osec;
12246   bfd_boolean suppress_size_errors;
12247
12248   htab = ppc_hash_table (info);
12249   if (htab == NULL)
12250     return FALSE;
12251
12252   suppress_size_errors = FALSE;
12253   if (stub_group_size == 1)
12254     {
12255       /* Default values.  */
12256       if (stubs_always_before_branch)
12257         stub_group_size = 0x1e00000;
12258       else
12259         stub_group_size = 0x1c00000;
12260       suppress_size_errors = TRUE;
12261     }
12262
12263   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12264     {
12265       asection *tail;
12266
12267       if (osec->id >= htab->sec_info_arr_size)
12268         continue;
12269
12270       tail = htab->sec_info[osec->id].u.list;
12271       while (tail != NULL)
12272         {
12273           asection *curr;
12274           asection *prev;
12275           bfd_size_type total;
12276           bfd_boolean big_sec;
12277           bfd_vma curr_toc;
12278           struct map_stub *group;
12279           bfd_size_type group_size;
12280
12281           curr = tail;
12282           total = tail->size;
12283           group_size = (ppc64_elf_section_data (tail) != NULL
12284                         && ppc64_elf_section_data (tail)->has_14bit_branch
12285                         ? stub_group_size >> 10 : stub_group_size);
12286
12287           big_sec = total > group_size;
12288           if (big_sec && !suppress_size_errors)
12289             /* xgettext:c-format */
12290             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12291                                 tail->owner, tail);
12292           curr_toc = htab->sec_info[tail->id].toc_off;
12293
12294           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12295                  && ((total += curr->output_offset - prev->output_offset)
12296                      < (ppc64_elf_section_data (prev) != NULL
12297                         && ppc64_elf_section_data (prev)->has_14bit_branch
12298                         ? (group_size = stub_group_size >> 10) : group_size))
12299                  && htab->sec_info[prev->id].toc_off == curr_toc)
12300             curr = prev;
12301
12302           /* OK, the size from the start of CURR to the end is less
12303              than group_size and thus can be handled by one stub
12304              section.  (or the tail section is itself larger than
12305              group_size, in which case we may be toast.)  We should
12306              really be keeping track of the total size of stubs added
12307              here, as stubs contribute to the final output section
12308              size.  That's a little tricky, and this way will only
12309              break if stubs added make the total size more than 2^25,
12310              ie. for the default stub_group_size, if stubs total more
12311              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12312           group = bfd_alloc (curr->owner, sizeof (*group));
12313           if (group == NULL)
12314             return FALSE;
12315           group->link_sec = curr;
12316           group->stub_sec = NULL;
12317           group->needs_save_res = 0;
12318           group->tls_get_addr_opt_bctrl = -1u;
12319           group->next = htab->group;
12320           htab->group = group;
12321           do
12322             {
12323               prev = htab->sec_info[tail->id].u.list;
12324               /* Set up this stub group.  */
12325               htab->sec_info[tail->id].u.group = group;
12326             }
12327           while (tail != curr && (tail = prev) != NULL);
12328
12329           /* But wait, there's more!  Input sections up to group_size
12330              bytes before the stub section can be handled by it too.
12331              Don't do this if we have a really large section after the
12332              stubs, as adding more stubs increases the chance that
12333              branches may not reach into the stub section.  */
12334           if (!stubs_always_before_branch && !big_sec)
12335             {
12336               total = 0;
12337               while (prev != NULL
12338                      && ((total += tail->output_offset - prev->output_offset)
12339                          < (ppc64_elf_section_data (prev) != NULL
12340                             && ppc64_elf_section_data (prev)->has_14bit_branch
12341                             ? (group_size = stub_group_size >> 10) : group_size))
12342                      && htab->sec_info[prev->id].toc_off == curr_toc)
12343                 {
12344                   tail = prev;
12345                   prev = htab->sec_info[tail->id].u.list;
12346                   htab->sec_info[tail->id].u.group = group;
12347                 }
12348             }
12349           tail = prev;
12350         }
12351     }
12352   return TRUE;
12353 }
12354
12355 static const unsigned char glink_eh_frame_cie[] =
12356 {
12357   0, 0, 0, 16,                          /* length.  */
12358   0, 0, 0, 0,                           /* id.  */
12359   1,                                    /* CIE version.  */
12360   'z', 'R', 0,                          /* Augmentation string.  */
12361   4,                                    /* Code alignment.  */
12362   0x78,                                 /* Data alignment.  */
12363   65,                                   /* RA reg.  */
12364   1,                                    /* Augmentation size.  */
12365   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12366   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12367 };
12368
12369 static size_t
12370 stub_eh_frame_size (struct map_stub *group, size_t align)
12371 {
12372   size_t this_size = 17;
12373   if (group->tls_get_addr_opt_bctrl != -1u)
12374     {
12375       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12376       if (to_bctrl < 64)
12377         this_size += 1;
12378       else if (to_bctrl < 256)
12379         this_size += 2;
12380       else if (to_bctrl < 65536)
12381         this_size += 3;
12382       else
12383         this_size += 5;
12384       this_size += 6;
12385     }
12386   this_size = (this_size + align - 1) & -align;
12387   return this_size;
12388 }
12389
12390 /* Stripping output sections is normally done before dynamic section
12391    symbols have been allocated.  This function is called later, and
12392    handles cases like htab->brlt which is mapped to its own output
12393    section.  */
12394
12395 static void
12396 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12397 {
12398   if (isec->size == 0
12399       && isec->output_section->size == 0
12400       && !(isec->output_section->flags & SEC_KEEP)
12401       && !bfd_section_removed_from_list (info->output_bfd,
12402                                          isec->output_section)
12403       && elf_section_data (isec->output_section)->dynindx == 0)
12404     {
12405       isec->output_section->flags |= SEC_EXCLUDE;
12406       bfd_section_list_remove (info->output_bfd, isec->output_section);
12407       info->output_bfd->section_count--;
12408     }
12409 }
12410
12411 /* Determine and set the size of the stub section for a final link.
12412
12413    The basic idea here is to examine all the relocations looking for
12414    PC-relative calls to a target that is unreachable with a "bl"
12415    instruction.  */
12416
12417 bfd_boolean
12418 ppc64_elf_size_stubs (struct bfd_link_info *info)
12419 {
12420   bfd_size_type stub_group_size;
12421   bfd_boolean stubs_always_before_branch;
12422   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12423
12424   if (htab == NULL)
12425     return FALSE;
12426
12427   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12428     htab->params->plt_thread_safe = 1;
12429   if (!htab->opd_abi)
12430     htab->params->plt_thread_safe = 0;
12431   else if (htab->params->plt_thread_safe == -1)
12432     {
12433       static const char *const thread_starter[] =
12434         {
12435           "pthread_create",
12436           /* libstdc++ */
12437           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12438           /* librt */
12439           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12440           "mq_notify", "create_timer",
12441           /* libanl */
12442           "getaddrinfo_a",
12443           /* libgomp */
12444           "GOMP_parallel",
12445           "GOMP_parallel_start",
12446           "GOMP_parallel_loop_static",
12447           "GOMP_parallel_loop_static_start",
12448           "GOMP_parallel_loop_dynamic",
12449           "GOMP_parallel_loop_dynamic_start",
12450           "GOMP_parallel_loop_guided",
12451           "GOMP_parallel_loop_guided_start",
12452           "GOMP_parallel_loop_runtime",
12453           "GOMP_parallel_loop_runtime_start",
12454           "GOMP_parallel_sections",
12455           "GOMP_parallel_sections_start",
12456           /* libgo */
12457           "__go_go",
12458         };
12459       unsigned i;
12460
12461       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12462         {
12463           struct elf_link_hash_entry *h;
12464           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12465                                     FALSE, FALSE, TRUE);
12466           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12467           if (htab->params->plt_thread_safe)
12468             break;
12469         }
12470     }
12471   stubs_always_before_branch = htab->params->group_size < 0;
12472   if (htab->params->group_size < 0)
12473     stub_group_size = -htab->params->group_size;
12474   else
12475     stub_group_size = htab->params->group_size;
12476
12477   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12478     return FALSE;
12479
12480 #define STUB_SHRINK_ITER 20
12481   /* Loop until no stubs added.  After iteration 20 of this loop we may
12482      exit on a stub section shrinking.  This is to break out of a
12483      pathological case where adding stubs on one iteration decreases
12484      section gaps (perhaps due to alignment), which then requires
12485      fewer or smaller stubs on the next iteration.  */
12486
12487   while (1)
12488     {
12489       bfd *input_bfd;
12490       unsigned int bfd_indx;
12491       struct map_stub *group;
12492
12493       htab->stub_iteration += 1;
12494
12495       for (input_bfd = info->input_bfds, bfd_indx = 0;
12496            input_bfd != NULL;
12497            input_bfd = input_bfd->link.next, bfd_indx++)
12498         {
12499           Elf_Internal_Shdr *symtab_hdr;
12500           asection *section;
12501           Elf_Internal_Sym *local_syms = NULL;
12502
12503           if (!is_ppc64_elf (input_bfd))
12504             continue;
12505
12506           /* We'll need the symbol table in a second.  */
12507           symtab_hdr = &elf_symtab_hdr (input_bfd);
12508           if (symtab_hdr->sh_info == 0)
12509             continue;
12510
12511           /* Walk over each section attached to the input bfd.  */
12512           for (section = input_bfd->sections;
12513                section != NULL;
12514                section = section->next)
12515             {
12516               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12517
12518               /* If there aren't any relocs, then there's nothing more
12519                  to do.  */
12520               if ((section->flags & SEC_RELOC) == 0
12521                   || (section->flags & SEC_ALLOC) == 0
12522                   || (section->flags & SEC_LOAD) == 0
12523                   || (section->flags & SEC_CODE) == 0
12524                   || section->reloc_count == 0)
12525                 continue;
12526
12527               /* If this section is a link-once section that will be
12528                  discarded, then don't create any stubs.  */
12529               if (section->output_section == NULL
12530                   || section->output_section->owner != info->output_bfd)
12531                 continue;
12532
12533               /* Get the relocs.  */
12534               internal_relocs
12535                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12536                                              info->keep_memory);
12537               if (internal_relocs == NULL)
12538                 goto error_ret_free_local;
12539
12540               /* Now examine each relocation.  */
12541               irela = internal_relocs;
12542               irelaend = irela + section->reloc_count;
12543               for (; irela < irelaend; irela++)
12544                 {
12545                   enum elf_ppc64_reloc_type r_type;
12546                   unsigned int r_indx;
12547                   enum ppc_stub_type stub_type;
12548                   struct ppc_stub_hash_entry *stub_entry;
12549                   asection *sym_sec, *code_sec;
12550                   bfd_vma sym_value, code_value;
12551                   bfd_vma destination;
12552                   unsigned long local_off;
12553                   bfd_boolean ok_dest;
12554                   struct ppc_link_hash_entry *hash;
12555                   struct ppc_link_hash_entry *fdh;
12556                   struct elf_link_hash_entry *h;
12557                   Elf_Internal_Sym *sym;
12558                   char *stub_name;
12559                   const asection *id_sec;
12560                   struct _opd_sec_data *opd;
12561                   struct plt_entry *plt_ent;
12562
12563                   r_type = ELF64_R_TYPE (irela->r_info);
12564                   r_indx = ELF64_R_SYM (irela->r_info);
12565
12566                   if (r_type >= R_PPC64_max)
12567                     {
12568                       bfd_set_error (bfd_error_bad_value);
12569                       goto error_ret_free_internal;
12570                     }
12571
12572                   /* Only look for stubs on branch instructions.  */
12573                   if (r_type != R_PPC64_REL24
12574                       && r_type != R_PPC64_REL14
12575                       && r_type != R_PPC64_REL14_BRTAKEN
12576                       && r_type != R_PPC64_REL14_BRNTAKEN)
12577                     continue;
12578
12579                   /* Now determine the call target, its name, value,
12580                      section.  */
12581                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12582                                   r_indx, input_bfd))
12583                     goto error_ret_free_internal;
12584                   hash = (struct ppc_link_hash_entry *) h;
12585
12586                   ok_dest = FALSE;
12587                   fdh = NULL;
12588                   sym_value = 0;
12589                   if (hash == NULL)
12590                     {
12591                       sym_value = sym->st_value;
12592                       if (sym_sec != NULL
12593                           && sym_sec->output_section != NULL)
12594                         ok_dest = TRUE;
12595                     }
12596                   else if (hash->elf.root.type == bfd_link_hash_defined
12597                            || hash->elf.root.type == bfd_link_hash_defweak)
12598                     {
12599                       sym_value = hash->elf.root.u.def.value;
12600                       if (sym_sec->output_section != NULL)
12601                         ok_dest = TRUE;
12602                     }
12603                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12604                            || hash->elf.root.type == bfd_link_hash_undefined)
12605                     {
12606                       /* Recognise an old ABI func code entry sym, and
12607                          use the func descriptor sym instead if it is
12608                          defined.  */
12609                       if (hash->elf.root.root.string[0] == '.'
12610                           && hash->oh != NULL)
12611                         {
12612                           fdh = ppc_follow_link (hash->oh);
12613                           if (fdh->elf.root.type == bfd_link_hash_defined
12614                               || fdh->elf.root.type == bfd_link_hash_defweak)
12615                             {
12616                               sym_sec = fdh->elf.root.u.def.section;
12617                               sym_value = fdh->elf.root.u.def.value;
12618                               if (sym_sec->output_section != NULL)
12619                                 ok_dest = TRUE;
12620                             }
12621                           else
12622                             fdh = NULL;
12623                         }
12624                     }
12625                   else
12626                     {
12627                       bfd_set_error (bfd_error_bad_value);
12628                       goto error_ret_free_internal;
12629                     }
12630
12631                   destination = 0;
12632                   local_off = 0;
12633                   if (ok_dest)
12634                     {
12635                       sym_value += irela->r_addend;
12636                       destination = (sym_value
12637                                      + sym_sec->output_offset
12638                                      + sym_sec->output_section->vma);
12639                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12640                                                             ? hash->elf.other
12641                                                             : sym->st_other);
12642                     }
12643
12644                   code_sec = sym_sec;
12645                   code_value = sym_value;
12646                   opd = get_opd_info (sym_sec);
12647                   if (opd != NULL)
12648                     {
12649                       bfd_vma dest;
12650
12651                       if (hash == NULL && opd->adjust != NULL)
12652                         {
12653                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12654                           if (adjust == -1)
12655                             continue;
12656                           code_value += adjust;
12657                           sym_value += adjust;
12658                         }
12659                       dest = opd_entry_value (sym_sec, sym_value,
12660                                               &code_sec, &code_value, FALSE);
12661                       if (dest != (bfd_vma) -1)
12662                         {
12663                           destination = dest;
12664                           if (fdh != NULL)
12665                             {
12666                               /* Fixup old ABI sym to point at code
12667                                  entry.  */
12668                               hash->elf.root.type = bfd_link_hash_defweak;
12669                               hash->elf.root.u.def.section = code_sec;
12670                               hash->elf.root.u.def.value = code_value;
12671                             }
12672                         }
12673                     }
12674
12675                   /* Determine what (if any) linker stub is needed.  */
12676                   plt_ent = NULL;
12677                   stub_type = ppc_type_of_stub (section, irela, &hash,
12678                                                 &plt_ent, destination,
12679                                                 local_off);
12680
12681                   if (stub_type != ppc_stub_plt_call)
12682                     {
12683                       /* Check whether we need a TOC adjusting stub.
12684                          Since the linker pastes together pieces from
12685                          different object files when creating the
12686                          _init and _fini functions, it may be that a
12687                          call to what looks like a local sym is in
12688                          fact a call needing a TOC adjustment.  */
12689                       if (code_sec != NULL
12690                           && code_sec->output_section != NULL
12691                           && (htab->sec_info[code_sec->id].toc_off
12692                               != htab->sec_info[section->id].toc_off)
12693                           && (code_sec->has_toc_reloc
12694                               || code_sec->makes_toc_func_call))
12695                         stub_type = ppc_stub_long_branch_r2off;
12696                     }
12697
12698                   if (stub_type == ppc_stub_none)
12699                     continue;
12700
12701                   /* __tls_get_addr calls might be eliminated.  */
12702                   if (stub_type != ppc_stub_plt_call
12703                       && hash != NULL
12704                       && (hash == htab->tls_get_addr
12705                           || hash == htab->tls_get_addr_fd)
12706                       && section->has_tls_reloc
12707                       && irela != internal_relocs)
12708                     {
12709                       /* Get tls info.  */
12710                       unsigned char *tls_mask;
12711
12712                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12713                                          irela - 1, input_bfd))
12714                         goto error_ret_free_internal;
12715                       if ((*tls_mask & TLS_TLS) != 0)
12716                         continue;
12717                     }
12718
12719                   if (stub_type == ppc_stub_plt_call)
12720                     {
12721                       if (!htab->opd_abi
12722                           && htab->params->plt_localentry0 != 0
12723                           && is_elfv2_localentry0 (&hash->elf))
12724                         htab->has_plt_localentry0 = 1;
12725                       else if (irela + 1 < irelaend
12726                                && irela[1].r_offset == irela->r_offset + 4
12727                                && (ELF64_R_TYPE (irela[1].r_info)
12728                                    == R_PPC64_TOCSAVE))
12729                         {
12730                           if (!tocsave_find (htab, INSERT,
12731                                              &local_syms, irela + 1, input_bfd))
12732                             goto error_ret_free_internal;
12733                         }
12734                       else
12735                         stub_type = ppc_stub_plt_call_r2save;
12736                     }
12737
12738                   /* Support for grouping stub sections.  */
12739                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12740
12741                   /* Get the name of this stub.  */
12742                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12743                   if (!stub_name)
12744                     goto error_ret_free_internal;
12745
12746                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12747                                                      stub_name, FALSE, FALSE);
12748                   if (stub_entry != NULL)
12749                     {
12750                       /* The proper stub has already been created.  */
12751                       free (stub_name);
12752                       if (stub_type == ppc_stub_plt_call_r2save)
12753                         stub_entry->stub_type = stub_type;
12754                       continue;
12755                     }
12756
12757                   stub_entry = ppc_add_stub (stub_name, section, info);
12758                   if (stub_entry == NULL)
12759                     {
12760                       free (stub_name);
12761                     error_ret_free_internal:
12762                       if (elf_section_data (section)->relocs == NULL)
12763                         free (internal_relocs);
12764                     error_ret_free_local:
12765                       if (local_syms != NULL
12766                           && (symtab_hdr->contents
12767                               != (unsigned char *) local_syms))
12768                         free (local_syms);
12769                       return FALSE;
12770                     }
12771
12772                   stub_entry->stub_type = stub_type;
12773                   if (stub_type != ppc_stub_plt_call
12774                       && stub_type != ppc_stub_plt_call_r2save)
12775                     {
12776                       stub_entry->target_value = code_value;
12777                       stub_entry->target_section = code_sec;
12778                     }
12779                   else
12780                     {
12781                       stub_entry->target_value = sym_value;
12782                       stub_entry->target_section = sym_sec;
12783                     }
12784                   stub_entry->h = hash;
12785                   stub_entry->plt_ent = plt_ent;
12786                   stub_entry->symtype
12787                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12788                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12789
12790                   if (stub_entry->h != NULL)
12791                     htab->stub_globals += 1;
12792                 }
12793
12794               /* We're done with the internal relocs, free them.  */
12795               if (elf_section_data (section)->relocs != internal_relocs)
12796                 free (internal_relocs);
12797             }
12798
12799           if (local_syms != NULL
12800               && symtab_hdr->contents != (unsigned char *) local_syms)
12801             {
12802               if (!info->keep_memory)
12803                 free (local_syms);
12804               else
12805                 symtab_hdr->contents = (unsigned char *) local_syms;
12806             }
12807         }
12808
12809       /* We may have added some stubs.  Find out the new size of the
12810          stub sections.  */
12811       for (group = htab->group; group != NULL; group = group->next)
12812         if (group->stub_sec != NULL)
12813           {
12814             asection *stub_sec = group->stub_sec;
12815
12816             if (htab->stub_iteration <= STUB_SHRINK_ITER
12817                 || stub_sec->rawsize < stub_sec->size)
12818               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12819               stub_sec->rawsize = stub_sec->size;
12820             stub_sec->size = 0;
12821             stub_sec->reloc_count = 0;
12822             stub_sec->flags &= ~SEC_RELOC;
12823           }
12824
12825       if (htab->stub_iteration <= STUB_SHRINK_ITER
12826           || htab->brlt->rawsize < htab->brlt->size)
12827         htab->brlt->rawsize = htab->brlt->size;
12828       htab->brlt->size = 0;
12829       htab->brlt->reloc_count = 0;
12830       htab->brlt->flags &= ~SEC_RELOC;
12831       if (htab->relbrlt != NULL)
12832         htab->relbrlt->size = 0;
12833
12834       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12835
12836       for (group = htab->group; group != NULL; group = group->next)
12837         if (group->needs_save_res)
12838           group->stub_sec->size += htab->sfpr->size;
12839
12840       if (info->emitrelocations
12841           && htab->glink != NULL && htab->glink->size != 0)
12842         {
12843           htab->glink->reloc_count = 1;
12844           htab->glink->flags |= SEC_RELOC;
12845         }
12846
12847       if (htab->glink_eh_frame != NULL
12848           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12849           && htab->glink_eh_frame->output_section->size > 8)
12850         {
12851           size_t size = 0, align = 4;
12852
12853           for (group = htab->group; group != NULL; group = group->next)
12854             if (group->stub_sec != NULL)
12855               size += stub_eh_frame_size (group, align);
12856           if (htab->glink != NULL && htab->glink->size != 0)
12857             size += (24 + align - 1) & -align;
12858           if (size != 0)
12859             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12860           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12861           size = (size + align - 1) & -align;
12862           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12863           htab->glink_eh_frame->size = size;
12864         }
12865
12866       if (htab->params->plt_stub_align != 0)
12867         for (group = htab->group; group != NULL; group = group->next)
12868           if (group->stub_sec != NULL)
12869             {
12870               int align = abs (htab->params->plt_stub_align);
12871               group->stub_sec->size
12872                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
12873             }
12874
12875       for (group = htab->group; group != NULL; group = group->next)
12876         if (group->stub_sec != NULL
12877             && group->stub_sec->rawsize != group->stub_sec->size
12878             && (htab->stub_iteration <= STUB_SHRINK_ITER
12879                 || group->stub_sec->rawsize < group->stub_sec->size))
12880           break;
12881
12882       if (group == NULL
12883           && (htab->brlt->rawsize == htab->brlt->size
12884               || (htab->stub_iteration > STUB_SHRINK_ITER
12885                   && htab->brlt->rawsize > htab->brlt->size))
12886           && (htab->glink_eh_frame == NULL
12887               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12888         break;
12889
12890       /* Ask the linker to do its stuff.  */
12891       (*htab->params->layout_sections_again) ();
12892     }
12893
12894   if (htab->glink_eh_frame != NULL
12895       && htab->glink_eh_frame->size != 0)
12896     {
12897       bfd_vma val;
12898       bfd_byte *p, *last_fde;
12899       size_t last_fde_len, size, align, pad;
12900       struct map_stub *group;
12901
12902       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12903       if (p == NULL)
12904         return FALSE;
12905       htab->glink_eh_frame->contents = p;
12906       last_fde = p;
12907       align = 4;
12908
12909       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12910       /* CIE length (rewrite in case little-endian).  */
12911       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12912       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12913       p += last_fde_len + 4;
12914
12915       for (group = htab->group; group != NULL; group = group->next)
12916         if (group->stub_sec != NULL)
12917           {
12918             last_fde = p;
12919             last_fde_len = stub_eh_frame_size (group, align) - 4;
12920             /* FDE length.  */
12921             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12922             p += 4;
12923             /* CIE pointer.  */
12924             val = p - htab->glink_eh_frame->contents;
12925             bfd_put_32 (htab->elf.dynobj, val, p);
12926             p += 4;
12927             /* Offset to stub section, written later.  */
12928             p += 4;
12929             /* stub section size.  */
12930             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12931             p += 4;
12932             /* Augmentation.  */
12933             p += 1;
12934             if (group->tls_get_addr_opt_bctrl != -1u)
12935               {
12936                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12937
12938                 /* This FDE needs more than just the default.
12939                    Describe __tls_get_addr_opt stub LR.  */
12940                 if (to_bctrl < 64)
12941                   *p++ = DW_CFA_advance_loc + to_bctrl;
12942                 else if (to_bctrl < 256)
12943                   {
12944                     *p++ = DW_CFA_advance_loc1;
12945                     *p++ = to_bctrl;
12946                   }
12947                 else if (to_bctrl < 65536)
12948                   {
12949                     *p++ = DW_CFA_advance_loc2;
12950                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12951                     p += 2;
12952                   }
12953                 else
12954                   {
12955                     *p++ = DW_CFA_advance_loc4;
12956                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12957                     p += 4;
12958                   }
12959                 *p++ = DW_CFA_offset_extended_sf;
12960                 *p++ = 65;
12961                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12962                 *p++ = DW_CFA_advance_loc + 4;
12963                 *p++ = DW_CFA_restore_extended;
12964                 *p++ = 65;
12965               }
12966             /* Pad.  */
12967             p = last_fde + last_fde_len + 4;
12968           }
12969       if (htab->glink != NULL && htab->glink->size != 0)
12970         {
12971           last_fde = p;
12972           last_fde_len = ((24 + align - 1) & -align) - 4;
12973           /* FDE length.  */
12974           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12975           p += 4;
12976           /* CIE pointer.  */
12977           val = p - htab->glink_eh_frame->contents;
12978           bfd_put_32 (htab->elf.dynobj, val, p);
12979           p += 4;
12980           /* Offset to .glink, written later.  */
12981           p += 4;
12982           /* .glink size.  */
12983           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12984           p += 4;
12985           /* Augmentation.  */
12986           p += 1;
12987
12988           *p++ = DW_CFA_advance_loc + 1;
12989           *p++ = DW_CFA_register;
12990           *p++ = 65;
12991           *p++ = htab->opd_abi ? 12 : 0;
12992           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12993           *p++ = DW_CFA_restore_extended;
12994           *p++ = 65;
12995           p += ((24 + align - 1) & -align) - 24;
12996         }
12997       /* Subsume any padding into the last FDE if user .eh_frame
12998          sections are aligned more than glink_eh_frame.  Otherwise any
12999          zero padding will be seen as a terminator.  */
13000       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13001       size = p - htab->glink_eh_frame->contents;
13002       pad = ((size + align - 1) & -align) - size;
13003       htab->glink_eh_frame->size = size + pad;
13004       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13005     }
13006
13007   maybe_strip_output (info, htab->brlt);
13008   if (htab->glink_eh_frame != NULL)
13009     maybe_strip_output (info, htab->glink_eh_frame);
13010
13011   return TRUE;
13012 }
13013
13014 /* Called after we have determined section placement.  If sections
13015    move, we'll be called again.  Provide a value for TOCstart.  */
13016
13017 bfd_vma
13018 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13019 {
13020   asection *s;
13021   bfd_vma TOCstart, adjust;
13022
13023   if (info != NULL)
13024     {
13025       struct elf_link_hash_entry *h;
13026       struct elf_link_hash_table *htab = elf_hash_table (info);
13027
13028       if (is_elf_hash_table (htab)
13029           && htab->hgot != NULL)
13030         h = htab->hgot;
13031       else
13032         {
13033           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13034           if (is_elf_hash_table (htab))
13035             htab->hgot = h;
13036         }
13037       if (h != NULL
13038           && h->root.type == bfd_link_hash_defined
13039           && !h->root.linker_def
13040           && (!is_elf_hash_table (htab)
13041               || h->def_regular))
13042         {
13043           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13044                       + h->root.u.def.section->output_offset
13045                       + h->root.u.def.section->output_section->vma);
13046           _bfd_set_gp_value (obfd, TOCstart);
13047           return TOCstart;
13048         }
13049     }
13050
13051   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13052      order.  The TOC starts where the first of these sections starts.  */
13053   s = bfd_get_section_by_name (obfd, ".got");
13054   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13055     s = bfd_get_section_by_name (obfd, ".toc");
13056   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13057     s = bfd_get_section_by_name (obfd, ".tocbss");
13058   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13059     s = bfd_get_section_by_name (obfd, ".plt");
13060   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13061     {
13062       /* This may happen for
13063          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13064          .toc directive
13065          o  bad linker script
13066          o --gc-sections and empty TOC sections
13067
13068          FIXME: Warn user?  */
13069
13070       /* Look for a likely section.  We probably won't even be
13071          using TOCstart.  */
13072       for (s = obfd->sections; s != NULL; s = s->next)
13073         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13074                          | SEC_EXCLUDE))
13075             == (SEC_ALLOC | SEC_SMALL_DATA))
13076           break;
13077       if (s == NULL)
13078         for (s = obfd->sections; s != NULL; s = s->next)
13079           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13080               == (SEC_ALLOC | SEC_SMALL_DATA))
13081             break;
13082       if (s == NULL)
13083         for (s = obfd->sections; s != NULL; s = s->next)
13084           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13085               == SEC_ALLOC)
13086             break;
13087       if (s == NULL)
13088         for (s = obfd->sections; s != NULL; s = s->next)
13089           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13090             break;
13091     }
13092
13093   TOCstart = 0;
13094   if (s != NULL)
13095     TOCstart = s->output_section->vma + s->output_offset;
13096
13097   /* Force alignment.  */
13098   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13099   TOCstart -= adjust;
13100   _bfd_set_gp_value (obfd, TOCstart);
13101
13102   if (info != NULL && s != NULL)
13103     {
13104       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13105
13106       if (htab != NULL)
13107         {
13108           if (htab->elf.hgot != NULL)
13109             {
13110               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13111               htab->elf.hgot->root.u.def.section = s;
13112             }
13113         }
13114       else
13115         {
13116           struct bfd_link_hash_entry *bh = NULL;
13117           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13118                                             s, TOC_BASE_OFF - adjust,
13119                                             NULL, FALSE, FALSE, &bh);
13120         }
13121     }
13122   return TOCstart;
13123 }
13124
13125 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13126    write out any global entry stubs, and PLT relocations.  */
13127
13128 static bfd_boolean
13129 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13130 {
13131   struct bfd_link_info *info;
13132   struct ppc_link_hash_table *htab;
13133   struct plt_entry *ent;
13134   asection *s;
13135
13136   if (h->root.type == bfd_link_hash_indirect)
13137     return TRUE;
13138
13139   info = inf;
13140   htab = ppc_hash_table (info);
13141   if (htab == NULL)
13142     return FALSE;
13143
13144   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13145     if (ent->plt.offset != (bfd_vma) -1)
13146       {
13147         /* This symbol has an entry in the procedure linkage
13148            table.  Set it up.  */
13149         Elf_Internal_Rela rela;
13150         asection *plt, *relplt;
13151         bfd_byte *loc;
13152
13153         if (!htab->elf.dynamic_sections_created
13154             || h->dynindx == -1)
13155           {
13156             if (!(h->def_regular
13157                   && (h->root.type == bfd_link_hash_defined
13158                       || h->root.type == bfd_link_hash_defweak)))
13159               continue;
13160             if (h->type == STT_GNU_IFUNC)
13161               {
13162                 plt = htab->elf.iplt;
13163                 relplt = htab->elf.irelplt;
13164                 htab->local_ifunc_resolver = 1;
13165                 if (htab->opd_abi)
13166                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13167                 else
13168                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13169               }
13170             else
13171               {
13172                 plt = htab->pltlocal;
13173                 if (bfd_link_pic (info))
13174                   {
13175                     relplt = htab->relpltlocal;
13176                     if (htab->opd_abi)
13177                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13178                     else
13179                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13180                   }
13181                 else
13182                   relplt = NULL;
13183               }
13184             rela.r_addend = (h->root.u.def.value
13185                              + h->root.u.def.section->output_offset
13186                              + h->root.u.def.section->output_section->vma
13187                              + ent->addend);
13188
13189             if (relplt == NULL)
13190               {
13191                 loc = plt->contents + ent->plt.offset;
13192                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13193                 if (htab->opd_abi)
13194                   {
13195                     bfd_vma toc = elf_gp (info->output_bfd);
13196                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13197                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13198                   }
13199               }
13200             else
13201               {
13202                 rela.r_offset = (plt->output_section->vma
13203                                  + plt->output_offset
13204                                  + ent->plt.offset);
13205                 loc = relplt->contents + (relplt->reloc_count++
13206                                           * sizeof (Elf64_External_Rela));
13207                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13208               }
13209           }
13210         else
13211           {
13212             rela.r_offset = (htab->elf.splt->output_section->vma
13213                              + htab->elf.splt->output_offset
13214                              + ent->plt.offset);
13215             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13216             rela.r_addend = ent->addend;
13217             loc = (htab->elf.srelplt->contents
13218                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13219                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13220             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13221               htab->maybe_local_ifunc_resolver = 1;
13222             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13223           }
13224       }
13225
13226   if (!h->pointer_equality_needed)
13227     return TRUE;
13228
13229   if (h->def_regular)
13230     return TRUE;
13231
13232   s = htab->global_entry;
13233   if (s == NULL || s->size == 0)
13234     return TRUE;
13235
13236   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13237     if (ent->plt.offset != (bfd_vma) -1
13238         && ent->addend == 0)
13239       {
13240         bfd_byte *p;
13241         asection *plt;
13242         bfd_vma off;
13243
13244         p = s->contents + h->root.u.def.value;
13245         plt = htab->elf.splt;
13246         if (!htab->elf.dynamic_sections_created
13247             || h->dynindx == -1)
13248           {
13249             if (h->type == STT_GNU_IFUNC)
13250               plt = htab->elf.iplt;
13251             else
13252               plt = htab->pltlocal;
13253           }
13254         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13255         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13256
13257         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13258           {
13259             info->callbacks->einfo
13260               (_("%P: linkage table error against `%pT'\n"),
13261                h->root.root.string);
13262             bfd_set_error (bfd_error_bad_value);
13263             htab->stub_error = TRUE;
13264           }
13265
13266         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13267         if (htab->params->emit_stub_syms)
13268           {
13269             size_t len = strlen (h->root.root.string);
13270             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13271
13272             if (name == NULL)
13273               return FALSE;
13274
13275             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13276             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13277             if (h == NULL)
13278               return FALSE;
13279             if (h->root.type == bfd_link_hash_new)
13280               {
13281                 h->root.type = bfd_link_hash_defined;
13282                 h->root.u.def.section = s;
13283                 h->root.u.def.value = p - s->contents;
13284                 h->ref_regular = 1;
13285                 h->def_regular = 1;
13286                 h->ref_regular_nonweak = 1;
13287                 h->forced_local = 1;
13288                 h->non_elf = 0;
13289                 h->root.linker_def = 1;
13290               }
13291           }
13292
13293         if (PPC_HA (off) != 0)
13294           {
13295             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13296             p += 4;
13297           }
13298         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13299         p += 4;
13300         bfd_put_32 (s->owner, MTCTR_R12, p);
13301         p += 4;
13302         bfd_put_32 (s->owner, BCTR, p);
13303         break;
13304       }
13305   return TRUE;
13306 }
13307
13308 /* Write PLT relocs for locals.  */
13309
13310 static bfd_boolean
13311 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13312 {
13313   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13314   bfd *ibfd;
13315
13316   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13317     {
13318       struct got_entry **lgot_ents, **end_lgot_ents;
13319       struct plt_entry **local_plt, **lplt, **end_local_plt;
13320       Elf_Internal_Shdr *symtab_hdr;
13321       bfd_size_type locsymcount;
13322       Elf_Internal_Sym *local_syms = NULL;
13323       struct plt_entry *ent;
13324
13325       if (!is_ppc64_elf (ibfd))
13326         continue;
13327
13328       lgot_ents = elf_local_got_ents (ibfd);
13329       if (!lgot_ents)
13330         continue;
13331
13332       symtab_hdr = &elf_symtab_hdr (ibfd);
13333       locsymcount = symtab_hdr->sh_info;
13334       end_lgot_ents = lgot_ents + locsymcount;
13335       local_plt = (struct plt_entry **) end_lgot_ents;
13336       end_local_plt = local_plt + locsymcount;
13337       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13338         for (ent = *lplt; ent != NULL; ent = ent->next)
13339           if (ent->plt.offset != (bfd_vma) -1)
13340             {
13341               Elf_Internal_Sym *sym;
13342               asection *sym_sec;
13343               asection *plt, *relplt;
13344               bfd_byte *loc;
13345               bfd_vma val;
13346
13347               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13348                               lplt - local_plt, ibfd))
13349                 {
13350                   if (local_syms != NULL
13351                       && symtab_hdr->contents != (unsigned char *) local_syms)
13352                     free (local_syms);
13353                   return FALSE;
13354                 }
13355
13356               val = sym->st_value + ent->addend;
13357               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13358               if (sym_sec != NULL && sym_sec->output_section != NULL)
13359                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13360
13361               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13362                 {
13363                   htab->local_ifunc_resolver = 1;
13364                   plt = htab->elf.iplt;
13365                   relplt = htab->elf.irelplt;
13366                 }
13367               else
13368                 {
13369                   plt = htab->pltlocal;
13370                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13371                 }
13372
13373               if (relplt == NULL)
13374                 {
13375                   loc = plt->contents + ent->plt.offset;
13376                   bfd_put_64 (info->output_bfd, val, loc);
13377                   if (htab->opd_abi)
13378                     {
13379                       bfd_vma toc = elf_gp (ibfd);
13380                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13381                     }
13382                 }
13383               else
13384                 {
13385                   Elf_Internal_Rela rela;
13386                   rela.r_offset = (ent->plt.offset
13387                                    + plt->output_offset
13388                                    + plt->output_section->vma);
13389                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13390                     {
13391                       if (htab->opd_abi)
13392                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13393                       else
13394                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13395                     }
13396                   else
13397                     {
13398                       if (htab->opd_abi)
13399                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13400                       else
13401                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13402                     }
13403                   rela.r_addend = val;
13404                   loc = relplt->contents + (relplt->reloc_count++
13405                                             * sizeof (Elf64_External_Rela));
13406                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13407                 }
13408             }
13409
13410       if (local_syms != NULL
13411           && symtab_hdr->contents != (unsigned char *) local_syms)
13412         {
13413           if (!info->keep_memory)
13414             free (local_syms);
13415           else
13416             symtab_hdr->contents = (unsigned char *) local_syms;
13417         }
13418     }
13419   return TRUE;
13420 }
13421
13422 /* Build all the stubs associated with the current output file.
13423    The stubs are kept in a hash table attached to the main linker
13424    hash table.  This function is called via gldelf64ppc_finish.  */
13425
13426 bfd_boolean
13427 ppc64_elf_build_stubs (struct bfd_link_info *info,
13428                        char **stats)
13429 {
13430   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13431   struct map_stub *group;
13432   asection *stub_sec;
13433   bfd_byte *p;
13434   int stub_sec_count = 0;
13435
13436   if (htab == NULL)
13437     return FALSE;
13438
13439   /* Allocate memory to hold the linker stubs.  */
13440   for (group = htab->group; group != NULL; group = group->next)
13441     if ((stub_sec = group->stub_sec) != NULL
13442         && stub_sec->size != 0)
13443       {
13444         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13445         if (stub_sec->contents == NULL)
13446           return FALSE;
13447         stub_sec->size = 0;
13448       }
13449
13450   if (htab->glink != NULL && htab->glink->size != 0)
13451     {
13452       unsigned int indx;
13453       bfd_vma plt0;
13454
13455       /* Build the .glink plt call stub.  */
13456       if (htab->params->emit_stub_syms)
13457         {
13458           struct elf_link_hash_entry *h;
13459           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13460                                     TRUE, FALSE, FALSE);
13461           if (h == NULL)
13462             return FALSE;
13463           if (h->root.type == bfd_link_hash_new)
13464             {
13465               h->root.type = bfd_link_hash_defined;
13466               h->root.u.def.section = htab->glink;
13467               h->root.u.def.value = 8;
13468               h->ref_regular = 1;
13469               h->def_regular = 1;
13470               h->ref_regular_nonweak = 1;
13471               h->forced_local = 1;
13472               h->non_elf = 0;
13473               h->root.linker_def = 1;
13474             }
13475         }
13476       plt0 = (htab->elf.splt->output_section->vma
13477               + htab->elf.splt->output_offset
13478               - 16);
13479       if (info->emitrelocations)
13480         {
13481           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13482           if (r == NULL)
13483             return FALSE;
13484           r->r_offset = (htab->glink->output_offset
13485                          + htab->glink->output_section->vma);
13486           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13487           r->r_addend = plt0;
13488         }
13489       p = htab->glink->contents;
13490       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13491       bfd_put_64 (htab->glink->owner, plt0, p);
13492       p += 8;
13493       if (htab->opd_abi)
13494         {
13495           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13496           p += 4;
13497           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13498           p += 4;
13499           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13500           p += 4;
13501           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13502           p += 4;
13503           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13504           p += 4;
13505           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13506           p += 4;
13507           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13508           p += 4;
13509           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13510           p += 4;
13511           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13512           p += 4;
13513           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13514           p += 4;
13515         }
13516       else
13517         {
13518           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13519           p += 4;
13520           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13521           p += 4;
13522           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13523           p += 4;
13524           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13525           p += 4;
13526           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13527           p += 4;
13528           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13529           p += 4;
13530           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13531           p += 4;
13532           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13533           p += 4;
13534           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13535           p += 4;
13536           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13537           p += 4;
13538           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13539           p += 4;
13540           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13541           p += 4;
13542           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13543           p += 4;
13544         }
13545       bfd_put_32 (htab->glink->owner, BCTR, p);
13546       p += 4;
13547       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13548
13549       /* Build the .glink lazy link call stubs.  */
13550       indx = 0;
13551       while (p < htab->glink->contents + htab->glink->size)
13552         {
13553           if (htab->opd_abi)
13554             {
13555               if (indx < 0x8000)
13556                 {
13557                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13558                   p += 4;
13559                 }
13560               else
13561                 {
13562                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13563                   p += 4;
13564                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13565                               p);
13566                   p += 4;
13567                 }
13568             }
13569           bfd_put_32 (htab->glink->owner,
13570                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13571           indx++;
13572           p += 4;
13573         }
13574     }
13575
13576   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13577   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13578
13579   if (!write_plt_relocs_for_local_syms (info))
13580     return FALSE;
13581
13582   if (htab->brlt != NULL && htab->brlt->size != 0)
13583     {
13584       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13585                                          htab->brlt->size);
13586       if (htab->brlt->contents == NULL)
13587         return FALSE;
13588     }
13589   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13590     {
13591       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13592                                             htab->relbrlt->size);
13593       if (htab->relbrlt->contents == NULL)
13594         return FALSE;
13595     }
13596
13597   /* Build the stubs as directed by the stub hash table.  */
13598   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13599
13600   for (group = htab->group; group != NULL; group = group->next)
13601     if (group->needs_save_res)
13602       group->stub_sec->size += htab->sfpr->size;
13603
13604   if (htab->relbrlt != NULL)
13605     htab->relbrlt->reloc_count = 0;
13606
13607   if (htab->params->plt_stub_align != 0)
13608     for (group = htab->group; group != NULL; group = group->next)
13609       if ((stub_sec = group->stub_sec) != NULL)
13610         {
13611           int align = abs (htab->params->plt_stub_align);
13612           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13613         }
13614
13615   for (group = htab->group; group != NULL; group = group->next)
13616     if (group->needs_save_res)
13617       {
13618         stub_sec = group->stub_sec;
13619         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13620                 htab->sfpr->contents, htab->sfpr->size);
13621         if (htab->params->emit_stub_syms)
13622           {
13623             unsigned int i;
13624
13625             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13626               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13627                 return FALSE;
13628           }
13629       }
13630
13631   for (group = htab->group; group != NULL; group = group->next)
13632     if ((stub_sec = group->stub_sec) != NULL)
13633       {
13634         stub_sec_count += 1;
13635         if (stub_sec->rawsize != stub_sec->size
13636             && (htab->stub_iteration <= STUB_SHRINK_ITER
13637                 || stub_sec->rawsize < stub_sec->size))
13638           break;
13639       }
13640
13641   if (group != NULL)
13642     {
13643       htab->stub_error = TRUE;
13644       _bfd_error_handler (_("stubs don't match calculated size"));
13645     }
13646
13647   if (htab->stub_error)
13648     return FALSE;
13649
13650   if (stats != NULL)
13651     {
13652       size_t len;
13653       *stats = bfd_malloc (500);
13654       if (*stats == NULL)
13655         return FALSE;
13656
13657       len = sprintf (*stats,
13658                      ngettext ("linker stubs in %u group\n",
13659                                "linker stubs in %u groups\n",
13660                                stub_sec_count),
13661                      stub_sec_count);
13662       sprintf (*stats + len, _("  branch       %lu\n"
13663                                "  toc adjust   %lu\n"
13664                                "  long branch  %lu\n"
13665                                "  long toc adj %lu\n"
13666                                "  plt call     %lu\n"
13667                                "  plt call toc %lu\n"
13668                                "  global entry %lu"),
13669                htab->stub_count[ppc_stub_long_branch - 1],
13670                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13671                htab->stub_count[ppc_stub_plt_branch - 1],
13672                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13673                htab->stub_count[ppc_stub_plt_call - 1],
13674                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13675                htab->stub_count[ppc_stub_global_entry - 1]);
13676     }
13677   return TRUE;
13678 }
13679
13680 /* What to do when ld finds relocations against symbols defined in
13681    discarded sections.  */
13682
13683 static unsigned int
13684 ppc64_elf_action_discarded (asection *sec)
13685 {
13686   if (strcmp (".opd", sec->name) == 0)
13687     return 0;
13688
13689   if (strcmp (".toc", sec->name) == 0)
13690     return 0;
13691
13692   if (strcmp (".toc1", sec->name) == 0)
13693     return 0;
13694
13695   return _bfd_elf_default_action_discarded (sec);
13696 }
13697
13698 /* The RELOCATE_SECTION function is called by the ELF backend linker
13699    to handle the relocations for a section.
13700
13701    The relocs are always passed as Rela structures; if the section
13702    actually uses Rel structures, the r_addend field will always be
13703    zero.
13704
13705    This function is responsible for adjust the section contents as
13706    necessary, and (if using Rela relocs and generating a
13707    relocatable output file) adjusting the reloc addend as
13708    necessary.
13709
13710    This function does not have to worry about setting the reloc
13711    address or the reloc symbol index.
13712
13713    LOCAL_SYMS is a pointer to the swapped in local symbols.
13714
13715    LOCAL_SECTIONS is an array giving the section in the input file
13716    corresponding to the st_shndx field of each local symbol.
13717
13718    The global hash table entry for the global symbols can be found
13719    via elf_sym_hashes (input_bfd).
13720
13721    When generating relocatable output, this function must handle
13722    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13723    going to be the section symbol corresponding to the output
13724    section, which means that the addend must be adjusted
13725    accordingly.  */
13726
13727 static bfd_boolean
13728 ppc64_elf_relocate_section (bfd *output_bfd,
13729                             struct bfd_link_info *info,
13730                             bfd *input_bfd,
13731                             asection *input_section,
13732                             bfd_byte *contents,
13733                             Elf_Internal_Rela *relocs,
13734                             Elf_Internal_Sym *local_syms,
13735                             asection **local_sections)
13736 {
13737   struct ppc_link_hash_table *htab;
13738   Elf_Internal_Shdr *symtab_hdr;
13739   struct elf_link_hash_entry **sym_hashes;
13740   Elf_Internal_Rela *rel;
13741   Elf_Internal_Rela *wrel;
13742   Elf_Internal_Rela *relend;
13743   Elf_Internal_Rela outrel;
13744   bfd_byte *loc;
13745   struct got_entry **local_got_ents;
13746   bfd_vma TOCstart;
13747   bfd_boolean ret = TRUE;
13748   bfd_boolean is_opd;
13749   /* Assume 'at' branch hints.  */
13750   bfd_boolean is_isa_v2 = TRUE;
13751   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13752
13753   /* Initialize howto table if needed.  */
13754   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13755     ppc_howto_init ();
13756
13757   htab = ppc_hash_table (info);
13758   if (htab == NULL)
13759     return FALSE;
13760
13761   /* Don't relocate stub sections.  */
13762   if (input_section->owner == htab->params->stub_bfd)
13763     return TRUE;
13764
13765   BFD_ASSERT (is_ppc64_elf (input_bfd));
13766
13767   local_got_ents = elf_local_got_ents (input_bfd);
13768   TOCstart = elf_gp (output_bfd);
13769   symtab_hdr = &elf_symtab_hdr (input_bfd);
13770   sym_hashes = elf_sym_hashes (input_bfd);
13771   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13772
13773   rel = wrel = relocs;
13774   relend = relocs + input_section->reloc_count;
13775   for (; rel < relend; wrel++, rel++)
13776     {
13777       enum elf_ppc64_reloc_type r_type;
13778       bfd_vma addend;
13779       bfd_reloc_status_type r;
13780       Elf_Internal_Sym *sym;
13781       asection *sec;
13782       struct elf_link_hash_entry *h_elf;
13783       struct ppc_link_hash_entry *h;
13784       struct ppc_link_hash_entry *fdh;
13785       const char *sym_name;
13786       unsigned long r_symndx, toc_symndx;
13787       bfd_vma toc_addend;
13788       unsigned char tls_mask, tls_gd, tls_type;
13789       unsigned char sym_type;
13790       bfd_vma relocation;
13791       bfd_boolean unresolved_reloc, save_unresolved_reloc;
13792       bfd_boolean warned;
13793       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13794       unsigned int insn;
13795       unsigned int mask;
13796       struct ppc_stub_hash_entry *stub_entry;
13797       bfd_vma max_br_offset;
13798       bfd_vma from;
13799       Elf_Internal_Rela orig_rel;
13800       reloc_howto_type *howto;
13801       struct reloc_howto_struct alt_howto;
13802
13803     again:
13804       orig_rel = *rel;
13805
13806       r_type = ELF64_R_TYPE (rel->r_info);
13807       r_symndx = ELF64_R_SYM (rel->r_info);
13808
13809       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13810          symbol of the previous ADDR64 reloc.  The symbol gives us the
13811          proper TOC base to use.  */
13812       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13813           && wrel != relocs
13814           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13815           && is_opd)
13816         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13817
13818       sym = NULL;
13819       sec = NULL;
13820       h_elf = NULL;
13821       sym_name = NULL;
13822       unresolved_reloc = FALSE;
13823       warned = FALSE;
13824
13825       if (r_symndx < symtab_hdr->sh_info)
13826         {
13827           /* It's a local symbol.  */
13828           struct _opd_sec_data *opd;
13829
13830           sym = local_syms + r_symndx;
13831           sec = local_sections[r_symndx];
13832           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13833           sym_type = ELF64_ST_TYPE (sym->st_info);
13834           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13835           opd = get_opd_info (sec);
13836           if (opd != NULL && opd->adjust != NULL)
13837             {
13838               long adjust = opd->adjust[OPD_NDX (sym->st_value
13839                                                  + rel->r_addend)];
13840               if (adjust == -1)
13841                 relocation = 0;
13842               else
13843                 {
13844                   /* If this is a relocation against the opd section sym
13845                      and we have edited .opd, adjust the reloc addend so
13846                      that ld -r and ld --emit-relocs output is correct.
13847                      If it is a reloc against some other .opd symbol,
13848                      then the symbol value will be adjusted later.  */
13849                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13850                     rel->r_addend += adjust;
13851                   else
13852                     relocation += adjust;
13853                 }
13854             }
13855         }
13856       else
13857         {
13858           bfd_boolean ignored;
13859
13860           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13861                                    r_symndx, symtab_hdr, sym_hashes,
13862                                    h_elf, sec, relocation,
13863                                    unresolved_reloc, warned, ignored);
13864           sym_name = h_elf->root.root.string;
13865           sym_type = h_elf->type;
13866           if (sec != NULL
13867               && sec->owner == output_bfd
13868               && strcmp (sec->name, ".opd") == 0)
13869             {
13870               /* This is a symbol defined in a linker script.  All
13871                  such are defined in output sections, even those
13872                  defined by simple assignment from a symbol defined in
13873                  an input section.  Transfer the symbol to an
13874                  appropriate input .opd section, so that a branch to
13875                  this symbol will be mapped to the location specified
13876                  by the opd entry.  */
13877               struct bfd_link_order *lo;
13878               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13879                 if (lo->type == bfd_indirect_link_order)
13880                   {
13881                     asection *isec = lo->u.indirect.section;
13882                     if (h_elf->root.u.def.value >= isec->output_offset
13883                         && h_elf->root.u.def.value < (isec->output_offset
13884                                                       + isec->size))
13885                       {
13886                         h_elf->root.u.def.value -= isec->output_offset;
13887                         h_elf->root.u.def.section = isec;
13888                         sec = isec;
13889                         break;
13890                       }
13891                   }
13892             }
13893         }
13894       h = (struct ppc_link_hash_entry *) h_elf;
13895
13896       if (sec != NULL && discarded_section (sec))
13897         {
13898           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13899                                input_bfd, input_section,
13900                                contents + rel->r_offset);
13901           wrel->r_offset = rel->r_offset;
13902           wrel->r_info = 0;
13903           wrel->r_addend = 0;
13904
13905           /* For ld -r, remove relocations in debug sections against
13906              symbols defined in discarded sections.  Not done for
13907              non-debug to preserve relocs in .eh_frame which the
13908              eh_frame editing code expects to be present.  */
13909           if (bfd_link_relocatable (info)
13910               && (input_section->flags & SEC_DEBUGGING))
13911             wrel--;
13912
13913           continue;
13914         }
13915
13916       if (bfd_link_relocatable (info))
13917         goto copy_reloc;
13918
13919       if (h != NULL && &h->elf == htab->elf.hgot)
13920         {
13921           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13922           sec = bfd_abs_section_ptr;
13923           unresolved_reloc = FALSE;
13924         }
13925
13926       /* TLS optimizations.  Replace instruction sequences and relocs
13927          based on information we collected in tls_optimize.  We edit
13928          RELOCS so that --emit-relocs will output something sensible
13929          for the final instruction stream.  */
13930       tls_mask = 0;
13931       tls_gd = 0;
13932       toc_symndx = 0;
13933       if (h != NULL)
13934         tls_mask = h->tls_mask;
13935       else if (local_got_ents != NULL)
13936         {
13937           struct plt_entry **local_plt = (struct plt_entry **)
13938             (local_got_ents + symtab_hdr->sh_info);
13939           unsigned char *lgot_masks = (unsigned char *)
13940             (local_plt + symtab_hdr->sh_info);
13941           tls_mask = lgot_masks[r_symndx];
13942         }
13943       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
13944           && (r_type == R_PPC64_TLS
13945               || r_type == R_PPC64_TLSGD
13946               || r_type == R_PPC64_TLSLD))
13947         {
13948           /* Check for toc tls entries.  */
13949           unsigned char *toc_tls;
13950
13951           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13952                              &local_syms, rel, input_bfd))
13953             return FALSE;
13954
13955           if (toc_tls)
13956             tls_mask = *toc_tls;
13957         }
13958
13959       /* Check that tls relocs are used with tls syms, and non-tls
13960          relocs are used with non-tls syms.  */
13961       if (r_symndx != STN_UNDEF
13962           && r_type != R_PPC64_NONE
13963           && (h == NULL
13964               || h->elf.root.type == bfd_link_hash_defined
13965               || h->elf.root.type == bfd_link_hash_defweak)
13966           && (IS_PPC64_TLS_RELOC (r_type)
13967               != (sym_type == STT_TLS
13968                   || (sym_type == STT_SECTION
13969                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13970         {
13971           if ((tls_mask & TLS_TLS) != 0
13972               && (r_type == R_PPC64_TLS
13973                   || r_type == R_PPC64_TLSGD
13974                   || r_type == R_PPC64_TLSLD))
13975             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13976             ;
13977           else
13978             info->callbacks->einfo
13979               (!IS_PPC64_TLS_RELOC (r_type)
13980                /* xgettext:c-format */
13981                ? _("%H: %s used with TLS symbol `%pT'\n")
13982                /* xgettext:c-format */
13983                : _("%H: %s used with non-TLS symbol `%pT'\n"),
13984                input_bfd, input_section, rel->r_offset,
13985                ppc64_elf_howto_table[r_type]->name,
13986                sym_name);
13987         }
13988
13989       /* Ensure reloc mapping code below stays sane.  */
13990       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13991           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13992           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13993           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13994           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13995           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13996           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13997           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13998           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13999           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14000         abort ();
14001
14002       switch (r_type)
14003         {
14004         default:
14005           break;
14006
14007         case R_PPC64_LO_DS_OPT:
14008           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14009           if ((insn & (0x3f << 26)) != 58u << 26)
14010             abort ();
14011           insn += (14u << 26) - (58u << 26);
14012           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14013           r_type = R_PPC64_TOC16_LO;
14014           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14015           break;
14016
14017         case R_PPC64_TOC16:
14018         case R_PPC64_TOC16_LO:
14019         case R_PPC64_TOC16_DS:
14020         case R_PPC64_TOC16_LO_DS:
14021           {
14022             /* Check for toc tls entries.  */
14023             unsigned char *toc_tls;
14024             int retval;
14025
14026             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14027                                    &local_syms, rel, input_bfd);
14028             if (retval == 0)
14029               return FALSE;
14030
14031             if (toc_tls)
14032               {
14033                 tls_mask = *toc_tls;
14034                 if (r_type == R_PPC64_TOC16_DS
14035                     || r_type == R_PPC64_TOC16_LO_DS)
14036                   {
14037                     if ((tls_mask & TLS_TLS) != 0
14038                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14039                       goto toctprel;
14040                   }
14041                 else
14042                   {
14043                     /* If we found a GD reloc pair, then we might be
14044                        doing a GD->IE transition.  */
14045                     if (retval == 2)
14046                       {
14047                         tls_gd = TLS_TPRELGD;
14048                         if ((tls_mask & TLS_TLS) != 0
14049                             && (tls_mask & TLS_GD) == 0)
14050                           goto tls_ldgd_opt;
14051                       }
14052                     else if (retval == 3)
14053                       {
14054                         if ((tls_mask & TLS_TLS) != 0
14055                             && (tls_mask & TLS_LD) == 0)
14056                           goto tls_ldgd_opt;
14057                       }
14058                   }
14059               }
14060           }
14061           break;
14062
14063         case R_PPC64_GOT_TPREL16_HI:
14064         case R_PPC64_GOT_TPREL16_HA:
14065           if ((tls_mask & TLS_TLS) != 0
14066               && (tls_mask & TLS_TPREL) == 0)
14067             {
14068               rel->r_offset -= d_offset;
14069               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14070               r_type = R_PPC64_NONE;
14071               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14072             }
14073           break;
14074
14075         case R_PPC64_GOT_TPREL16_DS:
14076         case R_PPC64_GOT_TPREL16_LO_DS:
14077           if ((tls_mask & TLS_TLS) != 0
14078               && (tls_mask & TLS_TPREL) == 0)
14079             {
14080             toctprel:
14081               insn = bfd_get_32 (input_bfd,
14082                                  contents + rel->r_offset - d_offset);
14083               insn &= 31 << 21;
14084               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14085               bfd_put_32 (input_bfd, insn,
14086                           contents + rel->r_offset - d_offset);
14087               r_type = R_PPC64_TPREL16_HA;
14088               if (toc_symndx != 0)
14089                 {
14090                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14091                   rel->r_addend = toc_addend;
14092                   /* We changed the symbol.  Start over in order to
14093                      get h, sym, sec etc. right.  */
14094                   goto again;
14095                 }
14096               else
14097                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14098             }
14099           break;
14100
14101         case R_PPC64_TLS:
14102           if ((tls_mask & TLS_TLS) != 0
14103               && (tls_mask & TLS_TPREL) == 0)
14104             {
14105               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14106               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14107               if (insn == 0)
14108                 abort ();
14109               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14110               /* Was PPC64_TLS which sits on insn boundary, now
14111                  PPC64_TPREL16_LO which is at low-order half-word.  */
14112               rel->r_offset += d_offset;
14113               r_type = R_PPC64_TPREL16_LO;
14114               if (toc_symndx != 0)
14115                 {
14116                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14117                   rel->r_addend = toc_addend;
14118                   /* We changed the symbol.  Start over in order to
14119                      get h, sym, sec etc. right.  */
14120                   goto again;
14121                 }
14122               else
14123                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14124             }
14125           break;
14126
14127         case R_PPC64_GOT_TLSGD16_HI:
14128         case R_PPC64_GOT_TLSGD16_HA:
14129           tls_gd = TLS_TPRELGD;
14130           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14131             goto tls_gdld_hi;
14132           break;
14133
14134         case R_PPC64_GOT_TLSLD16_HI:
14135         case R_PPC64_GOT_TLSLD16_HA:
14136           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14137             {
14138             tls_gdld_hi:
14139               if ((tls_mask & tls_gd) != 0)
14140                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14141                           + R_PPC64_GOT_TPREL16_DS);
14142               else
14143                 {
14144                   rel->r_offset -= d_offset;
14145                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14146                   r_type = R_PPC64_NONE;
14147                 }
14148               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14149             }
14150           break;
14151
14152         case R_PPC64_GOT_TLSGD16:
14153         case R_PPC64_GOT_TLSGD16_LO:
14154           tls_gd = TLS_TPRELGD;
14155           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14156             goto tls_ldgd_opt;
14157           break;
14158
14159         case R_PPC64_GOT_TLSLD16:
14160         case R_PPC64_GOT_TLSLD16_LO:
14161           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14162             {
14163               unsigned int insn1, insn2;
14164               bfd_vma offset;
14165
14166             tls_ldgd_opt:
14167               offset = (bfd_vma) -1;
14168               /* If not using the newer R_PPC64_TLSGD/LD to mark
14169                  __tls_get_addr calls, we must trust that the call
14170                  stays with its arg setup insns, ie. that the next
14171                  reloc is the __tls_get_addr call associated with
14172                  the current reloc.  Edit both insns.  */
14173               if (input_section->has_tls_get_addr_call
14174                   && rel + 1 < relend
14175                   && branch_reloc_hash_match (input_bfd, rel + 1,
14176                                               htab->tls_get_addr,
14177                                               htab->tls_get_addr_fd))
14178                 offset = rel[1].r_offset;
14179               /* We read the low GOT_TLS (or TOC16) insn because we
14180                  need to keep the destination reg.  It may be
14181                  something other than the usual r3, and moved to r3
14182                  before the call by intervening code.  */
14183               insn1 = bfd_get_32 (input_bfd,
14184                                   contents + rel->r_offset - d_offset);
14185               if ((tls_mask & tls_gd) != 0)
14186                 {
14187                   /* IE */
14188                   insn1 &= (0x1f << 21) | (0x1f << 16);
14189                   insn1 |= 58 << 26;    /* ld */
14190                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14191                   if (offset != (bfd_vma) -1)
14192                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14193                   if ((tls_mask & TLS_EXPLICIT) == 0)
14194                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14195                               + R_PPC64_GOT_TPREL16_DS);
14196                   else
14197                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14198                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14199                 }
14200               else
14201                 {
14202                   /* LE */
14203                   insn1 &= 0x1f << 21;
14204                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14205                   insn2 = 0x38630000;   /* addi 3,3,0 */
14206                   if (tls_gd == 0)
14207                     {
14208                       /* Was an LD reloc.  */
14209                       if (toc_symndx)
14210                         sec = local_sections[toc_symndx];
14211                       for (r_symndx = 0;
14212                            r_symndx < symtab_hdr->sh_info;
14213                            r_symndx++)
14214                         if (local_sections[r_symndx] == sec)
14215                           break;
14216                       if (r_symndx >= symtab_hdr->sh_info)
14217                         r_symndx = STN_UNDEF;
14218                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14219                       if (r_symndx != STN_UNDEF)
14220                         rel->r_addend -= (local_syms[r_symndx].st_value
14221                                           + sec->output_offset
14222                                           + sec->output_section->vma);
14223                     }
14224                   else if (toc_symndx != 0)
14225                     {
14226                       r_symndx = toc_symndx;
14227                       rel->r_addend = toc_addend;
14228                     }
14229                   r_type = R_PPC64_TPREL16_HA;
14230                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14231                   if (offset != (bfd_vma) -1)
14232                     {
14233                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14234                                                     R_PPC64_TPREL16_LO);
14235                       rel[1].r_offset = offset + d_offset;
14236                       rel[1].r_addend = rel->r_addend;
14237                     }
14238                 }
14239               bfd_put_32 (input_bfd, insn1,
14240                           contents + rel->r_offset - d_offset);
14241               if (offset != (bfd_vma) -1)
14242                 bfd_put_32 (input_bfd, insn2, contents + offset);
14243               if ((tls_mask & tls_gd) == 0
14244                   && (tls_gd == 0 || toc_symndx != 0))
14245                 {
14246                   /* We changed the symbol.  Start over in order
14247                      to get h, sym, sec etc. right.  */
14248                   goto again;
14249                 }
14250             }
14251           break;
14252
14253         case R_PPC64_TLSGD:
14254           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14255               && rel + 1 < relend)
14256             {
14257               unsigned int insn2;
14258               bfd_vma offset = rel->r_offset;
14259
14260               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14261                 {
14262                   bfd_put_32 (output_bfd, NOP, contents + offset);
14263                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14264                   break;
14265                 }
14266
14267               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14268                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14269
14270               if ((tls_mask & TLS_TPRELGD) != 0)
14271                 {
14272                   /* IE */
14273                   r_type = R_PPC64_NONE;
14274                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14275                 }
14276               else
14277                 {
14278                   /* LE */
14279                   if (toc_symndx != 0)
14280                     {
14281                       r_symndx = toc_symndx;
14282                       rel->r_addend = toc_addend;
14283                     }
14284                   r_type = R_PPC64_TPREL16_LO;
14285                   rel->r_offset = offset + d_offset;
14286                   insn2 = 0x38630000;   /* addi 3,3,0 */
14287                 }
14288               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14289               /* Zap the reloc on the _tls_get_addr call too.  */
14290               BFD_ASSERT (offset == rel[1].r_offset);
14291               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14292               bfd_put_32 (input_bfd, insn2, contents + offset);
14293               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14294                 goto again;
14295             }
14296           break;
14297
14298         case R_PPC64_TLSLD:
14299           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14300               && rel + 1 < relend)
14301             {
14302               unsigned int insn2;
14303               bfd_vma offset = rel->r_offset;
14304
14305               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14306                 {
14307                   bfd_put_32 (output_bfd, NOP, contents + offset);
14308                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14309                   break;
14310                 }
14311
14312               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14313                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14314
14315               if (toc_symndx)
14316                 sec = local_sections[toc_symndx];
14317               for (r_symndx = 0;
14318                    r_symndx < symtab_hdr->sh_info;
14319                    r_symndx++)
14320                 if (local_sections[r_symndx] == sec)
14321                   break;
14322               if (r_symndx >= symtab_hdr->sh_info)
14323                 r_symndx = STN_UNDEF;
14324               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14325               if (r_symndx != STN_UNDEF)
14326                 rel->r_addend -= (local_syms[r_symndx].st_value
14327                                   + sec->output_offset
14328                                   + sec->output_section->vma);
14329
14330               r_type = R_PPC64_TPREL16_LO;
14331               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14332               rel->r_offset = offset + d_offset;
14333               /* Zap the reloc on the _tls_get_addr call too.  */
14334               BFD_ASSERT (offset == rel[1].r_offset);
14335               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14336               insn2 = 0x38630000;       /* addi 3,3,0 */
14337               bfd_put_32 (input_bfd, insn2, contents + offset);
14338               goto again;
14339             }
14340           break;
14341
14342         case R_PPC64_DTPMOD64:
14343           if (rel + 1 < relend
14344               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14345               && rel[1].r_offset == rel->r_offset + 8)
14346             {
14347               if ((tls_mask & TLS_GD) == 0)
14348                 {
14349                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14350                   if ((tls_mask & TLS_TPRELGD) != 0)
14351                     r_type = R_PPC64_TPREL64;
14352                   else
14353                     {
14354                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14355                       r_type = R_PPC64_NONE;
14356                     }
14357                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14358                 }
14359             }
14360           else
14361             {
14362               if ((tls_mask & TLS_LD) == 0)
14363                 {
14364                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14365                   r_type = R_PPC64_NONE;
14366                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14367                 }
14368             }
14369           break;
14370
14371         case R_PPC64_TPREL64:
14372           if ((tls_mask & TLS_TPREL) == 0)
14373             {
14374               r_type = R_PPC64_NONE;
14375               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14376             }
14377           break;
14378
14379         case R_PPC64_ENTRY:
14380           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14381           if (!bfd_link_pic (info)
14382               && !info->traditional_format
14383               && relocation + 0x80008000 <= 0xffffffff)
14384             {
14385               unsigned int insn1, insn2;
14386
14387               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14388               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14389               if ((insn1 & ~0xfffc) == LD_R2_0R12
14390                   && insn2 == ADD_R2_R2_R12)
14391                 {
14392                   bfd_put_32 (input_bfd,
14393                               LIS_R2 + PPC_HA (relocation),
14394                               contents + rel->r_offset);
14395                   bfd_put_32 (input_bfd,
14396                               ADDI_R2_R2 + PPC_LO (relocation),
14397                               contents + rel->r_offset + 4);
14398                 }
14399             }
14400           else
14401             {
14402               relocation -= (rel->r_offset
14403                              + input_section->output_offset
14404                              + input_section->output_section->vma);
14405               if (relocation + 0x80008000 <= 0xffffffff)
14406                 {
14407                   unsigned int insn1, insn2;
14408
14409                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14410                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14411                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14412                       && insn2 == ADD_R2_R2_R12)
14413                     {
14414                       bfd_put_32 (input_bfd,
14415                                   ADDIS_R2_R12 + PPC_HA (relocation),
14416                                   contents + rel->r_offset);
14417                       bfd_put_32 (input_bfd,
14418                                   ADDI_R2_R2 + PPC_LO (relocation),
14419                                   contents + rel->r_offset + 4);
14420                     }
14421                 }
14422             }
14423           break;
14424
14425         case R_PPC64_REL16_HA:
14426           /* If we are generating a non-PIC executable, edit
14427              .  0:      addis 2,12,.TOC.-0b@ha
14428              .          addi 2,2,.TOC.-0b@l
14429              used by ELFv2 global entry points to set up r2, to
14430              .          lis 2,.TOC.@ha
14431              .          addi 2,2,.TOC.@l
14432              if .TOC. is in range.  */
14433           if (!bfd_link_pic (info)
14434               && !info->traditional_format
14435               && !htab->opd_abi
14436               && rel->r_addend == d_offset
14437               && h != NULL && &h->elf == htab->elf.hgot
14438               && rel + 1 < relend
14439               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14440               && rel[1].r_offset == rel->r_offset + 4
14441               && rel[1].r_addend == rel->r_addend + 4
14442               && relocation + 0x80008000 <= 0xffffffff)
14443             {
14444               unsigned int insn1, insn2;
14445               bfd_vma offset = rel->r_offset - d_offset;
14446               insn1 = bfd_get_32 (input_bfd, contents + offset);
14447               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14448               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14449                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14450                 {
14451                   r_type = R_PPC64_ADDR16_HA;
14452                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14453                   rel->r_addend -= d_offset;
14454                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14455                   rel[1].r_addend -= d_offset + 4;
14456                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14457                 }
14458             }
14459           break;
14460         }
14461
14462       /* Handle other relocations that tweak non-addend part of insn.  */
14463       insn = 0;
14464       max_br_offset = 1 << 25;
14465       addend = rel->r_addend;
14466       reloc_dest = DEST_NORMAL;
14467       switch (r_type)
14468         {
14469         default:
14470           break;
14471
14472         case R_PPC64_TOCSAVE:
14473           if (relocation + addend == (rel->r_offset
14474                                       + input_section->output_offset
14475                                       + input_section->output_section->vma)
14476               && tocsave_find (htab, NO_INSERT,
14477                                &local_syms, rel, input_bfd))
14478             {
14479               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14480               if (insn == NOP
14481                   || insn == CROR_151515 || insn == CROR_313131)
14482                 bfd_put_32 (input_bfd,
14483                             STD_R2_0R1 + STK_TOC (htab),
14484                             contents + rel->r_offset);
14485             }
14486           break;
14487
14488           /* Branch taken prediction relocations.  */
14489         case R_PPC64_ADDR14_BRTAKEN:
14490         case R_PPC64_REL14_BRTAKEN:
14491           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14492           /* Fall through.  */
14493
14494           /* Branch not taken prediction relocations.  */
14495         case R_PPC64_ADDR14_BRNTAKEN:
14496         case R_PPC64_REL14_BRNTAKEN:
14497           insn |= bfd_get_32 (input_bfd,
14498                               contents + rel->r_offset) & ~(0x01 << 21);
14499           /* Fall through.  */
14500
14501         case R_PPC64_REL14:
14502           max_br_offset = 1 << 15;
14503           /* Fall through.  */
14504
14505         case R_PPC64_REL24:
14506         case R_PPC64_PLTCALL:
14507           /* Calls to functions with a different TOC, such as calls to
14508              shared objects, need to alter the TOC pointer.  This is
14509              done using a linkage stub.  A REL24 branching to these
14510              linkage stubs needs to be followed by a nop, as the nop
14511              will be replaced with an instruction to restore the TOC
14512              base pointer.  */
14513           fdh = h;
14514           if (h != NULL
14515               && h->oh != NULL
14516               && h->oh->is_func_descriptor)
14517             fdh = ppc_follow_link (h->oh);
14518           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14519                                            htab);
14520           if (r_type == R_PPC64_PLTCALL
14521               && stub_entry != NULL
14522               && (stub_entry->stub_type == ppc_stub_plt_call
14523                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14524             stub_entry = NULL;
14525
14526           if (stub_entry != NULL
14527               && (stub_entry->stub_type == ppc_stub_plt_call
14528                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14529                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14530                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14531             {
14532               bfd_boolean can_plt_call = FALSE;
14533
14534               if (stub_entry->stub_type == ppc_stub_plt_call
14535                   && !htab->opd_abi
14536                   && htab->params->plt_localentry0 != 0
14537                   && is_elfv2_localentry0 (&h->elf))
14538                 {
14539                   /* The function doesn't use or change r2.  */
14540                   can_plt_call = TRUE;
14541                 }
14542
14543               /* All of these stubs may modify r2, so there must be a
14544                  branch and link followed by a nop.  The nop is
14545                  replaced by an insn to restore r2.  */
14546               else if (rel->r_offset + 8 <= input_section->size)
14547                 {
14548                   unsigned long br;
14549
14550                   br = bfd_get_32 (input_bfd,
14551                                    contents + rel->r_offset);
14552                   if ((br & 1) != 0)
14553                     {
14554                       unsigned long nop;
14555
14556                       nop = bfd_get_32 (input_bfd,
14557                                         contents + rel->r_offset + 4);
14558                       if (nop == LD_R2_0R1 + STK_TOC (htab))
14559                         can_plt_call = TRUE;
14560                       else if (nop == NOP
14561                                || nop == CROR_151515
14562                                || nop == CROR_313131)
14563                         {
14564                           if (h != NULL
14565                               && (h == htab->tls_get_addr_fd
14566                                   || h == htab->tls_get_addr)
14567                               && htab->params->tls_get_addr_opt)
14568                             {
14569                               /* Special stub used, leave nop alone.  */
14570                             }
14571                           else
14572                             bfd_put_32 (input_bfd,
14573                                         LD_R2_0R1 + STK_TOC (htab),
14574                                         contents + rel->r_offset + 4);
14575                           can_plt_call = TRUE;
14576                         }
14577                     }
14578                 }
14579
14580               if (!can_plt_call && h != NULL)
14581                 {
14582                   const char *name = h->elf.root.root.string;
14583
14584                   if (*name == '.')
14585                     ++name;
14586
14587                   if (strncmp (name, "__libc_start_main", 17) == 0
14588                       && (name[17] == 0 || name[17] == '@'))
14589                     {
14590                       /* Allow crt1 branch to go via a toc adjusting
14591                          stub.  Other calls that never return could do
14592                          the same, if we could detect such.  */
14593                       can_plt_call = TRUE;
14594                     }
14595                 }
14596
14597               if (!can_plt_call)
14598                 {
14599                   /* g++ as of 20130507 emits self-calls without a
14600                      following nop.  This is arguably wrong since we
14601                      have conflicting information.  On the one hand a
14602                      global symbol and on the other a local call
14603                      sequence, but don't error for this special case.
14604                      It isn't possible to cheaply verify we have
14605                      exactly such a call.  Allow all calls to the same
14606                      section.  */
14607                   asection *code_sec = sec;
14608
14609                   if (get_opd_info (sec) != NULL)
14610                     {
14611                       bfd_vma off = (relocation + addend
14612                                      - sec->output_section->vma
14613                                      - sec->output_offset);
14614
14615                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14616                     }
14617                   if (code_sec == input_section)
14618                     can_plt_call = TRUE;
14619                 }
14620
14621               if (!can_plt_call)
14622                 {
14623                   if (stub_entry->stub_type == ppc_stub_plt_call
14624                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14625                     info->callbacks->einfo
14626                       /* xgettext:c-format */
14627                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14628                          "recompile with -fPIC\n"),
14629                        input_bfd, input_section, rel->r_offset, sym_name);
14630                   else
14631                     info->callbacks->einfo
14632                       /* xgettext:c-format */
14633                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14634                          "(-mcmodel=small toc adjust stub)\n"),
14635                        input_bfd, input_section, rel->r_offset, sym_name);
14636
14637                   bfd_set_error (bfd_error_bad_value);
14638                   ret = FALSE;
14639                 }
14640
14641               if (can_plt_call
14642                   && (stub_entry->stub_type == ppc_stub_plt_call
14643                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14644                 unresolved_reloc = FALSE;
14645             }
14646
14647           if ((stub_entry == NULL
14648                || stub_entry->stub_type == ppc_stub_long_branch
14649                || stub_entry->stub_type == ppc_stub_plt_branch)
14650               && get_opd_info (sec) != NULL)
14651             {
14652               /* The branch destination is the value of the opd entry. */
14653               bfd_vma off = (relocation + addend
14654                              - sec->output_section->vma
14655                              - sec->output_offset);
14656               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14657               if (dest != (bfd_vma) -1)
14658                 {
14659                   relocation = dest;
14660                   addend = 0;
14661                   reloc_dest = DEST_OPD;
14662                 }
14663             }
14664
14665           /* If the branch is out of reach we ought to have a long
14666              branch stub.  */
14667           from = (rel->r_offset
14668                   + input_section->output_offset
14669                   + input_section->output_section->vma);
14670
14671           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14672                                                   ? fdh->elf.other
14673                                                   : sym->st_other);
14674
14675           if (stub_entry != NULL
14676               && (stub_entry->stub_type == ppc_stub_long_branch
14677                   || stub_entry->stub_type == ppc_stub_plt_branch)
14678               && (r_type == R_PPC64_ADDR14_BRTAKEN
14679                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14680                   || (relocation + addend - from + max_br_offset
14681                       < 2 * max_br_offset)))
14682             /* Don't use the stub if this branch is in range.  */
14683             stub_entry = NULL;
14684
14685           if (stub_entry != NULL)
14686             {
14687               /* Munge up the value and addend so that we call the stub
14688                  rather than the procedure directly.  */
14689               asection *stub_sec = stub_entry->group->stub_sec;
14690
14691               if (stub_entry->stub_type == ppc_stub_save_res)
14692                 relocation += (stub_sec->output_offset
14693                                + stub_sec->output_section->vma
14694                                + stub_sec->size - htab->sfpr->size
14695                                - htab->sfpr->output_offset
14696                                - htab->sfpr->output_section->vma);
14697               else
14698                 relocation = (stub_entry->stub_offset
14699                               + stub_sec->output_offset
14700                               + stub_sec->output_section->vma);
14701               addend = 0;
14702               reloc_dest = DEST_STUB;
14703
14704               if ((stub_entry->stub_type == ppc_stub_plt_call
14705                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14706                   && (ALWAYS_EMIT_R2SAVE
14707                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14708                   && rel + 1 < relend
14709                   && rel[1].r_offset == rel->r_offset + 4
14710                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14711                 relocation += 4;
14712             }
14713
14714           if (insn != 0)
14715             {
14716               if (is_isa_v2)
14717                 {
14718                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14719                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14720                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14721                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14722                     insn |= 0x02 << 21;
14723                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14724                     insn |= 0x08 << 21;
14725                   else
14726                     break;
14727                 }
14728               else
14729                 {
14730                   /* Invert 'y' bit if not the default.  */
14731                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14732                     insn ^= 0x01 << 21;
14733                 }
14734
14735               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14736             }
14737
14738           /* NOP out calls to undefined weak functions.
14739              We can thus call a weak function without first
14740              checking whether the function is defined.  */
14741           else if (h != NULL
14742                    && h->elf.root.type == bfd_link_hash_undefweak
14743                    && h->elf.dynindx == -1
14744                    && r_type == R_PPC64_REL24
14745                    && relocation == 0
14746                    && addend == 0)
14747             {
14748               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14749               goto copy_reloc;
14750             }
14751           break;
14752         }
14753
14754       /* Set `addend'.  */
14755       tls_type = 0;
14756       save_unresolved_reloc = unresolved_reloc;
14757       switch (r_type)
14758         {
14759         default:
14760           /* xgettext:c-format */
14761           _bfd_error_handler (_("%pB: %s unsupported"),
14762                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14763
14764           bfd_set_error (bfd_error_bad_value);
14765           ret = FALSE;
14766           goto copy_reloc;
14767
14768         case R_PPC64_NONE:
14769         case R_PPC64_TLS:
14770         case R_PPC64_TLSGD:
14771         case R_PPC64_TLSLD:
14772         case R_PPC64_TOCSAVE:
14773         case R_PPC64_GNU_VTINHERIT:
14774         case R_PPC64_GNU_VTENTRY:
14775         case R_PPC64_ENTRY:
14776           goto copy_reloc;
14777
14778           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14779              address in the GOT as relocation value instead of the
14780              symbol's value itself.  Also, create a GOT entry for the
14781              symbol and put the symbol value there.  */
14782         case R_PPC64_GOT_TLSGD16:
14783         case R_PPC64_GOT_TLSGD16_LO:
14784         case R_PPC64_GOT_TLSGD16_HI:
14785         case R_PPC64_GOT_TLSGD16_HA:
14786           tls_type = TLS_TLS | TLS_GD;
14787           goto dogot;
14788
14789         case R_PPC64_GOT_TLSLD16:
14790         case R_PPC64_GOT_TLSLD16_LO:
14791         case R_PPC64_GOT_TLSLD16_HI:
14792         case R_PPC64_GOT_TLSLD16_HA:
14793           tls_type = TLS_TLS | TLS_LD;
14794           goto dogot;
14795
14796         case R_PPC64_GOT_TPREL16_DS:
14797         case R_PPC64_GOT_TPREL16_LO_DS:
14798         case R_PPC64_GOT_TPREL16_HI:
14799         case R_PPC64_GOT_TPREL16_HA:
14800           tls_type = TLS_TLS | TLS_TPREL;
14801           goto dogot;
14802
14803         case R_PPC64_GOT_DTPREL16_DS:
14804         case R_PPC64_GOT_DTPREL16_LO_DS:
14805         case R_PPC64_GOT_DTPREL16_HI:
14806         case R_PPC64_GOT_DTPREL16_HA:
14807           tls_type = TLS_TLS | TLS_DTPREL;
14808           goto dogot;
14809
14810         case R_PPC64_GOT16:
14811         case R_PPC64_GOT16_LO:
14812         case R_PPC64_GOT16_HI:
14813         case R_PPC64_GOT16_HA:
14814         case R_PPC64_GOT16_DS:
14815         case R_PPC64_GOT16_LO_DS:
14816         dogot:
14817           {
14818             /* Relocation is to the entry for this symbol in the global
14819                offset table.  */
14820             asection *got;
14821             bfd_vma *offp;
14822             bfd_vma off;
14823             unsigned long indx = 0;
14824             struct got_entry *ent;
14825
14826             if (tls_type == (TLS_TLS | TLS_LD)
14827                 && (h == NULL
14828                     || !h->elf.def_dynamic))
14829               ent = ppc64_tlsld_got (input_bfd);
14830             else
14831               {
14832                 if (h != NULL)
14833                   {
14834                     if (!htab->elf.dynamic_sections_created
14835                         || h->elf.dynindx == -1
14836                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14837                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14838                       /* This is actually a static link, or it is a
14839                          -Bsymbolic link and the symbol is defined
14840                          locally, or the symbol was forced to be local
14841                          because of a version file.  */
14842                       ;
14843                     else
14844                       {
14845                         indx = h->elf.dynindx;
14846                         unresolved_reloc = FALSE;
14847                       }
14848                     ent = h->elf.got.glist;
14849                   }
14850                 else
14851                   {
14852                     if (local_got_ents == NULL)
14853                       abort ();
14854                     ent = local_got_ents[r_symndx];
14855                   }
14856
14857                 for (; ent != NULL; ent = ent->next)
14858                   if (ent->addend == orig_rel.r_addend
14859                       && ent->owner == input_bfd
14860                       && ent->tls_type == tls_type)
14861                     break;
14862               }
14863
14864             if (ent == NULL)
14865               abort ();
14866             if (ent->is_indirect)
14867               ent = ent->got.ent;
14868             offp = &ent->got.offset;
14869             got = ppc64_elf_tdata (ent->owner)->got;
14870             if (got == NULL)
14871               abort ();
14872
14873             /* The offset must always be a multiple of 8.  We use the
14874                least significant bit to record whether we have already
14875                processed this entry.  */
14876             off = *offp;
14877             if ((off & 1) != 0)
14878               off &= ~1;
14879             else
14880               {
14881                 /* Generate relocs for the dynamic linker, except in
14882                    the case of TLSLD where we'll use one entry per
14883                    module.  */
14884                 asection *relgot;
14885                 bfd_boolean ifunc;
14886
14887                 *offp = off | 1;
14888                 relgot = NULL;
14889                 ifunc = (h != NULL
14890                          ? h->elf.type == STT_GNU_IFUNC
14891                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14892                 if (ifunc)
14893                   {
14894                     relgot = htab->elf.irelplt;
14895                     if (indx == 0)
14896                       htab->local_ifunc_resolver = 1;
14897                     else if (is_static_defined (&h->elf))
14898                       htab->maybe_local_ifunc_resolver = 1;
14899                   }
14900                 else if (indx != 0
14901                          || (bfd_link_pic (info)
14902                              && (h == NULL
14903                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14904                                  || (tls_type == (TLS_TLS | TLS_LD)
14905                                      && !h->elf.def_dynamic))
14906                              && !(tls_type == (TLS_TLS | TLS_TPREL)
14907                                   && bfd_link_executable (info)
14908                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14909                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14910                 if (relgot != NULL)
14911                   {
14912                     outrel.r_offset = (got->output_section->vma
14913                                        + got->output_offset
14914                                        + off);
14915                     outrel.r_addend = addend;
14916                     if (tls_type & (TLS_LD | TLS_GD))
14917                       {
14918                         outrel.r_addend = 0;
14919                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14920                         if (tls_type == (TLS_TLS | TLS_GD))
14921                           {
14922                             loc = relgot->contents;
14923                             loc += (relgot->reloc_count++
14924                                     * sizeof (Elf64_External_Rela));
14925                             bfd_elf64_swap_reloca_out (output_bfd,
14926                                                        &outrel, loc);
14927                             outrel.r_offset += 8;
14928                             outrel.r_addend = addend;
14929                             outrel.r_info
14930                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14931                           }
14932                       }
14933                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14934                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14935                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14936                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14937                     else if (indx != 0)
14938                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14939                     else
14940                       {
14941                         if (ifunc)
14942                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14943                         else
14944                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14945
14946                         /* Write the .got section contents for the sake
14947                            of prelink.  */
14948                         loc = got->contents + off;
14949                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14950                                     loc);
14951                       }
14952
14953                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14954                       {
14955                         outrel.r_addend += relocation;
14956                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14957                           {
14958                             if (htab->elf.tls_sec == NULL)
14959                               outrel.r_addend = 0;
14960                             else
14961                               outrel.r_addend -= htab->elf.tls_sec->vma;
14962                           }
14963                       }
14964                     loc = relgot->contents;
14965                     loc += (relgot->reloc_count++
14966                             * sizeof (Elf64_External_Rela));
14967                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14968                   }
14969
14970                 /* Init the .got section contents here if we're not
14971                    emitting a reloc.  */
14972                 else
14973                   {
14974                     relocation += addend;
14975                     if (tls_type != 0)
14976                       {
14977                         if (htab->elf.tls_sec == NULL)
14978                           relocation = 0;
14979                         else
14980                           {
14981                             if (tls_type & TLS_LD)
14982                               relocation = 0;
14983                             else
14984                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14985                             if (tls_type & TLS_TPREL)
14986                               relocation += DTP_OFFSET - TP_OFFSET;
14987                           }
14988
14989                         if (tls_type & (TLS_GD | TLS_LD))
14990                           {
14991                             bfd_put_64 (output_bfd, relocation,
14992                                         got->contents + off + 8);
14993                             relocation = 1;
14994                           }
14995                       }
14996                     bfd_put_64 (output_bfd, relocation,
14997                                 got->contents + off);
14998                   }
14999               }
15000
15001             if (off >= (bfd_vma) -2)
15002               abort ();
15003
15004             relocation = got->output_section->vma + got->output_offset + off;
15005             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15006           }
15007           break;
15008
15009         case R_PPC64_PLT16_HA:
15010         case R_PPC64_PLT16_HI:
15011         case R_PPC64_PLT16_LO:
15012         case R_PPC64_PLT16_LO_DS:
15013         case R_PPC64_PLT32:
15014         case R_PPC64_PLT64:
15015         case R_PPC64_PLTSEQ:
15016         case R_PPC64_PLTCALL:
15017           /* Relocation is to the entry for this symbol in the
15018              procedure linkage table.  */
15019           unresolved_reloc = TRUE;
15020           {
15021             struct plt_entry **plt_list = NULL;
15022             if (h != NULL)
15023               plt_list = &h->elf.plt.plist;
15024             else if (local_got_ents != NULL)
15025               {
15026                 struct plt_entry **local_plt = (struct plt_entry **)
15027                   (local_got_ents + symtab_hdr->sh_info);
15028                 plt_list = local_plt + r_symndx;
15029               }
15030             if (plt_list)
15031               {
15032                 struct plt_entry *ent;
15033
15034                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15035                   if (ent->plt.offset != (bfd_vma) -1
15036                       && ent->addend == orig_rel.r_addend)
15037                     {
15038                       asection *plt;
15039                       bfd_vma got;
15040
15041                       plt = htab->elf.splt;
15042                       if (!htab->elf.dynamic_sections_created
15043                           || h == NULL
15044                           || h->elf.dynindx == -1)
15045                         {
15046                           if (h != NULL
15047                               ? h->elf.type == STT_GNU_IFUNC
15048                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15049                             plt = htab->elf.iplt;
15050                           else
15051                             plt = htab->pltlocal;
15052                         }
15053                       relocation = (plt->output_section->vma
15054                                     + plt->output_offset
15055                                     + ent->plt.offset);
15056                       if (r_type == R_PPC64_PLT16_HA
15057                           || r_type ==R_PPC64_PLT16_HI
15058                           || r_type ==R_PPC64_PLT16_LO
15059                           || r_type ==R_PPC64_PLT16_LO_DS)
15060                         {
15061                           got = (elf_gp (output_bfd)
15062                                  + htab->sec_info[input_section->id].toc_off);
15063                           relocation -= got;
15064                         }
15065                       addend = 0;
15066                       unresolved_reloc = FALSE;
15067                       break;
15068                     }
15069               }
15070           }
15071           break;
15072
15073         case R_PPC64_TOC:
15074           /* Relocation value is TOC base.  */
15075           relocation = TOCstart;
15076           if (r_symndx == STN_UNDEF)
15077             relocation += htab->sec_info[input_section->id].toc_off;
15078           else if (unresolved_reloc)
15079             ;
15080           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15081             relocation += htab->sec_info[sec->id].toc_off;
15082           else
15083             unresolved_reloc = TRUE;
15084           goto dodyn;
15085
15086           /* TOC16 relocs.  We want the offset relative to the TOC base,
15087              which is the address of the start of the TOC plus 0x8000.
15088              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15089              in this order.  */
15090         case R_PPC64_TOC16:
15091         case R_PPC64_TOC16_LO:
15092         case R_PPC64_TOC16_HI:
15093         case R_PPC64_TOC16_DS:
15094         case R_PPC64_TOC16_LO_DS:
15095         case R_PPC64_TOC16_HA:
15096           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15097           break;
15098
15099           /* Relocate against the beginning of the section.  */
15100         case R_PPC64_SECTOFF:
15101         case R_PPC64_SECTOFF_LO:
15102         case R_PPC64_SECTOFF_HI:
15103         case R_PPC64_SECTOFF_DS:
15104         case R_PPC64_SECTOFF_LO_DS:
15105         case R_PPC64_SECTOFF_HA:
15106           if (sec != NULL)
15107             addend -= sec->output_section->vma;
15108           break;
15109
15110         case R_PPC64_REL16:
15111         case R_PPC64_REL16_LO:
15112         case R_PPC64_REL16_HI:
15113         case R_PPC64_REL16_HA:
15114         case R_PPC64_REL16DX_HA:
15115           break;
15116
15117         case R_PPC64_REL14:
15118         case R_PPC64_REL14_BRNTAKEN:
15119         case R_PPC64_REL14_BRTAKEN:
15120         case R_PPC64_REL24:
15121           break;
15122
15123         case R_PPC64_TPREL16:
15124         case R_PPC64_TPREL16_LO:
15125         case R_PPC64_TPREL16_HI:
15126         case R_PPC64_TPREL16_HA:
15127         case R_PPC64_TPREL16_DS:
15128         case R_PPC64_TPREL16_LO_DS:
15129         case R_PPC64_TPREL16_HIGH:
15130         case R_PPC64_TPREL16_HIGHA:
15131         case R_PPC64_TPREL16_HIGHER:
15132         case R_PPC64_TPREL16_HIGHERA:
15133         case R_PPC64_TPREL16_HIGHEST:
15134         case R_PPC64_TPREL16_HIGHESTA:
15135           if (h != NULL
15136               && h->elf.root.type == bfd_link_hash_undefweak
15137               && h->elf.dynindx == -1)
15138             {
15139               /* Make this relocation against an undefined weak symbol
15140                  resolve to zero.  This is really just a tweak, since
15141                  code using weak externs ought to check that they are
15142                  defined before using them.  */
15143               bfd_byte *p = contents + rel->r_offset - d_offset;
15144
15145               insn = bfd_get_32 (input_bfd, p);
15146               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15147               if (insn != 0)
15148                 bfd_put_32 (input_bfd, insn, p);
15149               break;
15150             }
15151           if (htab->elf.tls_sec != NULL)
15152             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15153           /* The TPREL16 relocs shouldn't really be used in shared
15154              libs or with non-local symbols as that will result in
15155              DT_TEXTREL being set, but support them anyway.  */
15156           goto dodyn;
15157
15158         case R_PPC64_DTPREL16:
15159         case R_PPC64_DTPREL16_LO:
15160         case R_PPC64_DTPREL16_HI:
15161         case R_PPC64_DTPREL16_HA:
15162         case R_PPC64_DTPREL16_DS:
15163         case R_PPC64_DTPREL16_LO_DS:
15164         case R_PPC64_DTPREL16_HIGH:
15165         case R_PPC64_DTPREL16_HIGHA:
15166         case R_PPC64_DTPREL16_HIGHER:
15167         case R_PPC64_DTPREL16_HIGHERA:
15168         case R_PPC64_DTPREL16_HIGHEST:
15169         case R_PPC64_DTPREL16_HIGHESTA:
15170           if (htab->elf.tls_sec != NULL)
15171             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15172           break;
15173
15174         case R_PPC64_ADDR64_LOCAL:
15175           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15176                                               ? h->elf.other
15177                                               : sym->st_other);
15178           break;
15179
15180         case R_PPC64_DTPMOD64:
15181           relocation = 1;
15182           addend = 0;
15183           goto dodyn;
15184
15185         case R_PPC64_TPREL64:
15186           if (htab->elf.tls_sec != NULL)
15187             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15188           goto dodyn;
15189
15190         case R_PPC64_DTPREL64:
15191           if (htab->elf.tls_sec != NULL)
15192             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15193           /* Fall through.  */
15194
15195           /* Relocations that may need to be propagated if this is a
15196              dynamic object.  */
15197         case R_PPC64_REL30:
15198         case R_PPC64_REL32:
15199         case R_PPC64_REL64:
15200         case R_PPC64_ADDR14:
15201         case R_PPC64_ADDR14_BRNTAKEN:
15202         case R_PPC64_ADDR14_BRTAKEN:
15203         case R_PPC64_ADDR16:
15204         case R_PPC64_ADDR16_DS:
15205         case R_PPC64_ADDR16_HA:
15206         case R_PPC64_ADDR16_HI:
15207         case R_PPC64_ADDR16_HIGH:
15208         case R_PPC64_ADDR16_HIGHA:
15209         case R_PPC64_ADDR16_HIGHER:
15210         case R_PPC64_ADDR16_HIGHERA:
15211         case R_PPC64_ADDR16_HIGHEST:
15212         case R_PPC64_ADDR16_HIGHESTA:
15213         case R_PPC64_ADDR16_LO:
15214         case R_PPC64_ADDR16_LO_DS:
15215         case R_PPC64_ADDR24:
15216         case R_PPC64_ADDR32:
15217         case R_PPC64_ADDR64:
15218         case R_PPC64_UADDR16:
15219         case R_PPC64_UADDR32:
15220         case R_PPC64_UADDR64:
15221         dodyn:
15222           if ((input_section->flags & SEC_ALLOC) == 0)
15223             break;
15224
15225           if (NO_OPD_RELOCS && is_opd)
15226             break;
15227
15228           if (bfd_link_pic (info)
15229               ? ((h == NULL
15230                   || h->dyn_relocs != NULL)
15231                  && ((h != NULL && pc_dynrelocs (h))
15232                      || must_be_dyn_reloc (info, r_type)))
15233               : (h != NULL
15234                  ? h->dyn_relocs != NULL
15235                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15236             {
15237               bfd_boolean skip, relocate;
15238               asection *sreloc;
15239               bfd_vma out_off;
15240               long indx = 0;
15241
15242               /* When generating a dynamic object, these relocations
15243                  are copied into the output file to be resolved at run
15244                  time.  */
15245
15246               skip = FALSE;
15247               relocate = FALSE;
15248
15249               out_off = _bfd_elf_section_offset (output_bfd, info,
15250                                                  input_section, rel->r_offset);
15251               if (out_off == (bfd_vma) -1)
15252                 skip = TRUE;
15253               else if (out_off == (bfd_vma) -2)
15254                 skip = TRUE, relocate = TRUE;
15255               out_off += (input_section->output_section->vma
15256                           + input_section->output_offset);
15257               outrel.r_offset = out_off;
15258               outrel.r_addend = rel->r_addend;
15259
15260               /* Optimize unaligned reloc use.  */
15261               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15262                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15263                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15264               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15265                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15266                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15267               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15268                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15269                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15270
15271               if (skip)
15272                 memset (&outrel, 0, sizeof outrel);
15273               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15274                        && !is_opd
15275                        && r_type != R_PPC64_TOC)
15276                 {
15277                   indx = h->elf.dynindx;
15278                   BFD_ASSERT (indx != -1);
15279                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15280                 }
15281               else
15282                 {
15283                   /* This symbol is local, or marked to become local,
15284                      or this is an opd section reloc which must point
15285                      at a local function.  */
15286                   outrel.r_addend += relocation;
15287                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15288                     {
15289                       if (is_opd && h != NULL)
15290                         {
15291                           /* Lie about opd entries.  This case occurs
15292                              when building shared libraries and we
15293                              reference a function in another shared
15294                              lib.  The same thing happens for a weak
15295                              definition in an application that's
15296                              overridden by a strong definition in a
15297                              shared lib.  (I believe this is a generic
15298                              bug in binutils handling of weak syms.)
15299                              In these cases we won't use the opd
15300                              entry in this lib.  */
15301                           unresolved_reloc = FALSE;
15302                         }
15303                       if (!is_opd
15304                           && r_type == R_PPC64_ADDR64
15305                           && (h != NULL
15306                               ? h->elf.type == STT_GNU_IFUNC
15307                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15308                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15309                       else
15310                         {
15311                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15312
15313                           /* We need to relocate .opd contents for ld.so.
15314                              Prelink also wants simple and consistent rules
15315                              for relocs.  This make all RELATIVE relocs have
15316                              *r_offset equal to r_addend.  */
15317                           relocate = TRUE;
15318                         }
15319                     }
15320                   else
15321                     {
15322                       if (h != NULL
15323                           ? h->elf.type == STT_GNU_IFUNC
15324                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15325                         {
15326                           info->callbacks->einfo
15327                             /* xgettext:c-format */
15328                             (_("%H: %s for indirect "
15329                                "function `%pT' unsupported\n"),
15330                              input_bfd, input_section, rel->r_offset,
15331                              ppc64_elf_howto_table[r_type]->name,
15332                              sym_name);
15333                           ret = FALSE;
15334                         }
15335                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15336                         ;
15337                       else if (sec == NULL || sec->owner == NULL)
15338                         {
15339                           bfd_set_error (bfd_error_bad_value);
15340                           return FALSE;
15341                         }
15342                       else
15343                         {
15344                           asection *osec;
15345
15346                           osec = sec->output_section;
15347                           indx = elf_section_data (osec)->dynindx;
15348
15349                           if (indx == 0)
15350                             {
15351                               if ((osec->flags & SEC_READONLY) == 0
15352                                   && htab->elf.data_index_section != NULL)
15353                                 osec = htab->elf.data_index_section;
15354                               else
15355                                 osec = htab->elf.text_index_section;
15356                               indx = elf_section_data (osec)->dynindx;
15357                             }
15358                           BFD_ASSERT (indx != 0);
15359
15360                           /* We are turning this relocation into one
15361                              against a section symbol, so subtract out
15362                              the output section's address but not the
15363                              offset of the input section in the output
15364                              section.  */
15365                           outrel.r_addend -= osec->vma;
15366                         }
15367
15368                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15369                     }
15370                 }
15371
15372               sreloc = elf_section_data (input_section)->sreloc;
15373               if (h != NULL
15374                   ? h->elf.type == STT_GNU_IFUNC
15375                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15376                 {
15377                   sreloc = htab->elf.irelplt;
15378                   if (indx == 0)
15379                     htab->local_ifunc_resolver = 1;
15380                   else if (is_static_defined (&h->elf))
15381                     htab->maybe_local_ifunc_resolver = 1;
15382                 }
15383               if (sreloc == NULL)
15384                 abort ();
15385
15386               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15387                   >= sreloc->size)
15388                 abort ();
15389               loc = sreloc->contents;
15390               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15391               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15392
15393               /* If this reloc is against an external symbol, it will
15394                  be computed at runtime, so there's no need to do
15395                  anything now.  However, for the sake of prelink ensure
15396                  that the section contents are a known value.  */
15397               if (! relocate)
15398                 {
15399                   unresolved_reloc = FALSE;
15400                   /* The value chosen here is quite arbitrary as ld.so
15401                      ignores section contents except for the special
15402                      case of .opd where the contents might be accessed
15403                      before relocation.  Choose zero, as that won't
15404                      cause reloc overflow.  */
15405                   relocation = 0;
15406                   addend = 0;
15407                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15408                      to improve backward compatibility with older
15409                      versions of ld.  */
15410                   if (r_type == R_PPC64_ADDR64)
15411                     addend = outrel.r_addend;
15412                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15413                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15414                     addend = outrel.r_offset;
15415                 }
15416             }
15417           break;
15418
15419         case R_PPC64_COPY:
15420         case R_PPC64_GLOB_DAT:
15421         case R_PPC64_JMP_SLOT:
15422         case R_PPC64_JMP_IREL:
15423         case R_PPC64_RELATIVE:
15424           /* We shouldn't ever see these dynamic relocs in relocatable
15425              files.  */
15426           /* Fall through.  */
15427
15428         case R_PPC64_PLTGOT16:
15429         case R_PPC64_PLTGOT16_DS:
15430         case R_PPC64_PLTGOT16_HA:
15431         case R_PPC64_PLTGOT16_HI:
15432         case R_PPC64_PLTGOT16_LO:
15433         case R_PPC64_PLTGOT16_LO_DS:
15434         case R_PPC64_PLTREL32:
15435         case R_PPC64_PLTREL64:
15436           /* These ones haven't been implemented yet.  */
15437
15438           info->callbacks->einfo
15439             /* xgettext:c-format */
15440             (_("%P: %pB: %s is not supported for `%pT'\n"),
15441              input_bfd,
15442              ppc64_elf_howto_table[r_type]->name, sym_name);
15443
15444           bfd_set_error (bfd_error_invalid_operation);
15445           ret = FALSE;
15446           goto copy_reloc;
15447         }
15448
15449       /* Multi-instruction sequences that access the TOC can be
15450          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15451          to             nop;           addi rb,r2,x;  */
15452       switch (r_type)
15453         {
15454         default:
15455           break;
15456
15457         case R_PPC64_GOT_TLSLD16_HI:
15458         case R_PPC64_GOT_TLSGD16_HI:
15459         case R_PPC64_GOT_TPREL16_HI:
15460         case R_PPC64_GOT_DTPREL16_HI:
15461         case R_PPC64_GOT16_HI:
15462         case R_PPC64_TOC16_HI:
15463           /* These relocs would only be useful if building up an
15464              offset to later add to r2, perhaps in an indexed
15465              addressing mode instruction.  Don't try to optimize.
15466              Unfortunately, the possibility of someone building up an
15467              offset like this or even with the HA relocs, means that
15468              we need to check the high insn when optimizing the low
15469              insn.  */
15470           break;
15471
15472         case R_PPC64_PLTCALL:
15473           if (unresolved_reloc)
15474             {
15475               /* No plt entry.  Make this into a direct call.  */
15476               bfd_byte *p = contents + rel->r_offset;
15477               insn = bfd_get_32 (input_bfd, p);
15478               insn &= 1;
15479               bfd_put_32 (input_bfd, B_DOT | insn, p);
15480               bfd_put_32 (input_bfd, NOP, p + 4);
15481               unresolved_reloc = save_unresolved_reloc;
15482               r_type = R_PPC64_REL24;
15483             }
15484           break;
15485
15486         case R_PPC64_PLTSEQ:
15487           if (unresolved_reloc)
15488             {
15489               unresolved_reloc = FALSE;
15490               goto nop_it;
15491             }
15492           break;
15493
15494         case R_PPC64_PLT16_HA:
15495           if (unresolved_reloc)
15496             {
15497               unresolved_reloc = FALSE;
15498               goto nop_it;
15499             }
15500           /* Fall through.  */
15501         case R_PPC64_GOT_TLSLD16_HA:
15502         case R_PPC64_GOT_TLSGD16_HA:
15503         case R_PPC64_GOT_TPREL16_HA:
15504         case R_PPC64_GOT_DTPREL16_HA:
15505         case R_PPC64_GOT16_HA:
15506         case R_PPC64_TOC16_HA:
15507           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15508               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15509             {
15510               bfd_byte *p;
15511             nop_it:
15512               p = contents + (rel->r_offset & ~3);
15513               bfd_put_32 (input_bfd, NOP, p);
15514               goto copy_reloc;
15515             }
15516           break;
15517
15518         case R_PPC64_PLT16_LO:
15519         case R_PPC64_PLT16_LO_DS:
15520           if (unresolved_reloc)
15521             {
15522               unresolved_reloc = FALSE;
15523               goto nop_it;
15524             }
15525           /* Fall through.  */
15526         case R_PPC64_GOT_TLSLD16_LO:
15527         case R_PPC64_GOT_TLSGD16_LO:
15528         case R_PPC64_GOT_TPREL16_LO_DS:
15529         case R_PPC64_GOT_DTPREL16_LO_DS:
15530         case R_PPC64_GOT16_LO:
15531         case R_PPC64_GOT16_LO_DS:
15532         case R_PPC64_TOC16_LO:
15533         case R_PPC64_TOC16_LO_DS:
15534           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15535               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15536             {
15537               bfd_byte *p = contents + (rel->r_offset & ~3);
15538               insn = bfd_get_32 (input_bfd, p);
15539               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15540                 {
15541                   /* Transform addic to addi when we change reg.  */
15542                   insn &= ~((0x3f << 26) | (0x1f << 16));
15543                   insn |= (14u << 26) | (2 << 16);
15544                 }
15545               else
15546                 {
15547                   insn &= ~(0x1f << 16);
15548                   insn |= 2 << 16;
15549                 }
15550               bfd_put_32 (input_bfd, insn, p);
15551             }
15552           break;
15553
15554         case R_PPC64_TPREL16_HA:
15555           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15556             {
15557               bfd_byte *p = contents + (rel->r_offset & ~3);
15558               insn = bfd_get_32 (input_bfd, p);
15559               if ((insn & ((0x3f << 26) | 0x1f << 16))
15560                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15561                 /* xgettext:c-format */
15562                 info->callbacks->minfo
15563                   (_("%H: warning: %s unexpected insn %#x.\n"),
15564                    input_bfd, input_section, rel->r_offset,
15565                    ppc64_elf_howto_table[r_type]->name, insn);
15566               else
15567                 {
15568                   bfd_put_32 (input_bfd, NOP, p);
15569                   goto copy_reloc;
15570                 }
15571             }
15572           break;
15573
15574         case R_PPC64_TPREL16_LO:
15575         case R_PPC64_TPREL16_LO_DS:
15576           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15577             {
15578               bfd_byte *p = contents + (rel->r_offset & ~3);
15579               insn = bfd_get_32 (input_bfd, p);
15580               insn &= ~(0x1f << 16);
15581               insn |= 13 << 16;
15582               bfd_put_32 (input_bfd, insn, p);
15583             }
15584           break;
15585         }
15586
15587       /* Do any further special processing.  */
15588       switch (r_type)
15589         {
15590         default:
15591           break;
15592
15593         case R_PPC64_REL16_HA:
15594         case R_PPC64_REL16DX_HA:
15595         case R_PPC64_ADDR16_HA:
15596         case R_PPC64_ADDR16_HIGHA:
15597         case R_PPC64_ADDR16_HIGHERA:
15598         case R_PPC64_ADDR16_HIGHESTA:
15599         case R_PPC64_TOC16_HA:
15600         case R_PPC64_SECTOFF_HA:
15601         case R_PPC64_TPREL16_HA:
15602         case R_PPC64_TPREL16_HIGHA:
15603         case R_PPC64_TPREL16_HIGHERA:
15604         case R_PPC64_TPREL16_HIGHESTA:
15605         case R_PPC64_DTPREL16_HA:
15606         case R_PPC64_DTPREL16_HIGHA:
15607         case R_PPC64_DTPREL16_HIGHERA:
15608         case R_PPC64_DTPREL16_HIGHESTA:
15609           /* It's just possible that this symbol is a weak symbol
15610              that's not actually defined anywhere. In that case,
15611              'sec' would be NULL, and we should leave the symbol
15612              alone (it will be set to zero elsewhere in the link).  */
15613           if (sec == NULL)
15614             break;
15615           /* Fall through.  */
15616
15617         case R_PPC64_GOT16_HA:
15618         case R_PPC64_PLTGOT16_HA:
15619         case R_PPC64_PLT16_HA:
15620         case R_PPC64_GOT_TLSGD16_HA:
15621         case R_PPC64_GOT_TLSLD16_HA:
15622         case R_PPC64_GOT_TPREL16_HA:
15623         case R_PPC64_GOT_DTPREL16_HA:
15624           /* Add 0x10000 if sign bit in 0:15 is set.
15625              Bits 0:15 are not used.  */
15626           addend += 0x8000;
15627           break;
15628
15629         case R_PPC64_ADDR16_DS:
15630         case R_PPC64_ADDR16_LO_DS:
15631         case R_PPC64_GOT16_DS:
15632         case R_PPC64_GOT16_LO_DS:
15633         case R_PPC64_PLT16_LO_DS:
15634         case R_PPC64_SECTOFF_DS:
15635         case R_PPC64_SECTOFF_LO_DS:
15636         case R_PPC64_TOC16_DS:
15637         case R_PPC64_TOC16_LO_DS:
15638         case R_PPC64_PLTGOT16_DS:
15639         case R_PPC64_PLTGOT16_LO_DS:
15640         case R_PPC64_GOT_TPREL16_DS:
15641         case R_PPC64_GOT_TPREL16_LO_DS:
15642         case R_PPC64_GOT_DTPREL16_DS:
15643         case R_PPC64_GOT_DTPREL16_LO_DS:
15644         case R_PPC64_TPREL16_DS:
15645         case R_PPC64_TPREL16_LO_DS:
15646         case R_PPC64_DTPREL16_DS:
15647         case R_PPC64_DTPREL16_LO_DS:
15648           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15649           mask = 3;
15650           /* If this reloc is against an lq, lxv, or stxv insn, then
15651              the value must be a multiple of 16.  This is somewhat of
15652              a hack, but the "correct" way to do this by defining _DQ
15653              forms of all the _DS relocs bloats all reloc switches in
15654              this file.  It doesn't make much sense to use these
15655              relocs in data, so testing the insn should be safe.  */
15656           if ((insn & (0x3f << 26)) == (56u << 26)
15657               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15658             mask = 15;
15659           relocation += addend;
15660           addend = insn & (mask ^ 3);
15661           if ((relocation & mask) != 0)
15662             {
15663               relocation ^= relocation & mask;
15664               info->callbacks->einfo
15665                 /* xgettext:c-format */
15666                 (_("%H: error: %s not a multiple of %u\n"),
15667                  input_bfd, input_section, rel->r_offset,
15668                  ppc64_elf_howto_table[r_type]->name,
15669                  mask + 1);
15670               bfd_set_error (bfd_error_bad_value);
15671               ret = FALSE;
15672               goto copy_reloc;
15673             }
15674           break;
15675         }
15676
15677       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15678          because such sections are not SEC_ALLOC and thus ld.so will
15679          not process them.  */
15680       howto = ppc64_elf_howto_table[(int) r_type];
15681       if (unresolved_reloc
15682           && !((input_section->flags & SEC_DEBUGGING) != 0
15683                && h->elf.def_dynamic)
15684           && _bfd_elf_section_offset (output_bfd, info, input_section,
15685                                       rel->r_offset) != (bfd_vma) -1)
15686         {
15687           info->callbacks->einfo
15688             /* xgettext:c-format */
15689             (_("%H: unresolvable %s against `%pT'\n"),
15690              input_bfd, input_section, rel->r_offset,
15691              howto->name,
15692              h->elf.root.root.string);
15693           ret = FALSE;
15694         }
15695
15696       /* 16-bit fields in insns mostly have signed values, but a
15697          few insns have 16-bit unsigned values.  Really, we should
15698          have different reloc types.  */
15699       if (howto->complain_on_overflow != complain_overflow_dont
15700           && howto->dst_mask == 0xffff
15701           && (input_section->flags & SEC_CODE) != 0)
15702         {
15703           enum complain_overflow complain = complain_overflow_signed;
15704
15705           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15706           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15707             complain = complain_overflow_bitfield;
15708           else if (howto->rightshift == 0
15709                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15710                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15711                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15712                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15713                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15714                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15715             complain = complain_overflow_unsigned;
15716           if (howto->complain_on_overflow != complain)
15717             {
15718               alt_howto = *howto;
15719               alt_howto.complain_on_overflow = complain;
15720               howto = &alt_howto;
15721             }
15722         }
15723
15724       if (r_type == R_PPC64_REL16DX_HA)
15725         {
15726           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15727           if (rel->r_offset + 4 > input_section->size)
15728             r = bfd_reloc_outofrange;
15729           else
15730             {
15731               relocation += addend;
15732               relocation -= (rel->r_offset
15733                              + input_section->output_offset
15734                              + input_section->output_section->vma);
15735               relocation = (bfd_signed_vma) relocation >> 16;
15736               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15737               insn &= ~0x1fffc1;
15738               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15739               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15740               r = bfd_reloc_ok;
15741               if (relocation + 0x8000 > 0xffff)
15742                 r = bfd_reloc_overflow;
15743             }
15744         }
15745       else
15746         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15747                                       rel->r_offset, relocation, addend);
15748
15749       if (r != bfd_reloc_ok)
15750         {
15751           char *more_info = NULL;
15752           const char *reloc_name = howto->name;
15753
15754           if (reloc_dest != DEST_NORMAL)
15755             {
15756               more_info = bfd_malloc (strlen (reloc_name) + 8);
15757               if (more_info != NULL)
15758                 {
15759                   strcpy (more_info, reloc_name);
15760                   strcat (more_info, (reloc_dest == DEST_OPD
15761                                       ? " (OPD)" : " (stub)"));
15762                   reloc_name = more_info;
15763                 }
15764             }
15765
15766           if (r == bfd_reloc_overflow)
15767             {
15768               /* On code like "if (foo) foo();" don't report overflow
15769                  on a branch to zero when foo is undefined.  */
15770               if (!warned
15771                   && (reloc_dest == DEST_STUB
15772                       || !(h != NULL
15773                            && (h->elf.root.type == bfd_link_hash_undefweak
15774                                || h->elf.root.type == bfd_link_hash_undefined)
15775                            && is_branch_reloc (r_type))))
15776                 info->callbacks->reloc_overflow (info, &h->elf.root,
15777                                                  sym_name, reloc_name,
15778                                                  orig_rel.r_addend,
15779                                                  input_bfd, input_section,
15780                                                  rel->r_offset);
15781             }
15782           else
15783             {
15784               info->callbacks->einfo
15785                 /* xgettext:c-format */
15786                 (_("%H: %s against `%pT': error %d\n"),
15787                  input_bfd, input_section, rel->r_offset,
15788                  reloc_name, sym_name, (int) r);
15789               ret = FALSE;
15790             }
15791           if (more_info != NULL)
15792             free (more_info);
15793         }
15794     copy_reloc:
15795       if (wrel != rel)
15796         *wrel = *rel;
15797     }
15798
15799   if (wrel != rel)
15800     {
15801       Elf_Internal_Shdr *rel_hdr;
15802       size_t deleted = rel - wrel;
15803
15804       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15805       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15806       if (rel_hdr->sh_size == 0)
15807         {
15808           /* It is too late to remove an empty reloc section.  Leave
15809              one NONE reloc.
15810              ??? What is wrong with an empty section???  */
15811           rel_hdr->sh_size = rel_hdr->sh_entsize;
15812           deleted -= 1;
15813         }
15814       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15815       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15816       input_section->reloc_count -= deleted;
15817     }
15818
15819   /* If we're emitting relocations, then shortly after this function
15820      returns, reloc offsets and addends for this section will be
15821      adjusted.  Worse, reloc symbol indices will be for the output
15822      file rather than the input.  Save a copy of the relocs for
15823      opd_entry_value.  */
15824   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15825     {
15826       bfd_size_type amt;
15827       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15828       rel = bfd_alloc (input_bfd, amt);
15829       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15830       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15831       if (rel == NULL)
15832         return FALSE;
15833       memcpy (rel, relocs, amt);
15834     }
15835   return ret;
15836 }
15837
15838 /* Adjust the value of any local symbols in opd sections.  */
15839
15840 static int
15841 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15842                               const char *name ATTRIBUTE_UNUSED,
15843                               Elf_Internal_Sym *elfsym,
15844                               asection *input_sec,
15845                               struct elf_link_hash_entry *h)
15846 {
15847   struct _opd_sec_data *opd;
15848   long adjust;
15849   bfd_vma value;
15850
15851   if (h != NULL)
15852     return 1;
15853
15854   opd = get_opd_info (input_sec);
15855   if (opd == NULL || opd->adjust == NULL)
15856     return 1;
15857
15858   value = elfsym->st_value - input_sec->output_offset;
15859   if (!bfd_link_relocatable (info))
15860     value -= input_sec->output_section->vma;
15861
15862   adjust = opd->adjust[OPD_NDX (value)];
15863   if (adjust == -1)
15864     return 2;
15865
15866   elfsym->st_value += adjust;
15867   return 1;
15868 }
15869
15870 /* Finish up dynamic symbol handling.  We set the contents of various
15871    dynamic sections here.  */
15872
15873 static bfd_boolean
15874 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15875                                  struct bfd_link_info *info,
15876                                  struct elf_link_hash_entry *h,
15877                                  Elf_Internal_Sym *sym)
15878 {
15879   struct ppc_link_hash_table *htab;
15880   struct plt_entry *ent;
15881
15882   htab = ppc_hash_table (info);
15883   if (htab == NULL)
15884     return FALSE;
15885
15886   if (!htab->opd_abi && !h->def_regular)
15887     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15888       if (ent->plt.offset != (bfd_vma) -1)
15889         {
15890           /* Mark the symbol as undefined, rather than as
15891              defined in glink.  Leave the value if there were
15892              any relocations where pointer equality matters
15893              (this is a clue for the dynamic linker, to make
15894              function pointer comparisons work between an
15895              application and shared library), otherwise set it
15896              to zero.  */
15897           sym->st_shndx = SHN_UNDEF;
15898           if (!h->pointer_equality_needed)
15899             sym->st_value = 0;
15900           else if (!h->ref_regular_nonweak)
15901             {
15902               /* This breaks function pointer comparisons, but
15903                  that is better than breaking tests for a NULL
15904                  function pointer.  */
15905               sym->st_value = 0;
15906             }
15907           break;
15908         }
15909
15910   if (h->needs_copy)
15911     {
15912       /* This symbol needs a copy reloc.  Set it up.  */
15913       Elf_Internal_Rela rela;
15914       asection *srel;
15915       bfd_byte *loc;
15916
15917       if (h->dynindx == -1
15918           || (h->root.type != bfd_link_hash_defined
15919               && h->root.type != bfd_link_hash_defweak)
15920           || htab->elf.srelbss == NULL
15921           || htab->elf.sreldynrelro == NULL)
15922         abort ();
15923
15924       rela.r_offset = (h->root.u.def.value
15925                        + h->root.u.def.section->output_section->vma
15926                        + h->root.u.def.section->output_offset);
15927       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15928       rela.r_addend = 0;
15929       if (h->root.u.def.section == htab->elf.sdynrelro)
15930         srel = htab->elf.sreldynrelro;
15931       else
15932         srel = htab->elf.srelbss;
15933       loc = srel->contents;
15934       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15935       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15936     }
15937
15938   return TRUE;
15939 }
15940
15941 /* Used to decide how to sort relocs in an optimal manner for the
15942    dynamic linker, before writing them out.  */
15943
15944 static enum elf_reloc_type_class
15945 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15946                             const asection *rel_sec,
15947                             const Elf_Internal_Rela *rela)
15948 {
15949   enum elf_ppc64_reloc_type r_type;
15950   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15951
15952   if (rel_sec == htab->elf.irelplt)
15953     return reloc_class_ifunc;
15954
15955   r_type = ELF64_R_TYPE (rela->r_info);
15956   switch (r_type)
15957     {
15958     case R_PPC64_RELATIVE:
15959       return reloc_class_relative;
15960     case R_PPC64_JMP_SLOT:
15961       return reloc_class_plt;
15962     case R_PPC64_COPY:
15963       return reloc_class_copy;
15964     default:
15965       return reloc_class_normal;
15966     }
15967 }
15968
15969 /* Finish up the dynamic sections.  */
15970
15971 static bfd_boolean
15972 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15973                                    struct bfd_link_info *info)
15974 {
15975   struct ppc_link_hash_table *htab;
15976   bfd *dynobj;
15977   asection *sdyn;
15978
15979   htab = ppc_hash_table (info);
15980   if (htab == NULL)
15981     return FALSE;
15982
15983   dynobj = htab->elf.dynobj;
15984   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15985
15986   if (htab->elf.dynamic_sections_created)
15987     {
15988       Elf64_External_Dyn *dyncon, *dynconend;
15989
15990       if (sdyn == NULL || htab->elf.sgot == NULL)
15991         abort ();
15992
15993       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15994       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15995       for (; dyncon < dynconend; dyncon++)
15996         {
15997           Elf_Internal_Dyn dyn;
15998           asection *s;
15999
16000           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16001
16002           switch (dyn.d_tag)
16003             {
16004             default:
16005               continue;
16006
16007             case DT_PPC64_GLINK:
16008               s = htab->glink;
16009               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16010               /* We stupidly defined DT_PPC64_GLINK to be the start
16011                  of glink rather than the first entry point, which is
16012                  what ld.so needs, and now have a bigger stub to
16013                  support automatic multiple TOCs.  */
16014               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16015               break;
16016
16017             case DT_PPC64_OPD:
16018               s = bfd_get_section_by_name (output_bfd, ".opd");
16019               if (s == NULL)
16020                 continue;
16021               dyn.d_un.d_ptr = s->vma;
16022               break;
16023
16024             case DT_PPC64_OPT:
16025               if (htab->do_multi_toc && htab->multi_toc_needed)
16026                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16027               if (htab->has_plt_localentry0)
16028                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16029               break;
16030
16031             case DT_PPC64_OPDSZ:
16032               s = bfd_get_section_by_name (output_bfd, ".opd");
16033               if (s == NULL)
16034                 continue;
16035               dyn.d_un.d_val = s->size;
16036               break;
16037
16038             case DT_PLTGOT:
16039               s = htab->elf.splt;
16040               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16041               break;
16042
16043             case DT_JMPREL:
16044               s = htab->elf.srelplt;
16045               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16046               break;
16047
16048             case DT_PLTRELSZ:
16049               dyn.d_un.d_val = htab->elf.srelplt->size;
16050               break;
16051
16052             case DT_TEXTREL:
16053               if (htab->local_ifunc_resolver)
16054                 info->callbacks->einfo
16055                   (_("%X%P: text relocations and GNU indirect "
16056                      "functions will result in a segfault at runtime\n"));
16057               else if (htab->maybe_local_ifunc_resolver)
16058                 info->callbacks->einfo
16059                   (_("%P: warning: text relocations and GNU indirect "
16060                      "functions may result in a segfault at runtime\n"));
16061               continue;
16062             }
16063
16064           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16065         }
16066     }
16067
16068   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16069       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16070     {
16071       /* Fill in the first entry in the global offset table.
16072          We use it to hold the link-time TOCbase.  */
16073       bfd_put_64 (output_bfd,
16074                   elf_gp (output_bfd) + TOC_BASE_OFF,
16075                   htab->elf.sgot->contents);
16076
16077       /* Set .got entry size.  */
16078       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16079     }
16080
16081   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16082       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16083     {
16084       /* Set .plt entry size.  */
16085       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16086         = PLT_ENTRY_SIZE (htab);
16087     }
16088
16089   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16090      brlt ourselves if emitrelocations.  */
16091   if (htab->brlt != NULL
16092       && htab->brlt->reloc_count != 0
16093       && !_bfd_elf_link_output_relocs (output_bfd,
16094                                        htab->brlt,
16095                                        elf_section_data (htab->brlt)->rela.hdr,
16096                                        elf_section_data (htab->brlt)->relocs,
16097                                        NULL))
16098     return FALSE;
16099
16100   if (htab->glink != NULL
16101       && htab->glink->reloc_count != 0
16102       && !_bfd_elf_link_output_relocs (output_bfd,
16103                                        htab->glink,
16104                                        elf_section_data (htab->glink)->rela.hdr,
16105                                        elf_section_data (htab->glink)->relocs,
16106                                        NULL))
16107     return FALSE;
16108
16109   if (htab->glink_eh_frame != NULL
16110       && htab->glink_eh_frame->size != 0)
16111     {
16112       bfd_vma val;
16113       bfd_byte *p;
16114       struct map_stub *group;
16115       size_t align = 4;
16116
16117       p = htab->glink_eh_frame->contents;
16118       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16119
16120       for (group = htab->group; group != NULL; group = group->next)
16121         if (group->stub_sec != NULL)
16122           {
16123             /* Offset to stub section.  */
16124             val = (group->stub_sec->output_section->vma
16125                    + group->stub_sec->output_offset);
16126             val -= (htab->glink_eh_frame->output_section->vma
16127                     + htab->glink_eh_frame->output_offset
16128                     + (p + 8 - htab->glink_eh_frame->contents));
16129             if (val + 0x80000000 > 0xffffffff)
16130               {
16131                 _bfd_error_handler
16132                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16133                    group->stub_sec->name);
16134                 return FALSE;
16135               }
16136             bfd_put_32 (dynobj, val, p + 8);
16137             p += stub_eh_frame_size (group, align);
16138           }
16139       if (htab->glink != NULL && htab->glink->size != 0)
16140         {
16141           /* Offset to .glink.  */
16142           val = (htab->glink->output_section->vma
16143                  + htab->glink->output_offset
16144                  + 8);
16145           val -= (htab->glink_eh_frame->output_section->vma
16146                   + htab->glink_eh_frame->output_offset
16147                   + (p + 8 - htab->glink_eh_frame->contents));
16148           if (val + 0x80000000 > 0xffffffff)
16149             {
16150               _bfd_error_handler
16151                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16152                  htab->glink->name);
16153               return FALSE;
16154             }
16155           bfd_put_32 (dynobj, val, p + 8);
16156           p += (24 + align - 1) & -align;
16157         }
16158
16159       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16160           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16161                                                htab->glink_eh_frame,
16162                                                htab->glink_eh_frame->contents))
16163         return FALSE;
16164     }
16165
16166   /* We need to handle writing out multiple GOT sections ourselves,
16167      since we didn't add them to DYNOBJ.  We know dynobj is the first
16168      bfd.  */
16169   while ((dynobj = dynobj->link.next) != NULL)
16170     {
16171       asection *s;
16172
16173       if (!is_ppc64_elf (dynobj))
16174         continue;
16175
16176       s = ppc64_elf_tdata (dynobj)->got;
16177       if (s != NULL
16178           && s->size != 0
16179           && s->output_section != bfd_abs_section_ptr
16180           && !bfd_set_section_contents (output_bfd, s->output_section,
16181                                         s->contents, s->output_offset,
16182                                         s->size))
16183         return FALSE;
16184       s = ppc64_elf_tdata (dynobj)->relgot;
16185       if (s != NULL
16186           && s->size != 0
16187           && s->output_section != bfd_abs_section_ptr
16188           && !bfd_set_section_contents (output_bfd, s->output_section,
16189                                         s->contents, s->output_offset,
16190                                         s->size))
16191         return FALSE;
16192     }
16193
16194   return TRUE;
16195 }
16196
16197 #include "elf64-target.h"
16198
16199 /* FreeBSD support */
16200
16201 #undef  TARGET_LITTLE_SYM
16202 #undef  TARGET_LITTLE_NAME
16203
16204 #undef  TARGET_BIG_SYM
16205 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16206 #undef  TARGET_BIG_NAME
16207 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16208
16209 #undef  ELF_OSABI
16210 #define ELF_OSABI       ELFOSABI_FREEBSD
16211
16212 #undef  elf64_bed
16213 #define elf64_bed       elf64_powerpc_fbsd_bed
16214
16215 #include "elf64-target.h"