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   HOWTO (R_PPC64_TOCSAVE,
1340          0,                     /* rightshift */
1341          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1342          32,                    /* bitsize */
1343          FALSE,                 /* pc_relative */
1344          0,                     /* bitpos */
1345          complain_overflow_dont, /* complain_on_overflow */
1346          bfd_elf_generic_reloc, /* special_function */
1347          "R_PPC64_TOCSAVE",     /* name */
1348          FALSE,                 /* partial_inplace */
1349          0,                     /* src_mask */
1350          0,                     /* dst_mask */
1351          FALSE),                /* pcrel_offset */
1352
1353   /* Computes the load module index of the load module that contains the
1354      definition of its TLS sym.  */
1355   HOWTO (R_PPC64_DTPMOD64,
1356          0,                     /* rightshift */
1357          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1358          64,                    /* bitsize */
1359          FALSE,                 /* pc_relative */
1360          0,                     /* bitpos */
1361          complain_overflow_dont, /* complain_on_overflow */
1362          ppc64_elf_unhandled_reloc, /* special_function */
1363          "R_PPC64_DTPMOD64",    /* name */
1364          FALSE,                 /* partial_inplace */
1365          0,                     /* src_mask */
1366          ONES (64),             /* dst_mask */
1367          FALSE),                /* pcrel_offset */
1368
1369   /* Computes a dtv-relative displacement, the difference between the value
1370      of sym+add and the base address of the thread-local storage block that
1371      contains the definition of sym, minus 0x8000.  */
1372   HOWTO (R_PPC64_DTPREL64,
1373          0,                     /* rightshift */
1374          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1375          64,                    /* bitsize */
1376          FALSE,                 /* pc_relative */
1377          0,                     /* bitpos */
1378          complain_overflow_dont, /* complain_on_overflow */
1379          ppc64_elf_unhandled_reloc, /* special_function */
1380          "R_PPC64_DTPREL64",    /* name */
1381          FALSE,                 /* partial_inplace */
1382          0,                     /* src_mask */
1383          ONES (64),             /* dst_mask */
1384          FALSE),                /* pcrel_offset */
1385
1386   /* A 16 bit dtprel reloc.  */
1387   HOWTO (R_PPC64_DTPREL16,
1388          0,                     /* rightshift */
1389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          16,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_signed, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPREL16",    /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          0xffff,                /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Like DTPREL16, but no overflow.  */
1402   HOWTO (R_PPC64_DTPREL16_LO,
1403          0,                     /* rightshift */
1404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          16,                    /* bitsize */
1406          FALSE,                 /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_dont, /* complain_on_overflow */
1409          ppc64_elf_unhandled_reloc, /* special_function */
1410          "R_PPC64_DTPREL16_LO", /* name */
1411          FALSE,                 /* partial_inplace */
1412          0,                     /* src_mask */
1413          0xffff,                /* dst_mask */
1414          FALSE),                /* pcrel_offset */
1415
1416   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1417   HOWTO (R_PPC64_DTPREL16_HI,
1418          16,                    /* rightshift */
1419          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          16,                    /* bitsize */
1421          FALSE,                 /* pc_relative */
1422          0,                     /* bitpos */
1423          complain_overflow_signed, /* complain_on_overflow */
1424          ppc64_elf_unhandled_reloc, /* special_function */
1425          "R_PPC64_DTPREL16_HI", /* name */
1426          FALSE,                 /* partial_inplace */
1427          0,                     /* src_mask */
1428          0xffff,                /* dst_mask */
1429          FALSE),                /* pcrel_offset */
1430
1431   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1432   HOWTO (R_PPC64_DTPREL16_HA,
1433          16,                    /* rightshift */
1434          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          16,                    /* bitsize */
1436          FALSE,                 /* pc_relative */
1437          0,                     /* bitpos */
1438          complain_overflow_signed, /* complain_on_overflow */
1439          ppc64_elf_unhandled_reloc, /* special_function */
1440          "R_PPC64_DTPREL16_HA", /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0xffff,                /* dst_mask */
1444          FALSE),                /* pcrel_offset */
1445
1446   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1447   HOWTO (R_PPC64_DTPREL16_HIGHER,
1448          32,                    /* rightshift */
1449          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1450          16,                    /* bitsize */
1451          FALSE,                 /* pc_relative */
1452          0,                     /* bitpos */
1453          complain_overflow_dont, /* complain_on_overflow */
1454          ppc64_elf_unhandled_reloc, /* special_function */
1455          "R_PPC64_DTPREL16_HIGHER", /* name */
1456          FALSE,                 /* partial_inplace */
1457          0,                     /* src_mask */
1458          0xffff,                /* dst_mask */
1459          FALSE),                /* pcrel_offset */
1460
1461   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1462   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1463          32,                    /* rightshift */
1464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          16,                    /* bitsize */
1466          FALSE,                 /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_dont, /* complain_on_overflow */
1469          ppc64_elf_unhandled_reloc, /* special_function */
1470          "R_PPC64_DTPREL16_HIGHERA", /* name */
1471          FALSE,                 /* partial_inplace */
1472          0,                     /* src_mask */
1473          0xffff,                /* dst_mask */
1474          FALSE),                /* pcrel_offset */
1475
1476   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1477   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1478          48,                    /* rightshift */
1479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1480          16,                    /* bitsize */
1481          FALSE,                 /* pc_relative */
1482          0,                     /* bitpos */
1483          complain_overflow_dont, /* complain_on_overflow */
1484          ppc64_elf_unhandled_reloc, /* special_function */
1485          "R_PPC64_DTPREL16_HIGHEST", /* name */
1486          FALSE,                 /* partial_inplace */
1487          0,                     /* src_mask */
1488          0xffff,                /* dst_mask */
1489          FALSE),                /* pcrel_offset */
1490
1491   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1492   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1493          48,                    /* rightshift */
1494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          16,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          ppc64_elf_unhandled_reloc, /* special_function */
1500          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          0xffff,                /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* Like DTPREL16, but for insns with a DS field.  */
1507   HOWTO (R_PPC64_DTPREL16_DS,
1508          0,                     /* rightshift */
1509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          16,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_signed, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_DTPREL16_DS", /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          0xfffc,                /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* Like DTPREL16_DS, but no overflow.  */
1522   HOWTO (R_PPC64_DTPREL16_LO_DS,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_dont, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_DTPREL16_LO_DS", /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xfffc,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Computes a tp-relative displacement, the difference between the value of
1537      sym+add and the value of the thread pointer (r13).  */
1538   HOWTO (R_PPC64_TPREL64,
1539          0,                     /* rightshift */
1540          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          64,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_dont, /* complain_on_overflow */
1545          ppc64_elf_unhandled_reloc, /* special_function */
1546          "R_PPC64_TPREL64",     /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          ONES (64),             /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* A 16 bit tprel reloc.  */
1553   HOWTO (R_PPC64_TPREL16,
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_signed, /* complain_on_overflow */
1560          ppc64_elf_unhandled_reloc, /* special_function */
1561          "R_PPC64_TPREL16",     /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0xffff,                /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* Like TPREL16, but no overflow.  */
1568   HOWTO (R_PPC64_TPREL16_LO,
1569          0,                     /* rightshift */
1570          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1571          16,                    /* bitsize */
1572          FALSE,                 /* pc_relative */
1573          0,                     /* bitpos */
1574          complain_overflow_dont, /* complain_on_overflow */
1575          ppc64_elf_unhandled_reloc, /* special_function */
1576          "R_PPC64_TPREL16_LO",  /* name */
1577          FALSE,                 /* partial_inplace */
1578          0,                     /* src_mask */
1579          0xffff,                /* dst_mask */
1580          FALSE),                /* pcrel_offset */
1581
1582   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1583   HOWTO (R_PPC64_TPREL16_HI,
1584          16,                    /* rightshift */
1585          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          16,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_signed, /* complain_on_overflow */
1590          ppc64_elf_unhandled_reloc, /* special_function */
1591          "R_PPC64_TPREL16_HI",  /* name */
1592          FALSE,                 /* partial_inplace */
1593          0,                     /* src_mask */
1594          0xffff,                /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596
1597   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1598   HOWTO (R_PPC64_TPREL16_HA,
1599          16,                    /* rightshift */
1600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1601          16,                    /* bitsize */
1602          FALSE,                 /* pc_relative */
1603          0,                     /* bitpos */
1604          complain_overflow_signed, /* complain_on_overflow */
1605          ppc64_elf_unhandled_reloc, /* special_function */
1606          "R_PPC64_TPREL16_HA",  /* name */
1607          FALSE,                 /* partial_inplace */
1608          0,                     /* src_mask */
1609          0xffff,                /* dst_mask */
1610          FALSE),                /* pcrel_offset */
1611
1612   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1613   HOWTO (R_PPC64_TPREL16_HIGHER,
1614          32,                    /* rightshift */
1615          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1616          16,                    /* bitsize */
1617          FALSE,                 /* pc_relative */
1618          0,                     /* bitpos */
1619          complain_overflow_dont, /* complain_on_overflow */
1620          ppc64_elf_unhandled_reloc, /* special_function */
1621          "R_PPC64_TPREL16_HIGHER",      /* name */
1622          FALSE,                 /* partial_inplace */
1623          0,                     /* src_mask */
1624          0xffff,                /* dst_mask */
1625          FALSE),                /* pcrel_offset */
1626
1627   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1628   HOWTO (R_PPC64_TPREL16_HIGHERA,
1629          32,                    /* rightshift */
1630          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1631          16,                    /* bitsize */
1632          FALSE,                 /* pc_relative */
1633          0,                     /* bitpos */
1634          complain_overflow_dont, /* complain_on_overflow */
1635          ppc64_elf_unhandled_reloc, /* special_function */
1636          "R_PPC64_TPREL16_HIGHERA", /* name */
1637          FALSE,                 /* partial_inplace */
1638          0,                     /* src_mask */
1639          0xffff,                /* dst_mask */
1640          FALSE),                /* pcrel_offset */
1641
1642   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1643   HOWTO (R_PPC64_TPREL16_HIGHEST,
1644          48,                    /* rightshift */
1645          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1646          16,                    /* bitsize */
1647          FALSE,                 /* pc_relative */
1648          0,                     /* bitpos */
1649          complain_overflow_dont, /* complain_on_overflow */
1650          ppc64_elf_unhandled_reloc, /* special_function */
1651          "R_PPC64_TPREL16_HIGHEST", /* name */
1652          FALSE,                 /* partial_inplace */
1653          0,                     /* src_mask */
1654          0xffff,                /* dst_mask */
1655          FALSE),                /* pcrel_offset */
1656
1657   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1658   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1659          48,                    /* rightshift */
1660          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1661          16,                    /* bitsize */
1662          FALSE,                 /* pc_relative */
1663          0,                     /* bitpos */
1664          complain_overflow_dont, /* complain_on_overflow */
1665          ppc64_elf_unhandled_reloc, /* special_function */
1666          "R_PPC64_TPREL16_HIGHESTA", /* name */
1667          FALSE,                 /* partial_inplace */
1668          0,                     /* src_mask */
1669          0xffff,                /* dst_mask */
1670          FALSE),                /* pcrel_offset */
1671
1672   /* Like TPREL16, but for insns with a DS field.  */
1673   HOWTO (R_PPC64_TPREL16_DS,
1674          0,                     /* rightshift */
1675          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1676          16,                    /* bitsize */
1677          FALSE,                 /* pc_relative */
1678          0,                     /* bitpos */
1679          complain_overflow_signed, /* complain_on_overflow */
1680          ppc64_elf_unhandled_reloc, /* special_function */
1681          "R_PPC64_TPREL16_DS",  /* name */
1682          FALSE,                 /* partial_inplace */
1683          0,                     /* src_mask */
1684          0xfffc,                /* dst_mask */
1685          FALSE),                /* pcrel_offset */
1686
1687   /* Like TPREL16_DS, but no overflow.  */
1688   HOWTO (R_PPC64_TPREL16_LO_DS,
1689          0,                     /* rightshift */
1690          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1691          16,                    /* bitsize */
1692          FALSE,                 /* pc_relative */
1693          0,                     /* bitpos */
1694          complain_overflow_dont, /* complain_on_overflow */
1695          ppc64_elf_unhandled_reloc, /* special_function */
1696          "R_PPC64_TPREL16_LO_DS", /* name */
1697          FALSE,                 /* partial_inplace */
1698          0,                     /* src_mask */
1699          0xfffc,                /* dst_mask */
1700          FALSE),                /* pcrel_offset */
1701
1702   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1703      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1704      to the first entry relative to the TOC base (r2).  */
1705   HOWTO (R_PPC64_GOT_TLSGD16,
1706          0,                     /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_GOT_TLSGD16", /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xffff,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like GOT_TLSGD16, but no overflow.  */
1720   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1721          0,                     /* rightshift */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1723          16,                    /* bitsize */
1724          FALSE,                 /* pc_relative */
1725          0,                     /* bitpos */
1726          complain_overflow_dont, /* complain_on_overflow */
1727          ppc64_elf_unhandled_reloc, /* special_function */
1728          "R_PPC64_GOT_TLSGD16_LO", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xffff,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1735   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1736          16,                    /* rightshift */
1737          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1738          16,                    /* bitsize */
1739          FALSE,                 /* pc_relative */
1740          0,                     /* bitpos */
1741          complain_overflow_signed, /* complain_on_overflow */
1742          ppc64_elf_unhandled_reloc, /* special_function */
1743          "R_PPC64_GOT_TLSGD16_HI", /* name */
1744          FALSE,                 /* partial_inplace */
1745          0,                     /* src_mask */
1746          0xffff,                /* dst_mask */
1747          FALSE),                /* pcrel_offset */
1748
1749   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1750   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1751          16,                    /* rightshift */
1752          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1753          16,                    /* bitsize */
1754          FALSE,                 /* pc_relative */
1755          0,                     /* bitpos */
1756          complain_overflow_signed, /* complain_on_overflow */
1757          ppc64_elf_unhandled_reloc, /* special_function */
1758          "R_PPC64_GOT_TLSGD16_HA", /* name */
1759          FALSE,                 /* partial_inplace */
1760          0,                     /* src_mask */
1761          0xffff,                /* dst_mask */
1762          FALSE),                /* pcrel_offset */
1763
1764   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1765      with values (sym+add)@dtpmod and zero, and computes the offset to the
1766      first entry relative to the TOC base (r2).  */
1767   HOWTO (R_PPC64_GOT_TLSLD16,
1768          0,                     /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSLD16", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSLD16, but no overflow.  */
1782   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1783          0,                     /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_dont, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSLD16_LO", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1797   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1798          16,                    /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_signed, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_TLSLD16_HI", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xffff,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1812   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1813          16,                    /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_signed, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_TLSLD16_HA", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xffff,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1827      the offset to the entry relative to the TOC base (r2).  */
1828   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1829          0,                     /* 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_DTPREL16_DS", /* name */
1837          FALSE,                 /* partial_inplace */
1838          0,                     /* src_mask */
1839          0xfffc,                /* dst_mask */
1840          FALSE),                /* pcrel_offset */
1841
1842   /* Like GOT_DTPREL16_DS, but no overflow.  */
1843   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1844          0,                     /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_dont, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xfffc,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1858   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1859          16,                    /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_signed, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_DTPREL16_HI", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xffff,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1873   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1874          16,                    /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_signed, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_DTPREL16_HA", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xffff,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1888      offset to the entry relative to the TOC base (r2).  */
1889   HOWTO (R_PPC64_GOT_TPREL16_DS,
1890          0,                     /* 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_TPREL16_DS", /* name */
1898          FALSE,                 /* partial_inplace */
1899          0,                     /* src_mask */
1900          0xfffc,                /* dst_mask */
1901          FALSE),                /* pcrel_offset */
1902
1903   /* Like GOT_TPREL16_DS, but no overflow.  */
1904   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1905          0,                     /* rightshift */
1906          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1907          16,                    /* bitsize */
1908          FALSE,                 /* pc_relative */
1909          0,                     /* bitpos */
1910          complain_overflow_dont, /* complain_on_overflow */
1911          ppc64_elf_unhandled_reloc, /* special_function */
1912          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1913          FALSE,                 /* partial_inplace */
1914          0,                     /* src_mask */
1915          0xfffc,                /* dst_mask */
1916          FALSE),                /* pcrel_offset */
1917
1918   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1919   HOWTO (R_PPC64_GOT_TPREL16_HI,
1920          16,                    /* rightshift */
1921          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1922          16,                    /* bitsize */
1923          FALSE,                 /* pc_relative */
1924          0,                     /* bitpos */
1925          complain_overflow_signed, /* complain_on_overflow */
1926          ppc64_elf_unhandled_reloc, /* special_function */
1927          "R_PPC64_GOT_TPREL16_HI", /* name */
1928          FALSE,                 /* partial_inplace */
1929          0,                     /* src_mask */
1930          0xffff,                /* dst_mask */
1931          FALSE),                /* pcrel_offset */
1932
1933   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1934   HOWTO (R_PPC64_GOT_TPREL16_HA,
1935          16,                    /* rightshift */
1936          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1937          16,                    /* bitsize */
1938          FALSE,                 /* pc_relative */
1939          0,                     /* bitpos */
1940          complain_overflow_signed, /* complain_on_overflow */
1941          ppc64_elf_unhandled_reloc, /* special_function */
1942          "R_PPC64_GOT_TPREL16_HA", /* name */
1943          FALSE,                 /* partial_inplace */
1944          0,                     /* src_mask */
1945          0xffff,                /* dst_mask */
1946          FALSE),                /* pcrel_offset */
1947
1948   HOWTO (R_PPC64_JMP_IREL,      /* type */
1949          0,                     /* rightshift */
1950          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1951          0,                     /* bitsize */
1952          FALSE,                 /* pc_relative */
1953          0,                     /* bitpos */
1954          complain_overflow_dont, /* complain_on_overflow */
1955          ppc64_elf_unhandled_reloc, /* special_function */
1956          "R_PPC64_JMP_IREL",    /* name */
1957          FALSE,                 /* partial_inplace */
1958          0,                     /* src_mask */
1959          0,                     /* dst_mask */
1960          FALSE),                /* pcrel_offset */
1961
1962   HOWTO (R_PPC64_IRELATIVE,     /* type */
1963          0,                     /* rightshift */
1964          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1965          64,                    /* bitsize */
1966          FALSE,                 /* pc_relative */
1967          0,                     /* bitpos */
1968          complain_overflow_dont, /* complain_on_overflow */
1969          bfd_elf_generic_reloc, /* special_function */
1970          "R_PPC64_IRELATIVE",   /* name */
1971          FALSE,                 /* partial_inplace */
1972          0,                     /* src_mask */
1973          ONES (64),             /* dst_mask */
1974          FALSE),                /* pcrel_offset */
1975
1976   /* A 16 bit relative relocation.  */
1977   HOWTO (R_PPC64_REL16,         /* type */
1978          0,                     /* rightshift */
1979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1980          16,                    /* bitsize */
1981          TRUE,                  /* pc_relative */
1982          0,                     /* bitpos */
1983          complain_overflow_signed, /* complain_on_overflow */
1984          bfd_elf_generic_reloc, /* special_function */
1985          "R_PPC64_REL16",       /* name */
1986          FALSE,                 /* partial_inplace */
1987          0,                     /* src_mask */
1988          0xffff,                /* dst_mask */
1989          TRUE),                 /* pcrel_offset */
1990
1991   /* A 16 bit relative relocation without overflow.  */
1992   HOWTO (R_PPC64_REL16_LO,      /* type */
1993          0,                     /* rightshift */
1994          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          16,                    /* bitsize */
1996          TRUE,                  /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_dont,/* complain_on_overflow */
1999          bfd_elf_generic_reloc, /* special_function */
2000          "R_PPC64_REL16_LO",    /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0xffff,                /* dst_mask */
2004          TRUE),                 /* pcrel_offset */
2005
2006   /* The high order 16 bits of a relative address.  */
2007   HOWTO (R_PPC64_REL16_HI,      /* type */
2008          16,                    /* rightshift */
2009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          16,                    /* bitsize */
2011          TRUE,                  /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_signed, /* complain_on_overflow */
2014          bfd_elf_generic_reloc, /* special_function */
2015          "R_PPC64_REL16_HI",    /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0xffff,                /* dst_mask */
2019          TRUE),                 /* pcrel_offset */
2020
2021   /* The high order 16 bits of a relative address, plus 1 if the contents of
2022      the low 16 bits, treated as a signed number, is negative.  */
2023   HOWTO (R_PPC64_REL16_HA,      /* type */
2024          16,                    /* rightshift */
2025          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2026          16,                    /* bitsize */
2027          TRUE,                  /* pc_relative */
2028          0,                     /* bitpos */
2029          complain_overflow_signed, /* complain_on_overflow */
2030          ppc64_elf_ha_reloc,    /* special_function */
2031          "R_PPC64_REL16_HA",    /* name */
2032          FALSE,                 /* partial_inplace */
2033          0,                     /* src_mask */
2034          0xffff,                /* dst_mask */
2035          TRUE),                 /* pcrel_offset */
2036
2037   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2038   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2039          16,                    /* rightshift */
2040          2,                     /* 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          ppc64_elf_ha_reloc,    /* special_function */
2046          "R_PPC64_REL16DX_HA",  /* name */
2047          FALSE,                 /* partial_inplace */
2048          0,                     /* src_mask */
2049          0x1fffc1,              /* dst_mask */
2050          TRUE),                 /* pcrel_offset */
2051
2052   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2053   HOWTO (R_PPC64_16DX_HA,       /* type */
2054          16,                    /* rightshift */
2055          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2056          16,                    /* bitsize */
2057          FALSE,                 /* pc_relative */
2058          0,                     /* bitpos */
2059          complain_overflow_signed, /* complain_on_overflow */
2060          ppc64_elf_ha_reloc,    /* special_function */
2061          "R_PPC64_16DX_HA",     /* name */
2062          FALSE,                 /* partial_inplace */
2063          0,                     /* src_mask */
2064          0x1fffc1,              /* dst_mask */
2065          FALSE),                /* pcrel_offset */
2066
2067   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2068   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2069          16,                    /* rightshift */
2070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2071          16,                    /* bitsize */
2072          FALSE,                 /* pc_relative */
2073          0,                     /* bitpos */
2074          complain_overflow_dont, /* complain_on_overflow */
2075          bfd_elf_generic_reloc, /* special_function */
2076          "R_PPC64_ADDR16_HIGH", /* name */
2077          FALSE,                 /* partial_inplace */
2078          0,                     /* src_mask */
2079          0xffff,                /* dst_mask */
2080          FALSE),                /* pcrel_offset */
2081
2082   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2083   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2084          16,                    /* rightshift */
2085          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2086          16,                    /* bitsize */
2087          FALSE,                 /* pc_relative */
2088          0,                     /* bitpos */
2089          complain_overflow_dont, /* complain_on_overflow */
2090          ppc64_elf_ha_reloc,    /* special_function */
2091          "R_PPC64_ADDR16_HIGHA",        /* name */
2092          FALSE,                 /* partial_inplace */
2093          0,                     /* src_mask */
2094          0xffff,                /* dst_mask */
2095          FALSE),                /* pcrel_offset */
2096
2097   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2098   HOWTO (R_PPC64_DTPREL16_HIGH,
2099          16,                    /* rightshift */
2100          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2101          16,                    /* bitsize */
2102          FALSE,                 /* pc_relative */
2103          0,                     /* bitpos */
2104          complain_overflow_dont, /* complain_on_overflow */
2105          ppc64_elf_unhandled_reloc, /* special_function */
2106          "R_PPC64_DTPREL16_HIGH", /* name */
2107          FALSE,                 /* partial_inplace */
2108          0,                     /* src_mask */
2109          0xffff,                /* dst_mask */
2110          FALSE),                /* pcrel_offset */
2111
2112   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2113   HOWTO (R_PPC64_DTPREL16_HIGHA,
2114          16,                    /* rightshift */
2115          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2116          16,                    /* bitsize */
2117          FALSE,                 /* pc_relative */
2118          0,                     /* bitpos */
2119          complain_overflow_dont, /* complain_on_overflow */
2120          ppc64_elf_unhandled_reloc, /* special_function */
2121          "R_PPC64_DTPREL16_HIGHA", /* name */
2122          FALSE,                 /* partial_inplace */
2123          0,                     /* src_mask */
2124          0xffff,                /* dst_mask */
2125          FALSE),                /* pcrel_offset */
2126
2127   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2128   HOWTO (R_PPC64_TPREL16_HIGH,
2129          16,                    /* rightshift */
2130          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2131          16,                    /* bitsize */
2132          FALSE,                 /* pc_relative */
2133          0,                     /* bitpos */
2134          complain_overflow_dont, /* complain_on_overflow */
2135          ppc64_elf_unhandled_reloc, /* special_function */
2136          "R_PPC64_TPREL16_HIGH",        /* name */
2137          FALSE,                 /* partial_inplace */
2138          0,                     /* src_mask */
2139          0xffff,                /* dst_mask */
2140          FALSE),                /* pcrel_offset */
2141
2142   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2143   HOWTO (R_PPC64_TPREL16_HIGHA,
2144          16,                    /* rightshift */
2145          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2146          16,                    /* bitsize */
2147          FALSE,                 /* pc_relative */
2148          0,                     /* bitpos */
2149          complain_overflow_dont, /* complain_on_overflow */
2150          ppc64_elf_unhandled_reloc, /* special_function */
2151          "R_PPC64_TPREL16_HIGHA",       /* name */
2152          FALSE,                 /* partial_inplace */
2153          0,                     /* src_mask */
2154          0xffff,                /* dst_mask */
2155          FALSE),                /* pcrel_offset */
2156
2157   /* Marker reloc on ELFv2 large-model function entry.  */
2158   HOWTO (R_PPC64_ENTRY,
2159          0,                     /* rightshift */
2160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2161          32,                    /* bitsize */
2162          FALSE,                 /* pc_relative */
2163          0,                     /* bitpos */
2164          complain_overflow_dont, /* complain_on_overflow */
2165          bfd_elf_generic_reloc, /* special_function */
2166          "R_PPC64_ENTRY",       /* name */
2167          FALSE,                 /* partial_inplace */
2168          0,                     /* src_mask */
2169          0,                     /* dst_mask */
2170          FALSE),                /* pcrel_offset */
2171
2172   /* Like ADDR64, but use local entry point of function.  */
2173   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2174          0,                     /* rightshift */
2175          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2176          64,                    /* bitsize */
2177          FALSE,                 /* pc_relative */
2178          0,                     /* bitpos */
2179          complain_overflow_dont, /* complain_on_overflow */
2180          bfd_elf_generic_reloc, /* special_function */
2181          "R_PPC64_ADDR64_LOCAL", /* name */
2182          FALSE,                 /* partial_inplace */
2183          0,                     /* src_mask */
2184          ONES (64),             /* dst_mask */
2185          FALSE),                /* pcrel_offset */
2186
2187   /* GNU extension to record C++ vtable hierarchy.  */
2188   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2189          0,                     /* rightshift */
2190          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2191          0,                     /* bitsize */
2192          FALSE,                 /* pc_relative */
2193          0,                     /* bitpos */
2194          complain_overflow_dont, /* complain_on_overflow */
2195          NULL,                  /* special_function */
2196          "R_PPC64_GNU_VTINHERIT", /* name */
2197          FALSE,                 /* partial_inplace */
2198          0,                     /* src_mask */
2199          0,                     /* dst_mask */
2200          FALSE),                /* pcrel_offset */
2201
2202   /* GNU extension to record C++ vtable member usage.  */
2203   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2204          0,                     /* rightshift */
2205          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2206          0,                     /* bitsize */
2207          FALSE,                 /* pc_relative */
2208          0,                     /* bitpos */
2209          complain_overflow_dont, /* complain_on_overflow */
2210          NULL,                  /* special_function */
2211          "R_PPC64_GNU_VTENTRY", /* name */
2212          FALSE,                 /* partial_inplace */
2213          0,                     /* src_mask */
2214          0,                     /* dst_mask */
2215          FALSE),                /* pcrel_offset */
2216 };
2217
2218 \f
2219 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2220    be done.  */
2221
2222 static void
2223 ppc_howto_init (void)
2224 {
2225   unsigned int i, type;
2226
2227   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2228     {
2229       type = ppc64_elf_howto_raw[i].type;
2230       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2231       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2232     }
2233 }
2234
2235 static reloc_howto_type *
2236 ppc64_elf_reloc_type_lookup (bfd *abfd,
2237                              bfd_reloc_code_real_type code)
2238 {
2239   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2240
2241   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2242     /* Initialize howto table if needed.  */
2243     ppc_howto_init ();
2244
2245   switch (code)
2246     {
2247     default:
2248       /* xgettext:c-format */
2249       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2250       bfd_set_error (bfd_error_bad_value);
2251       return NULL;
2252
2253     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2254       break;
2255     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2256       break;
2257     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2258       break;
2259     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2260       break;
2261     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2262       break;
2263     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2264       break;
2265     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2266       break;
2267     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2268       break;
2269     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2270       break;
2271     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2272       break;
2273     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2274       break;
2275     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2278       break;
2279     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2280       break;
2281     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2282       break;
2283     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2284       break;
2285     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2286       break;
2287     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2288       break;
2289     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2290       break;
2291     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2292       break;
2293     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2294       break;
2295     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2296       break;
2297     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2298       break;
2299     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2300       break;
2301     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2302       break;
2303     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2304       break;
2305     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2306       break;
2307     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2308       break;
2309     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2310       break;
2311     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2312       break;
2313     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2314       break;
2315     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2316       break;
2317     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2318       break;
2319     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2322       break;
2323     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2324       break;
2325     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2326       break;
2327     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2328       break;
2329     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2330       break;
2331     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2332       break;
2333     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2334       break;
2335     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2336       break;
2337     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2338       break;
2339     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2342       break;
2343     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2348       break;
2349     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2350       break;
2351     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2352       break;
2353     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2354       break;
2355     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2358       break;
2359     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2362       break;
2363     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2364       break;
2365     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2366       break;
2367     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2368       break;
2369     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2370       break;
2371     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2372       break;
2373     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2374       break;
2375     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2376       break;
2377     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2378       break;
2379     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2380       break;
2381     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2382       break;
2383     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2386       break;
2387     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2388       break;
2389     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2390       break;
2391     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2392       break;
2393     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2394       break;
2395     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2396       break;
2397     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2400       break;
2401     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2402       break;
2403     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2404       break;
2405     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2406       break;
2407     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2408       break;
2409     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2428       break;
2429     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2432       break;
2433     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2436       break;
2437     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2438       break;
2439     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2440       break;
2441     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2448       break;
2449     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2450       break;
2451     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2452       break;
2453     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2460       break;
2461     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2462       break;
2463     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2464       break;
2465     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2466       break;
2467     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2468       break;
2469     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2470       break;
2471     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2472       break;
2473     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2474       break;
2475     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2476       break;
2477     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2478       break;
2479     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2480       break;
2481     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2482       break;
2483     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2484       break;
2485     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2486       break;
2487     }
2488
2489   return ppc64_elf_howto_table[r];
2490 };
2491
2492 static reloc_howto_type *
2493 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2494                              const char *r_name)
2495 {
2496   unsigned int i;
2497
2498   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2499     if (ppc64_elf_howto_raw[i].name != NULL
2500         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2501       return &ppc64_elf_howto_raw[i];
2502
2503
2504   return NULL;
2505 }
2506
2507 /* Set the howto pointer for a PowerPC ELF reloc.  */
2508
2509 static bfd_boolean
2510 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2511                          Elf_Internal_Rela *dst)
2512 {
2513   unsigned int type;
2514
2515   /* Initialize howto table if needed.  */
2516   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2517     ppc_howto_init ();
2518
2519   type = ELF64_R_TYPE (dst->r_info);
2520   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2521     {
2522       /* xgettext:c-format */
2523       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2524                           abfd, type);
2525       bfd_set_error (bfd_error_bad_value);
2526       return FALSE;
2527     }
2528   cache_ptr->howto = ppc64_elf_howto_table[type];
2529   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2530     {
2531       /* xgettext:c-format */
2532       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2533                           abfd, type);
2534       bfd_set_error (bfd_error_bad_value);
2535       return FALSE;
2536     }
2537
2538   return TRUE;
2539 }
2540
2541 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2542
2543 static bfd_reloc_status_type
2544 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2545                     void *data, asection *input_section,
2546                     bfd *output_bfd, char **error_message)
2547 {
2548   enum elf_ppc64_reloc_type r_type;
2549   long insn;
2550   bfd_size_type octets;
2551   bfd_vma value;
2552
2553   /* If this is a relocatable link (output_bfd test tells us), just
2554      call the generic function.  Any adjustment will be done at final
2555      link time.  */
2556   if (output_bfd != NULL)
2557     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2558                                   input_section, output_bfd, error_message);
2559
2560   /* Adjust the addend for sign extension of the low 16 bits.
2561      We won't actually be using the low 16 bits, so trashing them
2562      doesn't matter.  */
2563   reloc_entry->addend += 0x8000;
2564   r_type = reloc_entry->howto->type;
2565   if (r_type != R_PPC64_REL16DX_HA)
2566     return bfd_reloc_continue;
2567
2568   value = 0;
2569   if (!bfd_is_com_section (symbol->section))
2570     value = symbol->value;
2571   value += (reloc_entry->addend
2572             + symbol->section->output_offset
2573             + symbol->section->output_section->vma);
2574   value -= (reloc_entry->address
2575             + input_section->output_offset
2576             + input_section->output_section->vma);
2577   value = (bfd_signed_vma) value >> 16;
2578
2579   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2580   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2581   insn &= ~0x1fffc1;
2582   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2583   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2584   if (value + 0x8000 > 0xffff)
2585     return bfd_reloc_overflow;
2586   return bfd_reloc_ok;
2587 }
2588
2589 static bfd_reloc_status_type
2590 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2591                         void *data, asection *input_section,
2592                         bfd *output_bfd, char **error_message)
2593 {
2594   if (output_bfd != NULL)
2595     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2596                                   input_section, output_bfd, error_message);
2597
2598   if (strcmp (symbol->section->name, ".opd") == 0
2599       && (symbol->section->owner->flags & DYNAMIC) == 0)
2600     {
2601       bfd_vma dest = opd_entry_value (symbol->section,
2602                                       symbol->value + reloc_entry->addend,
2603                                       NULL, NULL, FALSE);
2604       if (dest != (bfd_vma) -1)
2605         reloc_entry->addend = dest - (symbol->value
2606                                       + symbol->section->output_section->vma
2607                                       + symbol->section->output_offset);
2608     }
2609   else
2610     {
2611       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2612
2613       if (symbol->section->owner != abfd
2614           && symbol->section->owner != NULL
2615           && abiversion (symbol->section->owner) >= 2)
2616         {
2617           unsigned int i;
2618
2619           for (i = 0; i < symbol->section->owner->symcount; ++i)
2620             {
2621               asymbol *symdef = symbol->section->owner->outsymbols[i];
2622
2623               if (strcmp (symdef->name, symbol->name) == 0)
2624                 {
2625                   elfsym = (elf_symbol_type *) symdef;
2626                   break;
2627                 }
2628             }
2629         }
2630       reloc_entry->addend
2631         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2632     }
2633   return bfd_reloc_continue;
2634 }
2635
2636 static bfd_reloc_status_type
2637 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2638                          void *data, asection *input_section,
2639                          bfd *output_bfd, char **error_message)
2640 {
2641   long insn;
2642   enum elf_ppc64_reloc_type r_type;
2643   bfd_size_type octets;
2644   /* Assume 'at' branch hints.  */
2645   bfd_boolean is_isa_v2 = TRUE;
2646
2647   /* If this is a relocatable link (output_bfd test tells us), just
2648      call the generic function.  Any adjustment will be done at final
2649      link time.  */
2650   if (output_bfd != NULL)
2651     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2652                                   input_section, output_bfd, error_message);
2653
2654   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2655   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2656   insn &= ~(0x01 << 21);
2657   r_type = reloc_entry->howto->type;
2658   if (r_type == R_PPC64_ADDR14_BRTAKEN
2659       || r_type == R_PPC64_REL14_BRTAKEN)
2660     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2661
2662   if (is_isa_v2)
2663     {
2664       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2665          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2666          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2667       if ((insn & (0x14 << 21)) == (0x04 << 21))
2668         insn |= 0x02 << 21;
2669       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2670         insn |= 0x08 << 21;
2671       else
2672         goto out;
2673     }
2674   else
2675     {
2676       bfd_vma target = 0;
2677       bfd_vma from;
2678
2679       if (!bfd_is_com_section (symbol->section))
2680         target = symbol->value;
2681       target += symbol->section->output_section->vma;
2682       target += symbol->section->output_offset;
2683       target += reloc_entry->addend;
2684
2685       from = (reloc_entry->address
2686               + input_section->output_offset
2687               + input_section->output_section->vma);
2688
2689       /* Invert 'y' bit if not the default.  */
2690       if ((bfd_signed_vma) (target - from) < 0)
2691         insn ^= 0x01 << 21;
2692     }
2693   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2694  out:
2695   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2696                                  input_section, output_bfd, error_message);
2697 }
2698
2699 static bfd_reloc_status_type
2700 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2701                          void *data, asection *input_section,
2702                          bfd *output_bfd, char **error_message)
2703 {
2704   /* If this is a relocatable link (output_bfd test tells us), just
2705      call the generic function.  Any adjustment will be done at final
2706      link time.  */
2707   if (output_bfd != NULL)
2708     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2709                                   input_section, output_bfd, error_message);
2710
2711   /* Subtract the symbol section base address.  */
2712   reloc_entry->addend -= symbol->section->output_section->vma;
2713   return bfd_reloc_continue;
2714 }
2715
2716 static bfd_reloc_status_type
2717 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2718                             void *data, asection *input_section,
2719                             bfd *output_bfd, char **error_message)
2720 {
2721   /* If this is a relocatable link (output_bfd test tells us), just
2722      call the generic function.  Any adjustment will be done at final
2723      link time.  */
2724   if (output_bfd != NULL)
2725     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2726                                   input_section, output_bfd, error_message);
2727
2728   /* Subtract the symbol section base address.  */
2729   reloc_entry->addend -= symbol->section->output_section->vma;
2730
2731   /* Adjust the addend for sign extension of the low 16 bits.  */
2732   reloc_entry->addend += 0x8000;
2733   return bfd_reloc_continue;
2734 }
2735
2736 static bfd_reloc_status_type
2737 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2738                      void *data, asection *input_section,
2739                      bfd *output_bfd, char **error_message)
2740 {
2741   bfd_vma TOCstart;
2742
2743   /* If this is a relocatable link (output_bfd test tells us), just
2744      call the generic function.  Any adjustment will be done at final
2745      link time.  */
2746   if (output_bfd != NULL)
2747     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2748                                   input_section, output_bfd, error_message);
2749
2750   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2751   if (TOCstart == 0)
2752     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2753
2754   /* Subtract the TOC base address.  */
2755   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2756   return bfd_reloc_continue;
2757 }
2758
2759 static bfd_reloc_status_type
2760 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2761                         void *data, asection *input_section,
2762                         bfd *output_bfd, char **error_message)
2763 {
2764   bfd_vma TOCstart;
2765
2766   /* If this is a relocatable link (output_bfd test tells us), just
2767      call the generic function.  Any adjustment will be done at final
2768      link time.  */
2769   if (output_bfd != NULL)
2770     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2771                                   input_section, output_bfd, error_message);
2772
2773   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2774   if (TOCstart == 0)
2775     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2776
2777   /* Subtract the TOC base address.  */
2778   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2779
2780   /* Adjust the addend for sign extension of the low 16 bits.  */
2781   reloc_entry->addend += 0x8000;
2782   return bfd_reloc_continue;
2783 }
2784
2785 static bfd_reloc_status_type
2786 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2787                        void *data, asection *input_section,
2788                        bfd *output_bfd, char **error_message)
2789 {
2790   bfd_vma TOCstart;
2791   bfd_size_type octets;
2792
2793   /* If this is a relocatable link (output_bfd test tells us), just
2794      call the generic function.  Any adjustment will be done at final
2795      link time.  */
2796   if (output_bfd != NULL)
2797     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2798                                   input_section, output_bfd, error_message);
2799
2800   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2801   if (TOCstart == 0)
2802     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2803
2804   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2805   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2806   return bfd_reloc_ok;
2807 }
2808
2809 static bfd_reloc_status_type
2810 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2811                            void *data, asection *input_section,
2812                            bfd *output_bfd, char **error_message)
2813 {
2814   /* If this is a relocatable link (output_bfd test tells us), just
2815      call the generic function.  Any adjustment will be done at final
2816      link time.  */
2817   if (output_bfd != NULL)
2818     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2819                                   input_section, output_bfd, error_message);
2820
2821   if (error_message != NULL)
2822     {
2823       static char buf[60];
2824       sprintf (buf, "generic linker can't handle %s",
2825                reloc_entry->howto->name);
2826       *error_message = buf;
2827     }
2828   return bfd_reloc_dangerous;
2829 }
2830
2831 /* Track GOT entries needed for a given symbol.  We might need more
2832    than one got entry per symbol.  */
2833 struct got_entry
2834 {
2835   struct got_entry *next;
2836
2837   /* The symbol addend that we'll be placing in the GOT.  */
2838   bfd_vma addend;
2839
2840   /* Unlike other ELF targets, we use separate GOT entries for the same
2841      symbol referenced from different input files.  This is to support
2842      automatic multiple TOC/GOT sections, where the TOC base can vary
2843      from one input file to another.  After partitioning into TOC groups
2844      we merge entries within the group.
2845
2846      Point to the BFD owning this GOT entry.  */
2847   bfd *owner;
2848
2849   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2850      TLS_TPREL or TLS_DTPREL for tls entries.  */
2851   unsigned char tls_type;
2852
2853   /* Non-zero if got.ent points to real entry.  */
2854   unsigned char is_indirect;
2855
2856   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2857   union
2858     {
2859       bfd_signed_vma refcount;
2860       bfd_vma offset;
2861       struct got_entry *ent;
2862     } got;
2863 };
2864
2865 /* The same for PLT.  */
2866 struct plt_entry
2867 {
2868   struct plt_entry *next;
2869
2870   bfd_vma addend;
2871
2872   union
2873     {
2874       bfd_signed_vma refcount;
2875       bfd_vma offset;
2876     } plt;
2877 };
2878
2879 struct ppc64_elf_obj_tdata
2880 {
2881   struct elf_obj_tdata elf;
2882
2883   /* Shortcuts to dynamic linker sections.  */
2884   asection *got;
2885   asection *relgot;
2886
2887   /* Used during garbage collection.  We attach global symbols defined
2888      on removed .opd entries to this section so that the sym is removed.  */
2889   asection *deleted_section;
2890
2891   /* TLS local dynamic got entry handling.  Support for multiple GOT
2892      sections means we potentially need one of these for each input bfd.  */
2893   struct got_entry tlsld_got;
2894
2895   union {
2896     /* A copy of relocs before they are modified for --emit-relocs.  */
2897     Elf_Internal_Rela *relocs;
2898
2899     /* Section contents.  */
2900     bfd_byte *contents;
2901   } opd;
2902
2903   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2904      the reloc to be in the range -32768 to 32767.  */
2905   unsigned int has_small_toc_reloc : 1;
2906
2907   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2908      instruction not one we handle.  */
2909   unsigned int unexpected_toc_insn : 1;
2910 };
2911
2912 #define ppc64_elf_tdata(bfd) \
2913   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2914
2915 #define ppc64_tlsld_got(bfd) \
2916   (&ppc64_elf_tdata (bfd)->tlsld_got)
2917
2918 #define is_ppc64_elf(bfd) \
2919   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2920    && elf_object_id (bfd) == PPC64_ELF_DATA)
2921
2922 /* Override the generic function because we store some extras.  */
2923
2924 static bfd_boolean
2925 ppc64_elf_mkobject (bfd *abfd)
2926 {
2927   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2928                                   PPC64_ELF_DATA);
2929 }
2930
2931 /* Fix bad default arch selected for a 64 bit input bfd when the
2932    default is 32 bit.  Also select arch based on apuinfo.  */
2933
2934 static bfd_boolean
2935 ppc64_elf_object_p (bfd *abfd)
2936 {
2937   if (!abfd->arch_info->the_default)
2938     return TRUE;
2939
2940   if (abfd->arch_info->bits_per_word == 32)
2941     {
2942       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2943
2944       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2945         {
2946           /* Relies on arch after 32 bit default being 64 bit default.  */
2947           abfd->arch_info = abfd->arch_info->next;
2948           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2949         }
2950     }
2951   return _bfd_elf_ppc_set_arch (abfd);
2952 }
2953
2954 /* Support for core dump NOTE sections.  */
2955
2956 static bfd_boolean
2957 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2958 {
2959   size_t offset, size;
2960
2961   if (note->descsz != 504)
2962     return FALSE;
2963
2964   /* pr_cursig */
2965   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2966
2967   /* pr_pid */
2968   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2969
2970   /* pr_reg */
2971   offset = 112;
2972   size = 384;
2973
2974   /* Make a ".reg/999" section.  */
2975   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2976                                           size, note->descpos + offset);
2977 }
2978
2979 static bfd_boolean
2980 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2981 {
2982   if (note->descsz != 136)
2983     return FALSE;
2984
2985   elf_tdata (abfd)->core->pid
2986     = bfd_get_32 (abfd, note->descdata + 24);
2987   elf_tdata (abfd)->core->program
2988     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2989   elf_tdata (abfd)->core->command
2990     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2991
2992   return TRUE;
2993 }
2994
2995 static char *
2996 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2997                            ...)
2998 {
2999   switch (note_type)
3000     {
3001     default:
3002       return NULL;
3003
3004     case NT_PRPSINFO:
3005       {
3006         char data[136];
3007         va_list ap;
3008
3009         va_start (ap, note_type);
3010         memset (data, 0, sizeof (data));
3011         strncpy (data + 40, va_arg (ap, const char *), 16);
3012         strncpy (data + 56, va_arg (ap, const char *), 80);
3013         va_end (ap);
3014         return elfcore_write_note (abfd, buf, bufsiz,
3015                                    "CORE", note_type, data, sizeof (data));
3016       }
3017
3018     case NT_PRSTATUS:
3019       {
3020         char data[504];
3021         va_list ap;
3022         long pid;
3023         int cursig;
3024         const void *greg;
3025
3026         va_start (ap, note_type);
3027         memset (data, 0, 112);
3028         pid = va_arg (ap, long);
3029         bfd_put_32 (abfd, pid, data + 32);
3030         cursig = va_arg (ap, int);
3031         bfd_put_16 (abfd, cursig, data + 12);
3032         greg = va_arg (ap, const void *);
3033         memcpy (data + 112, greg, 384);
3034         memset (data + 496, 0, 8);
3035         va_end (ap);
3036         return elfcore_write_note (abfd, buf, bufsiz,
3037                                    "CORE", note_type, data, sizeof (data));
3038       }
3039     }
3040 }
3041
3042 /* Add extra PPC sections.  */
3043
3044 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3045 {
3046   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3047   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3048   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3049   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3050   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3051   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3052   { NULL,                     0,  0, 0,            0 }
3053 };
3054
3055 enum _ppc64_sec_type {
3056   sec_normal = 0,
3057   sec_opd = 1,
3058   sec_toc = 2
3059 };
3060
3061 struct _ppc64_elf_section_data
3062 {
3063   struct bfd_elf_section_data elf;
3064
3065   union
3066   {
3067     /* An array with one entry for each opd function descriptor,
3068        and some spares since opd entries may be either 16 or 24 bytes.  */
3069 #define OPD_NDX(OFF) ((OFF) >> 4)
3070     struct _opd_sec_data
3071     {
3072       /* Points to the function code section for local opd entries.  */
3073       asection **func_sec;
3074
3075       /* After editing .opd, adjust references to opd local syms.  */
3076       long *adjust;
3077     } opd;
3078
3079     /* An array for toc sections, indexed by offset/8.  */
3080     struct _toc_sec_data
3081     {
3082       /* Specifies the relocation symbol index used at a given toc offset.  */
3083       unsigned *symndx;
3084
3085       /* And the relocation addend.  */
3086       bfd_vma *add;
3087     } toc;
3088   } u;
3089
3090   enum _ppc64_sec_type sec_type:2;
3091
3092   /* Flag set when small branches are detected.  Used to
3093      select suitable defaults for the stub group size.  */
3094   unsigned int has_14bit_branch:1;
3095 };
3096
3097 #define ppc64_elf_section_data(sec) \
3098   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3099
3100 static bfd_boolean
3101 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3102 {
3103   if (!sec->used_by_bfd)
3104     {
3105       struct _ppc64_elf_section_data *sdata;
3106       bfd_size_type amt = sizeof (*sdata);
3107
3108       sdata = bfd_zalloc (abfd, amt);
3109       if (sdata == NULL)
3110         return FALSE;
3111       sec->used_by_bfd = sdata;
3112     }
3113
3114   return _bfd_elf_new_section_hook (abfd, sec);
3115 }
3116
3117 static struct _opd_sec_data *
3118 get_opd_info (asection * sec)
3119 {
3120   if (sec != NULL
3121       && ppc64_elf_section_data (sec) != NULL
3122       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3123     return &ppc64_elf_section_data (sec)->u.opd;
3124   return NULL;
3125 }
3126 \f
3127 /* Parameters for the qsort hook.  */
3128 static bfd_boolean synthetic_relocatable;
3129 static asection *synthetic_opd;
3130
3131 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3132
3133 static int
3134 compare_symbols (const void *ap, const void *bp)
3135 {
3136   const asymbol *a = * (const asymbol **) ap;
3137   const asymbol *b = * (const asymbol **) bp;
3138
3139   /* Section symbols first.  */
3140   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3141     return -1;
3142   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3143     return 1;
3144
3145   /* then .opd symbols.  */
3146   if (synthetic_opd != NULL)
3147     {
3148       if (strcmp (a->section->name, ".opd") == 0
3149           && strcmp (b->section->name, ".opd") != 0)
3150         return -1;
3151       if (strcmp (a->section->name, ".opd") != 0
3152           && strcmp (b->section->name, ".opd") == 0)
3153         return 1;
3154     }
3155
3156   /* then other code symbols.  */
3157   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3158       == (SEC_CODE | SEC_ALLOC)
3159       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3160          != (SEC_CODE | SEC_ALLOC))
3161     return -1;
3162
3163   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3164       != (SEC_CODE | SEC_ALLOC)
3165       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3166          == (SEC_CODE | SEC_ALLOC))
3167     return 1;
3168
3169   if (synthetic_relocatable)
3170     {
3171       if (a->section->id < b->section->id)
3172         return -1;
3173
3174       if (a->section->id > b->section->id)
3175         return 1;
3176     }
3177
3178   if (a->value + a->section->vma < b->value + b->section->vma)
3179     return -1;
3180
3181   if (a->value + a->section->vma > b->value + b->section->vma)
3182     return 1;
3183
3184   /* For syms with the same value, prefer strong dynamic global function
3185      syms over other syms.  */
3186   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3190     return 1;
3191
3192   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3193     return -1;
3194
3195   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3196     return 1;
3197
3198   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3199     return -1;
3200
3201   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3202     return 1;
3203
3204   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3205     return -1;
3206
3207   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3208     return 1;
3209
3210   return a > b;
3211 }
3212
3213 /* Search SYMS for a symbol of the given VALUE.  */
3214
3215 static asymbol *
3216 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3217 {
3218   long mid;
3219
3220   if (id == (unsigned) -1)
3221     {
3222       while (lo < hi)
3223         {
3224           mid = (lo + hi) >> 1;
3225           if (syms[mid]->value + syms[mid]->section->vma < value)
3226             lo = mid + 1;
3227           else if (syms[mid]->value + syms[mid]->section->vma > value)
3228             hi = mid;
3229           else
3230             return syms[mid];
3231         }
3232     }
3233   else
3234     {
3235       while (lo < hi)
3236         {
3237           mid = (lo + hi) >> 1;
3238           if (syms[mid]->section->id < id)
3239             lo = mid + 1;
3240           else if (syms[mid]->section->id > id)
3241             hi = mid;
3242           else if (syms[mid]->value < value)
3243             lo = mid + 1;
3244           else if (syms[mid]->value > value)
3245             hi = mid;
3246           else
3247             return syms[mid];
3248         }
3249     }
3250   return NULL;
3251 }
3252
3253 static bfd_boolean
3254 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3255 {
3256   bfd_vma vma = *(bfd_vma *) ptr;
3257   return ((section->flags & SEC_ALLOC) != 0
3258           && section->vma <= vma
3259           && vma < section->vma + section->size);
3260 }
3261
3262 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3263    entry syms.  Also generate @plt symbols for the glink branch table.
3264    Returns count of synthetic symbols in RET or -1 on error.  */
3265
3266 static long
3267 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3268                                 long static_count, asymbol **static_syms,
3269                                 long dyn_count, asymbol **dyn_syms,
3270                                 asymbol **ret)
3271 {
3272   asymbol *s;
3273   size_t i, j, count;
3274   char *names;
3275   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3276   asection *opd = NULL;
3277   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3278   asymbol **syms;
3279   int abi = abiversion (abfd);
3280
3281   *ret = NULL;
3282
3283   if (abi < 2)
3284     {
3285       opd = bfd_get_section_by_name (abfd, ".opd");
3286       if (opd == NULL && abi == 1)
3287         return 0;
3288     }
3289
3290   syms = NULL;
3291   codesecsym = 0;
3292   codesecsymend = 0;
3293   secsymend = 0;
3294   opdsymend = 0;
3295   symcount = 0;
3296   if (opd != NULL)
3297     {
3298       symcount = static_count;
3299       if (!relocatable)
3300         symcount += dyn_count;
3301       if (symcount == 0)
3302         return 0;
3303
3304       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3305       if (syms == NULL)
3306         return -1;
3307
3308       if (!relocatable && static_count != 0 && dyn_count != 0)
3309         {
3310           /* Use both symbol tables.  */
3311           memcpy (syms, static_syms, static_count * sizeof (*syms));
3312           memcpy (syms + static_count, dyn_syms,
3313                   (dyn_count + 1) * sizeof (*syms));
3314         }
3315       else if (!relocatable && static_count == 0)
3316         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3317       else
3318         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3319
3320       /* Trim uninteresting symbols.  Interesting symbols are section,
3321          function, and notype symbols.  */
3322       for (i = 0, j = 0; i < symcount; ++i)
3323         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3324                                | BSF_RELC | BSF_SRELC)) == 0)
3325           syms[j++] = syms[i];
3326       symcount = j;
3327
3328       synthetic_relocatable = relocatable;
3329       synthetic_opd = opd;
3330       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3331
3332       if (!relocatable && symcount > 1)
3333         {
3334           /* Trim duplicate syms, since we may have merged the normal and
3335              dynamic symbols.  Actually, we only care about syms that have
3336              different values, so trim any with the same value.  */
3337           for (i = 1, j = 1; i < symcount; ++i)
3338             if (syms[i - 1]->value + syms[i - 1]->section->vma
3339                 != syms[i]->value + syms[i]->section->vma)
3340               syms[j++] = syms[i];
3341           symcount = j;
3342         }
3343
3344       i = 0;
3345       /* Note that here and in compare_symbols we can't compare opd and
3346          sym->section directly.  With separate debug info files, the
3347          symbols will be extracted from the debug file while abfd passed
3348          to this function is the real binary.  */
3349       if (strcmp (syms[i]->section->name, ".opd") == 0)
3350         ++i;
3351       codesecsym = i;
3352
3353       for (; i < symcount; ++i)
3354         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3355                                          | SEC_THREAD_LOCAL))
3356              != (SEC_CODE | SEC_ALLOC))
3357             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3358           break;
3359       codesecsymend = i;
3360
3361       for (; i < symcount; ++i)
3362         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3363           break;
3364       secsymend = i;
3365
3366       for (; i < symcount; ++i)
3367         if (strcmp (syms[i]->section->name, ".opd") != 0)
3368           break;
3369       opdsymend = i;
3370
3371       for (; i < symcount; ++i)
3372         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3373             != (SEC_CODE | SEC_ALLOC))
3374           break;
3375       symcount = i;
3376     }
3377   count = 0;
3378
3379   if (relocatable)
3380     {
3381       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3382       arelent *r;
3383       size_t size;
3384       size_t relcount;
3385
3386       if (opdsymend == secsymend)
3387         goto done;
3388
3389       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3390       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3391       if (relcount == 0)
3392         goto done;
3393
3394       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3395         {
3396           count = -1;
3397           goto done;
3398         }
3399
3400       size = 0;
3401       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3402         {
3403           asymbol *sym;
3404
3405           while (r < opd->relocation + relcount
3406                  && r->address < syms[i]->value + opd->vma)
3407             ++r;
3408
3409           if (r == opd->relocation + relcount)
3410             break;
3411
3412           if (r->address != syms[i]->value + opd->vma)
3413             continue;
3414
3415           if (r->howto->type != R_PPC64_ADDR64)
3416             continue;
3417
3418           sym = *r->sym_ptr_ptr;
3419           if (!sym_exists_at (syms, opdsymend, symcount,
3420                               sym->section->id, sym->value + r->addend))
3421             {
3422               ++count;
3423               size += sizeof (asymbol);
3424               size += strlen (syms[i]->name) + 2;
3425             }
3426         }
3427
3428       if (size == 0)
3429         goto done;
3430       s = *ret = bfd_malloc (size);
3431       if (s == NULL)
3432         {
3433           count = -1;
3434           goto done;
3435         }
3436
3437       names = (char *) (s + count);
3438
3439       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3440         {
3441           asymbol *sym;
3442
3443           while (r < opd->relocation + relcount
3444                  && r->address < syms[i]->value + opd->vma)
3445             ++r;
3446
3447           if (r == opd->relocation + relcount)
3448             break;
3449
3450           if (r->address != syms[i]->value + opd->vma)
3451             continue;
3452
3453           if (r->howto->type != R_PPC64_ADDR64)
3454             continue;
3455
3456           sym = *r->sym_ptr_ptr;
3457           if (!sym_exists_at (syms, opdsymend, symcount,
3458                               sym->section->id, sym->value + r->addend))
3459             {
3460               size_t len;
3461
3462               *s = *syms[i];
3463               s->flags |= BSF_SYNTHETIC;
3464               s->section = sym->section;
3465               s->value = sym->value + r->addend;
3466               s->name = names;
3467               *names++ = '.';
3468               len = strlen (syms[i]->name);
3469               memcpy (names, syms[i]->name, len + 1);
3470               names += len + 1;
3471               /* Have udata.p point back to the original symbol this
3472                  synthetic symbol was derived from.  */
3473               s->udata.p = syms[i];
3474               s++;
3475             }
3476         }
3477     }
3478   else
3479     {
3480       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3481       bfd_byte *contents = NULL;
3482       size_t size;
3483       size_t plt_count = 0;
3484       bfd_vma glink_vma = 0, resolv_vma = 0;
3485       asection *dynamic, *glink = NULL, *relplt = NULL;
3486       arelent *p;
3487
3488       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3489         {
3490         free_contents_and_exit_err:
3491           count = -1;
3492         free_contents_and_exit:
3493           if (contents)
3494             free (contents);
3495           goto done;
3496         }
3497
3498       size = 0;
3499       for (i = secsymend; i < opdsymend; ++i)
3500         {
3501           bfd_vma ent;
3502
3503           /* Ignore bogus symbols.  */
3504           if (syms[i]->value > opd->size - 8)
3505             continue;
3506
3507           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3508           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3509             {
3510               ++count;
3511               size += sizeof (asymbol);
3512               size += strlen (syms[i]->name) + 2;
3513             }
3514         }
3515
3516       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3517       if (dyn_count != 0
3518           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3519         {
3520           bfd_byte *dynbuf, *extdyn, *extdynend;
3521           size_t extdynsize;
3522           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3523
3524           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3525             goto free_contents_and_exit_err;
3526
3527           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3528           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3529
3530           extdyn = dynbuf;
3531           extdynend = extdyn + dynamic->size;
3532           for (; extdyn < extdynend; extdyn += extdynsize)
3533             {
3534               Elf_Internal_Dyn dyn;
3535               (*swap_dyn_in) (abfd, extdyn, &dyn);
3536
3537               if (dyn.d_tag == DT_NULL)
3538                 break;
3539
3540               if (dyn.d_tag == DT_PPC64_GLINK)
3541                 {
3542                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3543                      See comment in ppc64_elf_finish_dynamic_sections. */
3544                   glink_vma = dyn.d_un.d_val + 8 * 4;
3545                   /* The .glink section usually does not survive the final
3546                      link; search for the section (usually .text) where the
3547                      glink stubs now reside.  */
3548                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3549                                                 &glink_vma);
3550                   break;
3551                 }
3552             }
3553
3554           free (dynbuf);
3555         }
3556
3557       if (glink != NULL)
3558         {
3559           /* Determine __glink trampoline by reading the relative branch
3560              from the first glink stub.  */
3561           bfd_byte buf[4];
3562           unsigned int off = 0;
3563
3564           while (bfd_get_section_contents (abfd, glink, buf,
3565                                            glink_vma + off - glink->vma, 4))
3566             {
3567               unsigned int insn = bfd_get_32 (abfd, buf);
3568               insn ^= B_DOT;
3569               if ((insn & ~0x3fffffc) == 0)
3570                 {
3571                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3572                   break;
3573                 }
3574               off += 4;
3575               if (off > 4)
3576                 break;
3577             }
3578
3579           if (resolv_vma)
3580             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3581
3582           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3583           if (relplt != NULL)
3584             {
3585               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3586               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3587                 goto free_contents_and_exit_err;
3588
3589               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3590               size += plt_count * sizeof (asymbol);
3591
3592               p = relplt->relocation;
3593               for (i = 0; i < plt_count; i++, p++)
3594                 {
3595                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3596                   if (p->addend != 0)
3597                     size += sizeof ("+0x") - 1 + 16;
3598                 }
3599             }
3600         }
3601
3602       if (size == 0)
3603         goto free_contents_and_exit;
3604       s = *ret = bfd_malloc (size);
3605       if (s == NULL)
3606         goto free_contents_and_exit_err;
3607
3608       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3609
3610       for (i = secsymend; i < opdsymend; ++i)
3611         {
3612           bfd_vma ent;
3613
3614           if (syms[i]->value > opd->size - 8)
3615             continue;
3616
3617           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3618           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3619             {
3620               size_t lo, hi;
3621               size_t len;
3622               asection *sec = abfd->sections;
3623
3624               *s = *syms[i];
3625               lo = codesecsym;
3626               hi = codesecsymend;
3627               while (lo < hi)
3628                 {
3629                   size_t mid = (lo + hi) >> 1;
3630                   if (syms[mid]->section->vma < ent)
3631                     lo = mid + 1;
3632                   else if (syms[mid]->section->vma > ent)
3633                     hi = mid;
3634                   else
3635                     {
3636                       sec = syms[mid]->section;
3637                       break;
3638                     }
3639                 }
3640
3641               if (lo >= hi && lo > codesecsym)
3642                 sec = syms[lo - 1]->section;
3643
3644               for (; sec != NULL; sec = sec->next)
3645                 {
3646                   if (sec->vma > ent)
3647                     break;
3648                   /* SEC_LOAD may not be set if SEC is from a separate debug
3649                      info file.  */
3650                   if ((sec->flags & SEC_ALLOC) == 0)
3651                     break;
3652                   if ((sec->flags & SEC_CODE) != 0)
3653                     s->section = sec;
3654                 }
3655               s->flags |= BSF_SYNTHETIC;
3656               s->value = ent - s->section->vma;
3657               s->name = names;
3658               *names++ = '.';
3659               len = strlen (syms[i]->name);
3660               memcpy (names, syms[i]->name, len + 1);
3661               names += len + 1;
3662               /* Have udata.p point back to the original symbol this
3663                  synthetic symbol was derived from.  */
3664               s->udata.p = syms[i];
3665               s++;
3666             }
3667         }
3668       free (contents);
3669
3670       if (glink != NULL && relplt != NULL)
3671         {
3672           if (resolv_vma)
3673             {
3674               /* Add a symbol for the main glink trampoline.  */
3675               memset (s, 0, sizeof *s);
3676               s->the_bfd = abfd;
3677               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3678               s->section = glink;
3679               s->value = resolv_vma - glink->vma;
3680               s->name = names;
3681               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3682               names += sizeof ("__glink_PLTresolve");
3683               s++;
3684               count++;
3685             }
3686
3687           /* FIXME: It would be very much nicer to put sym@plt on the
3688              stub rather than on the glink branch table entry.  The
3689              objdump disassembler would then use a sensible symbol
3690              name on plt calls.  The difficulty in doing so is
3691              a) finding the stubs, and,
3692              b) matching stubs against plt entries, and,
3693              c) there can be multiple stubs for a given plt entry.
3694
3695              Solving (a) could be done by code scanning, but older
3696              ppc64 binaries used different stubs to current code.
3697              (b) is the tricky one since you need to known the toc
3698              pointer for at least one function that uses a pic stub to
3699              be able to calculate the plt address referenced.
3700              (c) means gdb would need to set multiple breakpoints (or
3701              find the glink branch itself) when setting breakpoints
3702              for pending shared library loads.  */
3703           p = relplt->relocation;
3704           for (i = 0; i < plt_count; i++, p++)
3705             {
3706               size_t len;
3707
3708               *s = **p->sym_ptr_ptr;
3709               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3710                  we are defining a symbol, ensure one of them is set.  */
3711               if ((s->flags & BSF_LOCAL) == 0)
3712                 s->flags |= BSF_GLOBAL;
3713               s->flags |= BSF_SYNTHETIC;
3714               s->section = glink;
3715               s->value = glink_vma - glink->vma;
3716               s->name = names;
3717               s->udata.p = NULL;
3718               len = strlen ((*p->sym_ptr_ptr)->name);
3719               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3720               names += len;
3721               if (p->addend != 0)
3722                 {
3723                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3724                   names += sizeof ("+0x") - 1;
3725                   bfd_sprintf_vma (abfd, names, p->addend);
3726                   names += strlen (names);
3727                 }
3728               memcpy (names, "@plt", sizeof ("@plt"));
3729               names += sizeof ("@plt");
3730               s++;
3731               if (abi < 2)
3732                 {
3733                   glink_vma += 8;
3734                   if (i >= 0x8000)
3735                     glink_vma += 4;
3736                 }
3737               else
3738                 glink_vma += 4;
3739             }
3740           count += plt_count;
3741         }
3742     }
3743
3744  done:
3745   free (syms);
3746   return count;
3747 }
3748 \f
3749 /* The following functions are specific to the ELF linker, while
3750    functions above are used generally.  Those named ppc64_elf_* are
3751    called by the main ELF linker code.  They appear in this file more
3752    or less in the order in which they are called.  eg.
3753    ppc64_elf_check_relocs is called early in the link process,
3754    ppc64_elf_finish_dynamic_sections is one of the last functions
3755    called.
3756
3757    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3758    functions have both a function code symbol and a function descriptor
3759    symbol.  A call to foo in a relocatable object file looks like:
3760
3761    .            .text
3762    .    x:
3763    .            bl      .foo
3764    .            nop
3765
3766    The function definition in another object file might be:
3767
3768    .            .section .opd
3769    .    foo:    .quad   .foo
3770    .            .quad   .TOC.@tocbase
3771    .            .quad   0
3772    .
3773    .            .text
3774    .    .foo:   blr
3775
3776    When the linker resolves the call during a static link, the branch
3777    unsurprisingly just goes to .foo and the .opd information is unused.
3778    If the function definition is in a shared library, things are a little
3779    different:  The call goes via a plt call stub, the opd information gets
3780    copied to the plt, and the linker patches the nop.
3781
3782    .    x:
3783    .            bl      .foo_stub
3784    .            ld      2,40(1)
3785    .
3786    .
3787    .    .foo_stub:
3788    .            std     2,40(1)                 # in practice, the call stub
3789    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3790    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3791    .            ld      12,0(11)
3792    .            ld      2,8(11)
3793    .            mtctr   12
3794    .            ld      11,16(11)
3795    .            bctr
3796    .
3797    .            .section .plt
3798    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3799
3800    The "reloc ()" notation is supposed to indicate that the linker emits
3801    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3802    copying.
3803
3804    What are the difficulties here?  Well, firstly, the relocations
3805    examined by the linker in check_relocs are against the function code
3806    sym .foo, while the dynamic relocation in the plt is emitted against
3807    the function descriptor symbol, foo.  Somewhere along the line, we need
3808    to carefully copy dynamic link information from one symbol to the other.
3809    Secondly, the generic part of the elf linker will make .foo a dynamic
3810    symbol as is normal for most other backends.  We need foo dynamic
3811    instead, at least for an application final link.  However, when
3812    creating a shared library containing foo, we need to have both symbols
3813    dynamic so that references to .foo are satisfied during the early
3814    stages of linking.  Otherwise the linker might decide to pull in a
3815    definition from some other object, eg. a static library.
3816
3817    Update: As of August 2004, we support a new convention.  Function
3818    calls may use the function descriptor symbol, ie. "bl foo".  This
3819    behaves exactly as "bl .foo".  */
3820
3821 /* Of those relocs that might be copied as dynamic relocs, this
3822    function selects those that must be copied when linking a shared
3823    library or PIE, even when the symbol is local.  */
3824
3825 static int
3826 must_be_dyn_reloc (struct bfd_link_info *info,
3827                    enum elf_ppc64_reloc_type r_type)
3828 {
3829   switch (r_type)
3830     {
3831     default:
3832       /* Only relative relocs can be resolved when the object load
3833          address isn't fixed.  DTPREL64 is excluded because the
3834          dynamic linker needs to differentiate global dynamic from
3835          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3836       return 1;
3837
3838     case R_PPC64_REL32:
3839     case R_PPC64_REL64:
3840     case R_PPC64_REL30:
3841       return 0;
3842
3843     case R_PPC64_TPREL16:
3844     case R_PPC64_TPREL16_LO:
3845     case R_PPC64_TPREL16_HI:
3846     case R_PPC64_TPREL16_HA:
3847     case R_PPC64_TPREL16_DS:
3848     case R_PPC64_TPREL16_LO_DS:
3849     case R_PPC64_TPREL16_HIGH:
3850     case R_PPC64_TPREL16_HIGHA:
3851     case R_PPC64_TPREL16_HIGHER:
3852     case R_PPC64_TPREL16_HIGHERA:
3853     case R_PPC64_TPREL16_HIGHEST:
3854     case R_PPC64_TPREL16_HIGHESTA:
3855     case R_PPC64_TPREL64:
3856       /* These relocations are relative but in a shared library the
3857          linker doesn't know the thread pointer base.  */
3858       return bfd_link_dll (info);
3859     }
3860 }
3861
3862 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3863    copying dynamic variables from a shared lib into an app's dynbss
3864    section, and instead use a dynamic relocation to point into the
3865    shared lib.  With code that gcc generates, it's vital that this be
3866    enabled;  In the PowerPC64 ABI, the address of a function is actually
3867    the address of a function descriptor, which resides in the .opd
3868    section.  gcc uses the descriptor directly rather than going via the
3869    GOT as some other ABI's do, which means that initialized function
3870    pointers must reference the descriptor.  Thus, a function pointer
3871    initialized to the address of a function in a shared library will
3872    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3873    redefines the function descriptor symbol to point to the copy.  This
3874    presents a problem as a plt entry for that function is also
3875    initialized from the function descriptor symbol and the copy reloc
3876    may not be initialized first.  */
3877 #define ELIMINATE_COPY_RELOCS 1
3878
3879 /* Section name for stubs is the associated section name plus this
3880    string.  */
3881 #define STUB_SUFFIX ".stub"
3882
3883 /* Linker stubs.
3884    ppc_stub_long_branch:
3885    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3886    destination, but a 24 bit branch in a stub section will reach.
3887    .    b       dest
3888
3889    ppc_stub_plt_branch:
3890    Similar to the above, but a 24 bit branch in the stub section won't
3891    reach its destination.
3892    .    addis   %r11,%r2,xxx@toc@ha
3893    .    ld      %r12,xxx@toc@l(%r11)
3894    .    mtctr   %r12
3895    .    bctr
3896
3897    ppc_stub_plt_call:
3898    Used to call a function in a shared library.  If it so happens that
3899    the plt entry referenced crosses a 64k boundary, then an extra
3900    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3901    .    std     %r2,40(%r1)
3902    .    addis   %r11,%r2,xxx@toc@ha
3903    .    ld      %r12,xxx+0@toc@l(%r11)
3904    .    mtctr   %r12
3905    .    ld      %r2,xxx+8@toc@l(%r11)
3906    .    ld      %r11,xxx+16@toc@l(%r11)
3907    .    bctr
3908
3909    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3910    code to adjust the value and save r2 to support multiple toc sections.
3911    A ppc_stub_long_branch with an r2 offset looks like:
3912    .    std     %r2,40(%r1)
3913    .    addis   %r2,%r2,off@ha
3914    .    addi    %r2,%r2,off@l
3915    .    b       dest
3916
3917    A ppc_stub_plt_branch with an r2 offset looks like:
3918    .    std     %r2,40(%r1)
3919    .    addis   %r11,%r2,xxx@toc@ha
3920    .    ld      %r12,xxx@toc@l(%r11)
3921    .    addis   %r2,%r2,off@ha
3922    .    addi    %r2,%r2,off@l
3923    .    mtctr   %r12
3924    .    bctr
3925
3926    In cases where the "addis" instruction would add zero, the "addis" is
3927    omitted and following instructions modified slightly in some cases.
3928 */
3929
3930 enum ppc_stub_type {
3931   ppc_stub_none,
3932   ppc_stub_long_branch,
3933   ppc_stub_long_branch_r2off,
3934   ppc_stub_plt_branch,
3935   ppc_stub_plt_branch_r2off,
3936   ppc_stub_plt_call,
3937   ppc_stub_plt_call_r2save,
3938   ppc_stub_global_entry,
3939   ppc_stub_save_res
3940 };
3941
3942 /* Information on stub grouping.  */
3943 struct map_stub
3944 {
3945   /* The stub section.  */
3946   asection *stub_sec;
3947   /* This is the section to which stubs in the group will be attached.  */
3948   asection *link_sec;
3949   /* Next group.  */
3950   struct map_stub *next;
3951   /* Whether to emit a copy of register save/restore functions in this
3952      group.  */
3953   int needs_save_res;
3954   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3955      or -1u if no such stub with bctrl exists.  */
3956   unsigned int tls_get_addr_opt_bctrl;
3957 };
3958
3959 struct ppc_stub_hash_entry {
3960
3961   /* Base hash table entry structure.  */
3962   struct bfd_hash_entry root;
3963
3964   enum ppc_stub_type stub_type;
3965
3966   /* Group information.  */
3967   struct map_stub *group;
3968
3969   /* Offset within stub_sec of the beginning of this stub.  */
3970   bfd_vma stub_offset;
3971
3972   /* Given the symbol's value and its section we can determine its final
3973      value when building the stubs (so the stub knows where to jump.  */
3974   bfd_vma target_value;
3975   asection *target_section;
3976
3977   /* The symbol table entry, if any, that this was derived from.  */
3978   struct ppc_link_hash_entry *h;
3979   struct plt_entry *plt_ent;
3980
3981   /* Symbol type.  */
3982   unsigned char symtype;
3983
3984   /* Symbol st_other.  */
3985   unsigned char other;
3986 };
3987
3988 struct ppc_branch_hash_entry {
3989
3990   /* Base hash table entry structure.  */
3991   struct bfd_hash_entry root;
3992
3993   /* Offset within branch lookup table.  */
3994   unsigned int offset;
3995
3996   /* Generation marker.  */
3997   unsigned int iter;
3998 };
3999
4000 /* Used to track dynamic relocations for local symbols.  */
4001 struct ppc_dyn_relocs
4002 {
4003   struct ppc_dyn_relocs *next;
4004
4005   /* The input section of the reloc.  */
4006   asection *sec;
4007
4008   /* Total number of relocs copied for the input section.  */
4009   unsigned int count : 31;
4010
4011   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4012   unsigned int ifunc : 1;
4013 };
4014
4015 struct ppc_link_hash_entry
4016 {
4017   struct elf_link_hash_entry elf;
4018
4019   union {
4020     /* A pointer to the most recently used stub hash entry against this
4021        symbol.  */
4022     struct ppc_stub_hash_entry *stub_cache;
4023
4024     /* A pointer to the next symbol starting with a '.'  */
4025     struct ppc_link_hash_entry *next_dot_sym;
4026   } u;
4027
4028   /* Track dynamic relocs copied for this symbol.  */
4029   struct elf_dyn_relocs *dyn_relocs;
4030
4031   /* Link between function code and descriptor symbols.  */
4032   struct ppc_link_hash_entry *oh;
4033
4034   /* Flag function code and descriptor symbols.  */
4035   unsigned int is_func:1;
4036   unsigned int is_func_descriptor:1;
4037   unsigned int fake:1;
4038
4039   /* Whether global opd/toc sym has been adjusted or not.
4040      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4041      should be set for all globals defined in any opd/toc section.  */
4042   unsigned int adjust_done:1;
4043
4044   /* Set if this is an out-of-line register save/restore function,
4045      with non-standard calling convention.  */
4046   unsigned int save_res:1;
4047
4048   /* Set if a duplicate symbol with non-zero localentry is detected,
4049      even when the duplicate symbol does not provide a definition.  */
4050   unsigned int non_zero_localentry:1;
4051
4052   /* Contexts in which symbol is used in the GOT (or TOC).
4053      Bits are or'd into the mask as the corresponding relocs are
4054      encountered during check_relocs, with TLS_TLS being set when any
4055      of the other TLS bits are set.  tls_optimize clears bits when
4056      optimizing to indicate the corresponding GOT entry type is not
4057      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4058      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4059      separate flag rather than setting TPREL just for convenience in
4060      distinguishing the two cases.
4061      These flags are also kept for local symbols.  */
4062 #define TLS_TLS          1      /* Any TLS reloc.  */
4063 #define TLS_GD           2      /* GD reloc. */
4064 #define TLS_LD           4      /* LD reloc. */
4065 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4066 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4067 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4068 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4069 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4070   unsigned char tls_mask;
4071
4072   /* The above field is also used to mark function symbols.  In which
4073      case TLS_TLS will be 0.  */
4074 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4075 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4076 #define NON_GOT        256      /* local symbol plt, not stored.  */
4077 };
4078
4079 /* ppc64 ELF linker hash table.  */
4080
4081 struct ppc_link_hash_table
4082 {
4083   struct elf_link_hash_table elf;
4084
4085   /* The stub hash table.  */
4086   struct bfd_hash_table stub_hash_table;
4087
4088   /* Another hash table for plt_branch stubs.  */
4089   struct bfd_hash_table branch_hash_table;
4090
4091   /* Hash table for function prologue tocsave.  */
4092   htab_t tocsave_htab;
4093
4094   /* Various options and other info passed from the linker.  */
4095   struct ppc64_elf_params *params;
4096
4097   /* The size of sec_info below.  */
4098   unsigned int sec_info_arr_size;
4099
4100   /* Per-section array of extra section info.  Done this way rather
4101      than as part of ppc64_elf_section_data so we have the info for
4102      non-ppc64 sections.  */
4103   struct
4104   {
4105     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4106     bfd_vma toc_off;
4107
4108     union
4109     {
4110       /* The section group that this section belongs to.  */
4111       struct map_stub *group;
4112       /* A temp section list pointer.  */
4113       asection *list;
4114     } u;
4115   } *sec_info;
4116
4117   /* Linked list of groups.  */
4118   struct map_stub *group;
4119
4120   /* Temp used when calculating TOC pointers.  */
4121   bfd_vma toc_curr;
4122   bfd *toc_bfd;
4123   asection *toc_first_sec;
4124
4125   /* Used when adding symbols.  */
4126   struct ppc_link_hash_entry *dot_syms;
4127
4128   /* Shortcuts to get to dynamic linker sections.  */
4129   asection *glink;
4130   asection *global_entry;
4131   asection *sfpr;
4132   asection *pltlocal;
4133   asection *relpltlocal;
4134   asection *brlt;
4135   asection *relbrlt;
4136   asection *glink_eh_frame;
4137
4138   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4139   struct ppc_link_hash_entry *tls_get_addr;
4140   struct ppc_link_hash_entry *tls_get_addr_fd;
4141
4142   /* The size of reliplt used by got entry relocs.  */
4143   bfd_size_type got_reli_size;
4144
4145   /* Statistics.  */
4146   unsigned long stub_count[ppc_stub_global_entry];
4147
4148   /* Number of stubs against global syms.  */
4149   unsigned long stub_globals;
4150
4151   /* Set if we're linking code with function descriptors.  */
4152   unsigned int opd_abi:1;
4153
4154   /* Support for multiple toc sections.  */
4155   unsigned int do_multi_toc:1;
4156   unsigned int multi_toc_needed:1;
4157   unsigned int second_toc_pass:1;
4158   unsigned int do_toc_opt:1;
4159
4160   /* Set if tls optimization is enabled.  */
4161   unsigned int do_tls_opt:1;
4162
4163   /* Set on error.  */
4164   unsigned int stub_error:1;
4165
4166   /* Whether func_desc_adjust needs to be run over symbols.  */
4167   unsigned int need_func_desc_adj:1;
4168
4169   /* Whether there exist local gnu indirect function resolvers,
4170      referenced by dynamic relocations.  */
4171   unsigned int local_ifunc_resolver:1;
4172   unsigned int maybe_local_ifunc_resolver:1;
4173
4174   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4175   unsigned int has_plt_localentry0:1;
4176
4177   /* Incremented every time we size stubs.  */
4178   unsigned int stub_iteration;
4179
4180   /* Small local sym cache.  */
4181   struct sym_cache sym_cache;
4182 };
4183
4184 /* Rename some of the generic section flags to better document how they
4185    are used here.  */
4186
4187 /* Nonzero if this section has TLS related relocations.  */
4188 #define has_tls_reloc sec_flg0
4189
4190 /* Nonzero if this section has a call to __tls_get_addr.  */
4191 #define has_tls_get_addr_call sec_flg1
4192
4193 /* Nonzero if this section has any toc or got relocs.  */
4194 #define has_toc_reloc sec_flg2
4195
4196 /* Nonzero if this section has a call to another section that uses
4197    the toc or got.  */
4198 #define makes_toc_func_call sec_flg3
4199
4200 /* Recursion protection when determining above flag.  */
4201 #define call_check_in_progress sec_flg4
4202 #define call_check_done sec_flg5
4203
4204 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4205
4206 #define ppc_hash_table(p) \
4207   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4208   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4209
4210 #define ppc_stub_hash_lookup(table, string, create, copy) \
4211   ((struct ppc_stub_hash_entry *) \
4212    bfd_hash_lookup ((table), (string), (create), (copy)))
4213
4214 #define ppc_branch_hash_lookup(table, string, create, copy) \
4215   ((struct ppc_branch_hash_entry *) \
4216    bfd_hash_lookup ((table), (string), (create), (copy)))
4217
4218 /* Create an entry in the stub hash table.  */
4219
4220 static struct bfd_hash_entry *
4221 stub_hash_newfunc (struct bfd_hash_entry *entry,
4222                    struct bfd_hash_table *table,
4223                    const char *string)
4224 {
4225   /* Allocate the structure if it has not already been allocated by a
4226      subclass.  */
4227   if (entry == NULL)
4228     {
4229       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4230       if (entry == NULL)
4231         return entry;
4232     }
4233
4234   /* Call the allocation method of the superclass.  */
4235   entry = bfd_hash_newfunc (entry, table, string);
4236   if (entry != NULL)
4237     {
4238       struct ppc_stub_hash_entry *eh;
4239
4240       /* Initialize the local fields.  */
4241       eh = (struct ppc_stub_hash_entry *) entry;
4242       eh->stub_type = ppc_stub_none;
4243       eh->group = NULL;
4244       eh->stub_offset = 0;
4245       eh->target_value = 0;
4246       eh->target_section = NULL;
4247       eh->h = NULL;
4248       eh->plt_ent = NULL;
4249       eh->other = 0;
4250     }
4251
4252   return entry;
4253 }
4254
4255 /* Create an entry in the branch hash table.  */
4256
4257 static struct bfd_hash_entry *
4258 branch_hash_newfunc (struct bfd_hash_entry *entry,
4259                      struct bfd_hash_table *table,
4260                      const char *string)
4261 {
4262   /* Allocate the structure if it has not already been allocated by a
4263      subclass.  */
4264   if (entry == NULL)
4265     {
4266       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4267       if (entry == NULL)
4268         return entry;
4269     }
4270
4271   /* Call the allocation method of the superclass.  */
4272   entry = bfd_hash_newfunc (entry, table, string);
4273   if (entry != NULL)
4274     {
4275       struct ppc_branch_hash_entry *eh;
4276
4277       /* Initialize the local fields.  */
4278       eh = (struct ppc_branch_hash_entry *) entry;
4279       eh->offset = 0;
4280       eh->iter = 0;
4281     }
4282
4283   return entry;
4284 }
4285
4286 /* Create an entry in a ppc64 ELF linker hash table.  */
4287
4288 static struct bfd_hash_entry *
4289 link_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_link_hash_entry));
4298       if (entry == NULL)
4299         return entry;
4300     }
4301
4302   /* Call the allocation method of the superclass.  */
4303   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4304   if (entry != NULL)
4305     {
4306       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4307
4308       memset (&eh->u.stub_cache, 0,
4309               (sizeof (struct ppc_link_hash_entry)
4310                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4311
4312       /* When making function calls, old ABI code references function entry
4313          points (dot symbols), while new ABI code references the function
4314          descriptor symbol.  We need to make any combination of reference and
4315          definition work together, without breaking archive linking.
4316
4317          For a defined function "foo" and an undefined call to "bar":
4318          An old object defines "foo" and ".foo", references ".bar" (possibly
4319          "bar" too).
4320          A new object defines "foo" and references "bar".
4321
4322          A new object thus has no problem with its undefined symbols being
4323          satisfied by definitions in an old object.  On the other hand, the
4324          old object won't have ".bar" satisfied by a new object.
4325
4326          Keep a list of newly added dot-symbols.  */
4327
4328       if (string[0] == '.')
4329         {
4330           struct ppc_link_hash_table *htab;
4331
4332           htab = (struct ppc_link_hash_table *) table;
4333           eh->u.next_dot_sym = htab->dot_syms;
4334           htab->dot_syms = eh;
4335         }
4336     }
4337
4338   return entry;
4339 }
4340
4341 struct tocsave_entry {
4342   asection *sec;
4343   bfd_vma offset;
4344 };
4345
4346 static hashval_t
4347 tocsave_htab_hash (const void *p)
4348 {
4349   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4350   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4351 }
4352
4353 static int
4354 tocsave_htab_eq (const void *p1, const void *p2)
4355 {
4356   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4357   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4358   return e1->sec == e2->sec && e1->offset == e2->offset;
4359 }
4360
4361 /* Destroy a ppc64 ELF linker hash table.  */
4362
4363 static void
4364 ppc64_elf_link_hash_table_free (bfd *obfd)
4365 {
4366   struct ppc_link_hash_table *htab;
4367
4368   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4369   if (htab->tocsave_htab)
4370     htab_delete (htab->tocsave_htab);
4371   bfd_hash_table_free (&htab->branch_hash_table);
4372   bfd_hash_table_free (&htab->stub_hash_table);
4373   _bfd_elf_link_hash_table_free (obfd);
4374 }
4375
4376 /* Create a ppc64 ELF linker hash table.  */
4377
4378 static struct bfd_link_hash_table *
4379 ppc64_elf_link_hash_table_create (bfd *abfd)
4380 {
4381   struct ppc_link_hash_table *htab;
4382   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4383
4384   htab = bfd_zmalloc (amt);
4385   if (htab == NULL)
4386     return NULL;
4387
4388   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4389                                       sizeof (struct ppc_link_hash_entry),
4390                                       PPC64_ELF_DATA))
4391     {
4392       free (htab);
4393       return NULL;
4394     }
4395
4396   /* Init the stub hash table too.  */
4397   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4398                             sizeof (struct ppc_stub_hash_entry)))
4399     {
4400       _bfd_elf_link_hash_table_free (abfd);
4401       return NULL;
4402     }
4403
4404   /* And the branch hash table.  */
4405   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4406                             sizeof (struct ppc_branch_hash_entry)))
4407     {
4408       bfd_hash_table_free (&htab->stub_hash_table);
4409       _bfd_elf_link_hash_table_free (abfd);
4410       return NULL;
4411     }
4412
4413   htab->tocsave_htab = htab_try_create (1024,
4414                                         tocsave_htab_hash,
4415                                         tocsave_htab_eq,
4416                                         NULL);
4417   if (htab->tocsave_htab == NULL)
4418     {
4419       ppc64_elf_link_hash_table_free (abfd);
4420       return NULL;
4421     }
4422   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4423
4424   /* Initializing two fields of the union is just cosmetic.  We really
4425      only care about glist, but when compiled on a 32-bit host the
4426      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4427      debugger inspection of these fields look nicer.  */
4428   htab->elf.init_got_refcount.refcount = 0;
4429   htab->elf.init_got_refcount.glist = NULL;
4430   htab->elf.init_plt_refcount.refcount = 0;
4431   htab->elf.init_plt_refcount.glist = NULL;
4432   htab->elf.init_got_offset.offset = 0;
4433   htab->elf.init_got_offset.glist = NULL;
4434   htab->elf.init_plt_offset.offset = 0;
4435   htab->elf.init_plt_offset.glist = NULL;
4436
4437   return &htab->elf.root;
4438 }
4439
4440 /* Create sections for linker generated code.  */
4441
4442 static bfd_boolean
4443 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4444 {
4445   struct ppc_link_hash_table *htab;
4446   flagword flags;
4447
4448   htab = ppc_hash_table (info);
4449
4450   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4451            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4452   if (htab->params->save_restore_funcs)
4453     {
4454       /* Create .sfpr for code to save and restore fp regs.  */
4455       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4456                                                        flags);
4457       if (htab->sfpr == NULL
4458           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4459         return FALSE;
4460     }
4461
4462   if (bfd_link_relocatable (info))
4463     return TRUE;
4464
4465   /* Create .glink for lazy dynamic linking support.  */
4466   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4467                                                     flags);
4468   if (htab->glink == NULL
4469       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4470     return FALSE;
4471
4472   /* The part of .glink used by global entry stubs, separate so that
4473      it can be aligned appropriately without affecting htab->glink.  */
4474   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4475                                                            flags);
4476   if (htab->global_entry == NULL
4477       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4478     return FALSE;
4479
4480   if (!info->no_ld_generated_unwind_info)
4481     {
4482       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4483                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4484       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4485                                                                  ".eh_frame",
4486                                                                  flags);
4487       if (htab->glink_eh_frame == NULL
4488           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4489         return FALSE;
4490     }
4491
4492   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4493   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4494   if (htab->elf.iplt == NULL
4495       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4496     return FALSE;
4497
4498   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4499            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4500   htab->elf.irelplt
4501     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4502   if (htab->elf.irelplt == NULL
4503       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4504     return FALSE;
4505
4506   /* Create branch lookup table for plt_branch stubs.  */
4507   flags = (SEC_ALLOC | SEC_LOAD
4508            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4509   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4510                                                    flags);
4511   if (htab->brlt == NULL
4512       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4513     return FALSE;
4514
4515   /* Local plt entries, put in .branch_lt but a separate section for
4516      convenience.  */
4517   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4518                                                        flags);
4519   if (htab->pltlocal == NULL
4520       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4521     return FALSE;
4522
4523   if (!bfd_link_pic (info))
4524     return TRUE;
4525
4526   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4527            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4528   htab->relbrlt
4529     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4530   if (htab->relbrlt == NULL
4531       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4532     return FALSE;
4533
4534   htab->relpltlocal
4535     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4536   if (htab->relpltlocal == NULL
4537       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4538     return FALSE;
4539
4540   return TRUE;
4541 }
4542
4543 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4544
4545 bfd_boolean
4546 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4547                          struct ppc64_elf_params *params)
4548 {
4549   struct ppc_link_hash_table *htab;
4550
4551   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4552
4553 /* Always hook our dynamic sections into the first bfd, which is the
4554    linker created stub bfd.  This ensures that the GOT header is at
4555    the start of the output TOC section.  */
4556   htab = ppc_hash_table (info);
4557   htab->elf.dynobj = params->stub_bfd;
4558   htab->params = params;
4559
4560   return create_linkage_sections (htab->elf.dynobj, info);
4561 }
4562
4563 /* Build a name for an entry in the stub hash table.  */
4564
4565 static char *
4566 ppc_stub_name (const asection *input_section,
4567                const asection *sym_sec,
4568                const struct ppc_link_hash_entry *h,
4569                const Elf_Internal_Rela *rel)
4570 {
4571   char *stub_name;
4572   ssize_t len;
4573
4574   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4575      offsets from a sym as a branch target?  In fact, we could
4576      probably assume the addend is always zero.  */
4577   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4578
4579   if (h)
4580     {
4581       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4582       stub_name = bfd_malloc (len);
4583       if (stub_name == NULL)
4584         return stub_name;
4585
4586       len = sprintf (stub_name, "%08x.%s+%x",
4587                      input_section->id & 0xffffffff,
4588                      h->elf.root.root.string,
4589                      (int) rel->r_addend & 0xffffffff);
4590     }
4591   else
4592     {
4593       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4594       stub_name = bfd_malloc (len);
4595       if (stub_name == NULL)
4596         return stub_name;
4597
4598       len = sprintf (stub_name, "%08x.%x:%x+%x",
4599                      input_section->id & 0xffffffff,
4600                      sym_sec->id & 0xffffffff,
4601                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4602                      (int) rel->r_addend & 0xffffffff);
4603     }
4604   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4605     stub_name[len - 2] = 0;
4606   return stub_name;
4607 }
4608
4609 /* Look up an entry in the stub hash.  Stub entries are cached because
4610    creating the stub name takes a bit of time.  */
4611
4612 static struct ppc_stub_hash_entry *
4613 ppc_get_stub_entry (const asection *input_section,
4614                     const asection *sym_sec,
4615                     struct ppc_link_hash_entry *h,
4616                     const Elf_Internal_Rela *rel,
4617                     struct ppc_link_hash_table *htab)
4618 {
4619   struct ppc_stub_hash_entry *stub_entry;
4620   struct map_stub *group;
4621
4622   /* If this input section is part of a group of sections sharing one
4623      stub section, then use the id of the first section in the group.
4624      Stub names need to include a section id, as there may well be
4625      more than one stub used to reach say, printf, and we need to
4626      distinguish between them.  */
4627   group = htab->sec_info[input_section->id].u.group;
4628   if (group == NULL)
4629     return NULL;
4630
4631   if (h != NULL && h->u.stub_cache != NULL
4632       && h->u.stub_cache->h == h
4633       && h->u.stub_cache->group == group)
4634     {
4635       stub_entry = h->u.stub_cache;
4636     }
4637   else
4638     {
4639       char *stub_name;
4640
4641       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4642       if (stub_name == NULL)
4643         return NULL;
4644
4645       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4646                                          stub_name, FALSE, FALSE);
4647       if (h != NULL)
4648         h->u.stub_cache = stub_entry;
4649
4650       free (stub_name);
4651     }
4652
4653   return stub_entry;
4654 }
4655
4656 /* Add a new stub entry to the stub hash.  Not all fields of the new
4657    stub entry are initialised.  */
4658
4659 static struct ppc_stub_hash_entry *
4660 ppc_add_stub (const char *stub_name,
4661               asection *section,
4662               struct bfd_link_info *info)
4663 {
4664   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4665   struct map_stub *group;
4666   asection *link_sec;
4667   asection *stub_sec;
4668   struct ppc_stub_hash_entry *stub_entry;
4669
4670   group = htab->sec_info[section->id].u.group;
4671   link_sec = group->link_sec;
4672   stub_sec = group->stub_sec;
4673   if (stub_sec == NULL)
4674     {
4675       size_t namelen;
4676       bfd_size_type len;
4677       char *s_name;
4678
4679       namelen = strlen (link_sec->name);
4680       len = namelen + sizeof (STUB_SUFFIX);
4681       s_name = bfd_alloc (htab->params->stub_bfd, len);
4682       if (s_name == NULL)
4683         return NULL;
4684
4685       memcpy (s_name, link_sec->name, namelen);
4686       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4687       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4688       if (stub_sec == NULL)
4689         return NULL;
4690       group->stub_sec = stub_sec;
4691     }
4692
4693   /* Enter this entry into the linker stub hash table.  */
4694   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4695                                      TRUE, FALSE);
4696   if (stub_entry == NULL)
4697     {
4698       /* xgettext:c-format */
4699       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4700                           section->owner, stub_name);
4701       return NULL;
4702     }
4703
4704   stub_entry->group = group;
4705   stub_entry->stub_offset = 0;
4706   return stub_entry;
4707 }
4708
4709 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4710    not already done.  */
4711
4712 static bfd_boolean
4713 create_got_section (bfd *abfd, struct bfd_link_info *info)
4714 {
4715   asection *got, *relgot;
4716   flagword flags;
4717   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4718
4719   if (!is_ppc64_elf (abfd))
4720     return FALSE;
4721   if (htab == NULL)
4722     return FALSE;
4723
4724   if (!htab->elf.sgot
4725       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4726     return FALSE;
4727
4728   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4729            | SEC_LINKER_CREATED);
4730
4731   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4732   if (!got
4733       || !bfd_set_section_alignment (abfd, got, 3))
4734     return FALSE;
4735
4736   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4737                                                flags | SEC_READONLY);
4738   if (!relgot
4739       || ! bfd_set_section_alignment (abfd, relgot, 3))
4740     return FALSE;
4741
4742   ppc64_elf_tdata (abfd)->got = got;
4743   ppc64_elf_tdata (abfd)->relgot = relgot;
4744   return TRUE;
4745 }
4746
4747 /* Follow indirect and warning symbol links.  */
4748
4749 static inline struct bfd_link_hash_entry *
4750 follow_link (struct bfd_link_hash_entry *h)
4751 {
4752   while (h->type == bfd_link_hash_indirect
4753          || h->type == bfd_link_hash_warning)
4754     h = h->u.i.link;
4755   return h;
4756 }
4757
4758 static inline struct elf_link_hash_entry *
4759 elf_follow_link (struct elf_link_hash_entry *h)
4760 {
4761   return (struct elf_link_hash_entry *) follow_link (&h->root);
4762 }
4763
4764 static inline struct ppc_link_hash_entry *
4765 ppc_follow_link (struct ppc_link_hash_entry *h)
4766 {
4767   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4768 }
4769
4770 /* Merge PLT info on FROM with that on TO.  */
4771
4772 static void
4773 move_plt_plist (struct ppc_link_hash_entry *from,
4774                 struct ppc_link_hash_entry *to)
4775 {
4776   if (from->elf.plt.plist != NULL)
4777     {
4778       if (to->elf.plt.plist != NULL)
4779         {
4780           struct plt_entry **entp;
4781           struct plt_entry *ent;
4782
4783           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4784             {
4785               struct plt_entry *dent;
4786
4787               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4788                 if (dent->addend == ent->addend)
4789                   {
4790                     dent->plt.refcount += ent->plt.refcount;
4791                     *entp = ent->next;
4792                     break;
4793                   }
4794               if (dent == NULL)
4795                 entp = &ent->next;
4796             }
4797           *entp = to->elf.plt.plist;
4798         }
4799
4800       to->elf.plt.plist = from->elf.plt.plist;
4801       from->elf.plt.plist = NULL;
4802     }
4803 }
4804
4805 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4806
4807 static void
4808 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4809                                 struct elf_link_hash_entry *dir,
4810                                 struct elf_link_hash_entry *ind)
4811 {
4812   struct ppc_link_hash_entry *edir, *eind;
4813
4814   edir = (struct ppc_link_hash_entry *) dir;
4815   eind = (struct ppc_link_hash_entry *) ind;
4816
4817   edir->is_func |= eind->is_func;
4818   edir->is_func_descriptor |= eind->is_func_descriptor;
4819   edir->tls_mask |= eind->tls_mask;
4820   if (eind->oh != NULL)
4821     edir->oh = ppc_follow_link (eind->oh);
4822
4823   if (edir->elf.versioned != versioned_hidden)
4824     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4825   edir->elf.ref_regular |= eind->elf.ref_regular;
4826   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4827   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4828   edir->elf.needs_plt |= eind->elf.needs_plt;
4829   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4830
4831   /* If we were called to copy over info for a weak sym, don't copy
4832      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4833      in order to simplify readonly_dynrelocs and save a field in the
4834      symbol hash entry, but that means dyn_relocs can't be used in any
4835      tests about a specific symbol, or affect other symbol flags which
4836      are then tested.  */
4837   if (eind->elf.root.type != bfd_link_hash_indirect)
4838     return;
4839
4840   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4841   if (eind->dyn_relocs != NULL)
4842     {
4843       if (edir->dyn_relocs != NULL)
4844         {
4845           struct elf_dyn_relocs **pp;
4846           struct elf_dyn_relocs *p;
4847
4848           /* Add reloc counts against the indirect sym to the direct sym
4849              list.  Merge any entries against the same section.  */
4850           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4851             {
4852               struct elf_dyn_relocs *q;
4853
4854               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4855                 if (q->sec == p->sec)
4856                   {
4857                     q->pc_count += p->pc_count;
4858                     q->count += p->count;
4859                     *pp = p->next;
4860                     break;
4861                   }
4862               if (q == NULL)
4863                 pp = &p->next;
4864             }
4865           *pp = edir->dyn_relocs;
4866         }
4867
4868       edir->dyn_relocs = eind->dyn_relocs;
4869       eind->dyn_relocs = NULL;
4870     }
4871
4872   /* Copy over got entries that we may have already seen to the
4873      symbol which just became indirect.  */
4874   if (eind->elf.got.glist != NULL)
4875     {
4876       if (edir->elf.got.glist != NULL)
4877         {
4878           struct got_entry **entp;
4879           struct got_entry *ent;
4880
4881           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4882             {
4883               struct got_entry *dent;
4884
4885               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4886                 if (dent->addend == ent->addend
4887                     && dent->owner == ent->owner
4888                     && dent->tls_type == ent->tls_type)
4889                   {
4890                     dent->got.refcount += ent->got.refcount;
4891                     *entp = ent->next;
4892                     break;
4893                   }
4894               if (dent == NULL)
4895                 entp = &ent->next;
4896             }
4897           *entp = edir->elf.got.glist;
4898         }
4899
4900       edir->elf.got.glist = eind->elf.got.glist;
4901       eind->elf.got.glist = NULL;
4902     }
4903
4904   /* And plt entries.  */
4905   move_plt_plist (eind, edir);
4906
4907   if (eind->elf.dynindx != -1)
4908     {
4909       if (edir->elf.dynindx != -1)
4910         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4911                                 edir->elf.dynstr_index);
4912       edir->elf.dynindx = eind->elf.dynindx;
4913       edir->elf.dynstr_index = eind->elf.dynstr_index;
4914       eind->elf.dynindx = -1;
4915       eind->elf.dynstr_index = 0;
4916     }
4917 }
4918
4919 /* Find the function descriptor hash entry from the given function code
4920    hash entry FH.  Link the entries via their OH fields.  */
4921
4922 static struct ppc_link_hash_entry *
4923 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4924 {
4925   struct ppc_link_hash_entry *fdh = fh->oh;
4926
4927   if (fdh == NULL)
4928     {
4929       const char *fd_name = fh->elf.root.root.string + 1;
4930
4931       fdh = (struct ppc_link_hash_entry *)
4932         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4933       if (fdh == NULL)
4934         return fdh;
4935
4936       fdh->is_func_descriptor = 1;
4937       fdh->oh = fh;
4938       fh->is_func = 1;
4939       fh->oh = fdh;
4940     }
4941
4942   fdh = ppc_follow_link (fdh);
4943   fdh->is_func_descriptor = 1;
4944   fdh->oh = fh;
4945   return fdh;
4946 }
4947
4948 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4949
4950 static struct ppc_link_hash_entry *
4951 make_fdh (struct bfd_link_info *info,
4952           struct ppc_link_hash_entry *fh)
4953 {
4954   bfd *abfd = fh->elf.root.u.undef.abfd;
4955   struct bfd_link_hash_entry *bh = NULL;
4956   struct ppc_link_hash_entry *fdh;
4957   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4958                     ? BSF_WEAK
4959                     : BSF_GLOBAL);
4960
4961   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4962                                          fh->elf.root.root.string + 1,
4963                                          flags, bfd_und_section_ptr, 0,
4964                                          NULL, FALSE, FALSE, &bh))
4965     return NULL;
4966
4967   fdh = (struct ppc_link_hash_entry *) bh;
4968   fdh->elf.non_elf = 0;
4969   fdh->fake = 1;
4970   fdh->is_func_descriptor = 1;
4971   fdh->oh = fh;
4972   fh->is_func = 1;
4973   fh->oh = fdh;
4974   return fdh;
4975 }
4976
4977 /* Fix function descriptor symbols defined in .opd sections to be
4978    function type.  */
4979
4980 static bfd_boolean
4981 ppc64_elf_add_symbol_hook (bfd *ibfd,
4982                            struct bfd_link_info *info,
4983                            Elf_Internal_Sym *isym,
4984                            const char **name,
4985                            flagword *flags ATTRIBUTE_UNUSED,
4986                            asection **sec,
4987                            bfd_vma *value)
4988 {
4989   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4990       && (ibfd->flags & DYNAMIC) == 0
4991       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4992     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4993
4994   if (*sec != NULL
4995       && strcmp ((*sec)->name, ".opd") == 0)
4996     {
4997       asection *code_sec;
4998
4999       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5000             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5001         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5002
5003       /* If the symbol is a function defined in .opd, and the function
5004          code is in a discarded group, let it appear to be undefined.  */
5005       if (!bfd_link_relocatable (info)
5006           && (*sec)->reloc_count != 0
5007           && opd_entry_value (*sec, *value, &code_sec, NULL,
5008                               FALSE) != (bfd_vma) -1
5009           && discarded_section (code_sec))
5010         {
5011           *sec = bfd_und_section_ptr;
5012           isym->st_shndx = SHN_UNDEF;
5013         }
5014     }
5015   else if (*sec != NULL
5016            && strcmp ((*sec)->name, ".toc") == 0
5017            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5018     {
5019       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5020       if (htab != NULL)
5021         htab->params->object_in_toc = 1;
5022     }
5023
5024   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5025     {
5026       if (abiversion (ibfd) == 0)
5027         set_abiversion (ibfd, 2);
5028       else if (abiversion (ibfd) == 1)
5029         {
5030           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5031                                 " for ABI version 1"), *name);
5032           bfd_set_error (bfd_error_bad_value);
5033           return FALSE;
5034         }
5035     }
5036
5037   return TRUE;
5038 }
5039
5040 /* Merge non-visibility st_other attributes: local entry point.  */
5041
5042 static void
5043 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5044                                   const Elf_Internal_Sym *isym,
5045                                   bfd_boolean definition,
5046                                   bfd_boolean dynamic)
5047 {
5048   if (definition && (!dynamic || !h->def_regular))
5049     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5050                 | ELF_ST_VISIBILITY (h->other));
5051 }
5052
5053 /* Hook called on merging a symbol.  We use this to clear "fake" since
5054    we now have a real symbol.  */
5055
5056 static bfd_boolean
5057 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5058                         const Elf_Internal_Sym *isym,
5059                         asection **psec ATTRIBUTE_UNUSED,
5060                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5061                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5062                         bfd *oldbfd ATTRIBUTE_UNUSED,
5063                         const asection *oldsec ATTRIBUTE_UNUSED)
5064 {
5065   ((struct ppc_link_hash_entry *) h)->fake = 0;
5066   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5067     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5068   return TRUE;
5069 }
5070
5071 /* This function makes an old ABI object reference to ".bar" cause the
5072    inclusion of a new ABI object archive that defines "bar".
5073    NAME is a symbol defined in an archive.  Return a symbol in the hash
5074    table that might be satisfied by the archive symbols.  */
5075
5076 static struct elf_link_hash_entry *
5077 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5078                                  struct bfd_link_info *info,
5079                                  const char *name)
5080 {
5081   struct elf_link_hash_entry *h;
5082   char *dot_name;
5083   size_t len;
5084
5085   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5086   if (h != NULL
5087       /* Don't return this sym if it is a fake function descriptor
5088          created by add_symbol_adjust.  */
5089       && !((struct ppc_link_hash_entry *) h)->fake)
5090     return h;
5091
5092   if (name[0] == '.')
5093     return h;
5094
5095   len = strlen (name);
5096   dot_name = bfd_alloc (abfd, len + 2);
5097   if (dot_name == NULL)
5098     return (struct elf_link_hash_entry *) -1;
5099   dot_name[0] = '.';
5100   memcpy (dot_name + 1, name, len + 1);
5101   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5102   bfd_release (abfd, dot_name);
5103   return h;
5104 }
5105
5106 /* This function satisfies all old ABI object references to ".bar" if a
5107    new ABI object defines "bar".  Well, at least, undefined dot symbols
5108    are made weak.  This stops later archive searches from including an
5109    object if we already have a function descriptor definition.  It also
5110    prevents the linker complaining about undefined symbols.
5111    We also check and correct mismatched symbol visibility here.  The
5112    most restrictive visibility of the function descriptor and the
5113    function entry symbol is used.  */
5114
5115 static bfd_boolean
5116 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5117 {
5118   struct ppc_link_hash_table *htab;
5119   struct ppc_link_hash_entry *fdh;
5120
5121   if (eh->elf.root.type == bfd_link_hash_warning)
5122     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5123
5124   if (eh->elf.root.type == bfd_link_hash_indirect)
5125     return TRUE;
5126
5127   if (eh->elf.root.root.string[0] != '.')
5128     abort ();
5129
5130   htab = ppc_hash_table (info);
5131   if (htab == NULL)
5132     return FALSE;
5133
5134   fdh = lookup_fdh (eh, htab);
5135   if (fdh == NULL
5136       && !bfd_link_relocatable (info)
5137       && (eh->elf.root.type == bfd_link_hash_undefined
5138           || eh->elf.root.type == bfd_link_hash_undefweak)
5139       && eh->elf.ref_regular)
5140     {
5141       /* Make an undefined function descriptor sym, in order to
5142          pull in an --as-needed shared lib.  Archives are handled
5143          elsewhere.  */
5144       fdh = make_fdh (info, eh);
5145       if (fdh == NULL)
5146         return FALSE;
5147     }
5148
5149   if (fdh != NULL)
5150     {
5151       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5152       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5153
5154       /* Make both descriptor and entry symbol have the most
5155          constraining visibility of either symbol.  */
5156       if (entry_vis < descr_vis)
5157         fdh->elf.other += entry_vis - descr_vis;
5158       else if (entry_vis > descr_vis)
5159         eh->elf.other += descr_vis - entry_vis;
5160
5161       /* Propagate reference flags from entry symbol to function
5162          descriptor symbol.  */
5163       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5164       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5165       fdh->elf.ref_regular |= eh->elf.ref_regular;
5166       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5167
5168       if (!fdh->elf.forced_local
5169           && fdh->elf.dynindx == -1
5170           && fdh->elf.versioned != versioned_hidden
5171           && (bfd_link_dll (info)
5172               || fdh->elf.def_dynamic
5173               || fdh->elf.ref_dynamic)
5174           && (eh->elf.ref_regular
5175               || eh->elf.def_regular))
5176         {
5177           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5178             return FALSE;
5179         }
5180     }
5181
5182   return TRUE;
5183 }
5184
5185 /* Set up opd section info and abiversion for IBFD, and process list
5186    of dot-symbols we made in link_hash_newfunc.  */
5187
5188 static bfd_boolean
5189 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5190 {
5191   struct ppc_link_hash_table *htab;
5192   struct ppc_link_hash_entry **p, *eh;
5193   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5194
5195   if (opd != NULL && opd->size != 0)
5196     {
5197       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5198       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5199
5200       if (abiversion (ibfd) == 0)
5201         set_abiversion (ibfd, 1);
5202       else if (abiversion (ibfd) >= 2)
5203         {
5204           /* xgettext:c-format */
5205           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5206                               ibfd, abiversion (ibfd));
5207           bfd_set_error (bfd_error_bad_value);
5208           return FALSE;
5209         }
5210     }
5211
5212   if (is_ppc64_elf (info->output_bfd))
5213     {
5214       /* For input files without an explicit abiversion in e_flags
5215          we should have flagged any with symbol st_other bits set
5216          as ELFv1 and above flagged those with .opd as ELFv2.
5217          Set the output abiversion if not yet set, and for any input
5218          still ambiguous, take its abiversion from the output.
5219          Differences in ABI are reported later.  */
5220       if (abiversion (info->output_bfd) == 0)
5221         set_abiversion (info->output_bfd, abiversion (ibfd));
5222       else if (abiversion (ibfd) == 0)
5223         set_abiversion (ibfd, abiversion (info->output_bfd));
5224     }
5225
5226   htab = ppc_hash_table (info);
5227   if (htab == NULL)
5228     return TRUE;
5229
5230   if (opd != NULL && opd->size != 0
5231       && (ibfd->flags & DYNAMIC) == 0
5232       && (opd->flags & SEC_RELOC) != 0
5233       && opd->reloc_count != 0
5234       && !bfd_is_abs_section (opd->output_section)
5235       && info->gc_sections)
5236     {
5237       /* Garbage collection needs some extra help with .opd sections.
5238          We don't want to necessarily keep everything referenced by
5239          relocs in .opd, as that would keep all functions.  Instead,
5240          if we reference an .opd symbol (a function descriptor), we
5241          want to keep the function code symbol's section.  This is
5242          easy for global symbols, but for local syms we need to keep
5243          information about the associated function section.  */
5244       bfd_size_type amt;
5245       asection **opd_sym_map;
5246       Elf_Internal_Shdr *symtab_hdr;
5247       Elf_Internal_Rela *relocs, *rel_end, *rel;
5248
5249       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5250       opd_sym_map = bfd_zalloc (ibfd, amt);
5251       if (opd_sym_map == NULL)
5252         return FALSE;
5253       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5254       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5255                                           info->keep_memory);
5256       if (relocs == NULL)
5257         return FALSE;
5258       symtab_hdr = &elf_symtab_hdr (ibfd);
5259       rel_end = relocs + opd->reloc_count - 1;
5260       for (rel = relocs; rel < rel_end; rel++)
5261         {
5262           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5263           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5264
5265           if (r_type == R_PPC64_ADDR64
5266               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5267               && r_symndx < symtab_hdr->sh_info)
5268             {
5269               Elf_Internal_Sym *isym;
5270               asection *s;
5271
5272               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5273               if (isym == NULL)
5274                 {
5275                   if (elf_section_data (opd)->relocs != relocs)
5276                     free (relocs);
5277                   return FALSE;
5278                 }
5279
5280               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5281               if (s != NULL && s != opd)
5282                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5283             }
5284         }
5285       if (elf_section_data (opd)->relocs != relocs)
5286         free (relocs);
5287     }
5288
5289   p = &htab->dot_syms;
5290   while ((eh = *p) != NULL)
5291     {
5292       *p = NULL;
5293       if (&eh->elf == htab->elf.hgot)
5294         ;
5295       else if (htab->elf.hgot == NULL
5296                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5297         htab->elf.hgot = &eh->elf;
5298       else if (abiversion (ibfd) <= 1)
5299         {
5300           htab->need_func_desc_adj = 1;
5301           if (!add_symbol_adjust (eh, info))
5302             return FALSE;
5303         }
5304       p = &eh->u.next_dot_sym;
5305     }
5306   return TRUE;
5307 }
5308
5309 /* Undo hash table changes when an --as-needed input file is determined
5310    not to be needed.  */
5311
5312 static bfd_boolean
5313 ppc64_elf_notice_as_needed (bfd *ibfd,
5314                             struct bfd_link_info *info,
5315                             enum notice_asneeded_action act)
5316 {
5317   if (act == notice_not_needed)
5318     {
5319       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5320
5321       if (htab == NULL)
5322         return FALSE;
5323
5324       htab->dot_syms = NULL;
5325     }
5326   return _bfd_elf_notice_as_needed (ibfd, info, act);
5327 }
5328
5329 /* If --just-symbols against a final linked binary, then assume we need
5330    toc adjusting stubs when calling functions defined there.  */
5331
5332 static void
5333 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5334 {
5335   if ((sec->flags & SEC_CODE) != 0
5336       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5337       && is_ppc64_elf (sec->owner))
5338     {
5339       if (abiversion (sec->owner) >= 2
5340           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5341         sec->has_toc_reloc = 1;
5342     }
5343   _bfd_elf_link_just_syms (sec, info);
5344 }
5345
5346 static struct plt_entry **
5347 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5348                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5349 {
5350   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5351   struct plt_entry **local_plt;
5352   unsigned char *local_got_tls_masks;
5353
5354   if (local_got_ents == NULL)
5355     {
5356       bfd_size_type size = symtab_hdr->sh_info;
5357
5358       size *= (sizeof (*local_got_ents)
5359                + sizeof (*local_plt)
5360                + sizeof (*local_got_tls_masks));
5361       local_got_ents = bfd_zalloc (abfd, size);
5362       if (local_got_ents == NULL)
5363         return NULL;
5364       elf_local_got_ents (abfd) = local_got_ents;
5365     }
5366
5367   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5368     {
5369       struct got_entry *ent;
5370
5371       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5372         if (ent->addend == r_addend
5373             && ent->owner == abfd
5374             && ent->tls_type == tls_type)
5375           break;
5376       if (ent == NULL)
5377         {
5378           bfd_size_type amt = sizeof (*ent);
5379           ent = bfd_alloc (abfd, amt);
5380           if (ent == NULL)
5381             return FALSE;
5382           ent->next = local_got_ents[r_symndx];
5383           ent->addend = r_addend;
5384           ent->owner = abfd;
5385           ent->tls_type = tls_type;
5386           ent->is_indirect = FALSE;
5387           ent->got.refcount = 0;
5388           local_got_ents[r_symndx] = ent;
5389         }
5390       ent->got.refcount += 1;
5391     }
5392
5393   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5394   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5395   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5396
5397   return local_plt + r_symndx;
5398 }
5399
5400 static bfd_boolean
5401 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5402 {
5403   struct plt_entry *ent;
5404
5405   for (ent = *plist; ent != NULL; ent = ent->next)
5406     if (ent->addend == addend)
5407       break;
5408   if (ent == NULL)
5409     {
5410       bfd_size_type amt = sizeof (*ent);
5411       ent = bfd_alloc (abfd, amt);
5412       if (ent == NULL)
5413         return FALSE;
5414       ent->next = *plist;
5415       ent->addend = addend;
5416       ent->plt.refcount = 0;
5417       *plist = ent;
5418     }
5419   ent->plt.refcount += 1;
5420   return TRUE;
5421 }
5422
5423 static bfd_boolean
5424 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5425 {
5426   return (r_type == R_PPC64_REL24
5427           || r_type == R_PPC64_REL14
5428           || r_type == R_PPC64_REL14_BRTAKEN
5429           || r_type == R_PPC64_REL14_BRNTAKEN
5430           || r_type == R_PPC64_ADDR24
5431           || r_type == R_PPC64_ADDR14
5432           || r_type == R_PPC64_ADDR14_BRTAKEN
5433           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5434 }
5435
5436 /* Look through the relocs for a section during the first phase, and
5437    calculate needed space in the global offset table, procedure
5438    linkage table, and dynamic reloc sections.  */
5439
5440 static bfd_boolean
5441 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5442                         asection *sec, const Elf_Internal_Rela *relocs)
5443 {
5444   struct ppc_link_hash_table *htab;
5445   Elf_Internal_Shdr *symtab_hdr;
5446   struct elf_link_hash_entry **sym_hashes;
5447   const Elf_Internal_Rela *rel;
5448   const Elf_Internal_Rela *rel_end;
5449   asection *sreloc;
5450   struct elf_link_hash_entry *tga, *dottga;
5451   bfd_boolean is_opd;
5452
5453   if (bfd_link_relocatable (info))
5454     return TRUE;
5455
5456   /* Don't do anything special with non-loaded, non-alloced sections.
5457      In particular, any relocs in such sections should not affect GOT
5458      and PLT reference counting (ie. we don't allow them to create GOT
5459      or PLT entries), there's no possibility or desire to optimize TLS
5460      relocs, and there's not much point in propagating relocs to shared
5461      libs that the dynamic linker won't relocate.  */
5462   if ((sec->flags & SEC_ALLOC) == 0)
5463     return TRUE;
5464
5465   BFD_ASSERT (is_ppc64_elf (abfd));
5466
5467   htab = ppc_hash_table (info);
5468   if (htab == NULL)
5469     return FALSE;
5470
5471   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5472                               FALSE, FALSE, TRUE);
5473   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5474                                  FALSE, FALSE, TRUE);
5475   symtab_hdr = &elf_symtab_hdr (abfd);
5476   sym_hashes = elf_sym_hashes (abfd);
5477   sreloc = NULL;
5478   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5479   rel_end = relocs + sec->reloc_count;
5480   for (rel = relocs; rel < rel_end; rel++)
5481     {
5482       unsigned long r_symndx;
5483       struct elf_link_hash_entry *h;
5484       enum elf_ppc64_reloc_type r_type;
5485       int tls_type;
5486       struct _ppc64_elf_section_data *ppc64_sec;
5487       struct plt_entry **ifunc, **plt_list;
5488
5489       r_symndx = ELF64_R_SYM (rel->r_info);
5490       if (r_symndx < symtab_hdr->sh_info)
5491         h = NULL;
5492       else
5493         {
5494           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5495           h = elf_follow_link (h);
5496
5497           if (h == htab->elf.hgot)
5498             sec->has_toc_reloc = 1;
5499         }
5500
5501       tls_type = 0;
5502       ifunc = NULL;
5503       if (h != NULL)
5504         {
5505           if (h->type == STT_GNU_IFUNC)
5506             {
5507               h->needs_plt = 1;
5508               ifunc = &h->plt.plist;
5509             }
5510         }
5511       else
5512         {
5513           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5514                                                           abfd, r_symndx);
5515           if (isym == NULL)
5516             return FALSE;
5517
5518           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5519             {
5520               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5521                                              rel->r_addend,
5522                                              NON_GOT | PLT_IFUNC);
5523               if (ifunc == NULL)
5524                 return FALSE;
5525             }
5526         }
5527
5528       r_type = ELF64_R_TYPE (rel->r_info);
5529       switch (r_type)
5530         {
5531         case R_PPC64_TLSGD:
5532         case R_PPC64_TLSLD:
5533           /* These special tls relocs tie a call to __tls_get_addr with
5534              its parameter symbol.  */
5535           if (h != NULL)
5536             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5537           else
5538             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5539                                         rel->r_addend,
5540                                         NON_GOT | TLS_TLS | TLS_MARK))
5541               return FALSE;
5542           sec->has_tls_reloc = 1;
5543           break;
5544
5545         case R_PPC64_GOT_TLSLD16:
5546         case R_PPC64_GOT_TLSLD16_LO:
5547         case R_PPC64_GOT_TLSLD16_HI:
5548         case R_PPC64_GOT_TLSLD16_HA:
5549           tls_type = TLS_TLS | TLS_LD;
5550           goto dogottls;
5551
5552         case R_PPC64_GOT_TLSGD16:
5553         case R_PPC64_GOT_TLSGD16_LO:
5554         case R_PPC64_GOT_TLSGD16_HI:
5555         case R_PPC64_GOT_TLSGD16_HA:
5556           tls_type = TLS_TLS | TLS_GD;
5557           goto dogottls;
5558
5559         case R_PPC64_GOT_TPREL16_DS:
5560         case R_PPC64_GOT_TPREL16_LO_DS:
5561         case R_PPC64_GOT_TPREL16_HI:
5562         case R_PPC64_GOT_TPREL16_HA:
5563           if (bfd_link_dll (info))
5564             info->flags |= DF_STATIC_TLS;
5565           tls_type = TLS_TLS | TLS_TPREL;
5566           goto dogottls;
5567
5568         case R_PPC64_GOT_DTPREL16_DS:
5569         case R_PPC64_GOT_DTPREL16_LO_DS:
5570         case R_PPC64_GOT_DTPREL16_HI:
5571         case R_PPC64_GOT_DTPREL16_HA:
5572           tls_type = TLS_TLS | TLS_DTPREL;
5573         dogottls:
5574           sec->has_tls_reloc = 1;
5575           /* Fall through */
5576
5577         case R_PPC64_GOT16:
5578         case R_PPC64_GOT16_DS:
5579         case R_PPC64_GOT16_HA:
5580         case R_PPC64_GOT16_HI:
5581         case R_PPC64_GOT16_LO:
5582         case R_PPC64_GOT16_LO_DS:
5583           /* This symbol requires a global offset table entry.  */
5584           sec->has_toc_reloc = 1;
5585           if (r_type == R_PPC64_GOT_TLSLD16
5586               || r_type == R_PPC64_GOT_TLSGD16
5587               || r_type == R_PPC64_GOT_TPREL16_DS
5588               || r_type == R_PPC64_GOT_DTPREL16_DS
5589               || r_type == R_PPC64_GOT16
5590               || r_type == R_PPC64_GOT16_DS)
5591             {
5592               htab->do_multi_toc = 1;
5593               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5594             }
5595
5596           if (ppc64_elf_tdata (abfd)->got == NULL
5597               && !create_got_section (abfd, info))
5598             return FALSE;
5599
5600           if (h != NULL)
5601             {
5602               struct ppc_link_hash_entry *eh;
5603               struct got_entry *ent;
5604
5605               eh = (struct ppc_link_hash_entry *) h;
5606               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5607                 if (ent->addend == rel->r_addend
5608                     && ent->owner == abfd
5609                     && ent->tls_type == tls_type)
5610                   break;
5611               if (ent == NULL)
5612                 {
5613                   bfd_size_type amt = sizeof (*ent);
5614                   ent = bfd_alloc (abfd, amt);
5615                   if (ent == NULL)
5616                     return FALSE;
5617                   ent->next = eh->elf.got.glist;
5618                   ent->addend = rel->r_addend;
5619                   ent->owner = abfd;
5620                   ent->tls_type = tls_type;
5621                   ent->is_indirect = FALSE;
5622                   ent->got.refcount = 0;
5623                   eh->elf.got.glist = ent;
5624                 }
5625               ent->got.refcount += 1;
5626               eh->tls_mask |= tls_type;
5627             }
5628           else
5629             /* This is a global offset table entry for a local symbol.  */
5630             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5631                                         rel->r_addend, tls_type))
5632               return FALSE;
5633
5634           /* We may also need a plt entry if the symbol turns out to be
5635              an ifunc.  */
5636           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5637             {
5638               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5639                 return FALSE;
5640             }
5641           break;
5642
5643         case R_PPC64_PLT16_HA:
5644         case R_PPC64_PLT16_HI:
5645         case R_PPC64_PLT16_LO:
5646         case R_PPC64_PLT16_LO_DS:
5647         case R_PPC64_PLT32:
5648         case R_PPC64_PLT64:
5649           /* This symbol requires a procedure linkage table entry.  */
5650           plt_list = ifunc;
5651           if (h != NULL)
5652             {
5653               h->needs_plt = 1;
5654               if (h->root.root.string[0] == '.'
5655                   && h->root.root.string[1] != '\0')
5656                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5657               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5658               plt_list = &h->plt.plist;
5659             }
5660           if (plt_list == NULL)
5661             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5662                                               rel->r_addend,
5663                                               NON_GOT | PLT_KEEP);
5664           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5665             return FALSE;
5666           break;
5667
5668           /* The following relocations don't need to propagate the
5669              relocation if linking a shared object since they are
5670              section relative.  */
5671         case R_PPC64_SECTOFF:
5672         case R_PPC64_SECTOFF_LO:
5673         case R_PPC64_SECTOFF_HI:
5674         case R_PPC64_SECTOFF_HA:
5675         case R_PPC64_SECTOFF_DS:
5676         case R_PPC64_SECTOFF_LO_DS:
5677         case R_PPC64_DTPREL16:
5678         case R_PPC64_DTPREL16_LO:
5679         case R_PPC64_DTPREL16_HI:
5680         case R_PPC64_DTPREL16_HA:
5681         case R_PPC64_DTPREL16_DS:
5682         case R_PPC64_DTPREL16_LO_DS:
5683         case R_PPC64_DTPREL16_HIGH:
5684         case R_PPC64_DTPREL16_HIGHA:
5685         case R_PPC64_DTPREL16_HIGHER:
5686         case R_PPC64_DTPREL16_HIGHERA:
5687         case R_PPC64_DTPREL16_HIGHEST:
5688         case R_PPC64_DTPREL16_HIGHESTA:
5689           break;
5690
5691           /* Nor do these.  */
5692         case R_PPC64_REL16:
5693         case R_PPC64_REL16_LO:
5694         case R_PPC64_REL16_HI:
5695         case R_PPC64_REL16_HA:
5696         case R_PPC64_REL16DX_HA:
5697           break;
5698
5699           /* Not supported as a dynamic relocation.  */
5700         case R_PPC64_ADDR64_LOCAL:
5701           if (bfd_link_pic (info))
5702             {
5703               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5704                 ppc_howto_init ();
5705               /* xgettext:c-format */
5706               info->callbacks->einfo (_("%H: %s reloc unsupported "
5707                                         "in shared libraries and PIEs\n"),
5708                                       abfd, sec, rel->r_offset,
5709                                       ppc64_elf_howto_table[r_type]->name);
5710               bfd_set_error (bfd_error_bad_value);
5711               return FALSE;
5712             }
5713           break;
5714
5715         case R_PPC64_TOC16:
5716         case R_PPC64_TOC16_DS:
5717           htab->do_multi_toc = 1;
5718           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5719           /* Fall through.  */
5720         case R_PPC64_TOC16_LO:
5721         case R_PPC64_TOC16_HI:
5722         case R_PPC64_TOC16_HA:
5723         case R_PPC64_TOC16_LO_DS:
5724           sec->has_toc_reloc = 1;
5725           break;
5726
5727           /* Marker reloc.  */
5728         case R_PPC64_ENTRY:
5729           break;
5730
5731           /* This relocation describes the C++ object vtable hierarchy.
5732              Reconstruct it for later use during GC.  */
5733         case R_PPC64_GNU_VTINHERIT:
5734           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5735             return FALSE;
5736           break;
5737
5738           /* This relocation describes which C++ vtable entries are actually
5739              used.  Record for later use during GC.  */
5740         case R_PPC64_GNU_VTENTRY:
5741           BFD_ASSERT (h != NULL);
5742           if (h != NULL
5743               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5744             return FALSE;
5745           break;
5746
5747         case R_PPC64_REL14:
5748         case R_PPC64_REL14_BRTAKEN:
5749         case R_PPC64_REL14_BRNTAKEN:
5750           {
5751             asection *dest = NULL;
5752
5753             /* Heuristic: If jumping outside our section, chances are
5754                we are going to need a stub.  */
5755             if (h != NULL)
5756               {
5757                 /* If the sym is weak it may be overridden later, so
5758                    don't assume we know where a weak sym lives.  */
5759                 if (h->root.type == bfd_link_hash_defined)
5760                   dest = h->root.u.def.section;
5761               }
5762             else
5763               {
5764                 Elf_Internal_Sym *isym;
5765
5766                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5767                                               abfd, r_symndx);
5768                 if (isym == NULL)
5769                   return FALSE;
5770
5771                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5772               }
5773
5774             if (dest != sec)
5775               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5776           }
5777           /* Fall through.  */
5778
5779         case R_PPC64_REL24:
5780           plt_list = ifunc;
5781           if (h != NULL)
5782             {
5783               h->needs_plt = 1;
5784               if (h->root.root.string[0] == '.'
5785                   && h->root.root.string[1] != '\0')
5786                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5787
5788               if (h == tga || h == dottga)
5789                 {
5790                   sec->has_tls_reloc = 1;
5791                   if (rel != relocs
5792                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5793                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5794                     /* We have a new-style __tls_get_addr call with
5795                        a marker reloc.  */
5796                     ;
5797                   else
5798                     /* Mark this section as having an old-style call.  */
5799                     sec->has_tls_get_addr_call = 1;
5800                 }
5801               plt_list = &h->plt.plist;
5802             }
5803
5804           /* We may need a .plt entry if the function this reloc
5805              refers to is in a shared lib.  */
5806           if (plt_list
5807               && !update_plt_info (abfd, plt_list, rel->r_addend))
5808             return FALSE;
5809           break;
5810
5811         case R_PPC64_ADDR14:
5812         case R_PPC64_ADDR14_BRNTAKEN:
5813         case R_PPC64_ADDR14_BRTAKEN:
5814         case R_PPC64_ADDR24:
5815           goto dodyn;
5816
5817         case R_PPC64_TPREL64:
5818           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5819           if (bfd_link_dll (info))
5820             info->flags |= DF_STATIC_TLS;
5821           goto dotlstoc;
5822
5823         case R_PPC64_DTPMOD64:
5824           if (rel + 1 < rel_end
5825               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5826               && rel[1].r_offset == rel->r_offset + 8)
5827             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5828           else
5829             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5830           goto dotlstoc;
5831
5832         case R_PPC64_DTPREL64:
5833           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5834           if (rel != relocs
5835               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5836               && rel[-1].r_offset == rel->r_offset - 8)
5837             /* This is the second reloc of a dtpmod, dtprel pair.
5838                Don't mark with TLS_DTPREL.  */
5839             goto dodyn;
5840
5841         dotlstoc:
5842           sec->has_tls_reloc = 1;
5843           if (h != NULL)
5844             {
5845               struct ppc_link_hash_entry *eh;
5846               eh = (struct ppc_link_hash_entry *) h;
5847               eh->tls_mask |= tls_type;
5848             }
5849           else
5850             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5851                                         rel->r_addend, tls_type))
5852               return FALSE;
5853
5854           ppc64_sec = ppc64_elf_section_data (sec);
5855           if (ppc64_sec->sec_type != sec_toc)
5856             {
5857               bfd_size_type amt;
5858
5859               /* One extra to simplify get_tls_mask.  */
5860               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5861               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5862               if (ppc64_sec->u.toc.symndx == NULL)
5863                 return FALSE;
5864               amt = sec->size * sizeof (bfd_vma) / 8;
5865               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5866               if (ppc64_sec->u.toc.add == NULL)
5867                 return FALSE;
5868               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5869               ppc64_sec->sec_type = sec_toc;
5870             }
5871           BFD_ASSERT (rel->r_offset % 8 == 0);
5872           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5873           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5874
5875           /* Mark the second slot of a GD or LD entry.
5876              -1 to indicate GD and -2 to indicate LD.  */
5877           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5878             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5879           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5880             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5881           goto dodyn;
5882
5883         case R_PPC64_TPREL16:
5884         case R_PPC64_TPREL16_LO:
5885         case R_PPC64_TPREL16_HI:
5886         case R_PPC64_TPREL16_HA:
5887         case R_PPC64_TPREL16_DS:
5888         case R_PPC64_TPREL16_LO_DS:
5889         case R_PPC64_TPREL16_HIGH:
5890         case R_PPC64_TPREL16_HIGHA:
5891         case R_PPC64_TPREL16_HIGHER:
5892         case R_PPC64_TPREL16_HIGHERA:
5893         case R_PPC64_TPREL16_HIGHEST:
5894         case R_PPC64_TPREL16_HIGHESTA:
5895           if (bfd_link_dll (info))
5896             info->flags |= DF_STATIC_TLS;
5897           goto dodyn;
5898
5899         case R_PPC64_ADDR64:
5900           if (is_opd
5901               && rel + 1 < rel_end
5902               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5903             {
5904               if (h != NULL)
5905                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5906             }
5907           /* Fall through.  */
5908
5909         case R_PPC64_ADDR16:
5910         case R_PPC64_ADDR16_DS:
5911         case R_PPC64_ADDR16_HA:
5912         case R_PPC64_ADDR16_HI:
5913         case R_PPC64_ADDR16_HIGH:
5914         case R_PPC64_ADDR16_HIGHA:
5915         case R_PPC64_ADDR16_HIGHER:
5916         case R_PPC64_ADDR16_HIGHERA:
5917         case R_PPC64_ADDR16_HIGHEST:
5918         case R_PPC64_ADDR16_HIGHESTA:
5919         case R_PPC64_ADDR16_LO:
5920         case R_PPC64_ADDR16_LO_DS:
5921           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5922               && rel->r_addend == 0)
5923             {
5924               /* We may need a .plt entry if this reloc refers to a
5925                  function in a shared lib.  */
5926               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5927                 return FALSE;
5928               h->pointer_equality_needed = 1;
5929             }
5930           /* Fall through.  */
5931
5932         case R_PPC64_REL30:
5933         case R_PPC64_REL32:
5934         case R_PPC64_REL64:
5935         case R_PPC64_ADDR32:
5936         case R_PPC64_UADDR16:
5937         case R_PPC64_UADDR32:
5938         case R_PPC64_UADDR64:
5939         case R_PPC64_TOC:
5940           if (h != NULL && !bfd_link_pic (info))
5941             /* We may need a copy reloc.  */
5942             h->non_got_ref = 1;
5943
5944           /* Don't propagate .opd relocs.  */
5945           if (NO_OPD_RELOCS && is_opd)
5946             break;
5947
5948           /* If we are creating a shared library, and this is a reloc
5949              against a global symbol, or a non PC relative reloc
5950              against a local symbol, then we need to copy the reloc
5951              into the shared library.  However, if we are linking with
5952              -Bsymbolic, we do not need to copy a reloc against a
5953              global symbol which is defined in an object we are
5954              including in the link (i.e., DEF_REGULAR is set).  At
5955              this point we have not seen all the input files, so it is
5956              possible that DEF_REGULAR is not set now but will be set
5957              later (it is never cleared).  In case of a weak definition,
5958              DEF_REGULAR may be cleared later by a strong definition in
5959              a shared library.  We account for that possibility below by
5960              storing information in the dyn_relocs field of the hash
5961              table entry.  A similar situation occurs when creating
5962              shared libraries and symbol visibility changes render the
5963              symbol local.
5964
5965              If on the other hand, we are creating an executable, we
5966              may need to keep relocations for symbols satisfied by a
5967              dynamic library if we manage to avoid copy relocs for the
5968              symbol.  */
5969         dodyn:
5970           if ((bfd_link_pic (info)
5971                && (must_be_dyn_reloc (info, r_type)
5972                    || (h != NULL
5973                        && (!SYMBOLIC_BIND (info, h)
5974                            || h->root.type == bfd_link_hash_defweak
5975                            || !h->def_regular))))
5976               || (ELIMINATE_COPY_RELOCS
5977                   && !bfd_link_pic (info)
5978                   && h != NULL
5979                   && (h->root.type == bfd_link_hash_defweak
5980                       || !h->def_regular))
5981               || (!bfd_link_pic (info)
5982                   && ifunc != NULL))
5983             {
5984               /* We must copy these reloc types into the output file.
5985                  Create a reloc section in dynobj and make room for
5986                  this reloc.  */
5987               if (sreloc == NULL)
5988                 {
5989                   sreloc = _bfd_elf_make_dynamic_reloc_section
5990                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5991
5992                   if (sreloc == NULL)
5993                     return FALSE;
5994                 }
5995
5996               /* If this is a global symbol, we count the number of
5997                  relocations we need for this symbol.  */
5998               if (h != NULL)
5999                 {
6000                   struct elf_dyn_relocs *p;
6001                   struct elf_dyn_relocs **head;
6002
6003                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6004                   p = *head;
6005                   if (p == NULL || p->sec != sec)
6006                     {
6007                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6008                       if (p == NULL)
6009                         return FALSE;
6010                       p->next = *head;
6011                       *head = p;
6012                       p->sec = sec;
6013                       p->count = 0;
6014                       p->pc_count = 0;
6015                     }
6016                   p->count += 1;
6017                   if (!must_be_dyn_reloc (info, r_type))
6018                     p->pc_count += 1;
6019                 }
6020               else
6021                 {
6022                   /* Track dynamic relocs needed for local syms too.
6023                      We really need local syms available to do this
6024                      easily.  Oh well.  */
6025                   struct ppc_dyn_relocs *p;
6026                   struct ppc_dyn_relocs **head;
6027                   bfd_boolean is_ifunc;
6028                   asection *s;
6029                   void *vpp;
6030                   Elf_Internal_Sym *isym;
6031
6032                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6033                                                 abfd, r_symndx);
6034                   if (isym == NULL)
6035                     return FALSE;
6036
6037                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6038                   if (s == NULL)
6039                     s = sec;
6040
6041                   vpp = &elf_section_data (s)->local_dynrel;
6042                   head = (struct ppc_dyn_relocs **) vpp;
6043                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6044                   p = *head;
6045                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6046                     p = p->next;
6047                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6048                     {
6049                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6050                       if (p == NULL)
6051                         return FALSE;
6052                       p->next = *head;
6053                       *head = p;
6054                       p->sec = sec;
6055                       p->ifunc = is_ifunc;
6056                       p->count = 0;
6057                     }
6058                   p->count += 1;
6059                 }
6060             }
6061           break;
6062
6063         default:
6064           break;
6065         }
6066     }
6067
6068   return TRUE;
6069 }
6070
6071 /* Merge backend specific data from an object file to the output
6072    object file when linking.  */
6073
6074 static bfd_boolean
6075 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6076 {
6077   bfd *obfd = info->output_bfd;
6078   unsigned long iflags, oflags;
6079
6080   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6081     return TRUE;
6082
6083   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6084     return TRUE;
6085
6086   if (!_bfd_generic_verify_endian_match (ibfd, info))
6087     return FALSE;
6088
6089   iflags = elf_elfheader (ibfd)->e_flags;
6090   oflags = elf_elfheader (obfd)->e_flags;
6091
6092   if (iflags & ~EF_PPC64_ABI)
6093     {
6094       _bfd_error_handler
6095         /* xgettext:c-format */
6096         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6097       bfd_set_error (bfd_error_bad_value);
6098       return FALSE;
6099     }
6100   else if (iflags != oflags && iflags != 0)
6101     {
6102       _bfd_error_handler
6103         /* xgettext:c-format */
6104         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6105          ibfd, iflags, oflags);
6106       bfd_set_error (bfd_error_bad_value);
6107       return FALSE;
6108     }
6109
6110   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6111
6112   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6113   _bfd_elf_merge_object_attributes (ibfd, info);
6114
6115   return TRUE;
6116 }
6117
6118 static bfd_boolean
6119 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6120 {
6121   /* Print normal ELF private data.  */
6122   _bfd_elf_print_private_bfd_data (abfd, ptr);
6123
6124   if (elf_elfheader (abfd)->e_flags != 0)
6125     {
6126       FILE *file = ptr;
6127
6128       fprintf (file, _("private flags = 0x%lx:"),
6129                elf_elfheader (abfd)->e_flags);
6130
6131       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6132         fprintf (file, _(" [abiv%ld]"),
6133                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6134       fputc ('\n', file);
6135     }
6136
6137   return TRUE;
6138 }
6139
6140 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6141    of the code entry point, and its section, which must be in the same
6142    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6143
6144 static bfd_vma
6145 opd_entry_value (asection *opd_sec,
6146                  bfd_vma offset,
6147                  asection **code_sec,
6148                  bfd_vma *code_off,
6149                  bfd_boolean in_code_sec)
6150 {
6151   bfd *opd_bfd = opd_sec->owner;
6152   Elf_Internal_Rela *relocs;
6153   Elf_Internal_Rela *lo, *hi, *look;
6154   bfd_vma val;
6155
6156   /* No relocs implies we are linking a --just-symbols object, or looking
6157      at a final linked executable with addr2line or somesuch.  */
6158   if (opd_sec->reloc_count == 0)
6159     {
6160       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6161
6162       if (contents == NULL)
6163         {
6164           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6165             return (bfd_vma) -1;
6166           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6167         }
6168
6169       /* PR 17512: file: 64b9dfbb.  */
6170       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6171         return (bfd_vma) -1;
6172
6173       val = bfd_get_64 (opd_bfd, contents + offset);
6174       if (code_sec != NULL)
6175         {
6176           asection *sec, *likely = NULL;
6177
6178           if (in_code_sec)
6179             {
6180               sec = *code_sec;
6181               if (sec->vma <= val
6182                   && val < sec->vma + sec->size)
6183                 likely = sec;
6184               else
6185                 val = -1;
6186             }
6187           else
6188             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6189               if (sec->vma <= val
6190                   && (sec->flags & SEC_LOAD) != 0
6191                   && (sec->flags & SEC_ALLOC) != 0)
6192                 likely = sec;
6193           if (likely != NULL)
6194             {
6195               *code_sec = likely;
6196               if (code_off != NULL)
6197                 *code_off = val - likely->vma;
6198             }
6199         }
6200       return val;
6201     }
6202
6203   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6204
6205   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6206   if (relocs == NULL)
6207     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6208   /* PR 17512: file: df8e1fd6.  */
6209   if (relocs == NULL)
6210     return (bfd_vma) -1;
6211
6212   /* Go find the opd reloc at the sym address.  */
6213   lo = relocs;
6214   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6215   val = (bfd_vma) -1;
6216   while (lo < hi)
6217     {
6218       look = lo + (hi - lo) / 2;
6219       if (look->r_offset < offset)
6220         lo = look + 1;
6221       else if (look->r_offset > offset)
6222         hi = look;
6223       else
6224         {
6225           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6226
6227           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6228               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6229             {
6230               unsigned long symndx = ELF64_R_SYM (look->r_info);
6231               asection *sec = NULL;
6232
6233               if (symndx >= symtab_hdr->sh_info
6234                   && elf_sym_hashes (opd_bfd) != NULL)
6235                 {
6236                   struct elf_link_hash_entry **sym_hashes;
6237                   struct elf_link_hash_entry *rh;
6238
6239                   sym_hashes = elf_sym_hashes (opd_bfd);
6240                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6241                   if (rh != NULL)
6242                     {
6243                       rh = elf_follow_link (rh);
6244                       if (rh->root.type != bfd_link_hash_defined
6245                           && rh->root.type != bfd_link_hash_defweak)
6246                         break;
6247                       if (rh->root.u.def.section->owner == opd_bfd)
6248                         {
6249                           val = rh->root.u.def.value;
6250                           sec = rh->root.u.def.section;
6251                         }
6252                     }
6253                 }
6254
6255               if (sec == NULL)
6256                 {
6257                   Elf_Internal_Sym *sym;
6258
6259                   if (symndx < symtab_hdr->sh_info)
6260                     {
6261                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6262                       if (sym == NULL)
6263                         {
6264                           size_t symcnt = symtab_hdr->sh_info;
6265                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6266                                                       symcnt, 0,
6267                                                       NULL, NULL, NULL);
6268                           if (sym == NULL)
6269                             break;
6270                           symtab_hdr->contents = (bfd_byte *) sym;
6271                         }
6272                       sym += symndx;
6273                     }
6274                   else
6275                     {
6276                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6277                                                   1, symndx,
6278                                                   NULL, NULL, NULL);
6279                       if (sym == NULL)
6280                         break;
6281                     }
6282                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6283                   if (sec == NULL)
6284                     break;
6285                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6286                   val = sym->st_value;
6287                 }
6288
6289               val += look->r_addend;
6290               if (code_off != NULL)
6291                 *code_off = val;
6292               if (code_sec != NULL)
6293                 {
6294                   if (in_code_sec && *code_sec != sec)
6295                     return -1;
6296                   else
6297                     *code_sec = sec;
6298                 }
6299               if (sec->output_section != NULL)
6300                 val += sec->output_section->vma + sec->output_offset;
6301             }
6302           break;
6303         }
6304     }
6305
6306   return val;
6307 }
6308
6309 /* If the ELF symbol SYM might be a function in SEC, return the
6310    function size and set *CODE_OFF to the function's entry point,
6311    otherwise return zero.  */
6312
6313 static bfd_size_type
6314 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6315                               bfd_vma *code_off)
6316 {
6317   bfd_size_type size;
6318
6319   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6320                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6321     return 0;
6322
6323   size = 0;
6324   if (!(sym->flags & BSF_SYNTHETIC))
6325     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6326
6327   if (strcmp (sym->section->name, ".opd") == 0)
6328     {
6329       struct _opd_sec_data *opd = get_opd_info (sym->section);
6330       bfd_vma symval = sym->value;
6331
6332       if (opd != NULL
6333           && opd->adjust != NULL
6334           && elf_section_data (sym->section)->relocs != NULL)
6335         {
6336           /* opd_entry_value will use cached relocs that have been
6337              adjusted, but with raw symbols.  That means both local
6338              and global symbols need adjusting.  */
6339           long adjust = opd->adjust[OPD_NDX (symval)];
6340           if (adjust == -1)
6341             return 0;
6342           symval += adjust;
6343         }
6344
6345       if (opd_entry_value (sym->section, symval,
6346                            &sec, code_off, TRUE) == (bfd_vma) -1)
6347         return 0;
6348       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6349          symbol.  This size has nothing to do with the code size of the
6350          function, which is what we're supposed to return, but the
6351          code size isn't available without looking up the dot-sym.
6352          However, doing that would be a waste of time particularly
6353          since elf_find_function will look at the dot-sym anyway.
6354          Now, elf_find_function will keep the largest size of any
6355          function sym found at the code address of interest, so return
6356          1 here to avoid it incorrectly caching a larger function size
6357          for a small function.  This does mean we return the wrong
6358          size for a new-ABI function of size 24, but all that does is
6359          disable caching for such functions.  */
6360       if (size == 24)
6361         size = 1;
6362     }
6363   else
6364     {
6365       if (sym->section != sec)
6366         return 0;
6367       *code_off = sym->value;
6368     }
6369   if (size == 0)
6370     size = 1;
6371   return size;
6372 }
6373
6374 /* Return true if symbol is a strong function defined in an ELFv2
6375    object with st_other localentry bits of zero, ie. its local entry
6376    point coincides with its global entry point.  */
6377
6378 static bfd_boolean
6379 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6380 {
6381   return (h != NULL
6382           && h->type == STT_FUNC
6383           && h->root.type == bfd_link_hash_defined
6384           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6385           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6386           && is_ppc64_elf (h->root.u.def.section->owner)
6387           && abiversion (h->root.u.def.section->owner) >= 2);
6388 }
6389
6390 /* Return true if symbol is defined in a regular object file.  */
6391
6392 static bfd_boolean
6393 is_static_defined (struct elf_link_hash_entry *h)
6394 {
6395   return ((h->root.type == bfd_link_hash_defined
6396            || h->root.type == bfd_link_hash_defweak)
6397           && h->root.u.def.section != NULL
6398           && h->root.u.def.section->output_section != NULL);
6399 }
6400
6401 /* If FDH is a function descriptor symbol, return the associated code
6402    entry symbol if it is defined.  Return NULL otherwise.  */
6403
6404 static struct ppc_link_hash_entry *
6405 defined_code_entry (struct ppc_link_hash_entry *fdh)
6406 {
6407   if (fdh->is_func_descriptor)
6408     {
6409       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6410       if (fh->elf.root.type == bfd_link_hash_defined
6411           || fh->elf.root.type == bfd_link_hash_defweak)
6412         return fh;
6413     }
6414   return NULL;
6415 }
6416
6417 /* If FH is a function code entry symbol, return the associated
6418    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6419
6420 static struct ppc_link_hash_entry *
6421 defined_func_desc (struct ppc_link_hash_entry *fh)
6422 {
6423   if (fh->oh != NULL
6424       && fh->oh->is_func_descriptor)
6425     {
6426       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6427       if (fdh->elf.root.type == bfd_link_hash_defined
6428           || fdh->elf.root.type == bfd_link_hash_defweak)
6429         return fdh;
6430     }
6431   return NULL;
6432 }
6433
6434 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6435
6436 /* Garbage collect sections, after first dealing with dot-symbols.  */
6437
6438 static bfd_boolean
6439 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6440 {
6441   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6442
6443   if (htab != NULL && htab->need_func_desc_adj)
6444     {
6445       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6446       htab->need_func_desc_adj = 0;
6447     }
6448   return bfd_elf_gc_sections (abfd, info);
6449 }
6450
6451 /* Mark all our entry sym sections, both opd and code section.  */
6452
6453 static void
6454 ppc64_elf_gc_keep (struct bfd_link_info *info)
6455 {
6456   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6457   struct bfd_sym_chain *sym;
6458
6459   if (htab == NULL)
6460     return;
6461
6462   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6463     {
6464       struct ppc_link_hash_entry *eh, *fh;
6465       asection *sec;
6466
6467       eh = (struct ppc_link_hash_entry *)
6468         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6469       if (eh == NULL)
6470         continue;
6471       if (eh->elf.root.type != bfd_link_hash_defined
6472           && eh->elf.root.type != bfd_link_hash_defweak)
6473         continue;
6474
6475       fh = defined_code_entry (eh);
6476       if (fh != NULL)
6477         {
6478           sec = fh->elf.root.u.def.section;
6479           sec->flags |= SEC_KEEP;
6480         }
6481       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6482                && opd_entry_value (eh->elf.root.u.def.section,
6483                                    eh->elf.root.u.def.value,
6484                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6485         sec->flags |= SEC_KEEP;
6486
6487       sec = eh->elf.root.u.def.section;
6488       sec->flags |= SEC_KEEP;
6489     }
6490 }
6491
6492 /* Mark sections containing dynamically referenced symbols.  When
6493    building shared libraries, we must assume that any visible symbol is
6494    referenced.  */
6495
6496 static bfd_boolean
6497 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6498 {
6499   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6500   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6501   struct ppc_link_hash_entry *fdh;
6502   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6503
6504   /* Dynamic linking info is on the func descriptor sym.  */
6505   fdh = defined_func_desc (eh);
6506   if (fdh != NULL)
6507     eh = fdh;
6508
6509   if ((eh->elf.root.type == bfd_link_hash_defined
6510        || eh->elf.root.type == bfd_link_hash_defweak)
6511       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6512           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6513               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6514               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6515               && (!bfd_link_executable (info)
6516                   || info->gc_keep_exported
6517                   || info->export_dynamic
6518                   || (eh->elf.dynamic
6519                       && d != NULL
6520                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6521               && (eh->elf.versioned >= versioned
6522                   || !bfd_hide_sym_by_version (info->version_info,
6523                                                eh->elf.root.root.string)))))
6524     {
6525       asection *code_sec;
6526       struct ppc_link_hash_entry *fh;
6527
6528       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6529
6530       /* Function descriptor syms cause the associated
6531          function code sym section to be marked.  */
6532       fh = defined_code_entry (eh);
6533       if (fh != NULL)
6534         {
6535           code_sec = fh->elf.root.u.def.section;
6536           code_sec->flags |= SEC_KEEP;
6537         }
6538       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6539                && opd_entry_value (eh->elf.root.u.def.section,
6540                                    eh->elf.root.u.def.value,
6541                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6542         code_sec->flags |= SEC_KEEP;
6543     }
6544
6545   return TRUE;
6546 }
6547
6548 /* Return the section that should be marked against GC for a given
6549    relocation.  */
6550
6551 static asection *
6552 ppc64_elf_gc_mark_hook (asection *sec,
6553                         struct bfd_link_info *info,
6554                         Elf_Internal_Rela *rel,
6555                         struct elf_link_hash_entry *h,
6556                         Elf_Internal_Sym *sym)
6557 {
6558   asection *rsec;
6559
6560   /* Syms return NULL if we're marking .opd, so we avoid marking all
6561      function sections, as all functions are referenced in .opd.  */
6562   rsec = NULL;
6563   if (get_opd_info (sec) != NULL)
6564     return rsec;
6565
6566   if (h != NULL)
6567     {
6568       enum elf_ppc64_reloc_type r_type;
6569       struct ppc_link_hash_entry *eh, *fh, *fdh;
6570
6571       r_type = ELF64_R_TYPE (rel->r_info);
6572       switch (r_type)
6573         {
6574         case R_PPC64_GNU_VTINHERIT:
6575         case R_PPC64_GNU_VTENTRY:
6576           break;
6577
6578         default:
6579           switch (h->root.type)
6580             {
6581             case bfd_link_hash_defined:
6582             case bfd_link_hash_defweak:
6583               eh = (struct ppc_link_hash_entry *) h;
6584               fdh = defined_func_desc (eh);
6585               if (fdh != NULL)
6586                 {
6587                   /* -mcall-aixdesc code references the dot-symbol on
6588                      a call reloc.  Mark the function descriptor too
6589                      against garbage collection.  */
6590                   fdh->elf.mark = 1;
6591                   if (fdh->elf.is_weakalias)
6592                     weakdef (&fdh->elf)->mark = 1;
6593                   eh = fdh;
6594                 }
6595
6596               /* Function descriptor syms cause the associated
6597                  function code sym section to be marked.  */
6598               fh = defined_code_entry (eh);
6599               if (fh != NULL)
6600                 {
6601                   /* They also mark their opd section.  */
6602                   eh->elf.root.u.def.section->gc_mark = 1;
6603
6604                   rsec = fh->elf.root.u.def.section;
6605                 }
6606               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6607                        && opd_entry_value (eh->elf.root.u.def.section,
6608                                            eh->elf.root.u.def.value,
6609                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6610                 eh->elf.root.u.def.section->gc_mark = 1;
6611               else
6612                 rsec = h->root.u.def.section;
6613               break;
6614
6615             case bfd_link_hash_common:
6616               rsec = h->root.u.c.p->section;
6617               break;
6618
6619             default:
6620               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6621             }
6622         }
6623     }
6624   else
6625     {
6626       struct _opd_sec_data *opd;
6627
6628       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6629       opd = get_opd_info (rsec);
6630       if (opd != NULL && opd->func_sec != NULL)
6631         {
6632           rsec->gc_mark = 1;
6633
6634           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6635         }
6636     }
6637
6638   return rsec;
6639 }
6640
6641 /* The maximum size of .sfpr.  */
6642 #define SFPR_MAX (218*4)
6643
6644 struct sfpr_def_parms
6645 {
6646   const char name[12];
6647   unsigned char lo, hi;
6648   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6649   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6650 };
6651
6652 /* Auto-generate _save*, _rest* functions in .sfpr.
6653    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6654    instead.  */
6655
6656 static bfd_boolean
6657 sfpr_define (struct bfd_link_info *info,
6658              const struct sfpr_def_parms *parm,
6659              asection *stub_sec)
6660 {
6661   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6662   unsigned int i;
6663   size_t len = strlen (parm->name);
6664   bfd_boolean writing = FALSE;
6665   char sym[16];
6666
6667   if (htab == NULL)
6668     return FALSE;
6669
6670   memcpy (sym, parm->name, len);
6671   sym[len + 2] = 0;
6672
6673   for (i = parm->lo; i <= parm->hi; i++)
6674     {
6675       struct ppc_link_hash_entry *h;
6676
6677       sym[len + 0] = i / 10 + '0';
6678       sym[len + 1] = i % 10 + '0';
6679       h = (struct ppc_link_hash_entry *)
6680         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6681       if (stub_sec != NULL)
6682         {
6683           if (h != NULL
6684               && h->elf.root.type == bfd_link_hash_defined
6685               && h->elf.root.u.def.section == htab->sfpr)
6686             {
6687               struct elf_link_hash_entry *s;
6688               char buf[32];
6689               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6690               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6691               if (s == NULL)
6692                 return FALSE;
6693               if (s->root.type == bfd_link_hash_new
6694                   || (s->root.type = bfd_link_hash_defined
6695                       && s->root.u.def.section == stub_sec))
6696                 {
6697                   s->root.type = bfd_link_hash_defined;
6698                   s->root.u.def.section = stub_sec;
6699                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6700                                          + h->elf.root.u.def.value);
6701                   s->ref_regular = 1;
6702                   s->def_regular = 1;
6703                   s->ref_regular_nonweak = 1;
6704                   s->forced_local = 1;
6705                   s->non_elf = 0;
6706                   s->root.linker_def = 1;
6707                 }
6708             }
6709           continue;
6710         }
6711       if (h != NULL)
6712         {
6713           h->save_res = 1;
6714           if (!h->elf.def_regular)
6715             {
6716               h->elf.root.type = bfd_link_hash_defined;
6717               h->elf.root.u.def.section = htab->sfpr;
6718               h->elf.root.u.def.value = htab->sfpr->size;
6719               h->elf.type = STT_FUNC;
6720               h->elf.def_regular = 1;
6721               h->elf.non_elf = 0;
6722               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6723               writing = TRUE;
6724               if (htab->sfpr->contents == NULL)
6725                 {
6726                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6727                   if (htab->sfpr->contents == NULL)
6728                     return FALSE;
6729                 }
6730             }
6731         }
6732       if (writing)
6733         {
6734           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6735           if (i != parm->hi)
6736             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6737           else
6738             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6739           htab->sfpr->size = p - htab->sfpr->contents;
6740         }
6741     }
6742
6743   return TRUE;
6744 }
6745
6746 static bfd_byte *
6747 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6748 {
6749   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6750   return p + 4;
6751 }
6752
6753 static bfd_byte *
6754 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6755 {
6756   p = savegpr0 (abfd, p, r);
6757   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6758   p = p + 4;
6759   bfd_put_32 (abfd, BLR, p);
6760   return p + 4;
6761 }
6762
6763 static bfd_byte *
6764 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6765 {
6766   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6767   return p + 4;
6768 }
6769
6770 static bfd_byte *
6771 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6772 {
6773   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6774   p = p + 4;
6775   p = restgpr0 (abfd, p, r);
6776   bfd_put_32 (abfd, MTLR_R0, p);
6777   p = p + 4;
6778   if (r == 29)
6779     {
6780       p = restgpr0 (abfd, p, 30);
6781       p = restgpr0 (abfd, p, 31);
6782     }
6783   bfd_put_32 (abfd, BLR, p);
6784   return p + 4;
6785 }
6786
6787 static bfd_byte *
6788 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6789 {
6790   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6791   return p + 4;
6792 }
6793
6794 static bfd_byte *
6795 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6796 {
6797   p = savegpr1 (abfd, p, r);
6798   bfd_put_32 (abfd, BLR, p);
6799   return p + 4;
6800 }
6801
6802 static bfd_byte *
6803 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6804 {
6805   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6806   return p + 4;
6807 }
6808
6809 static bfd_byte *
6810 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6811 {
6812   p = restgpr1 (abfd, p, r);
6813   bfd_put_32 (abfd, BLR, p);
6814   return p + 4;
6815 }
6816
6817 static bfd_byte *
6818 savefpr (bfd *abfd, bfd_byte *p, int r)
6819 {
6820   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6821   return p + 4;
6822 }
6823
6824 static bfd_byte *
6825 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6826 {
6827   p = savefpr (abfd, p, r);
6828   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6829   p = p + 4;
6830   bfd_put_32 (abfd, BLR, p);
6831   return p + 4;
6832 }
6833
6834 static bfd_byte *
6835 restfpr (bfd *abfd, bfd_byte *p, int r)
6836 {
6837   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6838   return p + 4;
6839 }
6840
6841 static bfd_byte *
6842 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6843 {
6844   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6845   p = p + 4;
6846   p = restfpr (abfd, p, r);
6847   bfd_put_32 (abfd, MTLR_R0, p);
6848   p = p + 4;
6849   if (r == 29)
6850     {
6851       p = restfpr (abfd, p, 30);
6852       p = restfpr (abfd, p, 31);
6853     }
6854   bfd_put_32 (abfd, BLR, p);
6855   return p + 4;
6856 }
6857
6858 static bfd_byte *
6859 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6860 {
6861   p = savefpr (abfd, p, r);
6862   bfd_put_32 (abfd, BLR, p);
6863   return p + 4;
6864 }
6865
6866 static bfd_byte *
6867 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6868 {
6869   p = restfpr (abfd, p, r);
6870   bfd_put_32 (abfd, BLR, p);
6871   return p + 4;
6872 }
6873
6874 static bfd_byte *
6875 savevr (bfd *abfd, bfd_byte *p, int r)
6876 {
6877   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6878   p = p + 4;
6879   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6880   return p + 4;
6881 }
6882
6883 static bfd_byte *
6884 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6885 {
6886   p = savevr (abfd, p, r);
6887   bfd_put_32 (abfd, BLR, p);
6888   return p + 4;
6889 }
6890
6891 static bfd_byte *
6892 restvr (bfd *abfd, bfd_byte *p, int r)
6893 {
6894   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6895   p = p + 4;
6896   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   p = restvr (abfd, p, r);
6904   bfd_put_32 (abfd, BLR, p);
6905   return p + 4;
6906 }
6907
6908 /* Called via elf_link_hash_traverse to transfer dynamic linking
6909    information on function code symbol entries to their corresponding
6910    function descriptor symbol entries.  */
6911
6912 static bfd_boolean
6913 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6914 {
6915   struct bfd_link_info *info;
6916   struct ppc_link_hash_table *htab;
6917   struct ppc_link_hash_entry *fh;
6918   struct ppc_link_hash_entry *fdh;
6919   bfd_boolean force_local;
6920
6921   fh = (struct ppc_link_hash_entry *) h;
6922   if (fh->elf.root.type == bfd_link_hash_indirect)
6923     return TRUE;
6924
6925   if (!fh->is_func)
6926     return TRUE;
6927
6928   if (fh->elf.root.root.string[0] != '.'
6929       || fh->elf.root.root.string[1] == '\0')
6930     return TRUE;
6931
6932   info = inf;
6933   htab = ppc_hash_table (info);
6934   if (htab == NULL)
6935     return FALSE;
6936
6937   /* Find the corresponding function descriptor symbol.  */
6938   fdh = lookup_fdh (fh, htab);
6939
6940   /* Resolve undefined references to dot-symbols as the value
6941      in the function descriptor, if we have one in a regular object.
6942      This is to satisfy cases like ".quad .foo".  Calls to functions
6943      in dynamic objects are handled elsewhere.  */
6944   if ((fh->elf.root.type == bfd_link_hash_undefined
6945        || fh->elf.root.type == bfd_link_hash_undefweak)
6946       && (fdh->elf.root.type == bfd_link_hash_defined
6947           || fdh->elf.root.type == bfd_link_hash_defweak)
6948       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6949       && opd_entry_value (fdh->elf.root.u.def.section,
6950                           fdh->elf.root.u.def.value,
6951                           &fh->elf.root.u.def.section,
6952                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6953     {
6954       fh->elf.root.type = fdh->elf.root.type;
6955       fh->elf.forced_local = 1;
6956       fh->elf.def_regular = fdh->elf.def_regular;
6957       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6958     }
6959
6960   if (!fh->elf.dynamic)
6961     {
6962       struct plt_entry *ent;
6963
6964       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6965         if (ent->plt.refcount > 0)
6966           break;
6967       if (ent == NULL)
6968         return TRUE;
6969     }
6970
6971   /* Create a descriptor as undefined if necessary.  */
6972   if (fdh == NULL
6973       && !bfd_link_executable (info)
6974       && (fh->elf.root.type == bfd_link_hash_undefined
6975           || fh->elf.root.type == bfd_link_hash_undefweak))
6976     {
6977       fdh = make_fdh (info, fh);
6978       if (fdh == NULL)
6979         return FALSE;
6980     }
6981
6982   /* We can't support overriding of symbols on a fake descriptor.  */
6983   if (fdh != NULL
6984       && fdh->fake
6985       && (fh->elf.root.type == bfd_link_hash_defined
6986           || fh->elf.root.type == bfd_link_hash_defweak))
6987     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6988
6989   /* Transfer dynamic linking information to the function descriptor.  */
6990   if (fdh != NULL)
6991     {
6992       fdh->elf.ref_regular |= fh->elf.ref_regular;
6993       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6994       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6995       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6996       fdh->elf.dynamic |= fh->elf.dynamic;
6997       fdh->elf.needs_plt |= (fh->elf.needs_plt
6998                              || fh->elf.type == STT_FUNC
6999                              || fh->elf.type == STT_GNU_IFUNC);
7000       move_plt_plist (fh, fdh);
7001
7002       if (!fdh->elf.forced_local
7003           && fh->elf.dynindx != -1)
7004         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7005           return FALSE;
7006     }
7007
7008   /* Now that the info is on the function descriptor, clear the
7009      function code sym info.  Any function code syms for which we
7010      don't have a definition in a regular file, we force local.
7011      This prevents a shared library from exporting syms that have
7012      been imported from another library.  Function code syms that
7013      are really in the library we must leave global to prevent the
7014      linker dragging in a definition from a static library.  */
7015   force_local = (!fh->elf.def_regular
7016                  || fdh == NULL
7017                  || !fdh->elf.def_regular
7018                  || fdh->elf.forced_local);
7019   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7020
7021   return TRUE;
7022 }
7023
7024 static const struct sfpr_def_parms save_res_funcs[] =
7025   {
7026     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7027     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7028     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7029     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7030     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7031     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7032     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7033     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7034     { "._savef", 14, 31, savefpr, savefpr1_tail },
7035     { "._restf", 14, 31, restfpr, restfpr1_tail },
7036     { "_savevr_", 20, 31, savevr, savevr_tail },
7037     { "_restvr_", 20, 31, restvr, restvr_tail }
7038   };
7039
7040 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7041    this hook to a) provide some gcc support functions, and b) transfer
7042    dynamic linking information gathered so far on function code symbol
7043    entries, to their corresponding function descriptor symbol entries.  */
7044
7045 static bfd_boolean
7046 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7047                             struct bfd_link_info *info)
7048 {
7049   struct ppc_link_hash_table *htab;
7050
7051   htab = ppc_hash_table (info);
7052   if (htab == NULL)
7053     return FALSE;
7054
7055   /* Provide any missing _save* and _rest* functions.  */
7056   if (htab->sfpr != NULL)
7057     {
7058       unsigned int i;
7059
7060       htab->sfpr->size = 0;
7061       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7062         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7063           return FALSE;
7064       if (htab->sfpr->size == 0)
7065         htab->sfpr->flags |= SEC_EXCLUDE;
7066     }
7067
7068   if (bfd_link_relocatable (info))
7069     return TRUE;
7070
7071   if (htab->elf.hgot != NULL)
7072     {
7073       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7074       /* Make .TOC. defined so as to prevent it being made dynamic.
7075          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7076       if (!htab->elf.hgot->def_regular
7077           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7078         {
7079           htab->elf.hgot->root.type = bfd_link_hash_defined;
7080           htab->elf.hgot->root.u.def.value = 0;
7081           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7082           htab->elf.hgot->def_regular = 1;
7083           htab->elf.hgot->root.linker_def = 1;
7084         }
7085       htab->elf.hgot->type = STT_OBJECT;
7086       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7087                                | STV_HIDDEN);
7088     }
7089
7090   if (htab->need_func_desc_adj)
7091     {
7092       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7093       htab->need_func_desc_adj = 0;
7094     }
7095
7096   return TRUE;
7097 }
7098
7099 /* Find dynamic relocs for H that apply to read-only sections.  */
7100
7101 static asection *
7102 readonly_dynrelocs (struct elf_link_hash_entry *h)
7103 {
7104   struct ppc_link_hash_entry *eh;
7105   struct elf_dyn_relocs *p;
7106
7107   eh = (struct ppc_link_hash_entry *) h;
7108   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7109     {
7110       asection *s = p->sec->output_section;
7111
7112       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7113         return p->sec;
7114     }
7115   return NULL;
7116 }
7117
7118 /* Return true if we have dynamic relocs against H or any of its weak
7119    aliases, that apply to read-only sections.  Cannot be used after
7120    size_dynamic_sections.  */
7121
7122 static bfd_boolean
7123 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7124 {
7125   struct ppc_link_hash_entry *eh;
7126
7127   eh = (struct ppc_link_hash_entry *) h;
7128   do
7129     {
7130       if (readonly_dynrelocs (&eh->elf))
7131         return TRUE;
7132       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7133     } while (eh != NULL && &eh->elf != h);
7134
7135   return FALSE;
7136 }
7137
7138 /* Return whether EH has pc-relative dynamic relocs.  */
7139
7140 static bfd_boolean
7141 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7142 {
7143   struct elf_dyn_relocs *p;
7144
7145   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7146     if (p->pc_count != 0)
7147       return TRUE;
7148   return FALSE;
7149 }
7150
7151 /* Return true if a global entry stub will be created for H.  Valid
7152    for ELFv2 before plt entries have been allocated.  */
7153
7154 static bfd_boolean
7155 global_entry_stub (struct elf_link_hash_entry *h)
7156 {
7157   struct plt_entry *pent;
7158
7159   if (!h->pointer_equality_needed
7160       || h->def_regular)
7161     return FALSE;
7162
7163   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7164     if (pent->plt.refcount > 0
7165         && pent->addend == 0)
7166       return TRUE;
7167
7168   return FALSE;
7169 }
7170
7171 /* Adjust a symbol defined by a dynamic object and referenced by a
7172    regular object.  The current definition is in some section of the
7173    dynamic object, but we're not including those sections.  We have to
7174    change the definition to something the rest of the link can
7175    understand.  */
7176
7177 static bfd_boolean
7178 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7179                                  struct elf_link_hash_entry *h)
7180 {
7181   struct ppc_link_hash_table *htab;
7182   asection *s, *srel;
7183
7184   htab = ppc_hash_table (info);
7185   if (htab == NULL)
7186     return FALSE;
7187
7188   /* Deal with function syms.  */
7189   if (h->type == STT_FUNC
7190       || h->type == STT_GNU_IFUNC
7191       || h->needs_plt)
7192     {
7193       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7194                            || SYMBOL_CALLS_LOCAL (info, h)
7195                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7196       /* Discard dyn_relocs when non-pic if we've decided that a
7197          function symbol is local and not an ifunc.  We keep dynamic
7198          relocs for ifuncs when local rather than always emitting a
7199          plt call stub for them and defining the symbol on the call
7200          stub.  We can't do that for ELFv1 anyway (a function symbol
7201          is defined on a descriptor, not code) and it can be faster at
7202          run-time due to not needing to bounce through a stub.  The
7203          dyn_relocs for ifuncs will be applied even in a static
7204          executable.  */
7205       if (!bfd_link_pic (info)
7206           && h->type != STT_GNU_IFUNC
7207           && local)
7208         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7209
7210       /* Clear procedure linkage table information for any symbol that
7211          won't need a .plt entry.  */
7212       struct plt_entry *ent;
7213       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7214         if (ent->plt.refcount > 0)
7215           break;
7216       if (ent == NULL
7217           || (h->type != STT_GNU_IFUNC
7218               && local
7219               && (((struct ppc_link_hash_entry *) h)->tls_mask
7220                   & (TLS_TLS | PLT_KEEP)) != PLT_KEEP))
7221         {
7222           h->plt.plist = NULL;
7223           h->needs_plt = 0;
7224           h->pointer_equality_needed = 0;
7225         }
7226       else if (abiversion (info->output_bfd) >= 2)
7227         {
7228           /* Taking a function's address in a read/write section
7229              doesn't require us to define the function symbol in the
7230              executable on a global entry stub.  A dynamic reloc can
7231              be used instead.  The reason we prefer a few more dynamic
7232              relocs is that calling via a global entry stub costs a
7233              few more instructions, and pointer_equality_needed causes
7234              extra work in ld.so when resolving these symbols.  */
7235           if (global_entry_stub (h))
7236             {
7237               if (!readonly_dynrelocs (h))
7238                 {
7239                   h->pointer_equality_needed = 0;
7240                   /* If we haven't seen a branch reloc then we don't need
7241                      a plt entry.  */
7242                   if (!h->needs_plt)
7243                     h->plt.plist = NULL;
7244                 }
7245               else if (!bfd_link_pic (info))
7246                 /* We are going to be defining the function symbol on the
7247                    plt stub, so no dyn_relocs needed when non-pic.  */
7248                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7249             }
7250
7251           /* ELFv2 function symbols can't have copy relocs.  */
7252           return TRUE;
7253         }
7254       else if (!h->needs_plt
7255                && !readonly_dynrelocs (h))
7256         {
7257           /* If we haven't seen a branch reloc then we don't need a
7258              plt entry.  */
7259           h->plt.plist = NULL;
7260           h->pointer_equality_needed = 0;
7261           return TRUE;
7262         }
7263     }
7264   else
7265     h->plt.plist = NULL;
7266
7267   /* If this is a weak symbol, and there is a real definition, the
7268      processor independent code will have arranged for us to see the
7269      real definition first, and we can just use the same value.  */
7270   if (h->is_weakalias)
7271     {
7272       struct elf_link_hash_entry *def = weakdef (h);
7273       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7274       h->root.u.def.section = def->root.u.def.section;
7275       h->root.u.def.value = def->root.u.def.value;
7276       if (def->root.u.def.section == htab->elf.sdynbss
7277           || def->root.u.def.section == htab->elf.sdynrelro)
7278         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7279       return TRUE;
7280     }
7281
7282   /* If we are creating a shared library, we must presume that the
7283      only references to the symbol are via the global offset table.
7284      For such cases we need not do anything here; the relocations will
7285      be handled correctly by relocate_section.  */
7286   if (bfd_link_pic (info))
7287     return TRUE;
7288
7289   /* If there are no references to this symbol that do not use the
7290      GOT, we don't need to generate a copy reloc.  */
7291   if (!h->non_got_ref)
7292     return TRUE;
7293
7294   /* Don't generate a copy reloc for symbols defined in the executable.  */
7295   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7296
7297       /* If -z nocopyreloc was given, don't generate them either.  */
7298       || info->nocopyreloc
7299
7300       /* If we don't find any dynamic relocs in read-only sections, then
7301          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7302       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7303
7304       /* Protected variables do not work with .dynbss.  The copy in
7305          .dynbss won't be used by the shared library with the protected
7306          definition for the variable.  Text relocations are preferable
7307          to an incorrect program.  */
7308       || h->protected_def)
7309     return TRUE;
7310
7311   if (h->plt.plist != NULL)
7312     {
7313       /* We should never get here, but unfortunately there are versions
7314          of gcc out there that improperly (for this ABI) put initialized
7315          function pointers, vtable refs and suchlike in read-only
7316          sections.  Allow them to proceed, but warn that this might
7317          break at runtime.  */
7318       info->callbacks->einfo
7319         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7320            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7321          h->root.root.string);
7322     }
7323
7324   /* This is a reference to a symbol defined by a dynamic object which
7325      is not a function.  */
7326
7327   /* We must allocate the symbol in our .dynbss section, which will
7328      become part of the .bss section of the executable.  There will be
7329      an entry for this symbol in the .dynsym section.  The dynamic
7330      object will contain position independent code, so all references
7331      from the dynamic object to this symbol will go through the global
7332      offset table.  The dynamic linker will use the .dynsym entry to
7333      determine the address it must put in the global offset table, so
7334      both the dynamic object and the regular object will refer to the
7335      same memory location for the variable.  */
7336   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7337     {
7338       s = htab->elf.sdynrelro;
7339       srel = htab->elf.sreldynrelro;
7340     }
7341   else
7342     {
7343       s = htab->elf.sdynbss;
7344       srel = htab->elf.srelbss;
7345     }
7346   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7347     {
7348       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7349          linker to copy the initial value out of the dynamic object
7350          and into the runtime process image.  */
7351       srel->size += sizeof (Elf64_External_Rela);
7352       h->needs_copy = 1;
7353     }
7354
7355   /* We no longer want dyn_relocs.  */
7356   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7357   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7358 }
7359
7360 /* If given a function descriptor symbol, hide both the function code
7361    sym and the descriptor.  */
7362 static void
7363 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7364                        struct elf_link_hash_entry *h,
7365                        bfd_boolean force_local)
7366 {
7367   struct ppc_link_hash_entry *eh;
7368   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7369
7370   eh = (struct ppc_link_hash_entry *) h;
7371   if (eh->is_func_descriptor)
7372     {
7373       struct ppc_link_hash_entry *fh = eh->oh;
7374
7375       if (fh == NULL)
7376         {
7377           const char *p, *q;
7378           struct elf_link_hash_table *htab = elf_hash_table (info);
7379           char save;
7380
7381           /* We aren't supposed to use alloca in BFD because on
7382              systems which do not have alloca the version in libiberty
7383              calls xmalloc, which might cause the program to crash
7384              when it runs out of memory.  This function doesn't have a
7385              return status, so there's no way to gracefully return an
7386              error.  So cheat.  We know that string[-1] can be safely
7387              accessed;  It's either a string in an ELF string table,
7388              or allocated in an objalloc structure.  */
7389
7390           p = eh->elf.root.root.string - 1;
7391           save = *p;
7392           *(char *) p = '.';
7393           fh = (struct ppc_link_hash_entry *)
7394             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7395           *(char *) p = save;
7396
7397           /* Unfortunately, if it so happens that the string we were
7398              looking for was allocated immediately before this string,
7399              then we overwrote the string terminator.  That's the only
7400              reason the lookup should fail.  */
7401           if (fh == NULL)
7402             {
7403               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7404               while (q >= eh->elf.root.root.string && *q == *p)
7405                 --q, --p;
7406               if (q < eh->elf.root.root.string && *p == '.')
7407                 fh = (struct ppc_link_hash_entry *)
7408                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7409             }
7410           if (fh != NULL)
7411             {
7412               eh->oh = fh;
7413               fh->oh = eh;
7414             }
7415         }
7416       if (fh != NULL)
7417         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7418     }
7419 }
7420
7421 static bfd_boolean
7422 get_sym_h (struct elf_link_hash_entry **hp,
7423            Elf_Internal_Sym **symp,
7424            asection **symsecp,
7425            unsigned char **tls_maskp,
7426            Elf_Internal_Sym **locsymsp,
7427            unsigned long r_symndx,
7428            bfd *ibfd)
7429 {
7430   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7431
7432   if (r_symndx >= symtab_hdr->sh_info)
7433     {
7434       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7435       struct elf_link_hash_entry *h;
7436
7437       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7438       h = elf_follow_link (h);
7439
7440       if (hp != NULL)
7441         *hp = h;
7442
7443       if (symp != NULL)
7444         *symp = NULL;
7445
7446       if (symsecp != NULL)
7447         {
7448           asection *symsec = NULL;
7449           if (h->root.type == bfd_link_hash_defined
7450               || h->root.type == bfd_link_hash_defweak)
7451             symsec = h->root.u.def.section;
7452           *symsecp = symsec;
7453         }
7454
7455       if (tls_maskp != NULL)
7456         {
7457           struct ppc_link_hash_entry *eh;
7458
7459           eh = (struct ppc_link_hash_entry *) h;
7460           *tls_maskp = &eh->tls_mask;
7461         }
7462     }
7463   else
7464     {
7465       Elf_Internal_Sym *sym;
7466       Elf_Internal_Sym *locsyms = *locsymsp;
7467
7468       if (locsyms == NULL)
7469         {
7470           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7471           if (locsyms == NULL)
7472             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7473                                             symtab_hdr->sh_info,
7474                                             0, NULL, NULL, NULL);
7475           if (locsyms == NULL)
7476             return FALSE;
7477           *locsymsp = locsyms;
7478         }
7479       sym = locsyms + r_symndx;
7480
7481       if (hp != NULL)
7482         *hp = NULL;
7483
7484       if (symp != NULL)
7485         *symp = sym;
7486
7487       if (symsecp != NULL)
7488         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7489
7490       if (tls_maskp != NULL)
7491         {
7492           struct got_entry **lgot_ents;
7493           unsigned char *tls_mask;
7494
7495           tls_mask = NULL;
7496           lgot_ents = elf_local_got_ents (ibfd);
7497           if (lgot_ents != NULL)
7498             {
7499               struct plt_entry **local_plt = (struct plt_entry **)
7500                 (lgot_ents + symtab_hdr->sh_info);
7501               unsigned char *lgot_masks = (unsigned char *)
7502                 (local_plt + symtab_hdr->sh_info);
7503               tls_mask = &lgot_masks[r_symndx];
7504             }
7505           *tls_maskp = tls_mask;
7506         }
7507     }
7508   return TRUE;
7509 }
7510
7511 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7512    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7513    type suitable for optimization, and 1 otherwise.  */
7514
7515 static int
7516 get_tls_mask (unsigned char **tls_maskp,
7517               unsigned long *toc_symndx,
7518               bfd_vma *toc_addend,
7519               Elf_Internal_Sym **locsymsp,
7520               const Elf_Internal_Rela *rel,
7521               bfd *ibfd)
7522 {
7523   unsigned long r_symndx;
7524   int next_r;
7525   struct elf_link_hash_entry *h;
7526   Elf_Internal_Sym *sym;
7527   asection *sec;
7528   bfd_vma off;
7529
7530   r_symndx = ELF64_R_SYM (rel->r_info);
7531   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7532     return 0;
7533
7534   if ((*tls_maskp != NULL
7535        && (**tls_maskp & TLS_TLS) != 0
7536        && **tls_maskp != (TLS_TLS | TLS_MARK))
7537       || sec == NULL
7538       || ppc64_elf_section_data (sec) == NULL
7539       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7540     return 1;
7541
7542   /* Look inside a TOC section too.  */
7543   if (h != NULL)
7544     {
7545       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7546       off = h->root.u.def.value;
7547     }
7548   else
7549     off = sym->st_value;
7550   off += rel->r_addend;
7551   BFD_ASSERT (off % 8 == 0);
7552   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7553   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7554   if (toc_symndx != NULL)
7555     *toc_symndx = r_symndx;
7556   if (toc_addend != NULL)
7557     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7558   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7559     return 0;
7560   if ((h == NULL || is_static_defined (h))
7561       && (next_r == -1 || next_r == -2))
7562     return 1 - next_r;
7563   return 1;
7564 }
7565
7566 /* Find (or create) an entry in the tocsave hash table.  */
7567
7568 static struct tocsave_entry *
7569 tocsave_find (struct ppc_link_hash_table *htab,
7570               enum insert_option insert,
7571               Elf_Internal_Sym **local_syms,
7572               const Elf_Internal_Rela *irela,
7573               bfd *ibfd)
7574 {
7575   unsigned long r_indx;
7576   struct elf_link_hash_entry *h;
7577   Elf_Internal_Sym *sym;
7578   struct tocsave_entry ent, *p;
7579   hashval_t hash;
7580   struct tocsave_entry **slot;
7581
7582   r_indx = ELF64_R_SYM (irela->r_info);
7583   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7584     return NULL;
7585   if (ent.sec == NULL || ent.sec->output_section == NULL)
7586     {
7587       _bfd_error_handler
7588         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7589       return NULL;
7590     }
7591
7592   if (h != NULL)
7593     ent.offset = h->root.u.def.value;
7594   else
7595     ent.offset = sym->st_value;
7596   ent.offset += irela->r_addend;
7597
7598   hash = tocsave_htab_hash (&ent);
7599   slot = ((struct tocsave_entry **)
7600           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7601   if (slot == NULL)
7602     return NULL;
7603
7604   if (*slot == NULL)
7605     {
7606       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7607       if (p == NULL)
7608         return NULL;
7609       *p = ent;
7610       *slot = p;
7611     }
7612   return *slot;
7613 }
7614
7615 /* Adjust all global syms defined in opd sections.  In gcc generated
7616    code for the old ABI, these will already have been done.  */
7617
7618 static bfd_boolean
7619 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7620 {
7621   struct ppc_link_hash_entry *eh;
7622   asection *sym_sec;
7623   struct _opd_sec_data *opd;
7624
7625   if (h->root.type == bfd_link_hash_indirect)
7626     return TRUE;
7627
7628   if (h->root.type != bfd_link_hash_defined
7629       && h->root.type != bfd_link_hash_defweak)
7630     return TRUE;
7631
7632   eh = (struct ppc_link_hash_entry *) h;
7633   if (eh->adjust_done)
7634     return TRUE;
7635
7636   sym_sec = eh->elf.root.u.def.section;
7637   opd = get_opd_info (sym_sec);
7638   if (opd != NULL && opd->adjust != NULL)
7639     {
7640       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7641       if (adjust == -1)
7642         {
7643           /* This entry has been deleted.  */
7644           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7645           if (dsec == NULL)
7646             {
7647               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7648                 if (discarded_section (dsec))
7649                   {
7650                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7651                     break;
7652                   }
7653             }
7654           eh->elf.root.u.def.value = 0;
7655           eh->elf.root.u.def.section = dsec;
7656         }
7657       else
7658         eh->elf.root.u.def.value += adjust;
7659       eh->adjust_done = 1;
7660     }
7661   return TRUE;
7662 }
7663
7664 /* Handles decrementing dynamic reloc counts for the reloc specified by
7665    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7666    have already been determined.  */
7667
7668 static bfd_boolean
7669 dec_dynrel_count (bfd_vma r_info,
7670                   asection *sec,
7671                   struct bfd_link_info *info,
7672                   Elf_Internal_Sym **local_syms,
7673                   struct elf_link_hash_entry *h,
7674                   Elf_Internal_Sym *sym)
7675 {
7676   enum elf_ppc64_reloc_type r_type;
7677   asection *sym_sec = NULL;
7678
7679   /* Can this reloc be dynamic?  This switch, and later tests here
7680      should be kept in sync with the code in check_relocs.  */
7681   r_type = ELF64_R_TYPE (r_info);
7682   switch (r_type)
7683     {
7684     default:
7685       return TRUE;
7686
7687     case R_PPC64_TPREL16:
7688     case R_PPC64_TPREL16_LO:
7689     case R_PPC64_TPREL16_HI:
7690     case R_PPC64_TPREL16_HA:
7691     case R_PPC64_TPREL16_DS:
7692     case R_PPC64_TPREL16_LO_DS:
7693     case R_PPC64_TPREL16_HIGH:
7694     case R_PPC64_TPREL16_HIGHA:
7695     case R_PPC64_TPREL16_HIGHER:
7696     case R_PPC64_TPREL16_HIGHERA:
7697     case R_PPC64_TPREL16_HIGHEST:
7698     case R_PPC64_TPREL16_HIGHESTA:
7699     case R_PPC64_TPREL64:
7700     case R_PPC64_DTPMOD64:
7701     case R_PPC64_DTPREL64:
7702     case R_PPC64_ADDR64:
7703     case R_PPC64_REL30:
7704     case R_PPC64_REL32:
7705     case R_PPC64_REL64:
7706     case R_PPC64_ADDR14:
7707     case R_PPC64_ADDR14_BRNTAKEN:
7708     case R_PPC64_ADDR14_BRTAKEN:
7709     case R_PPC64_ADDR16:
7710     case R_PPC64_ADDR16_DS:
7711     case R_PPC64_ADDR16_HA:
7712     case R_PPC64_ADDR16_HI:
7713     case R_PPC64_ADDR16_HIGH:
7714     case R_PPC64_ADDR16_HIGHA:
7715     case R_PPC64_ADDR16_HIGHER:
7716     case R_PPC64_ADDR16_HIGHERA:
7717     case R_PPC64_ADDR16_HIGHEST:
7718     case R_PPC64_ADDR16_HIGHESTA:
7719     case R_PPC64_ADDR16_LO:
7720     case R_PPC64_ADDR16_LO_DS:
7721     case R_PPC64_ADDR24:
7722     case R_PPC64_ADDR32:
7723     case R_PPC64_UADDR16:
7724     case R_PPC64_UADDR32:
7725     case R_PPC64_UADDR64:
7726     case R_PPC64_TOC:
7727       break;
7728     }
7729
7730   if (local_syms != NULL)
7731     {
7732       unsigned long r_symndx;
7733       bfd *ibfd = sec->owner;
7734
7735       r_symndx = ELF64_R_SYM (r_info);
7736       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7737         return FALSE;
7738     }
7739
7740   if ((bfd_link_pic (info)
7741        && (must_be_dyn_reloc (info, r_type)
7742            || (h != NULL
7743                && (!SYMBOLIC_BIND (info, h)
7744                    || h->root.type == bfd_link_hash_defweak
7745                    || !h->def_regular))))
7746       || (ELIMINATE_COPY_RELOCS
7747           && !bfd_link_pic (info)
7748           && h != NULL
7749           && (h->root.type == bfd_link_hash_defweak
7750               || !h->def_regular)))
7751     ;
7752   else
7753     return TRUE;
7754
7755   if (h != NULL)
7756     {
7757       struct elf_dyn_relocs *p;
7758       struct elf_dyn_relocs **pp;
7759       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7760
7761       /* elf_gc_sweep may have already removed all dyn relocs associated
7762          with local syms for a given section.  Also, symbol flags are
7763          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7764          report a dynreloc miscount.  */
7765       if (*pp == NULL && info->gc_sections)
7766         return TRUE;
7767
7768       while ((p = *pp) != NULL)
7769         {
7770           if (p->sec == sec)
7771             {
7772               if (!must_be_dyn_reloc (info, r_type))
7773                 p->pc_count -= 1;
7774               p->count -= 1;
7775               if (p->count == 0)
7776                 *pp = p->next;
7777               return TRUE;
7778             }
7779           pp = &p->next;
7780         }
7781     }
7782   else
7783     {
7784       struct ppc_dyn_relocs *p;
7785       struct ppc_dyn_relocs **pp;
7786       void *vpp;
7787       bfd_boolean is_ifunc;
7788
7789       if (local_syms == NULL)
7790         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7791       if (sym_sec == NULL)
7792         sym_sec = sec;
7793
7794       vpp = &elf_section_data (sym_sec)->local_dynrel;
7795       pp = (struct ppc_dyn_relocs **) vpp;
7796
7797       if (*pp == NULL && info->gc_sections)
7798         return TRUE;
7799
7800       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7801       while ((p = *pp) != NULL)
7802         {
7803           if (p->sec == sec && p->ifunc == is_ifunc)
7804             {
7805               p->count -= 1;
7806               if (p->count == 0)
7807                 *pp = p->next;
7808               return TRUE;
7809             }
7810           pp = &p->next;
7811         }
7812     }
7813
7814   /* xgettext:c-format */
7815   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7816                       sec->owner, sec);
7817   bfd_set_error (bfd_error_bad_value);
7818   return FALSE;
7819 }
7820
7821 /* Remove unused Official Procedure Descriptor entries.  Currently we
7822    only remove those associated with functions in discarded link-once
7823    sections, or weakly defined functions that have been overridden.  It
7824    would be possible to remove many more entries for statically linked
7825    applications.  */
7826
7827 bfd_boolean
7828 ppc64_elf_edit_opd (struct bfd_link_info *info)
7829 {
7830   bfd *ibfd;
7831   bfd_boolean some_edited = FALSE;
7832   asection *need_pad = NULL;
7833   struct ppc_link_hash_table *htab;
7834
7835   htab = ppc_hash_table (info);
7836   if (htab == NULL)
7837     return FALSE;
7838
7839   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7840     {
7841       asection *sec;
7842       Elf_Internal_Rela *relstart, *rel, *relend;
7843       Elf_Internal_Shdr *symtab_hdr;
7844       Elf_Internal_Sym *local_syms;
7845       struct _opd_sec_data *opd;
7846       bfd_boolean need_edit, add_aux_fields, broken;
7847       bfd_size_type cnt_16b = 0;
7848
7849       if (!is_ppc64_elf (ibfd))
7850         continue;
7851
7852       sec = bfd_get_section_by_name (ibfd, ".opd");
7853       if (sec == NULL || sec->size == 0)
7854         continue;
7855
7856       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7857         continue;
7858
7859       if (sec->output_section == bfd_abs_section_ptr)
7860         continue;
7861
7862       /* Look through the section relocs.  */
7863       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7864         continue;
7865
7866       local_syms = NULL;
7867       symtab_hdr = &elf_symtab_hdr (ibfd);
7868
7869       /* Read the relocations.  */
7870       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7871                                             info->keep_memory);
7872       if (relstart == NULL)
7873         return FALSE;
7874
7875       /* First run through the relocs to check they are sane, and to
7876          determine whether we need to edit this opd section.  */
7877       need_edit = FALSE;
7878       broken = FALSE;
7879       need_pad = sec;
7880       relend = relstart + sec->reloc_count;
7881       for (rel = relstart; rel < relend; )
7882         {
7883           enum elf_ppc64_reloc_type r_type;
7884           unsigned long r_symndx;
7885           asection *sym_sec;
7886           struct elf_link_hash_entry *h;
7887           Elf_Internal_Sym *sym;
7888           bfd_vma offset;
7889
7890           /* .opd contains an array of 16 or 24 byte entries.  We're
7891              only interested in the reloc pointing to a function entry
7892              point.  */
7893           offset = rel->r_offset;
7894           if (rel + 1 == relend
7895               || rel[1].r_offset != offset + 8)
7896             {
7897               /* If someone messes with .opd alignment then after a
7898                  "ld -r" we might have padding in the middle of .opd.
7899                  Also, there's nothing to prevent someone putting
7900                  something silly in .opd with the assembler.  No .opd
7901                  optimization for them!  */
7902             broken_opd:
7903               _bfd_error_handler
7904                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7905               broken = TRUE;
7906               break;
7907             }
7908
7909           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7910               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7911             {
7912               _bfd_error_handler
7913                 /* xgettext:c-format */
7914                 (_("%pB: unexpected reloc type %u in .opd section"),
7915                  ibfd, r_type);
7916               broken = TRUE;
7917               break;
7918             }
7919
7920           r_symndx = ELF64_R_SYM (rel->r_info);
7921           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7922                           r_symndx, ibfd))
7923             goto error_ret;
7924
7925           if (sym_sec == NULL || sym_sec->owner == NULL)
7926             {
7927               const char *sym_name;
7928               if (h != NULL)
7929                 sym_name = h->root.root.string;
7930               else
7931                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7932                                              sym_sec);
7933
7934               _bfd_error_handler
7935                 /* xgettext:c-format */
7936                 (_("%pB: undefined sym `%s' in .opd section"),
7937                  ibfd, sym_name);
7938               broken = TRUE;
7939               break;
7940             }
7941
7942           /* opd entries are always for functions defined in the
7943              current input bfd.  If the symbol isn't defined in the
7944              input bfd, then we won't be using the function in this
7945              bfd;  It must be defined in a linkonce section in another
7946              bfd, or is weak.  It's also possible that we are
7947              discarding the function due to a linker script /DISCARD/,
7948              which we test for via the output_section.  */
7949           if (sym_sec->owner != ibfd
7950               || sym_sec->output_section == bfd_abs_section_ptr)
7951             need_edit = TRUE;
7952
7953           rel += 2;
7954           if (rel + 1 == relend
7955               || (rel + 2 < relend
7956                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7957             ++rel;
7958
7959           if (rel == relend)
7960             {
7961               if (sec->size == offset + 24)
7962                 {
7963                   need_pad = NULL;
7964                   break;
7965                 }
7966               if (sec->size == offset + 16)
7967                 {
7968                   cnt_16b++;
7969                   break;
7970                 }
7971               goto broken_opd;
7972             }
7973           else if (rel + 1 < relend
7974                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7975                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7976             {
7977               if (rel[0].r_offset == offset + 16)
7978                 cnt_16b++;
7979               else if (rel[0].r_offset != offset + 24)
7980                 goto broken_opd;
7981             }
7982           else
7983             goto broken_opd;
7984         }
7985
7986       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7987
7988       if (!broken && (need_edit || add_aux_fields))
7989         {
7990           Elf_Internal_Rela *write_rel;
7991           Elf_Internal_Shdr *rel_hdr;
7992           bfd_byte *rptr, *wptr;
7993           bfd_byte *new_contents;
7994           bfd_size_type amt;
7995
7996           new_contents = NULL;
7997           amt = OPD_NDX (sec->size) * sizeof (long);
7998           opd = &ppc64_elf_section_data (sec)->u.opd;
7999           opd->adjust = bfd_zalloc (sec->owner, amt);
8000           if (opd->adjust == NULL)
8001             return FALSE;
8002
8003           /* This seems a waste of time as input .opd sections are all
8004              zeros as generated by gcc, but I suppose there's no reason
8005              this will always be so.  We might start putting something in
8006              the third word of .opd entries.  */
8007           if ((sec->flags & SEC_IN_MEMORY) == 0)
8008             {
8009               bfd_byte *loc;
8010               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8011                 {
8012                   if (loc != NULL)
8013                     free (loc);
8014                 error_ret:
8015                   if (local_syms != NULL
8016                       && symtab_hdr->contents != (unsigned char *) local_syms)
8017                     free (local_syms);
8018                   if (elf_section_data (sec)->relocs != relstart)
8019                     free (relstart);
8020                   return FALSE;
8021                 }
8022               sec->contents = loc;
8023               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8024             }
8025
8026           elf_section_data (sec)->relocs = relstart;
8027
8028           new_contents = sec->contents;
8029           if (add_aux_fields)
8030             {
8031               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8032               if (new_contents == NULL)
8033                 return FALSE;
8034               need_pad = NULL;
8035             }
8036           wptr = new_contents;
8037           rptr = sec->contents;
8038           write_rel = relstart;
8039           for (rel = relstart; rel < relend; )
8040             {
8041               unsigned long r_symndx;
8042               asection *sym_sec;
8043               struct elf_link_hash_entry *h;
8044               struct ppc_link_hash_entry *fdh = NULL;
8045               Elf_Internal_Sym *sym;
8046               long opd_ent_size;
8047               Elf_Internal_Rela *next_rel;
8048               bfd_boolean skip;
8049
8050               r_symndx = ELF64_R_SYM (rel->r_info);
8051               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8052                               r_symndx, ibfd))
8053                 goto error_ret;
8054
8055               next_rel = rel + 2;
8056               if (next_rel + 1 == relend
8057                   || (next_rel + 2 < relend
8058                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8059                 ++next_rel;
8060
8061               /* See if the .opd entry is full 24 byte or
8062                  16 byte (with fd_aux entry overlapped with next
8063                  fd_func).  */
8064               opd_ent_size = 24;
8065               if (next_rel == relend)
8066                 {
8067                   if (sec->size == rel->r_offset + 16)
8068                     opd_ent_size = 16;
8069                 }
8070               else if (next_rel->r_offset == rel->r_offset + 16)
8071                 opd_ent_size = 16;
8072
8073               if (h != NULL
8074                   && h->root.root.string[0] == '.')
8075                 {
8076                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8077                   if (fdh != NULL)
8078                     {
8079                       fdh = ppc_follow_link (fdh);
8080                       if (fdh->elf.root.type != bfd_link_hash_defined
8081                           && fdh->elf.root.type != bfd_link_hash_defweak)
8082                         fdh = NULL;
8083                     }
8084                 }
8085
8086               skip = (sym_sec->owner != ibfd
8087                       || sym_sec->output_section == bfd_abs_section_ptr);
8088               if (skip)
8089                 {
8090                   if (fdh != NULL && sym_sec->owner == ibfd)
8091                     {
8092                       /* Arrange for the function descriptor sym
8093                          to be dropped.  */
8094                       fdh->elf.root.u.def.value = 0;
8095                       fdh->elf.root.u.def.section = sym_sec;
8096                     }
8097                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8098
8099                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8100                     rel = next_rel;
8101                   else
8102                     while (1)
8103                       {
8104                         if (!dec_dynrel_count (rel->r_info, sec, info,
8105                                                NULL, h, sym))
8106                           goto error_ret;
8107
8108                         if (++rel == next_rel)
8109                           break;
8110
8111                         r_symndx = ELF64_R_SYM (rel->r_info);
8112                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8113                                         r_symndx, ibfd))
8114                           goto error_ret;
8115                       }
8116                 }
8117               else
8118                 {
8119                   /* We'll be keeping this opd entry.  */
8120                   long adjust;
8121
8122                   if (fdh != NULL)
8123                     {
8124                       /* Redefine the function descriptor symbol to
8125                          this location in the opd section.  It is
8126                          necessary to update the value here rather
8127                          than using an array of adjustments as we do
8128                          for local symbols, because various places
8129                          in the generic ELF code use the value
8130                          stored in u.def.value.  */
8131                       fdh->elf.root.u.def.value = wptr - new_contents;
8132                       fdh->adjust_done = 1;
8133                     }
8134
8135                   /* Local syms are a bit tricky.  We could
8136                      tweak them as they can be cached, but
8137                      we'd need to look through the local syms
8138                      for the function descriptor sym which we
8139                      don't have at the moment.  So keep an
8140                      array of adjustments.  */
8141                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8142                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8143
8144                   if (wptr != rptr)
8145                     memcpy (wptr, rptr, opd_ent_size);
8146                   wptr += opd_ent_size;
8147                   if (add_aux_fields && opd_ent_size == 16)
8148                     {
8149                       memset (wptr, '\0', 8);
8150                       wptr += 8;
8151                     }
8152
8153                   /* We need to adjust any reloc offsets to point to the
8154                      new opd entries.  */
8155                   for ( ; rel != next_rel; ++rel)
8156                     {
8157                       rel->r_offset += adjust;
8158                       if (write_rel != rel)
8159                         memcpy (write_rel, rel, sizeof (*rel));
8160                       ++write_rel;
8161                     }
8162                 }
8163
8164               rptr += opd_ent_size;
8165             }
8166
8167           sec->size = wptr - new_contents;
8168           sec->reloc_count = write_rel - relstart;
8169           if (add_aux_fields)
8170             {
8171               free (sec->contents);
8172               sec->contents = new_contents;
8173             }
8174
8175           /* Fudge the header size too, as this is used later in
8176              elf_bfd_final_link if we are emitting relocs.  */
8177           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8178           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8179           some_edited = TRUE;
8180         }
8181       else if (elf_section_data (sec)->relocs != relstart)
8182         free (relstart);
8183
8184       if (local_syms != NULL
8185           && symtab_hdr->contents != (unsigned char *) local_syms)
8186         {
8187           if (!info->keep_memory)
8188             free (local_syms);
8189           else
8190             symtab_hdr->contents = (unsigned char *) local_syms;
8191         }
8192     }
8193
8194   if (some_edited)
8195     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8196
8197   /* If we are doing a final link and the last .opd entry is just 16 byte
8198      long, add a 8 byte padding after it.  */
8199   if (need_pad != NULL && !bfd_link_relocatable (info))
8200     {
8201       bfd_byte *p;
8202
8203       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8204         {
8205           BFD_ASSERT (need_pad->size > 0);
8206
8207           p = bfd_malloc (need_pad->size + 8);
8208           if (p == NULL)
8209             return FALSE;
8210
8211           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8212                                           p, 0, need_pad->size))
8213             return FALSE;
8214
8215           need_pad->contents = p;
8216           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8217         }
8218       else
8219         {
8220           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8221           if (p == NULL)
8222             return FALSE;
8223
8224           need_pad->contents = p;
8225         }
8226
8227       memset (need_pad->contents + need_pad->size, 0, 8);
8228       need_pad->size += 8;
8229     }
8230
8231   return TRUE;
8232 }
8233
8234 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8235
8236 asection *
8237 ppc64_elf_tls_setup (struct bfd_link_info *info)
8238 {
8239   struct ppc_link_hash_table *htab;
8240
8241   htab = ppc_hash_table (info);
8242   if (htab == NULL)
8243     return NULL;
8244
8245   if (abiversion (info->output_bfd) == 1)
8246     htab->opd_abi = 1;
8247
8248   if (htab->params->no_multi_toc)
8249     htab->do_multi_toc = 0;
8250   else if (!htab->do_multi_toc)
8251     htab->params->no_multi_toc = 1;
8252
8253   /* Default to --no-plt-localentry, as this option can cause problems
8254      with symbol interposition.  For example, glibc libpthread.so and
8255      libc.so duplicate many pthread symbols, with a fallback
8256      implementation in libc.so.  In some cases the fallback does more
8257      work than the pthread implementation.  __pthread_condattr_destroy
8258      is one such symbol: the libpthread.so implementation is
8259      localentry:0 while the libc.so implementation is localentry:8.
8260      An app that "cleverly" uses dlopen to only load necessary
8261      libraries at runtime may omit loading libpthread.so when not
8262      running multi-threaded, which then results in the libc.so
8263      fallback symbols being used and ld.so complaining.  Now there
8264      are workarounds in ld (see non_zero_localentry) to detect the
8265      pthread situation, but that may not be the only case where
8266      --plt-localentry can cause trouble.  */
8267   if (htab->params->plt_localentry0 < 0)
8268     htab->params->plt_localentry0 = 0;
8269   if (htab->params->plt_localentry0
8270       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8271                                FALSE, FALSE, FALSE) == NULL)
8272     _bfd_error_handler
8273       (_("warning: --plt-localentry is especially dangerous without "
8274          "ld.so support to detect ABI violations"));
8275
8276   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8277                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8278                                               FALSE, FALSE, TRUE));
8279   /* Move dynamic linking info to the function descriptor sym.  */
8280   if (htab->tls_get_addr != NULL)
8281     func_desc_adjust (&htab->tls_get_addr->elf, info);
8282   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8283                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8284                                                  FALSE, FALSE, TRUE));
8285   if (htab->params->tls_get_addr_opt)
8286     {
8287       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8288
8289       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8290                                   FALSE, FALSE, TRUE);
8291       if (opt != NULL)
8292         func_desc_adjust (opt, info);
8293       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8294                                      FALSE, FALSE, TRUE);
8295       if (opt_fd != NULL
8296           && (opt_fd->root.type == bfd_link_hash_defined
8297               || opt_fd->root.type == bfd_link_hash_defweak))
8298         {
8299           /* If glibc supports an optimized __tls_get_addr call stub,
8300              signalled by the presence of __tls_get_addr_opt, and we'll
8301              be calling __tls_get_addr via a plt call stub, then
8302              make __tls_get_addr point to __tls_get_addr_opt.  */
8303           tga_fd = &htab->tls_get_addr_fd->elf;
8304           if (htab->elf.dynamic_sections_created
8305               && tga_fd != NULL
8306               && (tga_fd->type == STT_FUNC
8307                   || tga_fd->needs_plt)
8308               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8309                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8310             {
8311               struct plt_entry *ent;
8312
8313               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8314                 if (ent->plt.refcount > 0)
8315                   break;
8316               if (ent != NULL)
8317                 {
8318                   tga_fd->root.type = bfd_link_hash_indirect;
8319                   tga_fd->root.u.i.link = &opt_fd->root;
8320                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8321                   opt_fd->mark = 1;
8322                   if (opt_fd->dynindx != -1)
8323                     {
8324                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8325                       opt_fd->dynindx = -1;
8326                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8327                                               opt_fd->dynstr_index);
8328                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8329                         return NULL;
8330                     }
8331                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8332                   tga = &htab->tls_get_addr->elf;
8333                   if (opt != NULL && tga != NULL)
8334                     {
8335                       tga->root.type = bfd_link_hash_indirect;
8336                       tga->root.u.i.link = &opt->root;
8337                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8338                       opt->mark = 1;
8339                       _bfd_elf_link_hash_hide_symbol (info, opt,
8340                                                       tga->forced_local);
8341                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8342                     }
8343                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8344                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8345                   if (htab->tls_get_addr != NULL)
8346                     {
8347                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8348                       htab->tls_get_addr->is_func = 1;
8349                     }
8350                 }
8351             }
8352         }
8353       else if (htab->params->tls_get_addr_opt < 0)
8354         htab->params->tls_get_addr_opt = 0;
8355     }
8356   return _bfd_elf_tls_setup (info->output_bfd, info);
8357 }
8358
8359 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8360    HASH1 or HASH2.  */
8361
8362 static bfd_boolean
8363 branch_reloc_hash_match (const bfd *ibfd,
8364                          const Elf_Internal_Rela *rel,
8365                          const struct ppc_link_hash_entry *hash1,
8366                          const struct ppc_link_hash_entry *hash2)
8367 {
8368   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8369   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8370   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8371
8372   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8373     {
8374       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8375       struct elf_link_hash_entry *h;
8376
8377       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8378       h = elf_follow_link (h);
8379       if (h == &hash1->elf || h == &hash2->elf)
8380         return TRUE;
8381     }
8382   return FALSE;
8383 }
8384
8385 /* Run through all the TLS relocs looking for optimization
8386    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8387    a preliminary section layout so that we know the TLS segment
8388    offsets.  We can't optimize earlier because some optimizations need
8389    to know the tp offset, and we need to optimize before allocating
8390    dynamic relocations.  */
8391
8392 bfd_boolean
8393 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8394 {
8395   bfd *ibfd;
8396   asection *sec;
8397   struct ppc_link_hash_table *htab;
8398   unsigned char *toc_ref;
8399   int pass;
8400
8401   if (!bfd_link_executable (info))
8402     return TRUE;
8403
8404   htab = ppc_hash_table (info);
8405   if (htab == NULL)
8406     return FALSE;
8407
8408   /* Make two passes over the relocs.  On the first pass, mark toc
8409      entries involved with tls relocs, and check that tls relocs
8410      involved in setting up a tls_get_addr call are indeed followed by
8411      such a call.  If they are not, we can't do any tls optimization.
8412      On the second pass twiddle tls_mask flags to notify
8413      relocate_section that optimization can be done, and adjust got
8414      and plt refcounts.  */
8415   toc_ref = NULL;
8416   for (pass = 0; pass < 2; ++pass)
8417     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8418       {
8419         Elf_Internal_Sym *locsyms = NULL;
8420         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8421
8422         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8423           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8424             {
8425               Elf_Internal_Rela *relstart, *rel, *relend;
8426               bfd_boolean found_tls_get_addr_arg = 0;
8427
8428               /* Read the relocations.  */
8429               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8430                                                     info->keep_memory);
8431               if (relstart == NULL)
8432                 {
8433                   free (toc_ref);
8434                   return FALSE;
8435                 }
8436
8437               relend = relstart + sec->reloc_count;
8438               for (rel = relstart; rel < relend; rel++)
8439                 {
8440                   enum elf_ppc64_reloc_type r_type;
8441                   unsigned long r_symndx;
8442                   struct elf_link_hash_entry *h;
8443                   Elf_Internal_Sym *sym;
8444                   asection *sym_sec;
8445                   unsigned char *tls_mask;
8446                   unsigned char tls_set, tls_clear, tls_type = 0;
8447                   bfd_vma value;
8448                   bfd_boolean ok_tprel, is_local;
8449                   long toc_ref_index = 0;
8450                   int expecting_tls_get_addr = 0;
8451                   bfd_boolean ret = FALSE;
8452
8453                   r_symndx = ELF64_R_SYM (rel->r_info);
8454                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8455                                   r_symndx, ibfd))
8456                     {
8457                     err_free_rel:
8458                       if (elf_section_data (sec)->relocs != relstart)
8459                         free (relstart);
8460                       if (toc_ref != NULL)
8461                         free (toc_ref);
8462                       if (locsyms != NULL
8463                           && (elf_symtab_hdr (ibfd).contents
8464                               != (unsigned char *) locsyms))
8465                         free (locsyms);
8466                       return ret;
8467                     }
8468
8469                   if (h != NULL)
8470                     {
8471                       if (h->root.type == bfd_link_hash_defined
8472                           || h->root.type == bfd_link_hash_defweak)
8473                         value = h->root.u.def.value;
8474                       else if (h->root.type == bfd_link_hash_undefweak)
8475                         value = 0;
8476                       else
8477                         {
8478                           found_tls_get_addr_arg = 0;
8479                           continue;
8480                         }
8481                     }
8482                   else
8483                     /* Symbols referenced by TLS relocs must be of type
8484                        STT_TLS.  So no need for .opd local sym adjust.  */
8485                     value = sym->st_value;
8486
8487                   ok_tprel = FALSE;
8488                   is_local = FALSE;
8489                   if (h == NULL
8490                       || !h->def_dynamic)
8491                     {
8492                       is_local = TRUE;
8493                       if (h != NULL
8494                           && h->root.type == bfd_link_hash_undefweak)
8495                         ok_tprel = TRUE;
8496                       else if (sym_sec != NULL
8497                                && sym_sec->output_section != NULL)
8498                         {
8499                           value += sym_sec->output_offset;
8500                           value += sym_sec->output_section->vma;
8501                           value -= htab->elf.tls_sec->vma;
8502                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8503                                       < (bfd_vma) 1 << 32);
8504                         }
8505                     }
8506
8507                   r_type = ELF64_R_TYPE (rel->r_info);
8508                   /* If this section has old-style __tls_get_addr calls
8509                      without marker relocs, then check that each
8510                      __tls_get_addr call reloc is preceded by a reloc
8511                      that conceivably belongs to the __tls_get_addr arg
8512                      setup insn.  If we don't find matching arg setup
8513                      relocs, don't do any tls optimization.  */
8514                   if (pass == 0
8515                       && sec->has_tls_get_addr_call
8516                       && h != NULL
8517                       && (h == &htab->tls_get_addr->elf
8518                           || h == &htab->tls_get_addr_fd->elf)
8519                       && !found_tls_get_addr_arg
8520                       && is_branch_reloc (r_type))
8521                     {
8522                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8523                                                 "TLS optimization disabled\n"),
8524                                               ibfd, sec, rel->r_offset);
8525                       ret = TRUE;
8526                       goto err_free_rel;
8527                     }
8528
8529                   found_tls_get_addr_arg = 0;
8530                   switch (r_type)
8531                     {
8532                     case R_PPC64_GOT_TLSLD16:
8533                     case R_PPC64_GOT_TLSLD16_LO:
8534                       expecting_tls_get_addr = 1;
8535                       found_tls_get_addr_arg = 1;
8536                       /* Fall through.  */
8537
8538                     case R_PPC64_GOT_TLSLD16_HI:
8539                     case R_PPC64_GOT_TLSLD16_HA:
8540                       /* These relocs should never be against a symbol
8541                          defined in a shared lib.  Leave them alone if
8542                          that turns out to be the case.  */
8543                       if (!is_local)
8544                         continue;
8545
8546                       /* LD -> LE */
8547                       tls_set = 0;
8548                       tls_clear = TLS_LD;
8549                       tls_type = TLS_TLS | TLS_LD;
8550                       break;
8551
8552                     case R_PPC64_GOT_TLSGD16:
8553                     case R_PPC64_GOT_TLSGD16_LO:
8554                       expecting_tls_get_addr = 1;
8555                       found_tls_get_addr_arg = 1;
8556                       /* Fall through. */
8557
8558                     case R_PPC64_GOT_TLSGD16_HI:
8559                     case R_PPC64_GOT_TLSGD16_HA:
8560                       if (ok_tprel)
8561                         /* GD -> LE */
8562                         tls_set = 0;
8563                       else
8564                         /* GD -> IE */
8565                         tls_set = TLS_TLS | TLS_TPRELGD;
8566                       tls_clear = TLS_GD;
8567                       tls_type = TLS_TLS | TLS_GD;
8568                       break;
8569
8570                     case R_PPC64_GOT_TPREL16_DS:
8571                     case R_PPC64_GOT_TPREL16_LO_DS:
8572                     case R_PPC64_GOT_TPREL16_HI:
8573                     case R_PPC64_GOT_TPREL16_HA:
8574                       if (ok_tprel)
8575                         {
8576                           /* IE -> LE */
8577                           tls_set = 0;
8578                           tls_clear = TLS_TPREL;
8579                           tls_type = TLS_TLS | TLS_TPREL;
8580                           break;
8581                         }
8582                       continue;
8583
8584                     case R_PPC64_TLSGD:
8585                     case R_PPC64_TLSLD:
8586                       found_tls_get_addr_arg = 1;
8587                       /* Fall through.  */
8588
8589                     case R_PPC64_TLS:
8590                     case R_PPC64_TOC16:
8591                     case R_PPC64_TOC16_LO:
8592                       if (sym_sec == NULL || sym_sec != toc)
8593                         continue;
8594
8595                       /* Mark this toc entry as referenced by a TLS
8596                          code sequence.  We can do that now in the
8597                          case of R_PPC64_TLS, and after checking for
8598                          tls_get_addr for the TOC16 relocs.  */
8599                       if (toc_ref == NULL)
8600                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8601                       if (toc_ref == NULL)
8602                         goto err_free_rel;
8603
8604                       if (h != NULL)
8605                         value = h->root.u.def.value;
8606                       else
8607                         value = sym->st_value;
8608                       value += rel->r_addend;
8609                       if (value % 8 != 0)
8610                         continue;
8611                       BFD_ASSERT (value < toc->size
8612                                   && toc->output_offset % 8 == 0);
8613                       toc_ref_index = (value + toc->output_offset) / 8;
8614                       if (r_type == R_PPC64_TLS
8615                           || r_type == R_PPC64_TLSGD
8616                           || r_type == R_PPC64_TLSLD)
8617                         {
8618                           toc_ref[toc_ref_index] = 1;
8619                           continue;
8620                         }
8621
8622                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8623                         continue;
8624
8625                       tls_set = 0;
8626                       tls_clear = 0;
8627                       expecting_tls_get_addr = 2;
8628                       break;
8629
8630                     case R_PPC64_TPREL64:
8631                       if (pass == 0
8632                           || sec != toc
8633                           || toc_ref == NULL
8634                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8635                         continue;
8636                       if (ok_tprel)
8637                         {
8638                           /* IE -> LE */
8639                           tls_set = TLS_EXPLICIT;
8640                           tls_clear = TLS_TPREL;
8641                           break;
8642                         }
8643                       continue;
8644
8645                     case R_PPC64_DTPMOD64:
8646                       if (pass == 0
8647                           || sec != toc
8648                           || toc_ref == NULL
8649                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8650                         continue;
8651                       if (rel + 1 < relend
8652                           && (rel[1].r_info
8653                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8654                           && rel[1].r_offset == rel->r_offset + 8)
8655                         {
8656                           if (ok_tprel)
8657                             /* GD -> LE */
8658                             tls_set = TLS_EXPLICIT | TLS_GD;
8659                           else
8660                             /* GD -> IE */
8661                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8662                           tls_clear = TLS_GD;
8663                         }
8664                       else
8665                         {
8666                           if (!is_local)
8667                             continue;
8668
8669                           /* LD -> LE */
8670                           tls_set = TLS_EXPLICIT;
8671                           tls_clear = TLS_LD;
8672                         }
8673                       break;
8674
8675                     default:
8676                       continue;
8677                     }
8678
8679                   if (pass == 0)
8680                     {
8681                       if (!expecting_tls_get_addr
8682                           || !sec->has_tls_get_addr_call)
8683                         continue;
8684
8685                       if (rel + 1 < relend
8686                           && branch_reloc_hash_match (ibfd, rel + 1,
8687                                                       htab->tls_get_addr,
8688                                                       htab->tls_get_addr_fd))
8689                         {
8690                           if (expecting_tls_get_addr == 2)
8691                             {
8692                               /* Check for toc tls entries.  */
8693                               unsigned char *toc_tls;
8694                               int retval;
8695
8696                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8697                                                      &locsyms,
8698                                                      rel, ibfd);
8699                               if (retval == 0)
8700                                 goto err_free_rel;
8701                               if (toc_tls != NULL)
8702                                 {
8703                                   if ((*toc_tls & TLS_TLS) != 0
8704                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8705                                     found_tls_get_addr_arg = 1;
8706                                   if (retval > 1)
8707                                     toc_ref[toc_ref_index] = 1;
8708                                 }
8709                             }
8710                           continue;
8711                         }
8712
8713                       /* Uh oh, we didn't find the expected call.  We
8714                          could just mark this symbol to exclude it
8715                          from tls optimization but it's safer to skip
8716                          the entire optimization.  */
8717                       /* xgettext:c-format */
8718                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8719                                                 "TLS optimization disabled\n"),
8720                                               ibfd, sec, rel->r_offset);
8721                       ret = TRUE;
8722                       goto err_free_rel;
8723                     }
8724
8725                   /* If we don't have old-style __tls_get_addr calls
8726                      without TLSGD/TLSLD marker relocs, and we haven't
8727                      found a new-style __tls_get_addr call with a
8728                      marker for this symbol, then we either have a
8729                      broken object file or an -mlongcall style
8730                      indirect call to __tls_get_addr without a marker.
8731                      Disable optimization in this case.  */
8732                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8733                       && (tls_set & TLS_EXPLICIT) == 0
8734                       && !sec->has_tls_get_addr_call
8735                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8736                           != (TLS_TLS | TLS_MARK)))
8737                     continue;
8738
8739                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8740                     {
8741                       struct plt_entry *ent;
8742                       for (ent = htab->tls_get_addr->elf.plt.plist;
8743                            ent != NULL;
8744                            ent = ent->next)
8745                         if (ent->addend == 0)
8746                           {
8747                             if (ent->plt.refcount > 0)
8748                               {
8749                                 ent->plt.refcount -= 1;
8750                                 expecting_tls_get_addr = 0;
8751                               }
8752                             break;
8753                           }
8754                     }
8755
8756                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8757                     {
8758                       struct plt_entry *ent;
8759                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8760                            ent != NULL;
8761                            ent = ent->next)
8762                         if (ent->addend == 0)
8763                           {
8764                             if (ent->plt.refcount > 0)
8765                               ent->plt.refcount -= 1;
8766                             break;
8767                           }
8768                     }
8769
8770                   if (tls_clear == 0)
8771                     continue;
8772
8773                   if ((tls_set & TLS_EXPLICIT) == 0)
8774                     {
8775                       struct got_entry *ent;
8776
8777                       /* Adjust got entry for this reloc.  */
8778                       if (h != NULL)
8779                         ent = h->got.glist;
8780                       else
8781                         ent = elf_local_got_ents (ibfd)[r_symndx];
8782
8783                       for (; ent != NULL; ent = ent->next)
8784                         if (ent->addend == rel->r_addend
8785                             && ent->owner == ibfd
8786                             && ent->tls_type == tls_type)
8787                           break;
8788                       if (ent == NULL)
8789                         abort ();
8790
8791                       if (tls_set == 0)
8792                         {
8793                           /* We managed to get rid of a got entry.  */
8794                           if (ent->got.refcount > 0)
8795                             ent->got.refcount -= 1;
8796                         }
8797                     }
8798                   else
8799                     {
8800                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8801                          we'll lose one or two dyn relocs.  */
8802                       if (!dec_dynrel_count (rel->r_info, sec, info,
8803                                              NULL, h, sym))
8804                         return FALSE;
8805
8806                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8807                         {
8808                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8809                                                  NULL, h, sym))
8810                             return FALSE;
8811                         }
8812                     }
8813
8814                   *tls_mask |= tls_set;
8815                   *tls_mask &= ~tls_clear;
8816                 }
8817
8818               if (elf_section_data (sec)->relocs != relstart)
8819                 free (relstart);
8820             }
8821
8822         if (locsyms != NULL
8823             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8824           {
8825             if (!info->keep_memory)
8826               free (locsyms);
8827             else
8828               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8829           }
8830       }
8831
8832   if (toc_ref != NULL)
8833     free (toc_ref);
8834   htab->do_tls_opt = 1;
8835   return TRUE;
8836 }
8837
8838 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8839    the values of any global symbols in a toc section that has been
8840    edited.  Globals in toc sections should be a rarity, so this function
8841    sets a flag if any are found in toc sections other than the one just
8842    edited, so that further hash table traversals can be avoided.  */
8843
8844 struct adjust_toc_info
8845 {
8846   asection *toc;
8847   unsigned long *skip;
8848   bfd_boolean global_toc_syms;
8849 };
8850
8851 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8852
8853 static bfd_boolean
8854 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8855 {
8856   struct ppc_link_hash_entry *eh;
8857   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8858   unsigned long i;
8859
8860   if (h->root.type != bfd_link_hash_defined
8861       && h->root.type != bfd_link_hash_defweak)
8862     return TRUE;
8863
8864   eh = (struct ppc_link_hash_entry *) h;
8865   if (eh->adjust_done)
8866     return TRUE;
8867
8868   if (eh->elf.root.u.def.section == toc_inf->toc)
8869     {
8870       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8871         i = toc_inf->toc->rawsize >> 3;
8872       else
8873         i = eh->elf.root.u.def.value >> 3;
8874
8875       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8876         {
8877           _bfd_error_handler
8878             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8879           do
8880             ++i;
8881           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8882           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8883         }
8884
8885       eh->elf.root.u.def.value -= toc_inf->skip[i];
8886       eh->adjust_done = 1;
8887     }
8888   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8889     toc_inf->global_toc_syms = TRUE;
8890
8891   return TRUE;
8892 }
8893
8894 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8895    on a _LO variety toc/got reloc.  */
8896
8897 static bfd_boolean
8898 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8899 {
8900   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8901           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8902           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8903           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8904           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8905           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8906           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8907           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8908           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8909           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8910           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8911           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8912           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8913           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8914           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8915           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8916           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8917               /* Exclude lfqu by testing reloc.  If relocs are ever
8918                  defined for the reduced D field in psq_lu then those
8919                  will need testing too.  */
8920               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8921           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8922               && (insn & 1) == 0)
8923           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8924           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8925               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8926               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8927           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8928               && (insn & 1) == 0));
8929 }
8930
8931 /* Examine all relocs referencing .toc sections in order to remove
8932    unused .toc entries.  */
8933
8934 bfd_boolean
8935 ppc64_elf_edit_toc (struct bfd_link_info *info)
8936 {
8937   bfd *ibfd;
8938   struct adjust_toc_info toc_inf;
8939   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8940
8941   htab->do_toc_opt = 1;
8942   toc_inf.global_toc_syms = TRUE;
8943   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8944     {
8945       asection *toc, *sec;
8946       Elf_Internal_Shdr *symtab_hdr;
8947       Elf_Internal_Sym *local_syms;
8948       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8949       unsigned long *skip, *drop;
8950       unsigned char *used;
8951       unsigned char *keep, last, some_unused;
8952
8953       if (!is_ppc64_elf (ibfd))
8954         continue;
8955
8956       toc = bfd_get_section_by_name (ibfd, ".toc");
8957       if (toc == NULL
8958           || toc->size == 0
8959           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8960           || discarded_section (toc))
8961         continue;
8962
8963       toc_relocs = NULL;
8964       local_syms = NULL;
8965       symtab_hdr = &elf_symtab_hdr (ibfd);
8966
8967       /* Look at sections dropped from the final link.  */
8968       skip = NULL;
8969       relstart = NULL;
8970       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8971         {
8972           if (sec->reloc_count == 0
8973               || !discarded_section (sec)
8974               || get_opd_info (sec)
8975               || (sec->flags & SEC_ALLOC) == 0
8976               || (sec->flags & SEC_DEBUGGING) != 0)
8977             continue;
8978
8979           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8980           if (relstart == NULL)
8981             goto error_ret;
8982
8983           /* Run through the relocs to see which toc entries might be
8984              unused.  */
8985           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8986             {
8987               enum elf_ppc64_reloc_type r_type;
8988               unsigned long r_symndx;
8989               asection *sym_sec;
8990               struct elf_link_hash_entry *h;
8991               Elf_Internal_Sym *sym;
8992               bfd_vma val;
8993
8994               r_type = ELF64_R_TYPE (rel->r_info);
8995               switch (r_type)
8996                 {
8997                 default:
8998                   continue;
8999
9000                 case R_PPC64_TOC16:
9001                 case R_PPC64_TOC16_LO:
9002                 case R_PPC64_TOC16_HI:
9003                 case R_PPC64_TOC16_HA:
9004                 case R_PPC64_TOC16_DS:
9005                 case R_PPC64_TOC16_LO_DS:
9006                   break;
9007                 }
9008
9009               r_symndx = ELF64_R_SYM (rel->r_info);
9010               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9011                               r_symndx, ibfd))
9012                 goto error_ret;
9013
9014               if (sym_sec != toc)
9015                 continue;
9016
9017               if (h != NULL)
9018                 val = h->root.u.def.value;
9019               else
9020                 val = sym->st_value;
9021               val += rel->r_addend;
9022
9023               if (val >= toc->size)
9024                 continue;
9025
9026               /* Anything in the toc ought to be aligned to 8 bytes.
9027                  If not, don't mark as unused.  */
9028               if (val & 7)
9029                 continue;
9030
9031               if (skip == NULL)
9032                 {
9033                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9034                   if (skip == NULL)
9035                     goto error_ret;
9036                 }
9037
9038               skip[val >> 3] = ref_from_discarded;
9039             }
9040
9041           if (elf_section_data (sec)->relocs != relstart)
9042             free (relstart);
9043         }
9044
9045       /* For largetoc loads of address constants, we can convert
9046          .  addis rx,2,addr@got@ha
9047          .  ld ry,addr@got@l(rx)
9048          to
9049          .  addis rx,2,addr@toc@ha
9050          .  addi ry,rx,addr@toc@l
9051          when addr is within 2G of the toc pointer.  This then means
9052          that the word storing "addr" in the toc is no longer needed.  */
9053
9054       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9055           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9056           && toc->reloc_count != 0)
9057         {
9058           /* Read toc relocs.  */
9059           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9060                                                   info->keep_memory);
9061           if (toc_relocs == NULL)
9062             goto error_ret;
9063
9064           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9065             {
9066               enum elf_ppc64_reloc_type r_type;
9067               unsigned long r_symndx;
9068               asection *sym_sec;
9069               struct elf_link_hash_entry *h;
9070               Elf_Internal_Sym *sym;
9071               bfd_vma val, addr;
9072
9073               r_type = ELF64_R_TYPE (rel->r_info);
9074               if (r_type != R_PPC64_ADDR64)
9075                 continue;
9076
9077               r_symndx = ELF64_R_SYM (rel->r_info);
9078               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9079                               r_symndx, ibfd))
9080                 goto error_ret;
9081
9082               if (sym_sec == NULL
9083                   || sym_sec->output_section == NULL
9084                   || discarded_section (sym_sec))
9085                 continue;
9086
9087               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9088                 continue;
9089
9090               if (h != NULL)
9091                 {
9092                   if (h->type == STT_GNU_IFUNC)
9093                     continue;
9094                   val = h->root.u.def.value;
9095                 }
9096               else
9097                 {
9098                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9099                     continue;
9100                   val = sym->st_value;
9101                 }
9102               val += rel->r_addend;
9103               val += sym_sec->output_section->vma + sym_sec->output_offset;
9104
9105               /* We don't yet know the exact toc pointer value, but we
9106                  know it will be somewhere in the toc section.  Don't
9107                  optimize if the difference from any possible toc
9108                  pointer is outside [ff..f80008000, 7fff7fff].  */
9109               addr = toc->output_section->vma + TOC_BASE_OFF;
9110               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9111                 continue;
9112
9113               addr = toc->output_section->vma + toc->output_section->rawsize;
9114               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9115                 continue;
9116
9117               if (skip == NULL)
9118                 {
9119                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9120                   if (skip == NULL)
9121                     goto error_ret;
9122                 }
9123
9124               skip[rel->r_offset >> 3]
9125                 |= can_optimize | ((rel - toc_relocs) << 2);
9126             }
9127         }
9128
9129       if (skip == NULL)
9130         continue;
9131
9132       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9133       if (used == NULL)
9134         {
9135         error_ret:
9136           if (local_syms != NULL
9137               && symtab_hdr->contents != (unsigned char *) local_syms)
9138             free (local_syms);
9139           if (sec != NULL
9140               && relstart != NULL
9141               && elf_section_data (sec)->relocs != relstart)
9142             free (relstart);
9143           if (toc_relocs != NULL
9144               && elf_section_data (toc)->relocs != toc_relocs)
9145             free (toc_relocs);
9146           if (skip != NULL)
9147             free (skip);
9148           return FALSE;
9149         }
9150
9151       /* Now check all kept sections that might reference the toc.
9152          Check the toc itself last.  */
9153       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9154                   : ibfd->sections);
9155            sec != NULL;
9156            sec = (sec == toc ? NULL
9157                   : sec->next == NULL ? toc
9158                   : sec->next == toc && toc->next ? toc->next
9159                   : sec->next))
9160         {
9161           int repeat;
9162
9163           if (sec->reloc_count == 0
9164               || discarded_section (sec)
9165               || get_opd_info (sec)
9166               || (sec->flags & SEC_ALLOC) == 0
9167               || (sec->flags & SEC_DEBUGGING) != 0)
9168             continue;
9169
9170           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9171                                                 info->keep_memory);
9172           if (relstart == NULL)
9173             {
9174               free (used);
9175               goto error_ret;
9176             }
9177
9178           /* Mark toc entries referenced as used.  */
9179           do
9180             {
9181               repeat = 0;
9182               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9183                 {
9184                   enum elf_ppc64_reloc_type r_type;
9185                   unsigned long r_symndx;
9186                   asection *sym_sec;
9187                   struct elf_link_hash_entry *h;
9188                   Elf_Internal_Sym *sym;
9189                   bfd_vma val;
9190                   enum {no_check, check_lo, check_ha} insn_check;
9191
9192                   r_type = ELF64_R_TYPE (rel->r_info);
9193                   switch (r_type)
9194                     {
9195                     default:
9196                       insn_check = no_check;
9197                       break;
9198
9199                     case R_PPC64_GOT_TLSLD16_HA:
9200                     case R_PPC64_GOT_TLSGD16_HA:
9201                     case R_PPC64_GOT_TPREL16_HA:
9202                     case R_PPC64_GOT_DTPREL16_HA:
9203                     case R_PPC64_GOT16_HA:
9204                     case R_PPC64_TOC16_HA:
9205                       insn_check = check_ha;
9206                       break;
9207
9208                     case R_PPC64_GOT_TLSLD16_LO:
9209                     case R_PPC64_GOT_TLSGD16_LO:
9210                     case R_PPC64_GOT_TPREL16_LO_DS:
9211                     case R_PPC64_GOT_DTPREL16_LO_DS:
9212                     case R_PPC64_GOT16_LO:
9213                     case R_PPC64_GOT16_LO_DS:
9214                     case R_PPC64_TOC16_LO:
9215                     case R_PPC64_TOC16_LO_DS:
9216                       insn_check = check_lo;
9217                       break;
9218                     }
9219
9220                   if (insn_check != no_check)
9221                     {
9222                       bfd_vma off = rel->r_offset & ~3;
9223                       unsigned char buf[4];
9224                       unsigned int insn;
9225
9226                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9227                         {
9228                           free (used);
9229                           goto error_ret;
9230                         }
9231                       insn = bfd_get_32 (ibfd, buf);
9232                       if (insn_check == check_lo
9233                           ? !ok_lo_toc_insn (insn, r_type)
9234                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9235                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9236                         {
9237                           char str[12];
9238
9239                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9240                           sprintf (str, "%#08x", insn);
9241                           info->callbacks->einfo
9242                             /* xgettext:c-format */
9243                             (_("%H: toc optimization is not supported for"
9244                                " %s instruction\n"),
9245                              ibfd, sec, rel->r_offset & ~3, str);
9246                         }
9247                     }
9248
9249                   switch (r_type)
9250                     {
9251                     case R_PPC64_TOC16:
9252                     case R_PPC64_TOC16_LO:
9253                     case R_PPC64_TOC16_HI:
9254                     case R_PPC64_TOC16_HA:
9255                     case R_PPC64_TOC16_DS:
9256                     case R_PPC64_TOC16_LO_DS:
9257                       /* In case we're taking addresses of toc entries.  */
9258                     case R_PPC64_ADDR64:
9259                       break;
9260
9261                     default:
9262                       continue;
9263                     }
9264
9265                   r_symndx = ELF64_R_SYM (rel->r_info);
9266                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9267                                   r_symndx, ibfd))
9268                     {
9269                       free (used);
9270                       goto error_ret;
9271                     }
9272
9273                   if (sym_sec != toc)
9274                     continue;
9275
9276                   if (h != NULL)
9277                     val = h->root.u.def.value;
9278                   else
9279                     val = sym->st_value;
9280                   val += rel->r_addend;
9281
9282                   if (val >= toc->size)
9283                     continue;
9284
9285                   if ((skip[val >> 3] & can_optimize) != 0)
9286                     {
9287                       bfd_vma off;
9288                       unsigned char opc;
9289
9290                       switch (r_type)
9291                         {
9292                         case R_PPC64_TOC16_HA:
9293                           break;
9294
9295                         case R_PPC64_TOC16_LO_DS:
9296                           off = rel->r_offset;
9297                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9298                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9299                                                          off, 1))
9300                             {
9301                               free (used);
9302                               goto error_ret;
9303                             }
9304                           if ((opc & (0x3f << 2)) == (58u << 2))
9305                             break;
9306                           /* Fall through.  */
9307
9308                         default:
9309                           /* Wrong sort of reloc, or not a ld.  We may
9310                              as well clear ref_from_discarded too.  */
9311                           skip[val >> 3] = 0;
9312                         }
9313                     }
9314
9315                   if (sec != toc)
9316                     used[val >> 3] = 1;
9317                   /* For the toc section, we only mark as used if this
9318                      entry itself isn't unused.  */
9319                   else if ((used[rel->r_offset >> 3]
9320                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9321                            && !used[val >> 3])
9322                     {
9323                       /* Do all the relocs again, to catch reference
9324                          chains.  */
9325                       repeat = 1;
9326                       used[val >> 3] = 1;
9327                     }
9328                 }
9329             }
9330           while (repeat);
9331
9332           if (elf_section_data (sec)->relocs != relstart)
9333             free (relstart);
9334         }
9335
9336       /* Merge the used and skip arrays.  Assume that TOC
9337          doublewords not appearing as either used or unused belong
9338          to an entry more than one doubleword in size.  */
9339       for (drop = skip, keep = used, last = 0, some_unused = 0;
9340            drop < skip + (toc->size + 7) / 8;
9341            ++drop, ++keep)
9342         {
9343           if (*keep)
9344             {
9345               *drop &= ~ref_from_discarded;
9346               if ((*drop & can_optimize) != 0)
9347                 some_unused = 1;
9348               last = 0;
9349             }
9350           else if ((*drop & ref_from_discarded) != 0)
9351             {
9352               some_unused = 1;
9353               last = ref_from_discarded;
9354             }
9355           else
9356             *drop = last;
9357         }
9358
9359       free (used);
9360
9361       if (some_unused)
9362         {
9363           bfd_byte *contents, *src;
9364           unsigned long off;
9365           Elf_Internal_Sym *sym;
9366           bfd_boolean local_toc_syms = FALSE;
9367
9368           /* Shuffle the toc contents, and at the same time convert the
9369              skip array from booleans into offsets.  */
9370           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9371             goto error_ret;
9372
9373           elf_section_data (toc)->this_hdr.contents = contents;
9374
9375           for (src = contents, off = 0, drop = skip;
9376                src < contents + toc->size;
9377                src += 8, ++drop)
9378             {
9379               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9380                 off += 8;
9381               else if (off != 0)
9382                 {
9383                   *drop = off;
9384                   memcpy (src - off, src, 8);
9385                 }
9386             }
9387           *drop = off;
9388           toc->rawsize = toc->size;
9389           toc->size = src - contents - off;
9390
9391           /* Adjust addends for relocs against the toc section sym,
9392              and optimize any accesses we can.  */
9393           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9394             {
9395               if (sec->reloc_count == 0
9396                   || discarded_section (sec))
9397                 continue;
9398
9399               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9400                                                     info->keep_memory);
9401               if (relstart == NULL)
9402                 goto error_ret;
9403
9404               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9405                 {
9406                   enum elf_ppc64_reloc_type r_type;
9407                   unsigned long r_symndx;
9408                   asection *sym_sec;
9409                   struct elf_link_hash_entry *h;
9410                   bfd_vma val;
9411
9412                   r_type = ELF64_R_TYPE (rel->r_info);
9413                   switch (r_type)
9414                     {
9415                     default:
9416                       continue;
9417
9418                     case R_PPC64_TOC16:
9419                     case R_PPC64_TOC16_LO:
9420                     case R_PPC64_TOC16_HI:
9421                     case R_PPC64_TOC16_HA:
9422                     case R_PPC64_TOC16_DS:
9423                     case R_PPC64_TOC16_LO_DS:
9424                     case R_PPC64_ADDR64:
9425                       break;
9426                     }
9427
9428                   r_symndx = ELF64_R_SYM (rel->r_info);
9429                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9430                                   r_symndx, ibfd))
9431                     goto error_ret;
9432
9433                   if (sym_sec != toc)
9434                     continue;
9435
9436                   if (h != NULL)
9437                     val = h->root.u.def.value;
9438                   else
9439                     {
9440                       val = sym->st_value;
9441                       if (val != 0)
9442                         local_toc_syms = TRUE;
9443                     }
9444
9445                   val += rel->r_addend;
9446
9447                   if (val > toc->rawsize)
9448                     val = toc->rawsize;
9449                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9450                     continue;
9451                   else if ((skip[val >> 3] & can_optimize) != 0)
9452                     {
9453                       Elf_Internal_Rela *tocrel
9454                         = toc_relocs + (skip[val >> 3] >> 2);
9455                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9456
9457                       switch (r_type)
9458                         {
9459                         case R_PPC64_TOC16_HA:
9460                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9461                           break;
9462
9463                         case R_PPC64_TOC16_LO_DS:
9464                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9465                           break;
9466
9467                         default:
9468                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9469                             ppc_howto_init ();
9470                           info->callbacks->einfo
9471                             /* xgettext:c-format */
9472                             (_("%H: %s references "
9473                                "optimized away TOC entry\n"),
9474                              ibfd, sec, rel->r_offset,
9475                              ppc64_elf_howto_table[r_type]->name);
9476                           bfd_set_error (bfd_error_bad_value);
9477                           goto error_ret;
9478                         }
9479                       rel->r_addend = tocrel->r_addend;
9480                       elf_section_data (sec)->relocs = relstart;
9481                       continue;
9482                     }
9483
9484                   if (h != NULL || sym->st_value != 0)
9485                     continue;
9486
9487                   rel->r_addend -= skip[val >> 3];
9488                   elf_section_data (sec)->relocs = relstart;
9489                 }
9490
9491               if (elf_section_data (sec)->relocs != relstart)
9492                 free (relstart);
9493             }
9494
9495           /* We shouldn't have local or global symbols defined in the TOC,
9496              but handle them anyway.  */
9497           if (local_syms != NULL)
9498             for (sym = local_syms;
9499                  sym < local_syms + symtab_hdr->sh_info;
9500                  ++sym)
9501               if (sym->st_value != 0
9502                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9503                 {
9504                   unsigned long i;
9505
9506                   if (sym->st_value > toc->rawsize)
9507                     i = toc->rawsize >> 3;
9508                   else
9509                     i = sym->st_value >> 3;
9510
9511                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9512                     {
9513                       if (local_toc_syms)
9514                         _bfd_error_handler
9515                           (_("%s defined on removed toc entry"),
9516                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9517                       do
9518                         ++i;
9519                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9520                       sym->st_value = (bfd_vma) i << 3;
9521                     }
9522
9523                   sym->st_value -= skip[i];
9524                   symtab_hdr->contents = (unsigned char *) local_syms;
9525                 }
9526
9527           /* Adjust any global syms defined in this toc input section.  */
9528           if (toc_inf.global_toc_syms)
9529             {
9530               toc_inf.toc = toc;
9531               toc_inf.skip = skip;
9532               toc_inf.global_toc_syms = FALSE;
9533               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9534                                       &toc_inf);
9535             }
9536
9537           if (toc->reloc_count != 0)
9538             {
9539               Elf_Internal_Shdr *rel_hdr;
9540               Elf_Internal_Rela *wrel;
9541               bfd_size_type sz;
9542
9543               /* Remove unused toc relocs, and adjust those we keep.  */
9544               if (toc_relocs == NULL)
9545                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9546                                                         info->keep_memory);
9547               if (toc_relocs == NULL)
9548                 goto error_ret;
9549
9550               wrel = toc_relocs;
9551               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9552                 if ((skip[rel->r_offset >> 3]
9553                      & (ref_from_discarded | can_optimize)) == 0)
9554                   {
9555                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9556                     wrel->r_info = rel->r_info;
9557                     wrel->r_addend = rel->r_addend;
9558                     ++wrel;
9559                   }
9560                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9561                                             &local_syms, NULL, NULL))
9562                   goto error_ret;
9563
9564               elf_section_data (toc)->relocs = toc_relocs;
9565               toc->reloc_count = wrel - toc_relocs;
9566               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9567               sz = rel_hdr->sh_entsize;
9568               rel_hdr->sh_size = toc->reloc_count * sz;
9569             }
9570         }
9571       else if (toc_relocs != NULL
9572                && elf_section_data (toc)->relocs != toc_relocs)
9573         free (toc_relocs);
9574
9575       if (local_syms != NULL
9576           && symtab_hdr->contents != (unsigned char *) local_syms)
9577         {
9578           if (!info->keep_memory)
9579             free (local_syms);
9580           else
9581             symtab_hdr->contents = (unsigned char *) local_syms;
9582         }
9583       free (skip);
9584     }
9585
9586   return TRUE;
9587 }
9588
9589 /* Return true iff input section I references the TOC using
9590    instructions limited to +/-32k offsets.  */
9591
9592 bfd_boolean
9593 ppc64_elf_has_small_toc_reloc (asection *i)
9594 {
9595   return (is_ppc64_elf (i->owner)
9596           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9597 }
9598
9599 /* Allocate space for one GOT entry.  */
9600
9601 static void
9602 allocate_got (struct elf_link_hash_entry *h,
9603               struct bfd_link_info *info,
9604               struct got_entry *gent)
9605 {
9606   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9607   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9608   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9609                  ? 16 : 8);
9610   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9611                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9612   asection *got = ppc64_elf_tdata (gent->owner)->got;
9613
9614   gent->got.offset = got->size;
9615   got->size += entsize;
9616
9617   if (h->type == STT_GNU_IFUNC)
9618     {
9619       htab->elf.irelplt->size += rentsize;
9620       htab->got_reli_size += rentsize;
9621     }
9622   else if (((bfd_link_pic (info)
9623              && !((gent->tls_type & TLS_TPREL) != 0
9624                   && bfd_link_executable (info)
9625                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9626             || (htab->elf.dynamic_sections_created
9627                 && h->dynindx != -1
9628                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9629            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9630     {
9631       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9632       relgot->size += rentsize;
9633     }
9634 }
9635
9636 /* This function merges got entries in the same toc group.  */
9637
9638 static void
9639 merge_got_entries (struct got_entry **pent)
9640 {
9641   struct got_entry *ent, *ent2;
9642
9643   for (ent = *pent; ent != NULL; ent = ent->next)
9644     if (!ent->is_indirect)
9645       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9646         if (!ent2->is_indirect
9647             && ent2->addend == ent->addend
9648             && ent2->tls_type == ent->tls_type
9649             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9650           {
9651             ent2->is_indirect = TRUE;
9652             ent2->got.ent = ent;
9653           }
9654 }
9655
9656 /* If H is undefined, make it dynamic if that makes sense.  */
9657
9658 static bfd_boolean
9659 ensure_undef_dynamic (struct bfd_link_info *info,
9660                       struct elf_link_hash_entry *h)
9661 {
9662   struct elf_link_hash_table *htab = elf_hash_table (info);
9663
9664   if (htab->dynamic_sections_created
9665       && ((info->dynamic_undefined_weak != 0
9666            && h->root.type == bfd_link_hash_undefweak)
9667           || h->root.type == bfd_link_hash_undefined)
9668       && h->dynindx == -1
9669       && !h->forced_local
9670       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9671     return bfd_elf_link_record_dynamic_symbol (info, h);
9672   return TRUE;
9673 }
9674
9675 /* Allocate space in .plt, .got and associated reloc sections for
9676    dynamic relocs.  */
9677
9678 static bfd_boolean
9679 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9680 {
9681   struct bfd_link_info *info;
9682   struct ppc_link_hash_table *htab;
9683   asection *s;
9684   struct ppc_link_hash_entry *eh;
9685   struct got_entry **pgent, *gent;
9686
9687   if (h->root.type == bfd_link_hash_indirect)
9688     return TRUE;
9689
9690   info = (struct bfd_link_info *) inf;
9691   htab = ppc_hash_table (info);
9692   if (htab == NULL)
9693     return FALSE;
9694
9695   eh = (struct ppc_link_hash_entry *) h;
9696   /* Run through the TLS GD got entries first if we're changing them
9697      to TPREL.  */
9698   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9699     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9700       if (gent->got.refcount > 0
9701           && (gent->tls_type & TLS_GD) != 0)
9702         {
9703           /* This was a GD entry that has been converted to TPREL.  If
9704              there happens to be a TPREL entry we can use that one.  */
9705           struct got_entry *ent;
9706           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9707             if (ent->got.refcount > 0
9708                 && (ent->tls_type & TLS_TPREL) != 0
9709                 && ent->addend == gent->addend
9710                 && ent->owner == gent->owner)
9711               {
9712                 gent->got.refcount = 0;
9713                 break;
9714               }
9715
9716           /* If not, then we'll be using our own TPREL entry.  */
9717           if (gent->got.refcount != 0)
9718             gent->tls_type = TLS_TLS | TLS_TPREL;
9719         }
9720
9721   /* Remove any list entry that won't generate a word in the GOT before
9722      we call merge_got_entries.  Otherwise we risk merging to empty
9723      entries.  */
9724   pgent = &h->got.glist;
9725   while ((gent = *pgent) != NULL)
9726     if (gent->got.refcount > 0)
9727       {
9728         if ((gent->tls_type & TLS_LD) != 0
9729             && !h->def_dynamic)
9730           {
9731             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9732             *pgent = gent->next;
9733           }
9734         else
9735           pgent = &gent->next;
9736       }
9737     else
9738       *pgent = gent->next;
9739
9740   if (!htab->do_multi_toc)
9741     merge_got_entries (&h->got.glist);
9742
9743   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9744     if (!gent->is_indirect)
9745       {
9746         /* Make sure this symbol is output as a dynamic symbol.  */
9747         if (!ensure_undef_dynamic (info, h))
9748           return FALSE;
9749
9750         if (!is_ppc64_elf (gent->owner))
9751           abort ();
9752
9753         allocate_got (h, info, gent);
9754       }
9755
9756   /* If no dynamic sections we can't have dynamic relocs, except for
9757      IFUNCs which are handled even in static executables.  */
9758   if (!htab->elf.dynamic_sections_created
9759       && h->type != STT_GNU_IFUNC)
9760     eh->dyn_relocs = NULL;
9761
9762   /* Discard relocs on undefined symbols that must be local.  */
9763   else if (h->root.type == bfd_link_hash_undefined
9764            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9765     eh->dyn_relocs = NULL;
9766
9767   /* Also discard relocs on undefined weak syms with non-default
9768      visibility, or when dynamic_undefined_weak says so.  */
9769   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9770     eh->dyn_relocs = NULL;
9771
9772   if (eh->dyn_relocs != NULL)
9773     {
9774       struct elf_dyn_relocs *p, **pp;
9775
9776       /* In the shared -Bsymbolic case, discard space allocated for
9777          dynamic pc-relative relocs against symbols which turn out to
9778          be defined in regular objects.  For the normal shared case,
9779          discard space for relocs that have become local due to symbol
9780          visibility changes.  */
9781
9782       if (bfd_link_pic (info))
9783         {
9784           /* Relocs that use pc_count are those that appear on a call
9785              insn, or certain REL relocs (see must_be_dyn_reloc) that
9786              can be generated via assembly.  We want calls to
9787              protected symbols to resolve directly to the function
9788              rather than going via the plt.  If people want function
9789              pointer comparisons to work as expected then they should
9790              avoid writing weird assembly.  */
9791           if (SYMBOL_CALLS_LOCAL (info, h))
9792             {
9793               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9794                 {
9795                   p->count -= p->pc_count;
9796                   p->pc_count = 0;
9797                   if (p->count == 0)
9798                     *pp = p->next;
9799                   else
9800                     pp = &p->next;
9801                 }
9802             }
9803
9804           if (eh->dyn_relocs != NULL)
9805             {
9806               /* Make sure this symbol is output as a dynamic symbol.  */
9807               if (!ensure_undef_dynamic (info, h))
9808                 return FALSE;
9809             }
9810         }
9811       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9812         {
9813           /* For the non-pic case, discard space for relocs against
9814              symbols which turn out to need copy relocs or are not
9815              dynamic.  */
9816           if (h->dynamic_adjusted
9817               && !h->def_regular
9818               && !ELF_COMMON_DEF_P (h))
9819             {
9820               /* Make sure this symbol is output as a dynamic symbol.  */
9821               if (!ensure_undef_dynamic (info, h))
9822                 return FALSE;
9823
9824               if (h->dynindx == -1)
9825                 eh->dyn_relocs = NULL;
9826             }
9827           else
9828             eh->dyn_relocs = NULL;
9829         }
9830
9831       /* Finally, allocate space.  */
9832       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9833         {
9834           asection *sreloc = elf_section_data (p->sec)->sreloc;
9835           if (eh->elf.type == STT_GNU_IFUNC)
9836             sreloc = htab->elf.irelplt;
9837           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9838         }
9839     }
9840
9841   /* We might need a PLT entry when the symbol
9842      a) is dynamic, or
9843      b) is an ifunc, or
9844      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9845      d) has plt16 relocs and we are linking statically.  */
9846   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
9847       || h->type == STT_GNU_IFUNC
9848       || (h->needs_plt && h->dynamic_adjusted)
9849       || (h->needs_plt
9850           && h->def_regular
9851           && !htab->elf.dynamic_sections_created
9852           && (((struct ppc_link_hash_entry *) h)->tls_mask
9853               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
9854     {
9855       struct plt_entry *pent;
9856       bfd_boolean doneone = FALSE;
9857       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9858         if (pent->plt.refcount > 0)
9859           {
9860             if (!htab->elf.dynamic_sections_created
9861                 || h->dynindx == -1)
9862               {
9863                 if (h->type == STT_GNU_IFUNC)
9864                   {
9865                     s = htab->elf.iplt;
9866                     pent->plt.offset = s->size;
9867                     s->size += PLT_ENTRY_SIZE (htab);
9868                     s = htab->elf.irelplt;
9869                   }
9870                 else
9871                   {
9872                     s = htab->pltlocal;
9873                     pent->plt.offset = s->size;
9874                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
9875                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
9876                   }
9877               }
9878             else
9879               {
9880                 /* If this is the first .plt entry, make room for the special
9881                    first entry.  */
9882                 s = htab->elf.splt;
9883                 if (s->size == 0)
9884                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9885
9886                 pent->plt.offset = s->size;
9887
9888                 /* Make room for this entry.  */
9889                 s->size += PLT_ENTRY_SIZE (htab);
9890
9891                 /* Make room for the .glink code.  */
9892                 s = htab->glink;
9893                 if (s->size == 0)
9894                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
9895                 if (htab->opd_abi)
9896                   {
9897                     /* We need bigger stubs past index 32767.  */
9898                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9899                       s->size += 4;
9900                     s->size += 2*4;
9901                   }
9902                 else
9903                   s->size += 4;
9904
9905                 /* We also need to make an entry in the .rela.plt section.  */
9906                 s = htab->elf.srelplt;
9907               }
9908             if (s != NULL)
9909               s->size += sizeof (Elf64_External_Rela);
9910             doneone = TRUE;
9911           }
9912         else
9913           pent->plt.offset = (bfd_vma) -1;
9914       if (!doneone)
9915         {
9916           h->plt.plist = NULL;
9917           h->needs_plt = 0;
9918         }
9919     }
9920   else
9921     {
9922       h->plt.plist = NULL;
9923       h->needs_plt = 0;
9924     }
9925
9926   return TRUE;
9927 }
9928
9929 #define PPC_LO(v) ((v) & 0xffff)
9930 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9931 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9932
9933 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9934    to set up space for global entry stubs.  These are put in glink,
9935    after the branch table.  */
9936
9937 static bfd_boolean
9938 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9939 {
9940   struct bfd_link_info *info;
9941   struct ppc_link_hash_table *htab;
9942   struct plt_entry *pent;
9943   asection *s, *plt;
9944
9945   if (h->root.type == bfd_link_hash_indirect)
9946     return TRUE;
9947
9948   if (!h->pointer_equality_needed)
9949     return TRUE;
9950
9951   if (h->def_regular)
9952     return TRUE;
9953
9954   info = inf;
9955   htab = ppc_hash_table (info);
9956   if (htab == NULL)
9957     return FALSE;
9958
9959   s = htab->global_entry;
9960   plt = htab->elf.splt;
9961   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9962     if (pent->plt.offset != (bfd_vma) -1
9963         && pent->addend == 0)
9964       {
9965         /* For ELFv2, if this symbol is not defined in a regular file
9966            and we are not generating a shared library or pie, then we
9967            need to define the symbol in the executable on a call stub.
9968            This is to avoid text relocations.  */
9969         bfd_vma off, stub_align, stub_off, stub_size;
9970         unsigned int align_power;
9971
9972         stub_size = 16;
9973         stub_off = s->size;
9974         if (htab->params->plt_stub_align >= 0)
9975           align_power = htab->params->plt_stub_align;
9976         else
9977           align_power = -htab->params->plt_stub_align;
9978         /* Setting section alignment is delayed until we know it is
9979            non-empty.  Otherwise the .text output section will be
9980            aligned at least to plt_stub_align even when no global
9981            entry stubs are needed.  */
9982         if (s->alignment_power < align_power)
9983           s->alignment_power = align_power;
9984         stub_align = (bfd_vma) 1 << align_power;
9985         if (htab->params->plt_stub_align >= 0
9986             || ((((stub_off + stub_size - 1) & -stub_align)
9987                  - (stub_off & -stub_align))
9988                 > ((stub_size - 1) & -stub_align)))
9989           stub_off = (stub_off + stub_align - 1) & -stub_align;
9990         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9991         off -= stub_off + s->output_offset + s->output_section->vma;
9992         /* Note that for --plt-stub-align negative we have a possible
9993            dependency between stub offset and size.  Break that
9994            dependency by assuming the max stub size when calculating
9995            the stub offset.  */
9996         if (PPC_HA (off) == 0)
9997           stub_size -= 4;
9998         h->root.type = bfd_link_hash_defined;
9999         h->root.u.def.section = s;
10000         h->root.u.def.value = stub_off;
10001         s->size = stub_off + stub_size;
10002         break;
10003       }
10004   return TRUE;
10005 }
10006
10007 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10008    read-only sections.  */
10009
10010 static bfd_boolean
10011 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10012 {
10013   asection *sec;
10014
10015   if (h->root.type == bfd_link_hash_indirect)
10016     return TRUE;
10017
10018   sec = readonly_dynrelocs (h);
10019   if (sec != NULL)
10020     {
10021       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10022
10023       info->flags |= DF_TEXTREL;
10024       info->callbacks->minfo
10025         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10026          sec->owner, h->root.root.string, sec);
10027
10028       /* Not an error, just cut short the traversal.  */
10029       return FALSE;
10030     }
10031   return TRUE;
10032 }
10033
10034 /* Set the sizes of the dynamic sections.  */
10035
10036 static bfd_boolean
10037 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10038                                  struct bfd_link_info *info)
10039 {
10040   struct ppc_link_hash_table *htab;
10041   bfd *dynobj;
10042   asection *s;
10043   bfd_boolean relocs;
10044   bfd *ibfd;
10045   struct got_entry *first_tlsld;
10046
10047   htab = ppc_hash_table (info);
10048   if (htab == NULL)
10049     return FALSE;
10050
10051   dynobj = htab->elf.dynobj;
10052   if (dynobj == NULL)
10053     abort ();
10054
10055   if (htab->elf.dynamic_sections_created)
10056     {
10057       /* Set the contents of the .interp section to the interpreter.  */
10058       if (bfd_link_executable (info) && !info->nointerp)
10059         {
10060           s = bfd_get_linker_section (dynobj, ".interp");
10061           if (s == NULL)
10062             abort ();
10063           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10064           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10065         }
10066     }
10067
10068   /* Set up .got offsets for local syms, and space for local dynamic
10069      relocs.  */
10070   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10071     {
10072       struct got_entry **lgot_ents;
10073       struct got_entry **end_lgot_ents;
10074       struct plt_entry **local_plt;
10075       struct plt_entry **end_local_plt;
10076       unsigned char *lgot_masks;
10077       bfd_size_type locsymcount;
10078       Elf_Internal_Shdr *symtab_hdr;
10079
10080       if (!is_ppc64_elf (ibfd))
10081         continue;
10082
10083       for (s = ibfd->sections; s != NULL; s = s->next)
10084         {
10085           struct ppc_dyn_relocs *p;
10086
10087           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10088             {
10089               if (!bfd_is_abs_section (p->sec)
10090                   && bfd_is_abs_section (p->sec->output_section))
10091                 {
10092                   /* Input section has been discarded, either because
10093                      it is a copy of a linkonce section or due to
10094                      linker script /DISCARD/, so we'll be discarding
10095                      the relocs too.  */
10096                 }
10097               else if (p->count != 0)
10098                 {
10099                   asection *srel = elf_section_data (p->sec)->sreloc;
10100                   if (p->ifunc)
10101                     srel = htab->elf.irelplt;
10102                   srel->size += p->count * sizeof (Elf64_External_Rela);
10103                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10104                     info->flags |= DF_TEXTREL;
10105                 }
10106             }
10107         }
10108
10109       lgot_ents = elf_local_got_ents (ibfd);
10110       if (!lgot_ents)
10111         continue;
10112
10113       symtab_hdr = &elf_symtab_hdr (ibfd);
10114       locsymcount = symtab_hdr->sh_info;
10115       end_lgot_ents = lgot_ents + locsymcount;
10116       local_plt = (struct plt_entry **) end_lgot_ents;
10117       end_local_plt = local_plt + locsymcount;
10118       lgot_masks = (unsigned char *) end_local_plt;
10119       s = ppc64_elf_tdata (ibfd)->got;
10120       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10121         {
10122           struct got_entry **pent, *ent;
10123
10124           pent = lgot_ents;
10125           while ((ent = *pent) != NULL)
10126             if (ent->got.refcount > 0)
10127               {
10128                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10129                   {
10130                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10131                     *pent = ent->next;
10132                   }
10133                 else
10134                   {
10135                     unsigned int ent_size = 8;
10136                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10137
10138                     ent->got.offset = s->size;
10139                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10140                       {
10141                         ent_size *= 2;
10142                         rel_size *= 2;
10143                       }
10144                     s->size += ent_size;
10145                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10146                       {
10147                         htab->elf.irelplt->size += rel_size;
10148                         htab->got_reli_size += rel_size;
10149                       }
10150                     else if (bfd_link_pic (info)
10151                              && !((ent->tls_type & TLS_TPREL) != 0
10152                                   && bfd_link_executable (info)))
10153                       {
10154                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10155                         srel->size += rel_size;
10156                       }
10157                     pent = &ent->next;
10158                   }
10159               }
10160             else
10161               *pent = ent->next;
10162         }
10163
10164       /* Allocate space for plt calls to local syms.  */
10165       lgot_masks = (unsigned char *) end_local_plt;
10166       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10167         {
10168           struct plt_entry *ent;
10169
10170           for (ent = *local_plt; ent != NULL; ent = ent->next)
10171             if (ent->plt.refcount > 0)
10172               {
10173                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10174                   {
10175                     s = htab->elf.iplt;
10176                     ent->plt.offset = s->size;
10177                     s->size += PLT_ENTRY_SIZE (htab);
10178                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10179                   }
10180                 else if ((*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10181                   ent->plt.offset = (bfd_vma) -1;
10182                 else
10183                   {
10184                     s = htab->pltlocal;
10185                     ent->plt.offset = s->size;
10186                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10187                     if (bfd_link_pic (info))
10188                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10189                   }
10190               }
10191             else
10192               ent->plt.offset = (bfd_vma) -1;
10193         }
10194     }
10195
10196   /* Allocate global sym .plt and .got entries, and space for global
10197      sym dynamic relocs.  */
10198   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10199
10200   if (!htab->opd_abi && !bfd_link_pic (info))
10201     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10202
10203   first_tlsld = NULL;
10204   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10205     {
10206       struct got_entry *ent;
10207
10208       if (!is_ppc64_elf (ibfd))
10209         continue;
10210
10211       ent = ppc64_tlsld_got (ibfd);
10212       if (ent->got.refcount > 0)
10213         {
10214           if (!htab->do_multi_toc && first_tlsld != NULL)
10215             {
10216               ent->is_indirect = TRUE;
10217               ent->got.ent = first_tlsld;
10218             }
10219           else
10220             {
10221               if (first_tlsld == NULL)
10222                 first_tlsld = ent;
10223               s = ppc64_elf_tdata (ibfd)->got;
10224               ent->got.offset = s->size;
10225               ent->owner = ibfd;
10226               s->size += 16;
10227               if (bfd_link_pic (info))
10228                 {
10229                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10230                   srel->size += sizeof (Elf64_External_Rela);
10231                 }
10232             }
10233         }
10234       else
10235         ent->got.offset = (bfd_vma) -1;
10236     }
10237
10238   /* We now have determined the sizes of the various dynamic sections.
10239      Allocate memory for them.  */
10240   relocs = FALSE;
10241   for (s = dynobj->sections; s != NULL; s = s->next)
10242     {
10243       if ((s->flags & SEC_LINKER_CREATED) == 0)
10244         continue;
10245
10246       if (s == htab->brlt || s == htab->relbrlt)
10247         /* These haven't been allocated yet;  don't strip.  */
10248         continue;
10249       else if (s == htab->elf.sgot
10250                || s == htab->elf.splt
10251                || s == htab->elf.iplt
10252                || s == htab->pltlocal
10253                || s == htab->glink
10254                || s == htab->global_entry
10255                || s == htab->elf.sdynbss
10256                || s == htab->elf.sdynrelro)
10257         {
10258           /* Strip this section if we don't need it; see the
10259              comment below.  */
10260         }
10261       else if (s == htab->glink_eh_frame)
10262         {
10263           if (!bfd_is_abs_section (s->output_section))
10264             /* Not sized yet.  */
10265             continue;
10266         }
10267       else if (CONST_STRNEQ (s->name, ".rela"))
10268         {
10269           if (s->size != 0)
10270             {
10271               if (s != htab->elf.srelplt)
10272                 relocs = TRUE;
10273
10274               /* We use the reloc_count field as a counter if we need
10275                  to copy relocs into the output file.  */
10276               s->reloc_count = 0;
10277             }
10278         }
10279       else
10280         {
10281           /* It's not one of our sections, so don't allocate space.  */
10282           continue;
10283         }
10284
10285       if (s->size == 0)
10286         {
10287           /* If we don't need this section, strip it from the
10288              output file.  This is mostly to handle .rela.bss and
10289              .rela.plt.  We must create both sections in
10290              create_dynamic_sections, because they must be created
10291              before the linker maps input sections to output
10292              sections.  The linker does that before
10293              adjust_dynamic_symbol is called, and it is that
10294              function which decides whether anything needs to go
10295              into these sections.  */
10296           s->flags |= SEC_EXCLUDE;
10297           continue;
10298         }
10299
10300       if (bfd_is_abs_section (s->output_section))
10301         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10302                             s->name);
10303
10304       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10305         continue;
10306
10307       /* Allocate memory for the section contents.  We use bfd_zalloc
10308          here in case unused entries are not reclaimed before the
10309          section's contents are written out.  This should not happen,
10310          but this way if it does we get a R_PPC64_NONE reloc in .rela
10311          sections instead of garbage.
10312          We also rely on the section contents being zero when writing
10313          the GOT and .dynrelro.  */
10314       s->contents = bfd_zalloc (dynobj, s->size);
10315       if (s->contents == NULL)
10316         return FALSE;
10317     }
10318
10319   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10320     {
10321       if (!is_ppc64_elf (ibfd))
10322         continue;
10323
10324       s = ppc64_elf_tdata (ibfd)->got;
10325       if (s != NULL && s != htab->elf.sgot)
10326         {
10327           if (s->size == 0)
10328             s->flags |= SEC_EXCLUDE;
10329           else
10330             {
10331               s->contents = bfd_zalloc (ibfd, s->size);
10332               if (s->contents == NULL)
10333                 return FALSE;
10334             }
10335         }
10336       s = ppc64_elf_tdata (ibfd)->relgot;
10337       if (s != NULL)
10338         {
10339           if (s->size == 0)
10340             s->flags |= SEC_EXCLUDE;
10341           else
10342             {
10343               s->contents = bfd_zalloc (ibfd, s->size);
10344               if (s->contents == NULL)
10345                 return FALSE;
10346               relocs = TRUE;
10347               s->reloc_count = 0;
10348             }
10349         }
10350     }
10351
10352   if (htab->elf.dynamic_sections_created)
10353     {
10354       bfd_boolean tls_opt;
10355
10356       /* Add some entries to the .dynamic section.  We fill in the
10357          values later, in ppc64_elf_finish_dynamic_sections, but we
10358          must add the entries now so that we get the correct size for
10359          the .dynamic section.  The DT_DEBUG entry is filled in by the
10360          dynamic linker and used by the debugger.  */
10361 #define add_dynamic_entry(TAG, VAL) \
10362   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10363
10364       if (bfd_link_executable (info))
10365         {
10366           if (!add_dynamic_entry (DT_DEBUG, 0))
10367             return FALSE;
10368         }
10369
10370       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10371         {
10372           if (!add_dynamic_entry (DT_PLTGOT, 0)
10373               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10374               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10375               || !add_dynamic_entry (DT_JMPREL, 0)
10376               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10377             return FALSE;
10378         }
10379
10380       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10381         {
10382           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10383               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10384             return FALSE;
10385         }
10386
10387       tls_opt = (htab->params->tls_get_addr_opt
10388                  && htab->tls_get_addr_fd != NULL
10389                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10390       if (tls_opt || !htab->opd_abi)
10391         {
10392           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10393             return FALSE;
10394         }
10395
10396       if (relocs)
10397         {
10398           if (!add_dynamic_entry (DT_RELA, 0)
10399               || !add_dynamic_entry (DT_RELASZ, 0)
10400               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10401             return FALSE;
10402
10403           /* If any dynamic relocs apply to a read-only section,
10404              then we need a DT_TEXTREL entry.  */
10405           if ((info->flags & DF_TEXTREL) == 0)
10406             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10407
10408           if ((info->flags & DF_TEXTREL) != 0)
10409             {
10410               if (!add_dynamic_entry (DT_TEXTREL, 0))
10411                 return FALSE;
10412             }
10413         }
10414     }
10415 #undef add_dynamic_entry
10416
10417   return TRUE;
10418 }
10419
10420 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10421
10422 static bfd_boolean
10423 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10424 {
10425   if (h->plt.plist != NULL
10426       && !h->def_regular
10427       && !h->pointer_equality_needed)
10428     return FALSE;
10429
10430   return _bfd_elf_hash_symbol (h);
10431 }
10432
10433 /* Determine the type of stub needed, if any, for a call.  */
10434
10435 static inline enum ppc_stub_type
10436 ppc_type_of_stub (asection *input_sec,
10437                   const Elf_Internal_Rela *rel,
10438                   struct ppc_link_hash_entry **hash,
10439                   struct plt_entry **plt_ent,
10440                   bfd_vma destination,
10441                   unsigned long local_off)
10442 {
10443   struct ppc_link_hash_entry *h = *hash;
10444   bfd_vma location;
10445   bfd_vma branch_offset;
10446   bfd_vma max_branch_offset;
10447   enum elf_ppc64_reloc_type r_type;
10448
10449   if (h != NULL)
10450     {
10451       struct plt_entry *ent;
10452       struct ppc_link_hash_entry *fdh = h;
10453       if (h->oh != NULL
10454           && h->oh->is_func_descriptor)
10455         {
10456           fdh = ppc_follow_link (h->oh);
10457           *hash = fdh;
10458         }
10459
10460       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10461         if (ent->addend == rel->r_addend
10462             && ent->plt.offset != (bfd_vma) -1)
10463           {
10464             *plt_ent = ent;
10465             return ppc_stub_plt_call;
10466           }
10467
10468       /* Here, we know we don't have a plt entry.  If we don't have a
10469          either a defined function descriptor or a defined entry symbol
10470          in a regular object file, then it is pointless trying to make
10471          any other type of stub.  */
10472       if (!is_static_defined (&fdh->elf)
10473           && !is_static_defined (&h->elf))
10474         return ppc_stub_none;
10475     }
10476   else if (elf_local_got_ents (input_sec->owner) != NULL)
10477     {
10478       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10479       struct plt_entry **local_plt = (struct plt_entry **)
10480         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10481       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10482
10483       if (local_plt[r_symndx] != NULL)
10484         {
10485           struct plt_entry *ent;
10486
10487           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10488             if (ent->addend == rel->r_addend
10489                 && ent->plt.offset != (bfd_vma) -1)
10490               {
10491                 *plt_ent = ent;
10492                 return ppc_stub_plt_call;
10493               }
10494         }
10495     }
10496
10497   /* Determine where the call point is.  */
10498   location = (input_sec->output_offset
10499               + input_sec->output_section->vma
10500               + rel->r_offset);
10501
10502   branch_offset = destination - location;
10503   r_type = ELF64_R_TYPE (rel->r_info);
10504
10505   /* Determine if a long branch stub is needed.  */
10506   max_branch_offset = 1 << 25;
10507   if (r_type != R_PPC64_REL24)
10508     max_branch_offset = 1 << 15;
10509
10510   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10511     /* We need a stub.  Figure out whether a long_branch or plt_branch
10512        is needed later.  */
10513     return ppc_stub_long_branch;
10514
10515   return ppc_stub_none;
10516 }
10517
10518 /* With power7 weakly ordered memory model, it is possible for ld.so
10519    to update a plt entry in one thread and have another thread see a
10520    stale zero toc entry.  To avoid this we need some sort of acquire
10521    barrier in the call stub.  One solution is to make the load of the
10522    toc word seem to appear to depend on the load of the function entry
10523    word.  Another solution is to test for r2 being zero, and branch to
10524    the appropriate glink entry if so.
10525
10526    .    fake dep barrier        compare
10527    .    ld 12,xxx(2)            ld 12,xxx(2)
10528    .    mtctr 12                mtctr 12
10529    .    xor 11,12,12            ld 2,xxx+8(2)
10530    .    add 2,2,11              cmpldi 2,0
10531    .    ld 2,xxx+8(2)           bnectr+
10532    .    bctr                    b <glink_entry>
10533
10534    The solution involving the compare turns out to be faster, so
10535    that's what we use unless the branch won't reach.  */
10536
10537 #define ALWAYS_USE_FAKE_DEP 0
10538 #define ALWAYS_EMIT_R2SAVE 0
10539
10540 static inline unsigned int
10541 plt_stub_size (struct ppc_link_hash_table *htab,
10542                struct ppc_stub_hash_entry *stub_entry,
10543                bfd_vma off)
10544 {
10545   unsigned size = 12;
10546
10547   if (ALWAYS_EMIT_R2SAVE
10548       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10549     size += 4;
10550   if (PPC_HA (off) != 0)
10551     size += 4;
10552   if (htab->opd_abi)
10553     {
10554       size += 4;
10555       if (htab->params->plt_static_chain)
10556         size += 4;
10557       if (htab->params->plt_thread_safe
10558           && htab->elf.dynamic_sections_created
10559           && stub_entry->h != NULL
10560           && stub_entry->h->elf.dynindx != -1)
10561         size += 8;
10562       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10563         size += 4;
10564     }
10565   if (stub_entry->h != NULL
10566       && (stub_entry->h == htab->tls_get_addr_fd
10567           || stub_entry->h == htab->tls_get_addr)
10568       && htab->params->tls_get_addr_opt)
10569     {
10570       size += 7 * 4;
10571       if (ALWAYS_EMIT_R2SAVE
10572           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10573         size += 6 * 4;
10574     }
10575   return size;
10576 }
10577
10578 /* Depending on the sign of plt_stub_align:
10579    If positive, return the padding to align to a 2**plt_stub_align
10580    boundary.
10581    If negative, if this stub would cross fewer 2**plt_stub_align
10582    boundaries if we align, then return the padding needed to do so.  */
10583
10584 static inline unsigned int
10585 plt_stub_pad (struct ppc_link_hash_table *htab,
10586               struct ppc_stub_hash_entry *stub_entry,
10587               bfd_vma plt_off)
10588 {
10589   int stub_align;
10590   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10591   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10592
10593   if (htab->params->plt_stub_align >= 0)
10594     {
10595       stub_align = 1 << htab->params->plt_stub_align;
10596       if ((stub_off & (stub_align - 1)) != 0)
10597         return stub_align - (stub_off & (stub_align - 1));
10598       return 0;
10599     }
10600
10601   stub_align = 1 << -htab->params->plt_stub_align;
10602   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10603       > ((stub_size - 1) & -stub_align))
10604     return stub_align - (stub_off & (stub_align - 1));
10605   return 0;
10606 }
10607
10608 /* Build a .plt call stub.  */
10609
10610 static inline bfd_byte *
10611 build_plt_stub (struct ppc_link_hash_table *htab,
10612                 struct ppc_stub_hash_entry *stub_entry,
10613                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10614 {
10615   bfd *obfd = htab->params->stub_bfd;
10616   bfd_boolean plt_load_toc = htab->opd_abi;
10617   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10618   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10619                                  && htab->elf.dynamic_sections_created
10620                                  && stub_entry->h != NULL
10621                                  && stub_entry->h->elf.dynindx != -1);
10622   bfd_boolean use_fake_dep = plt_thread_safe;
10623   bfd_vma cmp_branch_off = 0;
10624
10625   if (!ALWAYS_USE_FAKE_DEP
10626       && plt_load_toc
10627       && plt_thread_safe
10628       && !((stub_entry->h == htab->tls_get_addr_fd
10629             || stub_entry->h == htab->tls_get_addr)
10630            && htab->params->tls_get_addr_opt))
10631     {
10632       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10633       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10634                           / PLT_ENTRY_SIZE (htab));
10635       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10636       bfd_vma to, from;
10637
10638       if (pltindex > 32768)
10639         glinkoff += (pltindex - 32768) * 4;
10640       to = (glinkoff
10641             + htab->glink->output_offset
10642             + htab->glink->output_section->vma);
10643       from = (p - stub_entry->group->stub_sec->contents
10644               + 4 * (ALWAYS_EMIT_R2SAVE
10645                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10646               + 4 * (PPC_HA (offset) != 0)
10647               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10648                      != PPC_HA (offset))
10649               + 4 * (plt_static_chain != 0)
10650               + 20
10651               + stub_entry->group->stub_sec->output_offset
10652               + stub_entry->group->stub_sec->output_section->vma);
10653       cmp_branch_off = to - from;
10654       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10655     }
10656
10657   if (PPC_HA (offset) != 0)
10658     {
10659       if (r != NULL)
10660         {
10661           if (ALWAYS_EMIT_R2SAVE
10662               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10663             r[0].r_offset += 4;
10664           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10665           r[1].r_offset = r[0].r_offset + 4;
10666           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10667           r[1].r_addend = r[0].r_addend;
10668           if (plt_load_toc)
10669             {
10670               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10671                 {
10672                   r[2].r_offset = r[1].r_offset + 4;
10673                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10674                   r[2].r_addend = r[0].r_addend;
10675                 }
10676               else
10677                 {
10678                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10679                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10680                   r[2].r_addend = r[0].r_addend + 8;
10681                   if (plt_static_chain)
10682                     {
10683                       r[3].r_offset = r[2].r_offset + 4;
10684                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10685                       r[3].r_addend = r[0].r_addend + 16;
10686                     }
10687                 }
10688             }
10689         }
10690       if (ALWAYS_EMIT_R2SAVE
10691           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10692         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10693       if (plt_load_toc)
10694         {
10695           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10696           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10697         }
10698       else
10699         {
10700           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10701           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10702         }
10703       if (plt_load_toc
10704           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10705         {
10706           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10707           offset = 0;
10708         }
10709       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10710       if (plt_load_toc)
10711         {
10712           if (use_fake_dep)
10713             {
10714               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10715               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10716             }
10717           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10718           if (plt_static_chain)
10719             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10720         }
10721     }
10722   else
10723     {
10724       if (r != NULL)
10725         {
10726           if (ALWAYS_EMIT_R2SAVE
10727               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10728             r[0].r_offset += 4;
10729           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10730           if (plt_load_toc)
10731             {
10732               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10733                 {
10734                   r[1].r_offset = r[0].r_offset + 4;
10735                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10736                   r[1].r_addend = r[0].r_addend;
10737                 }
10738               else
10739                 {
10740                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10741                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10742                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10743                   if (plt_static_chain)
10744                     {
10745                       r[2].r_offset = r[1].r_offset + 4;
10746                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10747                       r[2].r_addend = r[0].r_addend + 8;
10748                     }
10749                 }
10750             }
10751         }
10752       if (ALWAYS_EMIT_R2SAVE
10753           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10754         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10755       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10756       if (plt_load_toc
10757           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10758         {
10759           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10760           offset = 0;
10761         }
10762       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10763       if (plt_load_toc)
10764         {
10765           if (use_fake_dep)
10766             {
10767               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10768               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10769             }
10770           if (plt_static_chain)
10771             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10772           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10773         }
10774     }
10775   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10776     {
10777       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10778       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10779       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10780     }
10781   else
10782     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10783   return p;
10784 }
10785
10786 /* Build a special .plt call stub for __tls_get_addr.  */
10787
10788 #define LD_R11_0R3      0xe9630000
10789 #define LD_R12_0R3      0xe9830000
10790 #define MR_R0_R3        0x7c601b78
10791 #define CMPDI_R11_0     0x2c2b0000
10792 #define ADD_R3_R12_R13  0x7c6c6a14
10793 #define BEQLR           0x4d820020
10794 #define MR_R3_R0        0x7c030378
10795 #define STD_R11_0R1     0xf9610000
10796 #define BCTRL           0x4e800421
10797 #define LD_R11_0R1      0xe9610000
10798 #define MTLR_R11        0x7d6803a6
10799
10800 static inline bfd_byte *
10801 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10802                          struct ppc_stub_hash_entry *stub_entry,
10803                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10804 {
10805   bfd *obfd = htab->params->stub_bfd;
10806
10807   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10808   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10809   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10810   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10811   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10812   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10813   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10814   if (r != NULL)
10815     r[0].r_offset += 7 * 4;
10816   if (!ALWAYS_EMIT_R2SAVE
10817       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10818     return build_plt_stub (htab, stub_entry, p, offset, r);
10819
10820   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10821   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10822
10823   if (r != NULL)
10824     r[0].r_offset += 2 * 4;
10825   p = build_plt_stub (htab, stub_entry, p, offset, r);
10826   bfd_put_32 (obfd, BCTRL, p - 4);
10827
10828   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10829   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10830   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10831   bfd_put_32 (obfd, BLR, p),                    p += 4;
10832
10833   return p;
10834 }
10835
10836 static Elf_Internal_Rela *
10837 get_relocs (asection *sec, int count)
10838 {
10839   Elf_Internal_Rela *relocs;
10840   struct bfd_elf_section_data *elfsec_data;
10841
10842   elfsec_data = elf_section_data (sec);
10843   relocs = elfsec_data->relocs;
10844   if (relocs == NULL)
10845     {
10846       bfd_size_type relsize;
10847       relsize = sec->reloc_count * sizeof (*relocs);
10848       relocs = bfd_alloc (sec->owner, relsize);
10849       if (relocs == NULL)
10850         return NULL;
10851       elfsec_data->relocs = relocs;
10852       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10853                                           sizeof (Elf_Internal_Shdr));
10854       if (elfsec_data->rela.hdr == NULL)
10855         return NULL;
10856       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10857                                         * sizeof (Elf64_External_Rela));
10858       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10859       sec->reloc_count = 0;
10860     }
10861   relocs += sec->reloc_count;
10862   sec->reloc_count += count;
10863   return relocs;
10864 }
10865
10866 static bfd_vma
10867 get_r2off (struct bfd_link_info *info,
10868            struct ppc_stub_hash_entry *stub_entry)
10869 {
10870   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10871   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10872
10873   if (r2off == 0)
10874     {
10875       /* Support linking -R objects.  Get the toc pointer from the
10876          opd entry.  */
10877       char buf[8];
10878       if (!htab->opd_abi)
10879         return r2off;
10880       asection *opd = stub_entry->h->elf.root.u.def.section;
10881       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10882
10883       if (strcmp (opd->name, ".opd") != 0
10884           || opd->reloc_count != 0)
10885         {
10886           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
10887                                   stub_entry->h->elf.root.root.string);
10888           bfd_set_error (bfd_error_bad_value);
10889           return (bfd_vma) -1;
10890         }
10891       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10892         return (bfd_vma) -1;
10893       r2off = bfd_get_64 (opd->owner, buf);
10894       r2off -= elf_gp (info->output_bfd);
10895     }
10896   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10897   return r2off;
10898 }
10899
10900 static bfd_boolean
10901 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10902 {
10903   struct ppc_stub_hash_entry *stub_entry;
10904   struct ppc_branch_hash_entry *br_entry;
10905   struct bfd_link_info *info;
10906   struct ppc_link_hash_table *htab;
10907   bfd_byte *loc;
10908   bfd_byte *p;
10909   bfd_vma dest, off;
10910   Elf_Internal_Rela *r;
10911   asection *plt;
10912
10913   /* Massage our args to the form they really have.  */
10914   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10915   info = in_arg;
10916
10917   htab = ppc_hash_table (info);
10918   if (htab == NULL)
10919     return FALSE;
10920
10921   /* Make a note of the offset within the stubs for this entry.  */
10922   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10923   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10924
10925   htab->stub_count[stub_entry->stub_type - 1] += 1;
10926   switch (stub_entry->stub_type)
10927     {
10928     case ppc_stub_long_branch:
10929     case ppc_stub_long_branch_r2off:
10930       /* Branches are relative.  This is where we are going to.  */
10931       dest = (stub_entry->target_value
10932               + stub_entry->target_section->output_offset
10933               + stub_entry->target_section->output_section->vma);
10934       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10935       off = dest;
10936
10937       /* And this is where we are coming from.  */
10938       off -= (stub_entry->stub_offset
10939               + stub_entry->group->stub_sec->output_offset
10940               + stub_entry->group->stub_sec->output_section->vma);
10941
10942       p = loc;
10943       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10944         {
10945           bfd_vma r2off = get_r2off (info, stub_entry);
10946
10947           if (r2off == (bfd_vma) -1)
10948             {
10949               htab->stub_error = TRUE;
10950               return FALSE;
10951             }
10952           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
10953           p += 4;
10954           if (PPC_HA (r2off) != 0)
10955             {
10956               bfd_put_32 (htab->params->stub_bfd,
10957                           ADDIS_R2_R2 | PPC_HA (r2off), p);
10958               p += 4;
10959             }
10960           if (PPC_LO (r2off) != 0)
10961             {
10962               bfd_put_32 (htab->params->stub_bfd,
10963                           ADDI_R2_R2 | PPC_LO (r2off), p);
10964               p += 4;
10965             }
10966           off -= p - loc;
10967         }
10968       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
10969       p += 4;
10970
10971       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10972         {
10973           _bfd_error_handler
10974             (_("long branch stub `%s' offset overflow"),
10975              stub_entry->root.string);
10976           htab->stub_error = TRUE;
10977           return FALSE;
10978         }
10979
10980       if (info->emitrelocations)
10981         {
10982           r = get_relocs (stub_entry->group->stub_sec, 1);
10983           if (r == NULL)
10984             return FALSE;
10985           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
10986           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10987           r->r_addend = dest;
10988           if (stub_entry->h != NULL)
10989             {
10990               struct elf_link_hash_entry **hashes;
10991               unsigned long symndx;
10992               struct ppc_link_hash_entry *h;
10993
10994               hashes = elf_sym_hashes (htab->params->stub_bfd);
10995               if (hashes == NULL)
10996                 {
10997                   bfd_size_type hsize;
10998
10999                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11000                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11001                   if (hashes == NULL)
11002                     return FALSE;
11003                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11004                   htab->stub_globals = 1;
11005                 }
11006               symndx = htab->stub_globals++;
11007               h = stub_entry->h;
11008               hashes[symndx] = &h->elf;
11009               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11010               if (h->oh != NULL && h->oh->is_func)
11011                 h = ppc_follow_link (h->oh);
11012               if (h->elf.root.u.def.section != stub_entry->target_section)
11013                 /* H is an opd symbol.  The addend must be zero.  */
11014                 r->r_addend = 0;
11015               else
11016                 {
11017                   off = (h->elf.root.u.def.value
11018                          + h->elf.root.u.def.section->output_offset
11019                          + h->elf.root.u.def.section->output_section->vma);
11020                   r->r_addend -= off;
11021                 }
11022             }
11023         }
11024       break;
11025
11026     case ppc_stub_plt_branch:
11027     case ppc_stub_plt_branch_r2off:
11028       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11029                                          stub_entry->root.string + 9,
11030                                          FALSE, FALSE);
11031       if (br_entry == NULL)
11032         {
11033           _bfd_error_handler (_("can't find branch stub `%s'"),
11034                               stub_entry->root.string);
11035           htab->stub_error = TRUE;
11036           return FALSE;
11037         }
11038
11039       dest = (stub_entry->target_value
11040               + stub_entry->target_section->output_offset
11041               + stub_entry->target_section->output_section->vma);
11042       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11043         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11044
11045       bfd_put_64 (htab->brlt->owner, dest,
11046                   htab->brlt->contents + br_entry->offset);
11047
11048       if (br_entry->iter == htab->stub_iteration)
11049         {
11050           br_entry->iter = 0;
11051
11052           if (htab->relbrlt != NULL)
11053             {
11054               /* Create a reloc for the branch lookup table entry.  */
11055               Elf_Internal_Rela rela;
11056               bfd_byte *rl;
11057
11058               rela.r_offset = (br_entry->offset
11059                                + htab->brlt->output_offset
11060                                + htab->brlt->output_section->vma);
11061               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11062               rela.r_addend = dest;
11063
11064               rl = htab->relbrlt->contents;
11065               rl += (htab->relbrlt->reloc_count++
11066                      * sizeof (Elf64_External_Rela));
11067               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11068             }
11069           else if (info->emitrelocations)
11070             {
11071               r = get_relocs (htab->brlt, 1);
11072               if (r == NULL)
11073                 return FALSE;
11074               /* brlt, being SEC_LINKER_CREATED does not go through the
11075                  normal reloc processing.  Symbols and offsets are not
11076                  translated from input file to output file form, so
11077                  set up the offset per the output file.  */
11078               r->r_offset = (br_entry->offset
11079                              + htab->brlt->output_offset
11080                              + htab->brlt->output_section->vma);
11081               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11082               r->r_addend = dest;
11083             }
11084         }
11085
11086       dest = (br_entry->offset
11087               + htab->brlt->output_offset
11088               + htab->brlt->output_section->vma);
11089
11090       off = (dest
11091              - elf_gp (info->output_bfd)
11092              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11093
11094       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11095         {
11096           info->callbacks->einfo
11097             (_("%P: linkage table error against `%pT'\n"),
11098              stub_entry->root.string);
11099           bfd_set_error (bfd_error_bad_value);
11100           htab->stub_error = TRUE;
11101           return FALSE;
11102         }
11103
11104       if (info->emitrelocations)
11105         {
11106           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11107           if (r == NULL)
11108             return FALSE;
11109           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11110           if (bfd_big_endian (info->output_bfd))
11111             r[0].r_offset += 2;
11112           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11113             r[0].r_offset += 4;
11114           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11115           r[0].r_addend = dest;
11116           if (PPC_HA (off) != 0)
11117             {
11118               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11119               r[1].r_offset = r[0].r_offset + 4;
11120               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11121               r[1].r_addend = r[0].r_addend;
11122             }
11123         }
11124
11125       p = loc;
11126       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11127         {
11128           if (PPC_HA (off) != 0)
11129             {
11130               bfd_put_32 (htab->params->stub_bfd,
11131                           ADDIS_R12_R2 | PPC_HA (off), p);
11132               p += 4;
11133               bfd_put_32 (htab->params->stub_bfd,
11134                           LD_R12_0R12 | PPC_LO (off), p);
11135             }
11136           else
11137             bfd_put_32 (htab->params->stub_bfd,
11138                         LD_R12_0R2 | PPC_LO (off), p);
11139         }
11140       else
11141         {
11142           bfd_vma r2off = get_r2off (info, stub_entry);
11143
11144           if (r2off == (bfd_vma) -1)
11145             {
11146               htab->stub_error = TRUE;
11147               return FALSE;
11148             }
11149
11150           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11151           p += 4;
11152           if (PPC_HA (off) != 0)
11153             {
11154               bfd_put_32 (htab->params->stub_bfd,
11155                           ADDIS_R12_R2 | PPC_HA (off), p);
11156               p += 4;
11157               bfd_put_32 (htab->params->stub_bfd,
11158                           LD_R12_0R12 | PPC_LO (off), p);
11159             }
11160           else
11161             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11162
11163           if (PPC_HA (r2off) != 0)
11164             {
11165               p += 4;
11166               bfd_put_32 (htab->params->stub_bfd,
11167                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11168             }
11169           if (PPC_LO (r2off) != 0)
11170             {
11171               p += 4;
11172               bfd_put_32 (htab->params->stub_bfd,
11173                           ADDI_R2_R2 | PPC_LO (r2off), p);
11174             }
11175         }
11176       p += 4;
11177       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11178       p += 4;
11179       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11180       p += 4;
11181       break;
11182
11183     case ppc_stub_plt_call:
11184     case ppc_stub_plt_call_r2save:
11185       if (stub_entry->h != NULL
11186           && stub_entry->h->is_func_descriptor
11187           && stub_entry->h->oh != NULL)
11188         {
11189           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11190
11191           /* If the old-ABI "dot-symbol" is undefined make it weak so
11192              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11193           if (fh->elf.root.type == bfd_link_hash_undefined
11194               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11195                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11196             fh->elf.root.type = bfd_link_hash_undefweak;
11197         }
11198
11199       /* Now build the stub.  */
11200       dest = stub_entry->plt_ent->plt.offset & ~1;
11201       if (dest >= (bfd_vma) -2)
11202         abort ();
11203
11204       plt = htab->elf.splt;
11205       if (!htab->elf.dynamic_sections_created
11206           || stub_entry->h == NULL
11207           || stub_entry->h->elf.dynindx == -1)
11208         {
11209           if (stub_entry->symtype == STT_GNU_IFUNC)
11210             plt = htab->elf.iplt;
11211           else
11212             plt = htab->pltlocal;
11213         }
11214
11215       dest += plt->output_offset + plt->output_section->vma;
11216
11217       off = (dest
11218              - elf_gp (info->output_bfd)
11219              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11220
11221       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11222         {
11223           info->callbacks->einfo
11224             /* xgettext:c-format */
11225             (_("%P: linkage table error against `%pT'\n"),
11226              stub_entry->h != NULL
11227              ? stub_entry->h->elf.root.root.string
11228              : "<local sym>");
11229           bfd_set_error (bfd_error_bad_value);
11230           htab->stub_error = TRUE;
11231           return FALSE;
11232         }
11233
11234       if (htab->params->plt_stub_align != 0)
11235         {
11236           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11237
11238           stub_entry->group->stub_sec->size += pad;
11239           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11240           loc += pad;
11241         }
11242
11243       r = NULL;
11244       if (info->emitrelocations)
11245         {
11246           r = get_relocs (stub_entry->group->stub_sec,
11247                           ((PPC_HA (off) != 0)
11248                            + (htab->opd_abi
11249                               ? 2 + (htab->params->plt_static_chain
11250                                      && PPC_HA (off + 16) == PPC_HA (off))
11251                               : 1)));
11252           if (r == NULL)
11253             return FALSE;
11254           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11255           if (bfd_big_endian (info->output_bfd))
11256             r[0].r_offset += 2;
11257           r[0].r_addend = dest;
11258         }
11259       if (stub_entry->h != NULL
11260           && (stub_entry->h == htab->tls_get_addr_fd
11261               || stub_entry->h == htab->tls_get_addr)
11262           && htab->params->tls_get_addr_opt)
11263         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11264       else
11265         p = build_plt_stub (htab, stub_entry, loc, off, r);
11266       break;
11267
11268     case ppc_stub_save_res:
11269       return TRUE;
11270
11271     default:
11272       BFD_FAIL ();
11273       return FALSE;
11274     }
11275
11276   stub_entry->group->stub_sec->size += p - loc;
11277
11278   if (htab->params->emit_stub_syms)
11279     {
11280       struct elf_link_hash_entry *h;
11281       size_t len1, len2;
11282       char *name;
11283       const char *const stub_str[] = { "long_branch",
11284                                        "long_branch_r2off",
11285                                        "plt_branch",
11286                                        "plt_branch_r2off",
11287                                        "plt_call",
11288                                        "plt_call" };
11289
11290       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11291       len2 = strlen (stub_entry->root.string);
11292       name = bfd_malloc (len1 + len2 + 2);
11293       if (name == NULL)
11294         return FALSE;
11295       memcpy (name, stub_entry->root.string, 9);
11296       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11297       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11298       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11299       if (h == NULL)
11300         return FALSE;
11301       if (h->root.type == bfd_link_hash_new)
11302         {
11303           h->root.type = bfd_link_hash_defined;
11304           h->root.u.def.section = stub_entry->group->stub_sec;
11305           h->root.u.def.value = stub_entry->stub_offset;
11306           h->ref_regular = 1;
11307           h->def_regular = 1;
11308           h->ref_regular_nonweak = 1;
11309           h->forced_local = 1;
11310           h->non_elf = 0;
11311           h->root.linker_def = 1;
11312         }
11313     }
11314
11315   return TRUE;
11316 }
11317
11318 /* As above, but don't actually build the stub.  Just bump offset so
11319    we know stub section sizes, and select plt_branch stubs where
11320    long_branch stubs won't do.  */
11321
11322 static bfd_boolean
11323 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11324 {
11325   struct ppc_stub_hash_entry *stub_entry;
11326   struct bfd_link_info *info;
11327   struct ppc_link_hash_table *htab;
11328   bfd_vma off;
11329   int size;
11330
11331   /* Massage our args to the form they really have.  */
11332   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11333   info = in_arg;
11334
11335   htab = ppc_hash_table (info);
11336   if (htab == NULL)
11337     return FALSE;
11338
11339   if (stub_entry->h != NULL
11340       && stub_entry->h->save_res
11341       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11342       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11343     {
11344       /* Don't make stubs to out-of-line register save/restore
11345          functions.  Instead, emit copies of the functions.  */
11346       stub_entry->group->needs_save_res = 1;
11347       stub_entry->stub_type = ppc_stub_save_res;
11348       return TRUE;
11349     }
11350
11351   if (stub_entry->stub_type == ppc_stub_plt_call
11352       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11353     {
11354       asection *plt;
11355       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11356       if (off >= (bfd_vma) -2)
11357         abort ();
11358       plt = htab->elf.splt;
11359       if (!htab->elf.dynamic_sections_created
11360           || stub_entry->h == NULL
11361           || stub_entry->h->elf.dynindx == -1)
11362         {
11363           if (stub_entry->symtype == STT_GNU_IFUNC)
11364             plt = htab->elf.iplt;
11365           else
11366             plt = htab->pltlocal;
11367         }
11368       off += (plt->output_offset
11369               + plt->output_section->vma
11370               - elf_gp (info->output_bfd)
11371               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11372
11373       size = plt_stub_size (htab, stub_entry, off);
11374       if (stub_entry->h != NULL
11375           && (stub_entry->h == htab->tls_get_addr_fd
11376               || stub_entry->h == htab->tls_get_addr)
11377           && htab->params->tls_get_addr_opt
11378           && (ALWAYS_EMIT_R2SAVE
11379               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11380         stub_entry->group->tls_get_addr_opt_bctrl
11381           = stub_entry->group->stub_sec->size + size - 5 * 4;
11382
11383       if (htab->params->plt_stub_align)
11384         size += plt_stub_pad (htab, stub_entry, off);
11385       if (info->emitrelocations)
11386         {
11387           stub_entry->group->stub_sec->reloc_count
11388             += ((PPC_HA (off) != 0)
11389                 + (htab->opd_abi
11390                    ? 2 + (htab->params->plt_static_chain
11391                           && PPC_HA (off + 16) == PPC_HA (off))
11392                    : 1));
11393           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11394         }
11395     }
11396   else
11397     {
11398       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11399          variants.  */
11400       bfd_vma r2off = 0;
11401       bfd_vma local_off = 0;
11402
11403       off = (stub_entry->target_value
11404              + stub_entry->target_section->output_offset
11405              + stub_entry->target_section->output_section->vma);
11406       off -= (stub_entry->group->stub_sec->size
11407               + stub_entry->group->stub_sec->output_offset
11408               + stub_entry->group->stub_sec->output_section->vma);
11409
11410       /* Reset the stub type from the plt variant in case we now
11411          can reach with a shorter stub.  */
11412       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11413         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11414
11415       size = 4;
11416       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11417         {
11418           r2off = get_r2off (info, stub_entry);
11419           if (r2off == (bfd_vma) -1)
11420             {
11421               htab->stub_error = TRUE;
11422               return FALSE;
11423             }
11424           size = 8;
11425           if (PPC_HA (r2off) != 0)
11426             size += 4;
11427           if (PPC_LO (r2off) != 0)
11428             size += 4;
11429           off -= size - 4;
11430         }
11431
11432       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11433
11434       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11435          Do the same for -R objects without function descriptors.  */
11436       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11437           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11438               && r2off == 0
11439               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11440         {
11441           struct ppc_branch_hash_entry *br_entry;
11442
11443           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11444                                              stub_entry->root.string + 9,
11445                                              TRUE, FALSE);
11446           if (br_entry == NULL)
11447             {
11448               _bfd_error_handler (_("can't build branch stub `%s'"),
11449                                   stub_entry->root.string);
11450               htab->stub_error = TRUE;
11451               return FALSE;
11452             }
11453
11454           if (br_entry->iter != htab->stub_iteration)
11455             {
11456               br_entry->iter = htab->stub_iteration;
11457               br_entry->offset = htab->brlt->size;
11458               htab->brlt->size += 8;
11459
11460               if (htab->relbrlt != NULL)
11461                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11462               else if (info->emitrelocations)
11463                 {
11464                   htab->brlt->reloc_count += 1;
11465                   htab->brlt->flags |= SEC_RELOC;
11466                 }
11467             }
11468
11469           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11470           off = (br_entry->offset
11471                  + htab->brlt->output_offset
11472                  + htab->brlt->output_section->vma
11473                  - elf_gp (info->output_bfd)
11474                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11475
11476           if (info->emitrelocations)
11477             {
11478               stub_entry->group->stub_sec->reloc_count
11479                 += 1 + (PPC_HA (off) != 0);
11480               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11481             }
11482
11483           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11484             {
11485               size = 12;
11486               if (PPC_HA (off) != 0)
11487                 size = 16;
11488             }
11489           else
11490             {
11491               size = 16;
11492               if (PPC_HA (off) != 0)
11493                 size += 4;
11494
11495               if (PPC_HA (r2off) != 0)
11496                 size += 4;
11497               if (PPC_LO (r2off) != 0)
11498                 size += 4;
11499             }
11500         }
11501       else if (info->emitrelocations)
11502         {
11503           stub_entry->group->stub_sec->reloc_count += 1;
11504           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11505         }
11506     }
11507
11508   stub_entry->group->stub_sec->size += size;
11509   return TRUE;
11510 }
11511
11512 /* Set up various things so that we can make a list of input sections
11513    for each output section included in the link.  Returns -1 on error,
11514    0 when no stubs will be needed, and 1 on success.  */
11515
11516 int
11517 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11518 {
11519   unsigned int id;
11520   bfd_size_type amt;
11521   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11522
11523   if (htab == NULL)
11524     return -1;
11525
11526   htab->sec_info_arr_size = bfd_get_next_section_id ();
11527   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11528   htab->sec_info = bfd_zmalloc (amt);
11529   if (htab->sec_info == NULL)
11530     return -1;
11531
11532   /* Set toc_off for com, und, abs and ind sections.  */
11533   for (id = 0; id < 3; id++)
11534     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11535
11536   return 1;
11537 }
11538
11539 /* Set up for first pass at multitoc partitioning.  */
11540
11541 void
11542 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11543 {
11544   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11545
11546   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11547   htab->toc_bfd = NULL;
11548   htab->toc_first_sec = NULL;
11549 }
11550
11551 /* The linker repeatedly calls this function for each TOC input section
11552    and linker generated GOT section.  Group input bfds such that the toc
11553    within a group is less than 64k in size.  */
11554
11555 bfd_boolean
11556 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11557 {
11558   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11559   bfd_vma addr, off, limit;
11560
11561   if (htab == NULL)
11562     return FALSE;
11563
11564   if (!htab->second_toc_pass)
11565     {
11566       /* Keep track of the first .toc or .got section for this input bfd.  */
11567       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11568
11569       if (new_bfd)
11570         {
11571           htab->toc_bfd = isec->owner;
11572           htab->toc_first_sec = isec;
11573         }
11574
11575       addr = isec->output_offset + isec->output_section->vma;
11576       off = addr - htab->toc_curr;
11577       limit = 0x80008000;
11578       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11579         limit = 0x10000;
11580       if (off + isec->size > limit)
11581         {
11582           addr = (htab->toc_first_sec->output_offset
11583                   + htab->toc_first_sec->output_section->vma);
11584           htab->toc_curr = addr;
11585           htab->toc_curr &= -TOC_BASE_ALIGN;
11586         }
11587
11588       /* toc_curr is the base address of this toc group.  Set elf_gp
11589          for the input section to be the offset relative to the
11590          output toc base plus 0x8000.  Making the input elf_gp an
11591          offset allows us to move the toc as a whole without
11592          recalculating input elf_gp.  */
11593       off = htab->toc_curr - elf_gp (info->output_bfd);
11594       off += TOC_BASE_OFF;
11595
11596       /* Die if someone uses a linker script that doesn't keep input
11597          file .toc and .got together.  */
11598       if (new_bfd
11599           && elf_gp (isec->owner) != 0
11600           && elf_gp (isec->owner) != off)
11601         return FALSE;
11602
11603       elf_gp (isec->owner) = off;
11604       return TRUE;
11605     }
11606
11607   /* During the second pass toc_first_sec points to the start of
11608      a toc group, and toc_curr is used to track the old elf_gp.
11609      We use toc_bfd to ensure we only look at each bfd once.  */
11610   if (htab->toc_bfd == isec->owner)
11611     return TRUE;
11612   htab->toc_bfd = isec->owner;
11613
11614   if (htab->toc_first_sec == NULL
11615       || htab->toc_curr != elf_gp (isec->owner))
11616     {
11617       htab->toc_curr = elf_gp (isec->owner);
11618       htab->toc_first_sec = isec;
11619     }
11620   addr = (htab->toc_first_sec->output_offset
11621           + htab->toc_first_sec->output_section->vma);
11622   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11623   elf_gp (isec->owner) = off;
11624
11625   return TRUE;
11626 }
11627
11628 /* Called via elf_link_hash_traverse to merge GOT entries for global
11629    symbol H.  */
11630
11631 static bfd_boolean
11632 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11633 {
11634   if (h->root.type == bfd_link_hash_indirect)
11635     return TRUE;
11636
11637   merge_got_entries (&h->got.glist);
11638
11639   return TRUE;
11640 }
11641
11642 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11643    symbol H.  */
11644
11645 static bfd_boolean
11646 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11647 {
11648   struct got_entry *gent;
11649
11650   if (h->root.type == bfd_link_hash_indirect)
11651     return TRUE;
11652
11653   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11654     if (!gent->is_indirect)
11655       allocate_got (h, (struct bfd_link_info *) inf, gent);
11656   return TRUE;
11657 }
11658
11659 /* Called on the first multitoc pass after the last call to
11660    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11661    entries.  */
11662
11663 bfd_boolean
11664 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11665 {
11666   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11667   struct bfd *ibfd, *ibfd2;
11668   bfd_boolean done_something;
11669
11670   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11671
11672   if (!htab->do_multi_toc)
11673     return FALSE;
11674
11675   /* Merge global sym got entries within a toc group.  */
11676   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11677
11678   /* And tlsld_got.  */
11679   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11680     {
11681       struct got_entry *ent, *ent2;
11682
11683       if (!is_ppc64_elf (ibfd))
11684         continue;
11685
11686       ent = ppc64_tlsld_got (ibfd);
11687       if (!ent->is_indirect
11688           && ent->got.offset != (bfd_vma) -1)
11689         {
11690           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11691             {
11692               if (!is_ppc64_elf (ibfd2))
11693                 continue;
11694
11695               ent2 = ppc64_tlsld_got (ibfd2);
11696               if (!ent2->is_indirect
11697                   && ent2->got.offset != (bfd_vma) -1
11698                   && elf_gp (ibfd2) == elf_gp (ibfd))
11699                 {
11700                   ent2->is_indirect = TRUE;
11701                   ent2->got.ent = ent;
11702                 }
11703             }
11704         }
11705     }
11706
11707   /* Zap sizes of got sections.  */
11708   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11709   htab->elf.irelplt->size -= htab->got_reli_size;
11710   htab->got_reli_size = 0;
11711
11712   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11713     {
11714       asection *got, *relgot;
11715
11716       if (!is_ppc64_elf (ibfd))
11717         continue;
11718
11719       got = ppc64_elf_tdata (ibfd)->got;
11720       if (got != NULL)
11721         {
11722           got->rawsize = got->size;
11723           got->size = 0;
11724           relgot = ppc64_elf_tdata (ibfd)->relgot;
11725           relgot->rawsize = relgot->size;
11726           relgot->size = 0;
11727         }
11728     }
11729
11730   /* Now reallocate the got, local syms first.  We don't need to
11731      allocate section contents again since we never increase size.  */
11732   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11733     {
11734       struct got_entry **lgot_ents;
11735       struct got_entry **end_lgot_ents;
11736       struct plt_entry **local_plt;
11737       struct plt_entry **end_local_plt;
11738       unsigned char *lgot_masks;
11739       bfd_size_type locsymcount;
11740       Elf_Internal_Shdr *symtab_hdr;
11741       asection *s;
11742
11743       if (!is_ppc64_elf (ibfd))
11744         continue;
11745
11746       lgot_ents = elf_local_got_ents (ibfd);
11747       if (!lgot_ents)
11748         continue;
11749
11750       symtab_hdr = &elf_symtab_hdr (ibfd);
11751       locsymcount = symtab_hdr->sh_info;
11752       end_lgot_ents = lgot_ents + locsymcount;
11753       local_plt = (struct plt_entry **) end_lgot_ents;
11754       end_local_plt = local_plt + locsymcount;
11755       lgot_masks = (unsigned char *) end_local_plt;
11756       s = ppc64_elf_tdata (ibfd)->got;
11757       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11758         {
11759           struct got_entry *ent;
11760
11761           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11762             {
11763               unsigned int ent_size = 8;
11764               unsigned int rel_size = sizeof (Elf64_External_Rela);
11765
11766               ent->got.offset = s->size;
11767               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11768                 {
11769                   ent_size *= 2;
11770                   rel_size *= 2;
11771                 }
11772               s->size += ent_size;
11773               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
11774                 {
11775                   htab->elf.irelplt->size += rel_size;
11776                   htab->got_reli_size += rel_size;
11777                 }
11778               else if (bfd_link_pic (info)
11779                        && !((ent->tls_type & TLS_TPREL) != 0
11780                             && bfd_link_executable (info)))
11781                 {
11782                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11783                   srel->size += rel_size;
11784                 }
11785             }
11786         }
11787     }
11788
11789   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11790
11791   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11792     {
11793       struct got_entry *ent;
11794
11795       if (!is_ppc64_elf (ibfd))
11796         continue;
11797
11798       ent = ppc64_tlsld_got (ibfd);
11799       if (!ent->is_indirect
11800           && ent->got.offset != (bfd_vma) -1)
11801         {
11802           asection *s = ppc64_elf_tdata (ibfd)->got;
11803           ent->got.offset = s->size;
11804           s->size += 16;
11805           if (bfd_link_pic (info))
11806             {
11807               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11808               srel->size += sizeof (Elf64_External_Rela);
11809             }
11810         }
11811     }
11812
11813   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11814   if (!done_something)
11815     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11816       {
11817         asection *got;
11818
11819         if (!is_ppc64_elf (ibfd))
11820           continue;
11821
11822         got = ppc64_elf_tdata (ibfd)->got;
11823         if (got != NULL)
11824           {
11825             done_something = got->rawsize != got->size;
11826             if (done_something)
11827               break;
11828           }
11829       }
11830
11831   if (done_something)
11832     (*htab->params->layout_sections_again) ();
11833
11834   /* Set up for second pass over toc sections to recalculate elf_gp
11835      on input sections.  */
11836   htab->toc_bfd = NULL;
11837   htab->toc_first_sec = NULL;
11838   htab->second_toc_pass = TRUE;
11839   return done_something;
11840 }
11841
11842 /* Called after second pass of multitoc partitioning.  */
11843
11844 void
11845 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11846 {
11847   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11848
11849   /* After the second pass, toc_curr tracks the TOC offset used
11850      for code sections below in ppc64_elf_next_input_section.  */
11851   htab->toc_curr = TOC_BASE_OFF;
11852 }
11853
11854 /* No toc references were found in ISEC.  If the code in ISEC makes no
11855    calls, then there's no need to use toc adjusting stubs when branching
11856    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11857    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11858    needed, and 2 if a cyclical call-graph was found but no other reason
11859    for a stub was detected.  If called from the top level, a return of
11860    2 means the same as a return of 0.  */
11861
11862 static int
11863 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11864 {
11865   int ret;
11866
11867   /* Mark this section as checked.  */
11868   isec->call_check_done = 1;
11869
11870   /* We know none of our code bearing sections will need toc stubs.  */
11871   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11872     return 0;
11873
11874   if (isec->size == 0)
11875     return 0;
11876
11877   if (isec->output_section == NULL)
11878     return 0;
11879
11880   ret = 0;
11881   if (isec->reloc_count != 0)
11882     {
11883       Elf_Internal_Rela *relstart, *rel;
11884       Elf_Internal_Sym *local_syms;
11885       struct ppc_link_hash_table *htab;
11886
11887       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11888                                             info->keep_memory);
11889       if (relstart == NULL)
11890         return -1;
11891
11892       /* Look for branches to outside of this section.  */
11893       local_syms = NULL;
11894       htab = ppc_hash_table (info);
11895       if (htab == NULL)
11896         return -1;
11897
11898       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11899         {
11900           enum elf_ppc64_reloc_type r_type;
11901           unsigned long r_symndx;
11902           struct elf_link_hash_entry *h;
11903           struct ppc_link_hash_entry *eh;
11904           Elf_Internal_Sym *sym;
11905           asection *sym_sec;
11906           struct _opd_sec_data *opd;
11907           bfd_vma sym_value;
11908           bfd_vma dest;
11909
11910           r_type = ELF64_R_TYPE (rel->r_info);
11911           if (r_type != R_PPC64_REL24
11912               && r_type != R_PPC64_REL14
11913               && r_type != R_PPC64_REL14_BRTAKEN
11914               && r_type != R_PPC64_REL14_BRNTAKEN)
11915             continue;
11916
11917           r_symndx = ELF64_R_SYM (rel->r_info);
11918           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11919                           isec->owner))
11920             {
11921               ret = -1;
11922               break;
11923             }
11924
11925           /* Calls to dynamic lib functions go through a plt call stub
11926              that uses r2.  */
11927           eh = (struct ppc_link_hash_entry *) h;
11928           if (eh != NULL
11929               && (eh->elf.plt.plist != NULL
11930                   || (eh->oh != NULL
11931                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11932             {
11933               ret = 1;
11934               break;
11935             }
11936
11937           if (sym_sec == NULL)
11938             /* Ignore other undefined symbols.  */
11939             continue;
11940
11941           /* Assume branches to other sections not included in the
11942              link need stubs too, to cover -R and absolute syms.  */
11943           if (sym_sec->output_section == NULL)
11944             {
11945               ret = 1;
11946               break;
11947             }
11948
11949           if (h == NULL)
11950             sym_value = sym->st_value;
11951           else
11952             {
11953               if (h->root.type != bfd_link_hash_defined
11954                   && h->root.type != bfd_link_hash_defweak)
11955                 abort ();
11956               sym_value = h->root.u.def.value;
11957             }
11958           sym_value += rel->r_addend;
11959
11960           /* If this branch reloc uses an opd sym, find the code section.  */
11961           opd = get_opd_info (sym_sec);
11962           if (opd != NULL)
11963             {
11964               if (h == NULL && opd->adjust != NULL)
11965                 {
11966                   long adjust;
11967
11968                   adjust = opd->adjust[OPD_NDX (sym_value)];
11969                   if (adjust == -1)
11970                     /* Assume deleted functions won't ever be called.  */
11971                     continue;
11972                   sym_value += adjust;
11973                 }
11974
11975               dest = opd_entry_value (sym_sec, sym_value,
11976                                       &sym_sec, NULL, FALSE);
11977               if (dest == (bfd_vma) -1)
11978                 continue;
11979             }
11980           else
11981             dest = (sym_value
11982                     + sym_sec->output_offset
11983                     + sym_sec->output_section->vma);
11984
11985           /* Ignore branch to self.  */
11986           if (sym_sec == isec)
11987             continue;
11988
11989           /* If the called function uses the toc, we need a stub.  */
11990           if (sym_sec->has_toc_reloc
11991               || sym_sec->makes_toc_func_call)
11992             {
11993               ret = 1;
11994               break;
11995             }
11996
11997           /* Assume any branch that needs a long branch stub might in fact
11998              need a plt_branch stub.  A plt_branch stub uses r2.  */
11999           else if (dest - (isec->output_offset
12000                            + isec->output_section->vma
12001                            + rel->r_offset) + (1 << 25)
12002                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12003                                                              ? h->other
12004                                                              : sym->st_other))
12005             {
12006               ret = 1;
12007               break;
12008             }
12009
12010           /* If calling back to a section in the process of being
12011              tested, we can't say for sure that no toc adjusting stubs
12012              are needed, so don't return zero.  */
12013           else if (sym_sec->call_check_in_progress)
12014             ret = 2;
12015
12016           /* Branches to another section that itself doesn't have any TOC
12017              references are OK.  Recursively call ourselves to check.  */
12018           else if (!sym_sec->call_check_done)
12019             {
12020               int recur;
12021
12022               /* Mark current section as indeterminate, so that other
12023                  sections that call back to current won't be marked as
12024                  known.  */
12025               isec->call_check_in_progress = 1;
12026               recur = toc_adjusting_stub_needed (info, sym_sec);
12027               isec->call_check_in_progress = 0;
12028
12029               if (recur != 0)
12030                 {
12031                   ret = recur;
12032                   if (recur != 2)
12033                     break;
12034                 }
12035             }
12036         }
12037
12038       if (local_syms != NULL
12039           && (elf_symtab_hdr (isec->owner).contents
12040               != (unsigned char *) local_syms))
12041         free (local_syms);
12042       if (elf_section_data (isec)->relocs != relstart)
12043         free (relstart);
12044     }
12045
12046   if ((ret & 1) == 0
12047       && isec->map_head.s != NULL
12048       && (strcmp (isec->output_section->name, ".init") == 0
12049           || strcmp (isec->output_section->name, ".fini") == 0))
12050     {
12051       if (isec->map_head.s->has_toc_reloc
12052           || isec->map_head.s->makes_toc_func_call)
12053         ret = 1;
12054       else if (!isec->map_head.s->call_check_done)
12055         {
12056           int recur;
12057           isec->call_check_in_progress = 1;
12058           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12059           isec->call_check_in_progress = 0;
12060           if (recur != 0)
12061             ret = recur;
12062         }
12063     }
12064
12065   if (ret == 1)
12066     isec->makes_toc_func_call = 1;
12067
12068   return ret;
12069 }
12070
12071 /* The linker repeatedly calls this function for each input section,
12072    in the order that input sections are linked into output sections.
12073    Build lists of input sections to determine groupings between which
12074    we may insert linker stubs.  */
12075
12076 bfd_boolean
12077 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12078 {
12079   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12080
12081   if (htab == NULL)
12082     return FALSE;
12083
12084   if ((isec->output_section->flags & SEC_CODE) != 0
12085       && isec->output_section->id < htab->sec_info_arr_size)
12086     {
12087       /* This happens to make the list in reverse order,
12088          which is what we want.  */
12089       htab->sec_info[isec->id].u.list
12090         = htab->sec_info[isec->output_section->id].u.list;
12091       htab->sec_info[isec->output_section->id].u.list = isec;
12092     }
12093
12094   if (htab->multi_toc_needed)
12095     {
12096       /* Analyse sections that aren't already flagged as needing a
12097          valid toc pointer.  Exclude .fixup for the linux kernel.
12098          .fixup contains branches, but only back to the function that
12099          hit an exception.  */
12100       if (!(isec->has_toc_reloc
12101             || (isec->flags & SEC_CODE) == 0
12102             || strcmp (isec->name, ".fixup") == 0
12103             || isec->call_check_done))
12104         {
12105           if (toc_adjusting_stub_needed (info, isec) < 0)
12106             return FALSE;
12107         }
12108       /* Make all sections use the TOC assigned for this object file.
12109          This will be wrong for pasted sections;  We fix that in
12110          check_pasted_section().  */
12111       if (elf_gp (isec->owner) != 0)
12112         htab->toc_curr = elf_gp (isec->owner);
12113     }
12114
12115   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12116   return TRUE;
12117 }
12118
12119 /* Check that all .init and .fini sections use the same toc, if they
12120    have toc relocs.  */
12121
12122 static bfd_boolean
12123 check_pasted_section (struct bfd_link_info *info, const char *name)
12124 {
12125   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12126
12127   if (o != NULL)
12128     {
12129       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12130       bfd_vma toc_off = 0;
12131       asection *i;
12132
12133       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12134         if (i->has_toc_reloc)
12135           {
12136             if (toc_off == 0)
12137               toc_off = htab->sec_info[i->id].toc_off;
12138             else if (toc_off != htab->sec_info[i->id].toc_off)
12139               return FALSE;
12140           }
12141
12142       if (toc_off == 0)
12143         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12144           if (i->makes_toc_func_call)
12145             {
12146               toc_off = htab->sec_info[i->id].toc_off;
12147               break;
12148             }
12149
12150       /* Make sure the whole pasted function uses the same toc offset.  */
12151       if (toc_off != 0)
12152         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12153           htab->sec_info[i->id].toc_off = toc_off;
12154     }
12155   return TRUE;
12156 }
12157
12158 bfd_boolean
12159 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12160 {
12161   return (check_pasted_section (info, ".init")
12162           & check_pasted_section (info, ".fini"));
12163 }
12164
12165 /* See whether we can group stub sections together.  Grouping stub
12166    sections may result in fewer stubs.  More importantly, we need to
12167    put all .init* and .fini* stubs at the beginning of the .init or
12168    .fini output sections respectively, because glibc splits the
12169    _init and _fini functions into multiple parts.  Putting a stub in
12170    the middle of a function is not a good idea.  */
12171
12172 static bfd_boolean
12173 group_sections (struct bfd_link_info *info,
12174                 bfd_size_type stub_group_size,
12175                 bfd_boolean stubs_always_before_branch)
12176 {
12177   struct ppc_link_hash_table *htab;
12178   asection *osec;
12179   bfd_boolean suppress_size_errors;
12180
12181   htab = ppc_hash_table (info);
12182   if (htab == NULL)
12183     return FALSE;
12184
12185   suppress_size_errors = FALSE;
12186   if (stub_group_size == 1)
12187     {
12188       /* Default values.  */
12189       if (stubs_always_before_branch)
12190         stub_group_size = 0x1e00000;
12191       else
12192         stub_group_size = 0x1c00000;
12193       suppress_size_errors = TRUE;
12194     }
12195
12196   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12197     {
12198       asection *tail;
12199
12200       if (osec->id >= htab->sec_info_arr_size)
12201         continue;
12202
12203       tail = htab->sec_info[osec->id].u.list;
12204       while (tail != NULL)
12205         {
12206           asection *curr;
12207           asection *prev;
12208           bfd_size_type total;
12209           bfd_boolean big_sec;
12210           bfd_vma curr_toc;
12211           struct map_stub *group;
12212           bfd_size_type group_size;
12213
12214           curr = tail;
12215           total = tail->size;
12216           group_size = (ppc64_elf_section_data (tail) != NULL
12217                         && ppc64_elf_section_data (tail)->has_14bit_branch
12218                         ? stub_group_size >> 10 : stub_group_size);
12219
12220           big_sec = total > group_size;
12221           if (big_sec && !suppress_size_errors)
12222             /* xgettext:c-format */
12223             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12224                                 tail->owner, tail);
12225           curr_toc = htab->sec_info[tail->id].toc_off;
12226
12227           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12228                  && ((total += curr->output_offset - prev->output_offset)
12229                      < (ppc64_elf_section_data (prev) != NULL
12230                         && ppc64_elf_section_data (prev)->has_14bit_branch
12231                         ? (group_size = stub_group_size >> 10) : group_size))
12232                  && htab->sec_info[prev->id].toc_off == curr_toc)
12233             curr = prev;
12234
12235           /* OK, the size from the start of CURR to the end is less
12236              than group_size and thus can be handled by one stub
12237              section.  (or the tail section is itself larger than
12238              group_size, in which case we may be toast.)  We should
12239              really be keeping track of the total size of stubs added
12240              here, as stubs contribute to the final output section
12241              size.  That's a little tricky, and this way will only
12242              break if stubs added make the total size more than 2^25,
12243              ie. for the default stub_group_size, if stubs total more
12244              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12245           group = bfd_alloc (curr->owner, sizeof (*group));
12246           if (group == NULL)
12247             return FALSE;
12248           group->link_sec = curr;
12249           group->stub_sec = NULL;
12250           group->needs_save_res = 0;
12251           group->tls_get_addr_opt_bctrl = -1u;
12252           group->next = htab->group;
12253           htab->group = group;
12254           do
12255             {
12256               prev = htab->sec_info[tail->id].u.list;
12257               /* Set up this stub group.  */
12258               htab->sec_info[tail->id].u.group = group;
12259             }
12260           while (tail != curr && (tail = prev) != NULL);
12261
12262           /* But wait, there's more!  Input sections up to group_size
12263              bytes before the stub section can be handled by it too.
12264              Don't do this if we have a really large section after the
12265              stubs, as adding more stubs increases the chance that
12266              branches may not reach into the stub section.  */
12267           if (!stubs_always_before_branch && !big_sec)
12268             {
12269               total = 0;
12270               while (prev != NULL
12271                      && ((total += tail->output_offset - prev->output_offset)
12272                          < (ppc64_elf_section_data (prev) != NULL
12273                             && ppc64_elf_section_data (prev)->has_14bit_branch
12274                             ? (group_size = stub_group_size >> 10) : group_size))
12275                      && htab->sec_info[prev->id].toc_off == curr_toc)
12276                 {
12277                   tail = prev;
12278                   prev = htab->sec_info[tail->id].u.list;
12279                   htab->sec_info[tail->id].u.group = group;
12280                 }
12281             }
12282           tail = prev;
12283         }
12284     }
12285   return TRUE;
12286 }
12287
12288 static const unsigned char glink_eh_frame_cie[] =
12289 {
12290   0, 0, 0, 16,                          /* length.  */
12291   0, 0, 0, 0,                           /* id.  */
12292   1,                                    /* CIE version.  */
12293   'z', 'R', 0,                          /* Augmentation string.  */
12294   4,                                    /* Code alignment.  */
12295   0x78,                                 /* Data alignment.  */
12296   65,                                   /* RA reg.  */
12297   1,                                    /* Augmentation size.  */
12298   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12299   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12300 };
12301
12302 static size_t
12303 stub_eh_frame_size (struct map_stub *group, size_t align)
12304 {
12305   size_t this_size = 17;
12306   if (group->tls_get_addr_opt_bctrl != -1u)
12307     {
12308       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12309       if (to_bctrl < 64)
12310         this_size += 1;
12311       else if (to_bctrl < 256)
12312         this_size += 2;
12313       else if (to_bctrl < 65536)
12314         this_size += 3;
12315       else
12316         this_size += 5;
12317       this_size += 6;
12318     }
12319   this_size = (this_size + align - 1) & -align;
12320   return this_size;
12321 }
12322
12323 /* Stripping output sections is normally done before dynamic section
12324    symbols have been allocated.  This function is called later, and
12325    handles cases like htab->brlt which is mapped to its own output
12326    section.  */
12327
12328 static void
12329 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12330 {
12331   if (isec->size == 0
12332       && isec->output_section->size == 0
12333       && !(isec->output_section->flags & SEC_KEEP)
12334       && !bfd_section_removed_from_list (info->output_bfd,
12335                                          isec->output_section)
12336       && elf_section_data (isec->output_section)->dynindx == 0)
12337     {
12338       isec->output_section->flags |= SEC_EXCLUDE;
12339       bfd_section_list_remove (info->output_bfd, isec->output_section);
12340       info->output_bfd->section_count--;
12341     }
12342 }
12343
12344 /* Determine and set the size of the stub section for a final link.
12345
12346    The basic idea here is to examine all the relocations looking for
12347    PC-relative calls to a target that is unreachable with a "bl"
12348    instruction.  */
12349
12350 bfd_boolean
12351 ppc64_elf_size_stubs (struct bfd_link_info *info)
12352 {
12353   bfd_size_type stub_group_size;
12354   bfd_boolean stubs_always_before_branch;
12355   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12356
12357   if (htab == NULL)
12358     return FALSE;
12359
12360   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12361     htab->params->plt_thread_safe = 1;
12362   if (!htab->opd_abi)
12363     htab->params->plt_thread_safe = 0;
12364   else if (htab->params->plt_thread_safe == -1)
12365     {
12366       static const char *const thread_starter[] =
12367         {
12368           "pthread_create",
12369           /* libstdc++ */
12370           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12371           /* librt */
12372           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12373           "mq_notify", "create_timer",
12374           /* libanl */
12375           "getaddrinfo_a",
12376           /* libgomp */
12377           "GOMP_parallel",
12378           "GOMP_parallel_start",
12379           "GOMP_parallel_loop_static",
12380           "GOMP_parallel_loop_static_start",
12381           "GOMP_parallel_loop_dynamic",
12382           "GOMP_parallel_loop_dynamic_start",
12383           "GOMP_parallel_loop_guided",
12384           "GOMP_parallel_loop_guided_start",
12385           "GOMP_parallel_loop_runtime",
12386           "GOMP_parallel_loop_runtime_start",
12387           "GOMP_parallel_sections",
12388           "GOMP_parallel_sections_start",
12389           /* libgo */
12390           "__go_go",
12391         };
12392       unsigned i;
12393
12394       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12395         {
12396           struct elf_link_hash_entry *h;
12397           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12398                                     FALSE, FALSE, TRUE);
12399           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12400           if (htab->params->plt_thread_safe)
12401             break;
12402         }
12403     }
12404   stubs_always_before_branch = htab->params->group_size < 0;
12405   if (htab->params->group_size < 0)
12406     stub_group_size = -htab->params->group_size;
12407   else
12408     stub_group_size = htab->params->group_size;
12409
12410   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12411     return FALSE;
12412
12413 #define STUB_SHRINK_ITER 20
12414   /* Loop until no stubs added.  After iteration 20 of this loop we may
12415      exit on a stub section shrinking.  This is to break out of a
12416      pathological case where adding stubs on one iteration decreases
12417      section gaps (perhaps due to alignment), which then requires
12418      fewer or smaller stubs on the next iteration.  */
12419
12420   while (1)
12421     {
12422       bfd *input_bfd;
12423       unsigned int bfd_indx;
12424       struct map_stub *group;
12425
12426       htab->stub_iteration += 1;
12427
12428       for (input_bfd = info->input_bfds, bfd_indx = 0;
12429            input_bfd != NULL;
12430            input_bfd = input_bfd->link.next, bfd_indx++)
12431         {
12432           Elf_Internal_Shdr *symtab_hdr;
12433           asection *section;
12434           Elf_Internal_Sym *local_syms = NULL;
12435
12436           if (!is_ppc64_elf (input_bfd))
12437             continue;
12438
12439           /* We'll need the symbol table in a second.  */
12440           symtab_hdr = &elf_symtab_hdr (input_bfd);
12441           if (symtab_hdr->sh_info == 0)
12442             continue;
12443
12444           /* Walk over each section attached to the input bfd.  */
12445           for (section = input_bfd->sections;
12446                section != NULL;
12447                section = section->next)
12448             {
12449               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12450
12451               /* If there aren't any relocs, then there's nothing more
12452                  to do.  */
12453               if ((section->flags & SEC_RELOC) == 0
12454                   || (section->flags & SEC_ALLOC) == 0
12455                   || (section->flags & SEC_LOAD) == 0
12456                   || (section->flags & SEC_CODE) == 0
12457                   || section->reloc_count == 0)
12458                 continue;
12459
12460               /* If this section is a link-once section that will be
12461                  discarded, then don't create any stubs.  */
12462               if (section->output_section == NULL
12463                   || section->output_section->owner != info->output_bfd)
12464                 continue;
12465
12466               /* Get the relocs.  */
12467               internal_relocs
12468                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12469                                              info->keep_memory);
12470               if (internal_relocs == NULL)
12471                 goto error_ret_free_local;
12472
12473               /* Now examine each relocation.  */
12474               irela = internal_relocs;
12475               irelaend = irela + section->reloc_count;
12476               for (; irela < irelaend; irela++)
12477                 {
12478                   enum elf_ppc64_reloc_type r_type;
12479                   unsigned int r_indx;
12480                   enum ppc_stub_type stub_type;
12481                   struct ppc_stub_hash_entry *stub_entry;
12482                   asection *sym_sec, *code_sec;
12483                   bfd_vma sym_value, code_value;
12484                   bfd_vma destination;
12485                   unsigned long local_off;
12486                   bfd_boolean ok_dest;
12487                   struct ppc_link_hash_entry *hash;
12488                   struct ppc_link_hash_entry *fdh;
12489                   struct elf_link_hash_entry *h;
12490                   Elf_Internal_Sym *sym;
12491                   char *stub_name;
12492                   const asection *id_sec;
12493                   struct _opd_sec_data *opd;
12494                   struct plt_entry *plt_ent;
12495
12496                   r_type = ELF64_R_TYPE (irela->r_info);
12497                   r_indx = ELF64_R_SYM (irela->r_info);
12498
12499                   if (r_type >= R_PPC64_max)
12500                     {
12501                       bfd_set_error (bfd_error_bad_value);
12502                       goto error_ret_free_internal;
12503                     }
12504
12505                   /* Only look for stubs on branch instructions.  */
12506                   if (r_type != R_PPC64_REL24
12507                       && r_type != R_PPC64_REL14
12508                       && r_type != R_PPC64_REL14_BRTAKEN
12509                       && r_type != R_PPC64_REL14_BRNTAKEN)
12510                     continue;
12511
12512                   /* Now determine the call target, its name, value,
12513                      section.  */
12514                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12515                                   r_indx, input_bfd))
12516                     goto error_ret_free_internal;
12517                   hash = (struct ppc_link_hash_entry *) h;
12518
12519                   ok_dest = FALSE;
12520                   fdh = NULL;
12521                   sym_value = 0;
12522                   if (hash == NULL)
12523                     {
12524                       sym_value = sym->st_value;
12525                       if (sym_sec != NULL
12526                           && sym_sec->output_section != NULL)
12527                         ok_dest = TRUE;
12528                     }
12529                   else if (hash->elf.root.type == bfd_link_hash_defined
12530                            || hash->elf.root.type == bfd_link_hash_defweak)
12531                     {
12532                       sym_value = hash->elf.root.u.def.value;
12533                       if (sym_sec->output_section != NULL)
12534                         ok_dest = TRUE;
12535                     }
12536                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12537                            || hash->elf.root.type == bfd_link_hash_undefined)
12538                     {
12539                       /* Recognise an old ABI func code entry sym, and
12540                          use the func descriptor sym instead if it is
12541                          defined.  */
12542                       if (hash->elf.root.root.string[0] == '.'
12543                           && hash->oh != NULL)
12544                         {
12545                           fdh = ppc_follow_link (hash->oh);
12546                           if (fdh->elf.root.type == bfd_link_hash_defined
12547                               || fdh->elf.root.type == bfd_link_hash_defweak)
12548                             {
12549                               sym_sec = fdh->elf.root.u.def.section;
12550                               sym_value = fdh->elf.root.u.def.value;
12551                               if (sym_sec->output_section != NULL)
12552                                 ok_dest = TRUE;
12553                             }
12554                           else
12555                             fdh = NULL;
12556                         }
12557                     }
12558                   else
12559                     {
12560                       bfd_set_error (bfd_error_bad_value);
12561                       goto error_ret_free_internal;
12562                     }
12563
12564                   destination = 0;
12565                   local_off = 0;
12566                   if (ok_dest)
12567                     {
12568                       sym_value += irela->r_addend;
12569                       destination = (sym_value
12570                                      + sym_sec->output_offset
12571                                      + sym_sec->output_section->vma);
12572                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12573                                                             ? hash->elf.other
12574                                                             : sym->st_other);
12575                     }
12576
12577                   code_sec = sym_sec;
12578                   code_value = sym_value;
12579                   opd = get_opd_info (sym_sec);
12580                   if (opd != NULL)
12581                     {
12582                       bfd_vma dest;
12583
12584                       if (hash == NULL && opd->adjust != NULL)
12585                         {
12586                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12587                           if (adjust == -1)
12588                             continue;
12589                           code_value += adjust;
12590                           sym_value += adjust;
12591                         }
12592                       dest = opd_entry_value (sym_sec, sym_value,
12593                                               &code_sec, &code_value, FALSE);
12594                       if (dest != (bfd_vma) -1)
12595                         {
12596                           destination = dest;
12597                           if (fdh != NULL)
12598                             {
12599                               /* Fixup old ABI sym to point at code
12600                                  entry.  */
12601                               hash->elf.root.type = bfd_link_hash_defweak;
12602                               hash->elf.root.u.def.section = code_sec;
12603                               hash->elf.root.u.def.value = code_value;
12604                             }
12605                         }
12606                     }
12607
12608                   /* Determine what (if any) linker stub is needed.  */
12609                   plt_ent = NULL;
12610                   stub_type = ppc_type_of_stub (section, irela, &hash,
12611                                                 &plt_ent, destination,
12612                                                 local_off);
12613
12614                   if (stub_type != ppc_stub_plt_call)
12615                     {
12616                       /* Check whether we need a TOC adjusting stub.
12617                          Since the linker pastes together pieces from
12618                          different object files when creating the
12619                          _init and _fini functions, it may be that a
12620                          call to what looks like a local sym is in
12621                          fact a call needing a TOC adjustment.  */
12622                       if (code_sec != NULL
12623                           && code_sec->output_section != NULL
12624                           && (htab->sec_info[code_sec->id].toc_off
12625                               != htab->sec_info[section->id].toc_off)
12626                           && (code_sec->has_toc_reloc
12627                               || code_sec->makes_toc_func_call))
12628                         stub_type = ppc_stub_long_branch_r2off;
12629                     }
12630
12631                   if (stub_type == ppc_stub_none)
12632                     continue;
12633
12634                   /* __tls_get_addr calls might be eliminated.  */
12635                   if (stub_type != ppc_stub_plt_call
12636                       && hash != NULL
12637                       && (hash == htab->tls_get_addr
12638                           || hash == htab->tls_get_addr_fd)
12639                       && section->has_tls_reloc
12640                       && irela != internal_relocs)
12641                     {
12642                       /* Get tls info.  */
12643                       unsigned char *tls_mask;
12644
12645                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12646                                          irela - 1, input_bfd))
12647                         goto error_ret_free_internal;
12648                       if ((*tls_mask & TLS_TLS) != 0)
12649                         continue;
12650                     }
12651
12652                   if (stub_type == ppc_stub_plt_call)
12653                     {
12654                       if (!htab->opd_abi
12655                           && htab->params->plt_localentry0 != 0
12656                           && is_elfv2_localentry0 (&hash->elf))
12657                         htab->has_plt_localentry0 = 1;
12658                       else if (irela + 1 < irelaend
12659                                && irela[1].r_offset == irela->r_offset + 4
12660                                && (ELF64_R_TYPE (irela[1].r_info)
12661                                    == R_PPC64_TOCSAVE))
12662                         {
12663                           if (!tocsave_find (htab, INSERT,
12664                                              &local_syms, irela + 1, input_bfd))
12665                             goto error_ret_free_internal;
12666                         }
12667                       else
12668                         stub_type = ppc_stub_plt_call_r2save;
12669                     }
12670
12671                   /* Support for grouping stub sections.  */
12672                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12673
12674                   /* Get the name of this stub.  */
12675                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12676                   if (!stub_name)
12677                     goto error_ret_free_internal;
12678
12679                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12680                                                      stub_name, FALSE, FALSE);
12681                   if (stub_entry != NULL)
12682                     {
12683                       /* The proper stub has already been created.  */
12684                       free (stub_name);
12685                       if (stub_type == ppc_stub_plt_call_r2save)
12686                         stub_entry->stub_type = stub_type;
12687                       continue;
12688                     }
12689
12690                   stub_entry = ppc_add_stub (stub_name, section, info);
12691                   if (stub_entry == NULL)
12692                     {
12693                       free (stub_name);
12694                     error_ret_free_internal:
12695                       if (elf_section_data (section)->relocs == NULL)
12696                         free (internal_relocs);
12697                     error_ret_free_local:
12698                       if (local_syms != NULL
12699                           && (symtab_hdr->contents
12700                               != (unsigned char *) local_syms))
12701                         free (local_syms);
12702                       return FALSE;
12703                     }
12704
12705                   stub_entry->stub_type = stub_type;
12706                   if (stub_type != ppc_stub_plt_call
12707                       && stub_type != ppc_stub_plt_call_r2save)
12708                     {
12709                       stub_entry->target_value = code_value;
12710                       stub_entry->target_section = code_sec;
12711                     }
12712                   else
12713                     {
12714                       stub_entry->target_value = sym_value;
12715                       stub_entry->target_section = sym_sec;
12716                     }
12717                   stub_entry->h = hash;
12718                   stub_entry->plt_ent = plt_ent;
12719                   stub_entry->symtype
12720                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12721                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12722
12723                   if (stub_entry->h != NULL)
12724                     htab->stub_globals += 1;
12725                 }
12726
12727               /* We're done with the internal relocs, free them.  */
12728               if (elf_section_data (section)->relocs != internal_relocs)
12729                 free (internal_relocs);
12730             }
12731
12732           if (local_syms != NULL
12733               && symtab_hdr->contents != (unsigned char *) local_syms)
12734             {
12735               if (!info->keep_memory)
12736                 free (local_syms);
12737               else
12738                 symtab_hdr->contents = (unsigned char *) local_syms;
12739             }
12740         }
12741
12742       /* We may have added some stubs.  Find out the new size of the
12743          stub sections.  */
12744       for (group = htab->group; group != NULL; group = group->next)
12745         if (group->stub_sec != NULL)
12746           {
12747             asection *stub_sec = group->stub_sec;
12748
12749             if (htab->stub_iteration <= STUB_SHRINK_ITER
12750                 || stub_sec->rawsize < stub_sec->size)
12751               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12752               stub_sec->rawsize = stub_sec->size;
12753             stub_sec->size = 0;
12754             stub_sec->reloc_count = 0;
12755             stub_sec->flags &= ~SEC_RELOC;
12756           }
12757
12758       if (htab->stub_iteration <= STUB_SHRINK_ITER
12759           || htab->brlt->rawsize < htab->brlt->size)
12760         htab->brlt->rawsize = htab->brlt->size;
12761       htab->brlt->size = 0;
12762       htab->brlt->reloc_count = 0;
12763       htab->brlt->flags &= ~SEC_RELOC;
12764       if (htab->relbrlt != NULL)
12765         htab->relbrlt->size = 0;
12766
12767       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12768
12769       for (group = htab->group; group != NULL; group = group->next)
12770         if (group->needs_save_res)
12771           group->stub_sec->size += htab->sfpr->size;
12772
12773       if (info->emitrelocations
12774           && htab->glink != NULL && htab->glink->size != 0)
12775         {
12776           htab->glink->reloc_count = 1;
12777           htab->glink->flags |= SEC_RELOC;
12778         }
12779
12780       if (htab->glink_eh_frame != NULL
12781           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12782           && htab->glink_eh_frame->output_section->size > 8)
12783         {
12784           size_t size = 0, align = 4;
12785
12786           for (group = htab->group; group != NULL; group = group->next)
12787             if (group->stub_sec != NULL)
12788               size += stub_eh_frame_size (group, align);
12789           if (htab->glink != NULL && htab->glink->size != 0)
12790             size += (24 + align - 1) & -align;
12791           if (size != 0)
12792             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12793           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12794           size = (size + align - 1) & -align;
12795           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12796           htab->glink_eh_frame->size = size;
12797         }
12798
12799       if (htab->params->plt_stub_align != 0)
12800         for (group = htab->group; group != NULL; group = group->next)
12801           if (group->stub_sec != NULL)
12802             {
12803               int align = abs (htab->params->plt_stub_align);
12804               group->stub_sec->size
12805                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
12806             }
12807
12808       for (group = htab->group; group != NULL; group = group->next)
12809         if (group->stub_sec != NULL
12810             && group->stub_sec->rawsize != group->stub_sec->size
12811             && (htab->stub_iteration <= STUB_SHRINK_ITER
12812                 || group->stub_sec->rawsize < group->stub_sec->size))
12813           break;
12814
12815       if (group == NULL
12816           && (htab->brlt->rawsize == htab->brlt->size
12817               || (htab->stub_iteration > STUB_SHRINK_ITER
12818                   && htab->brlt->rawsize > htab->brlt->size))
12819           && (htab->glink_eh_frame == NULL
12820               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12821         break;
12822
12823       /* Ask the linker to do its stuff.  */
12824       (*htab->params->layout_sections_again) ();
12825     }
12826
12827   if (htab->glink_eh_frame != NULL
12828       && htab->glink_eh_frame->size != 0)
12829     {
12830       bfd_vma val;
12831       bfd_byte *p, *last_fde;
12832       size_t last_fde_len, size, align, pad;
12833       struct map_stub *group;
12834
12835       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12836       if (p == NULL)
12837         return FALSE;
12838       htab->glink_eh_frame->contents = p;
12839       last_fde = p;
12840       align = 4;
12841
12842       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12843       /* CIE length (rewrite in case little-endian).  */
12844       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12845       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12846       p += last_fde_len + 4;
12847
12848       for (group = htab->group; group != NULL; group = group->next)
12849         if (group->stub_sec != NULL)
12850           {
12851             last_fde = p;
12852             last_fde_len = stub_eh_frame_size (group, align) - 4;
12853             /* FDE length.  */
12854             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12855             p += 4;
12856             /* CIE pointer.  */
12857             val = p - htab->glink_eh_frame->contents;
12858             bfd_put_32 (htab->elf.dynobj, val, p);
12859             p += 4;
12860             /* Offset to stub section, written later.  */
12861             p += 4;
12862             /* stub section size.  */
12863             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12864             p += 4;
12865             /* Augmentation.  */
12866             p += 1;
12867             if (group->tls_get_addr_opt_bctrl != -1u)
12868               {
12869                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12870
12871                 /* This FDE needs more than just the default.
12872                    Describe __tls_get_addr_opt stub LR.  */
12873                 if (to_bctrl < 64)
12874                   *p++ = DW_CFA_advance_loc + to_bctrl;
12875                 else if (to_bctrl < 256)
12876                   {
12877                     *p++ = DW_CFA_advance_loc1;
12878                     *p++ = to_bctrl;
12879                   }
12880                 else if (to_bctrl < 65536)
12881                   {
12882                     *p++ = DW_CFA_advance_loc2;
12883                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12884                     p += 2;
12885                   }
12886                 else
12887                   {
12888                     *p++ = DW_CFA_advance_loc4;
12889                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12890                     p += 4;
12891                   }
12892                 *p++ = DW_CFA_offset_extended_sf;
12893                 *p++ = 65;
12894                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12895                 *p++ = DW_CFA_advance_loc + 4;
12896                 *p++ = DW_CFA_restore_extended;
12897                 *p++ = 65;
12898               }
12899             /* Pad.  */
12900             p = last_fde + last_fde_len + 4;
12901           }
12902       if (htab->glink != NULL && htab->glink->size != 0)
12903         {
12904           last_fde = p;
12905           last_fde_len = ((24 + align - 1) & -align) - 4;
12906           /* FDE length.  */
12907           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12908           p += 4;
12909           /* CIE pointer.  */
12910           val = p - htab->glink_eh_frame->contents;
12911           bfd_put_32 (htab->elf.dynobj, val, p);
12912           p += 4;
12913           /* Offset to .glink, written later.  */
12914           p += 4;
12915           /* .glink size.  */
12916           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12917           p += 4;
12918           /* Augmentation.  */
12919           p += 1;
12920
12921           *p++ = DW_CFA_advance_loc + 1;
12922           *p++ = DW_CFA_register;
12923           *p++ = 65;
12924           *p++ = htab->opd_abi ? 12 : 0;
12925           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12926           *p++ = DW_CFA_restore_extended;
12927           *p++ = 65;
12928           p += ((24 + align - 1) & -align) - 24;
12929         }
12930       /* Subsume any padding into the last FDE if user .eh_frame
12931          sections are aligned more than glink_eh_frame.  Otherwise any
12932          zero padding will be seen as a terminator.  */
12933       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12934       size = p - htab->glink_eh_frame->contents;
12935       pad = ((size + align - 1) & -align) - size;
12936       htab->glink_eh_frame->size = size + pad;
12937       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12938     }
12939
12940   maybe_strip_output (info, htab->brlt);
12941   if (htab->glink_eh_frame != NULL)
12942     maybe_strip_output (info, htab->glink_eh_frame);
12943
12944   return TRUE;
12945 }
12946
12947 /* Called after we have determined section placement.  If sections
12948    move, we'll be called again.  Provide a value for TOCstart.  */
12949
12950 bfd_vma
12951 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12952 {
12953   asection *s;
12954   bfd_vma TOCstart, adjust;
12955
12956   if (info != NULL)
12957     {
12958       struct elf_link_hash_entry *h;
12959       struct elf_link_hash_table *htab = elf_hash_table (info);
12960
12961       if (is_elf_hash_table (htab)
12962           && htab->hgot != NULL)
12963         h = htab->hgot;
12964       else
12965         {
12966           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12967           if (is_elf_hash_table (htab))
12968             htab->hgot = h;
12969         }
12970       if (h != NULL
12971           && h->root.type == bfd_link_hash_defined
12972           && !h->root.linker_def
12973           && (!is_elf_hash_table (htab)
12974               || h->def_regular))
12975         {
12976           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12977                       + h->root.u.def.section->output_offset
12978                       + h->root.u.def.section->output_section->vma);
12979           _bfd_set_gp_value (obfd, TOCstart);
12980           return TOCstart;
12981         }
12982     }
12983
12984   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12985      order.  The TOC starts where the first of these sections starts.  */
12986   s = bfd_get_section_by_name (obfd, ".got");
12987   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12988     s = bfd_get_section_by_name (obfd, ".toc");
12989   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12990     s = bfd_get_section_by_name (obfd, ".tocbss");
12991   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12992     s = bfd_get_section_by_name (obfd, ".plt");
12993   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12994     {
12995       /* This may happen for
12996          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12997          .toc directive
12998          o  bad linker script
12999          o --gc-sections and empty TOC sections
13000
13001          FIXME: Warn user?  */
13002
13003       /* Look for a likely section.  We probably won't even be
13004          using TOCstart.  */
13005       for (s = obfd->sections; s != NULL; s = s->next)
13006         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13007                          | SEC_EXCLUDE))
13008             == (SEC_ALLOC | SEC_SMALL_DATA))
13009           break;
13010       if (s == NULL)
13011         for (s = obfd->sections; s != NULL; s = s->next)
13012           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13013               == (SEC_ALLOC | SEC_SMALL_DATA))
13014             break;
13015       if (s == NULL)
13016         for (s = obfd->sections; s != NULL; s = s->next)
13017           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13018               == SEC_ALLOC)
13019             break;
13020       if (s == NULL)
13021         for (s = obfd->sections; s != NULL; s = s->next)
13022           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13023             break;
13024     }
13025
13026   TOCstart = 0;
13027   if (s != NULL)
13028     TOCstart = s->output_section->vma + s->output_offset;
13029
13030   /* Force alignment.  */
13031   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13032   TOCstart -= adjust;
13033   _bfd_set_gp_value (obfd, TOCstart);
13034
13035   if (info != NULL && s != NULL)
13036     {
13037       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13038
13039       if (htab != NULL)
13040         {
13041           if (htab->elf.hgot != NULL)
13042             {
13043               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13044               htab->elf.hgot->root.u.def.section = s;
13045             }
13046         }
13047       else
13048         {
13049           struct bfd_link_hash_entry *bh = NULL;
13050           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13051                                             s, TOC_BASE_OFF - adjust,
13052                                             NULL, FALSE, FALSE, &bh);
13053         }
13054     }
13055   return TOCstart;
13056 }
13057
13058 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13059    write out any global entry stubs, and PLT relocations.  */
13060
13061 static bfd_boolean
13062 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13063 {
13064   struct bfd_link_info *info;
13065   struct ppc_link_hash_table *htab;
13066   struct plt_entry *ent;
13067   asection *s;
13068
13069   if (h->root.type == bfd_link_hash_indirect)
13070     return TRUE;
13071
13072   info = inf;
13073   htab = ppc_hash_table (info);
13074   if (htab == NULL)
13075     return FALSE;
13076
13077   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13078     if (ent->plt.offset != (bfd_vma) -1)
13079       {
13080         /* This symbol has an entry in the procedure linkage
13081            table.  Set it up.  */
13082         Elf_Internal_Rela rela;
13083         asection *plt, *relplt;
13084         bfd_byte *loc;
13085
13086         if (!htab->elf.dynamic_sections_created
13087             || h->dynindx == -1)
13088           {
13089             if (!(h->def_regular
13090                   && (h->root.type == bfd_link_hash_defined
13091                       || h->root.type == bfd_link_hash_defweak)))
13092               continue;
13093             if (h->type == STT_GNU_IFUNC)
13094               {
13095                 plt = htab->elf.iplt;
13096                 relplt = htab->elf.irelplt;
13097                 htab->local_ifunc_resolver = 1;
13098                 if (htab->opd_abi)
13099                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13100                 else
13101                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13102               }
13103             else
13104               {
13105                 plt = htab->pltlocal;
13106                 if (bfd_link_pic (info))
13107                   {
13108                     relplt = htab->relpltlocal;
13109                     if (htab->opd_abi)
13110                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13111                     else
13112                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13113                   }
13114                 else
13115                   relplt = NULL;
13116               }
13117             rela.r_addend = (h->root.u.def.value
13118                              + h->root.u.def.section->output_offset
13119                              + h->root.u.def.section->output_section->vma
13120                              + ent->addend);
13121
13122             if (relplt == NULL)
13123               {
13124                 loc = plt->contents + ent->plt.offset;
13125                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13126                 if (htab->opd_abi)
13127                   {
13128                     bfd_vma toc = elf_gp (info->output_bfd);
13129                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13130                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13131                   }
13132               }
13133             else
13134               {
13135                 rela.r_offset = (plt->output_section->vma
13136                                  + plt->output_offset
13137                                  + ent->plt.offset);
13138                 loc = relplt->contents + (relplt->reloc_count++
13139                                           * sizeof (Elf64_External_Rela));
13140                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13141               }
13142           }
13143         else
13144           {
13145             rela.r_offset = (htab->elf.splt->output_section->vma
13146                              + htab->elf.splt->output_offset
13147                              + ent->plt.offset);
13148             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13149             rela.r_addend = ent->addend;
13150             loc = (htab->elf.srelplt->contents
13151                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13152                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13153             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13154               htab->maybe_local_ifunc_resolver = 1;
13155             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13156           }
13157       }
13158
13159   if (!h->pointer_equality_needed)
13160     return TRUE;
13161
13162   if (h->def_regular)
13163     return TRUE;
13164
13165   s = htab->global_entry;
13166   if (s == NULL || s->size == 0)
13167     return TRUE;
13168
13169   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13170     if (ent->plt.offset != (bfd_vma) -1
13171         && ent->addend == 0)
13172       {
13173         bfd_byte *p;
13174         asection *plt;
13175         bfd_vma off;
13176
13177         p = s->contents + h->root.u.def.value;
13178         plt = htab->elf.splt;
13179         if (!htab->elf.dynamic_sections_created
13180             || h->dynindx == -1)
13181           {
13182             if (h->type == STT_GNU_IFUNC)
13183               plt = htab->elf.iplt;
13184             else
13185               plt = htab->pltlocal;
13186           }
13187         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13188         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13189
13190         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13191           {
13192             info->callbacks->einfo
13193               (_("%P: linkage table error against `%pT'\n"),
13194                h->root.root.string);
13195             bfd_set_error (bfd_error_bad_value);
13196             htab->stub_error = TRUE;
13197           }
13198
13199         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13200         if (htab->params->emit_stub_syms)
13201           {
13202             size_t len = strlen (h->root.root.string);
13203             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13204
13205             if (name == NULL)
13206               return FALSE;
13207
13208             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13209             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13210             if (h == NULL)
13211               return FALSE;
13212             if (h->root.type == bfd_link_hash_new)
13213               {
13214                 h->root.type = bfd_link_hash_defined;
13215                 h->root.u.def.section = s;
13216                 h->root.u.def.value = p - s->contents;
13217                 h->ref_regular = 1;
13218                 h->def_regular = 1;
13219                 h->ref_regular_nonweak = 1;
13220                 h->forced_local = 1;
13221                 h->non_elf = 0;
13222                 h->root.linker_def = 1;
13223               }
13224           }
13225
13226         if (PPC_HA (off) != 0)
13227           {
13228             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13229             p += 4;
13230           }
13231         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13232         p += 4;
13233         bfd_put_32 (s->owner, MTCTR_R12, p);
13234         p += 4;
13235         bfd_put_32 (s->owner, BCTR, p);
13236         break;
13237       }
13238   return TRUE;
13239 }
13240
13241 /* Write PLT relocs for locals.  */
13242
13243 static bfd_boolean
13244 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13245 {
13246   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13247   bfd *ibfd;
13248
13249   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13250     {
13251       struct got_entry **lgot_ents, **end_lgot_ents;
13252       struct plt_entry **local_plt, **lplt, **end_local_plt;
13253       Elf_Internal_Shdr *symtab_hdr;
13254       bfd_size_type locsymcount;
13255       Elf_Internal_Sym *local_syms = NULL;
13256       struct plt_entry *ent;
13257
13258       if (!is_ppc64_elf (ibfd))
13259         continue;
13260
13261       lgot_ents = elf_local_got_ents (ibfd);
13262       if (!lgot_ents)
13263         continue;
13264
13265       symtab_hdr = &elf_symtab_hdr (ibfd);
13266       locsymcount = symtab_hdr->sh_info;
13267       end_lgot_ents = lgot_ents + locsymcount;
13268       local_plt = (struct plt_entry **) end_lgot_ents;
13269       end_local_plt = local_plt + locsymcount;
13270       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13271         for (ent = *lplt; ent != NULL; ent = ent->next)
13272           if (ent->plt.offset != (bfd_vma) -1)
13273             {
13274               Elf_Internal_Sym *sym;
13275               asection *sym_sec;
13276               asection *plt, *relplt;
13277               bfd_byte *loc;
13278               bfd_vma val;
13279
13280               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13281                               lplt - local_plt, ibfd))
13282                 {
13283                   if (local_syms != NULL
13284                       && symtab_hdr->contents != (unsigned char *) local_syms)
13285                     free (local_syms);
13286                   return FALSE;
13287                 }
13288
13289               val = sym->st_value + ent->addend;
13290               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13291               if (sym_sec != NULL && sym_sec->output_section != NULL)
13292                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13293
13294               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13295                 {
13296                   htab->local_ifunc_resolver = 1;
13297                   plt = htab->elf.iplt;
13298                   relplt = htab->elf.irelplt;
13299                 }
13300               else
13301                 {
13302                   plt = htab->pltlocal;
13303                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13304                 }
13305
13306               if (relplt == NULL)
13307                 {
13308                   loc = plt->contents + ent->plt.offset;
13309                   bfd_put_64 (info->output_bfd, val, loc);
13310                   if (htab->opd_abi)
13311                     {
13312                       bfd_vma toc = elf_gp (ibfd);
13313                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13314                     }
13315                 }
13316               else
13317                 {
13318                   Elf_Internal_Rela rela;
13319                   rela.r_offset = (ent->plt.offset
13320                                    + plt->output_offset
13321                                    + plt->output_section->vma);
13322                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13323                     {
13324                       if (htab->opd_abi)
13325                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13326                       else
13327                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13328                     }
13329                   else
13330                     {
13331                       if (htab->opd_abi)
13332                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13333                       else
13334                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13335                     }
13336                   rela.r_addend = val;
13337                   loc = relplt->contents + (relplt->reloc_count++
13338                                             * sizeof (Elf64_External_Rela));
13339                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13340                 }
13341             }
13342
13343       if (local_syms != NULL
13344           && symtab_hdr->contents != (unsigned char *) local_syms)
13345         {
13346           if (!info->keep_memory)
13347             free (local_syms);
13348           else
13349             symtab_hdr->contents = (unsigned char *) local_syms;
13350         }
13351     }
13352   return TRUE;
13353 }
13354
13355 /* Build all the stubs associated with the current output file.
13356    The stubs are kept in a hash table attached to the main linker
13357    hash table.  This function is called via gldelf64ppc_finish.  */
13358
13359 bfd_boolean
13360 ppc64_elf_build_stubs (struct bfd_link_info *info,
13361                        char **stats)
13362 {
13363   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13364   struct map_stub *group;
13365   asection *stub_sec;
13366   bfd_byte *p;
13367   int stub_sec_count = 0;
13368
13369   if (htab == NULL)
13370     return FALSE;
13371
13372   /* Allocate memory to hold the linker stubs.  */
13373   for (group = htab->group; group != NULL; group = group->next)
13374     if ((stub_sec = group->stub_sec) != NULL
13375         && stub_sec->size != 0)
13376       {
13377         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13378         if (stub_sec->contents == NULL)
13379           return FALSE;
13380         stub_sec->size = 0;
13381       }
13382
13383   if (htab->glink != NULL && htab->glink->size != 0)
13384     {
13385       unsigned int indx;
13386       bfd_vma plt0;
13387
13388       /* Build the .glink plt call stub.  */
13389       if (htab->params->emit_stub_syms)
13390         {
13391           struct elf_link_hash_entry *h;
13392           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13393                                     TRUE, FALSE, FALSE);
13394           if (h == NULL)
13395             return FALSE;
13396           if (h->root.type == bfd_link_hash_new)
13397             {
13398               h->root.type = bfd_link_hash_defined;
13399               h->root.u.def.section = htab->glink;
13400               h->root.u.def.value = 8;
13401               h->ref_regular = 1;
13402               h->def_regular = 1;
13403               h->ref_regular_nonweak = 1;
13404               h->forced_local = 1;
13405               h->non_elf = 0;
13406               h->root.linker_def = 1;
13407             }
13408         }
13409       plt0 = (htab->elf.splt->output_section->vma
13410               + htab->elf.splt->output_offset
13411               - 16);
13412       if (info->emitrelocations)
13413         {
13414           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13415           if (r == NULL)
13416             return FALSE;
13417           r->r_offset = (htab->glink->output_offset
13418                          + htab->glink->output_section->vma);
13419           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13420           r->r_addend = plt0;
13421         }
13422       p = htab->glink->contents;
13423       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13424       bfd_put_64 (htab->glink->owner, plt0, p);
13425       p += 8;
13426       if (htab->opd_abi)
13427         {
13428           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13429           p += 4;
13430           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13431           p += 4;
13432           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13433           p += 4;
13434           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13435           p += 4;
13436           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13437           p += 4;
13438           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13439           p += 4;
13440           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13441           p += 4;
13442           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13443           p += 4;
13444           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13445           p += 4;
13446           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13447           p += 4;
13448         }
13449       else
13450         {
13451           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13452           p += 4;
13453           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13454           p += 4;
13455           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13456           p += 4;
13457           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13458           p += 4;
13459           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13460           p += 4;
13461           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13462           p += 4;
13463           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13464           p += 4;
13465           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13466           p += 4;
13467           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13468           p += 4;
13469           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13470           p += 4;
13471           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13472           p += 4;
13473           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13474           p += 4;
13475           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13476           p += 4;
13477         }
13478       bfd_put_32 (htab->glink->owner, BCTR, p);
13479       p += 4;
13480       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13481
13482       /* Build the .glink lazy link call stubs.  */
13483       indx = 0;
13484       while (p < htab->glink->contents + htab->glink->size)
13485         {
13486           if (htab->opd_abi)
13487             {
13488               if (indx < 0x8000)
13489                 {
13490                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13491                   p += 4;
13492                 }
13493               else
13494                 {
13495                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13496                   p += 4;
13497                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13498                               p);
13499                   p += 4;
13500                 }
13501             }
13502           bfd_put_32 (htab->glink->owner,
13503                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13504           indx++;
13505           p += 4;
13506         }
13507     }
13508
13509   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13510   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13511
13512   if (!write_plt_relocs_for_local_syms (info))
13513     return FALSE;
13514
13515   if (htab->brlt != NULL && htab->brlt->size != 0)
13516     {
13517       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13518                                          htab->brlt->size);
13519       if (htab->brlt->contents == NULL)
13520         return FALSE;
13521     }
13522   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13523     {
13524       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13525                                             htab->relbrlt->size);
13526       if (htab->relbrlt->contents == NULL)
13527         return FALSE;
13528     }
13529
13530   /* Build the stubs as directed by the stub hash table.  */
13531   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13532
13533   for (group = htab->group; group != NULL; group = group->next)
13534     if (group->needs_save_res)
13535       group->stub_sec->size += htab->sfpr->size;
13536
13537   if (htab->relbrlt != NULL)
13538     htab->relbrlt->reloc_count = 0;
13539
13540   if (htab->params->plt_stub_align != 0)
13541     for (group = htab->group; group != NULL; group = group->next)
13542       if ((stub_sec = group->stub_sec) != NULL)
13543         {
13544           int align = abs (htab->params->plt_stub_align);
13545           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13546         }
13547
13548   for (group = htab->group; group != NULL; group = group->next)
13549     if (group->needs_save_res)
13550       {
13551         stub_sec = group->stub_sec;
13552         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13553                 htab->sfpr->contents, htab->sfpr->size);
13554         if (htab->params->emit_stub_syms)
13555           {
13556             unsigned int i;
13557
13558             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13559               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13560                 return FALSE;
13561           }
13562       }
13563
13564   for (group = htab->group; group != NULL; group = group->next)
13565     if ((stub_sec = group->stub_sec) != NULL)
13566       {
13567         stub_sec_count += 1;
13568         if (stub_sec->rawsize != stub_sec->size
13569             && (htab->stub_iteration <= STUB_SHRINK_ITER
13570                 || stub_sec->rawsize < stub_sec->size))
13571           break;
13572       }
13573
13574   if (group != NULL)
13575     {
13576       htab->stub_error = TRUE;
13577       _bfd_error_handler (_("stubs don't match calculated size"));
13578     }
13579
13580   if (htab->stub_error)
13581     return FALSE;
13582
13583   if (stats != NULL)
13584     {
13585       size_t len;
13586       *stats = bfd_malloc (500);
13587       if (*stats == NULL)
13588         return FALSE;
13589
13590       len = sprintf (*stats,
13591                      ngettext ("linker stubs in %u group\n",
13592                                "linker stubs in %u groups\n",
13593                                stub_sec_count),
13594                      stub_sec_count);
13595       sprintf (*stats + len, _("  branch       %lu\n"
13596                                "  toc adjust   %lu\n"
13597                                "  long branch  %lu\n"
13598                                "  long toc adj %lu\n"
13599                                "  plt call     %lu\n"
13600                                "  plt call toc %lu\n"
13601                                "  global entry %lu"),
13602                htab->stub_count[ppc_stub_long_branch - 1],
13603                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13604                htab->stub_count[ppc_stub_plt_branch - 1],
13605                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13606                htab->stub_count[ppc_stub_plt_call - 1],
13607                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13608                htab->stub_count[ppc_stub_global_entry - 1]);
13609     }
13610   return TRUE;
13611 }
13612
13613 /* What to do when ld finds relocations against symbols defined in
13614    discarded sections.  */
13615
13616 static unsigned int
13617 ppc64_elf_action_discarded (asection *sec)
13618 {
13619   if (strcmp (".opd", sec->name) == 0)
13620     return 0;
13621
13622   if (strcmp (".toc", sec->name) == 0)
13623     return 0;
13624
13625   if (strcmp (".toc1", sec->name) == 0)
13626     return 0;
13627
13628   return _bfd_elf_default_action_discarded (sec);
13629 }
13630
13631 /* The RELOCATE_SECTION function is called by the ELF backend linker
13632    to handle the relocations for a section.
13633
13634    The relocs are always passed as Rela structures; if the section
13635    actually uses Rel structures, the r_addend field will always be
13636    zero.
13637
13638    This function is responsible for adjust the section contents as
13639    necessary, and (if using Rela relocs and generating a
13640    relocatable output file) adjusting the reloc addend as
13641    necessary.
13642
13643    This function does not have to worry about setting the reloc
13644    address or the reloc symbol index.
13645
13646    LOCAL_SYMS is a pointer to the swapped in local symbols.
13647
13648    LOCAL_SECTIONS is an array giving the section in the input file
13649    corresponding to the st_shndx field of each local symbol.
13650
13651    The global hash table entry for the global symbols can be found
13652    via elf_sym_hashes (input_bfd).
13653
13654    When generating relocatable output, this function must handle
13655    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13656    going to be the section symbol corresponding to the output
13657    section, which means that the addend must be adjusted
13658    accordingly.  */
13659
13660 static bfd_boolean
13661 ppc64_elf_relocate_section (bfd *output_bfd,
13662                             struct bfd_link_info *info,
13663                             bfd *input_bfd,
13664                             asection *input_section,
13665                             bfd_byte *contents,
13666                             Elf_Internal_Rela *relocs,
13667                             Elf_Internal_Sym *local_syms,
13668                             asection **local_sections)
13669 {
13670   struct ppc_link_hash_table *htab;
13671   Elf_Internal_Shdr *symtab_hdr;
13672   struct elf_link_hash_entry **sym_hashes;
13673   Elf_Internal_Rela *rel;
13674   Elf_Internal_Rela *wrel;
13675   Elf_Internal_Rela *relend;
13676   Elf_Internal_Rela outrel;
13677   bfd_byte *loc;
13678   struct got_entry **local_got_ents;
13679   bfd_vma TOCstart;
13680   bfd_boolean ret = TRUE;
13681   bfd_boolean is_opd;
13682   /* Assume 'at' branch hints.  */
13683   bfd_boolean is_isa_v2 = TRUE;
13684   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13685
13686   /* Initialize howto table if needed.  */
13687   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13688     ppc_howto_init ();
13689
13690   htab = ppc_hash_table (info);
13691   if (htab == NULL)
13692     return FALSE;
13693
13694   /* Don't relocate stub sections.  */
13695   if (input_section->owner == htab->params->stub_bfd)
13696     return TRUE;
13697
13698   BFD_ASSERT (is_ppc64_elf (input_bfd));
13699
13700   local_got_ents = elf_local_got_ents (input_bfd);
13701   TOCstart = elf_gp (output_bfd);
13702   symtab_hdr = &elf_symtab_hdr (input_bfd);
13703   sym_hashes = elf_sym_hashes (input_bfd);
13704   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13705
13706   rel = wrel = relocs;
13707   relend = relocs + input_section->reloc_count;
13708   for (; rel < relend; wrel++, rel++)
13709     {
13710       enum elf_ppc64_reloc_type r_type;
13711       bfd_vma addend;
13712       bfd_reloc_status_type r;
13713       Elf_Internal_Sym *sym;
13714       asection *sec;
13715       struct elf_link_hash_entry *h_elf;
13716       struct ppc_link_hash_entry *h;
13717       struct ppc_link_hash_entry *fdh;
13718       const char *sym_name;
13719       unsigned long r_symndx, toc_symndx;
13720       bfd_vma toc_addend;
13721       unsigned char tls_mask, tls_gd, tls_type;
13722       unsigned char sym_type;
13723       bfd_vma relocation;
13724       bfd_boolean unresolved_reloc;
13725       bfd_boolean warned;
13726       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13727       unsigned int insn;
13728       unsigned int mask;
13729       struct ppc_stub_hash_entry *stub_entry;
13730       bfd_vma max_br_offset;
13731       bfd_vma from;
13732       Elf_Internal_Rela orig_rel;
13733       reloc_howto_type *howto;
13734       struct reloc_howto_struct alt_howto;
13735
13736     again:
13737       orig_rel = *rel;
13738
13739       r_type = ELF64_R_TYPE (rel->r_info);
13740       r_symndx = ELF64_R_SYM (rel->r_info);
13741
13742       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13743          symbol of the previous ADDR64 reloc.  The symbol gives us the
13744          proper TOC base to use.  */
13745       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13746           && wrel != relocs
13747           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13748           && is_opd)
13749         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13750
13751       sym = NULL;
13752       sec = NULL;
13753       h_elf = NULL;
13754       sym_name = NULL;
13755       unresolved_reloc = FALSE;
13756       warned = FALSE;
13757
13758       if (r_symndx < symtab_hdr->sh_info)
13759         {
13760           /* It's a local symbol.  */
13761           struct _opd_sec_data *opd;
13762
13763           sym = local_syms + r_symndx;
13764           sec = local_sections[r_symndx];
13765           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13766           sym_type = ELF64_ST_TYPE (sym->st_info);
13767           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13768           opd = get_opd_info (sec);
13769           if (opd != NULL && opd->adjust != NULL)
13770             {
13771               long adjust = opd->adjust[OPD_NDX (sym->st_value
13772                                                  + rel->r_addend)];
13773               if (adjust == -1)
13774                 relocation = 0;
13775               else
13776                 {
13777                   /* If this is a relocation against the opd section sym
13778                      and we have edited .opd, adjust the reloc addend so
13779                      that ld -r and ld --emit-relocs output is correct.
13780                      If it is a reloc against some other .opd symbol,
13781                      then the symbol value will be adjusted later.  */
13782                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13783                     rel->r_addend += adjust;
13784                   else
13785                     relocation += adjust;
13786                 }
13787             }
13788         }
13789       else
13790         {
13791           bfd_boolean ignored;
13792
13793           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13794                                    r_symndx, symtab_hdr, sym_hashes,
13795                                    h_elf, sec, relocation,
13796                                    unresolved_reloc, warned, ignored);
13797           sym_name = h_elf->root.root.string;
13798           sym_type = h_elf->type;
13799           if (sec != NULL
13800               && sec->owner == output_bfd
13801               && strcmp (sec->name, ".opd") == 0)
13802             {
13803               /* This is a symbol defined in a linker script.  All
13804                  such are defined in output sections, even those
13805                  defined by simple assignment from a symbol defined in
13806                  an input section.  Transfer the symbol to an
13807                  appropriate input .opd section, so that a branch to
13808                  this symbol will be mapped to the location specified
13809                  by the opd entry.  */
13810               struct bfd_link_order *lo;
13811               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13812                 if (lo->type == bfd_indirect_link_order)
13813                   {
13814                     asection *isec = lo->u.indirect.section;
13815                     if (h_elf->root.u.def.value >= isec->output_offset
13816                         && h_elf->root.u.def.value < (isec->output_offset
13817                                                       + isec->size))
13818                       {
13819                         h_elf->root.u.def.value -= isec->output_offset;
13820                         h_elf->root.u.def.section = isec;
13821                         sec = isec;
13822                         break;
13823                       }
13824                   }
13825             }
13826         }
13827       h = (struct ppc_link_hash_entry *) h_elf;
13828
13829       if (sec != NULL && discarded_section (sec))
13830         {
13831           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13832                                input_bfd, input_section,
13833                                contents + rel->r_offset);
13834           wrel->r_offset = rel->r_offset;
13835           wrel->r_info = 0;
13836           wrel->r_addend = 0;
13837
13838           /* For ld -r, remove relocations in debug sections against
13839              symbols defined in discarded sections.  Not done for
13840              non-debug to preserve relocs in .eh_frame which the
13841              eh_frame editing code expects to be present.  */
13842           if (bfd_link_relocatable (info)
13843               && (input_section->flags & SEC_DEBUGGING))
13844             wrel--;
13845
13846           continue;
13847         }
13848
13849       if (bfd_link_relocatable (info))
13850         goto copy_reloc;
13851
13852       if (h != NULL && &h->elf == htab->elf.hgot)
13853         {
13854           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13855           sec = bfd_abs_section_ptr;
13856           unresolved_reloc = FALSE;
13857         }
13858
13859       /* TLS optimizations.  Replace instruction sequences and relocs
13860          based on information we collected in tls_optimize.  We edit
13861          RELOCS so that --emit-relocs will output something sensible
13862          for the final instruction stream.  */
13863       tls_mask = 0;
13864       tls_gd = 0;
13865       toc_symndx = 0;
13866       if (h != NULL)
13867         tls_mask = h->tls_mask;
13868       else if (local_got_ents != NULL)
13869         {
13870           struct plt_entry **local_plt = (struct plt_entry **)
13871             (local_got_ents + symtab_hdr->sh_info);
13872           unsigned char *lgot_masks = (unsigned char *)
13873             (local_plt + symtab_hdr->sh_info);
13874           tls_mask = lgot_masks[r_symndx];
13875         }
13876       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
13877           && (r_type == R_PPC64_TLS
13878               || r_type == R_PPC64_TLSGD
13879               || r_type == R_PPC64_TLSLD))
13880         {
13881           /* Check for toc tls entries.  */
13882           unsigned char *toc_tls;
13883
13884           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13885                              &local_syms, rel, input_bfd))
13886             return FALSE;
13887
13888           if (toc_tls)
13889             tls_mask = *toc_tls;
13890         }
13891
13892       /* Check that tls relocs are used with tls syms, and non-tls
13893          relocs are used with non-tls syms.  */
13894       if (r_symndx != STN_UNDEF
13895           && r_type != R_PPC64_NONE
13896           && (h == NULL
13897               || h->elf.root.type == bfd_link_hash_defined
13898               || h->elf.root.type == bfd_link_hash_defweak)
13899           && (IS_PPC64_TLS_RELOC (r_type)
13900               != (sym_type == STT_TLS
13901                   || (sym_type == STT_SECTION
13902                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13903         {
13904           if ((tls_mask & TLS_TLS) != 0
13905               && (r_type == R_PPC64_TLS
13906                   || r_type == R_PPC64_TLSGD
13907                   || r_type == R_PPC64_TLSLD))
13908             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13909             ;
13910           else
13911             info->callbacks->einfo
13912               (!IS_PPC64_TLS_RELOC (r_type)
13913                /* xgettext:c-format */
13914                ? _("%H: %s used with TLS symbol `%pT'\n")
13915                /* xgettext:c-format */
13916                : _("%H: %s used with non-TLS symbol `%pT'\n"),
13917                input_bfd, input_section, rel->r_offset,
13918                ppc64_elf_howto_table[r_type]->name,
13919                sym_name);
13920         }
13921
13922       /* Ensure reloc mapping code below stays sane.  */
13923       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13924           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13925           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13926           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13927           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13928           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13929           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13930           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13931           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13932           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13933         abort ();
13934
13935       switch (r_type)
13936         {
13937         default:
13938           break;
13939
13940         case R_PPC64_LO_DS_OPT:
13941           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13942           if ((insn & (0x3f << 26)) != 58u << 26)
13943             abort ();
13944           insn += (14u << 26) - (58u << 26);
13945           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13946           r_type = R_PPC64_TOC16_LO;
13947           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13948           break;
13949
13950         case R_PPC64_TOC16:
13951         case R_PPC64_TOC16_LO:
13952         case R_PPC64_TOC16_DS:
13953         case R_PPC64_TOC16_LO_DS:
13954           {
13955             /* Check for toc tls entries.  */
13956             unsigned char *toc_tls;
13957             int retval;
13958
13959             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13960                                    &local_syms, rel, input_bfd);
13961             if (retval == 0)
13962               return FALSE;
13963
13964             if (toc_tls)
13965               {
13966                 tls_mask = *toc_tls;
13967                 if (r_type == R_PPC64_TOC16_DS
13968                     || r_type == R_PPC64_TOC16_LO_DS)
13969                   {
13970                     if ((tls_mask & TLS_TLS) != 0
13971                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13972                       goto toctprel;
13973                   }
13974                 else
13975                   {
13976                     /* If we found a GD reloc pair, then we might be
13977                        doing a GD->IE transition.  */
13978                     if (retval == 2)
13979                       {
13980                         tls_gd = TLS_TPRELGD;
13981                         if ((tls_mask & TLS_TLS) != 0
13982                             && (tls_mask & TLS_GD) == 0)
13983                           goto tls_ldgd_opt;
13984                       }
13985                     else if (retval == 3)
13986                       {
13987                         if ((tls_mask & TLS_TLS) != 0
13988                             && (tls_mask & TLS_LD) == 0)
13989                           goto tls_ldgd_opt;
13990                       }
13991                   }
13992               }
13993           }
13994           break;
13995
13996         case R_PPC64_GOT_TPREL16_HI:
13997         case R_PPC64_GOT_TPREL16_HA:
13998           if ((tls_mask & TLS_TLS) != 0
13999               && (tls_mask & TLS_TPREL) == 0)
14000             {
14001               rel->r_offset -= d_offset;
14002               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14003               r_type = R_PPC64_NONE;
14004               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14005             }
14006           break;
14007
14008         case R_PPC64_GOT_TPREL16_DS:
14009         case R_PPC64_GOT_TPREL16_LO_DS:
14010           if ((tls_mask & TLS_TLS) != 0
14011               && (tls_mask & TLS_TPREL) == 0)
14012             {
14013             toctprel:
14014               insn = bfd_get_32 (input_bfd,
14015                                  contents + rel->r_offset - d_offset);
14016               insn &= 31 << 21;
14017               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14018               bfd_put_32 (input_bfd, insn,
14019                           contents + rel->r_offset - d_offset);
14020               r_type = R_PPC64_TPREL16_HA;
14021               if (toc_symndx != 0)
14022                 {
14023                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14024                   rel->r_addend = toc_addend;
14025                   /* We changed the symbol.  Start over in order to
14026                      get h, sym, sec etc. right.  */
14027                   goto again;
14028                 }
14029               else
14030                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14031             }
14032           break;
14033
14034         case R_PPC64_TLS:
14035           if ((tls_mask & TLS_TLS) != 0
14036               && (tls_mask & TLS_TPREL) == 0)
14037             {
14038               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14039               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14040               if (insn == 0)
14041                 abort ();
14042               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14043               /* Was PPC64_TLS which sits on insn boundary, now
14044                  PPC64_TPREL16_LO which is at low-order half-word.  */
14045               rel->r_offset += d_offset;
14046               r_type = R_PPC64_TPREL16_LO;
14047               if (toc_symndx != 0)
14048                 {
14049                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14050                   rel->r_addend = toc_addend;
14051                   /* We changed the symbol.  Start over in order to
14052                      get h, sym, sec etc. right.  */
14053                   goto again;
14054                 }
14055               else
14056                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14057             }
14058           break;
14059
14060         case R_PPC64_GOT_TLSGD16_HI:
14061         case R_PPC64_GOT_TLSGD16_HA:
14062           tls_gd = TLS_TPRELGD;
14063           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14064             goto tls_gdld_hi;
14065           break;
14066
14067         case R_PPC64_GOT_TLSLD16_HI:
14068         case R_PPC64_GOT_TLSLD16_HA:
14069           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14070             {
14071             tls_gdld_hi:
14072               if ((tls_mask & tls_gd) != 0)
14073                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14074                           + R_PPC64_GOT_TPREL16_DS);
14075               else
14076                 {
14077                   rel->r_offset -= d_offset;
14078                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14079                   r_type = R_PPC64_NONE;
14080                 }
14081               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14082             }
14083           break;
14084
14085         case R_PPC64_GOT_TLSGD16:
14086         case R_PPC64_GOT_TLSGD16_LO:
14087           tls_gd = TLS_TPRELGD;
14088           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14089             goto tls_ldgd_opt;
14090           break;
14091
14092         case R_PPC64_GOT_TLSLD16:
14093         case R_PPC64_GOT_TLSLD16_LO:
14094           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14095             {
14096               unsigned int insn1, insn2;
14097               bfd_vma offset;
14098
14099             tls_ldgd_opt:
14100               offset = (bfd_vma) -1;
14101               /* If not using the newer R_PPC64_TLSGD/LD to mark
14102                  __tls_get_addr calls, we must trust that the call
14103                  stays with its arg setup insns, ie. that the next
14104                  reloc is the __tls_get_addr call associated with
14105                  the current reloc.  Edit both insns.  */
14106               if (input_section->has_tls_get_addr_call
14107                   && rel + 1 < relend
14108                   && branch_reloc_hash_match (input_bfd, rel + 1,
14109                                               htab->tls_get_addr,
14110                                               htab->tls_get_addr_fd))
14111                 offset = rel[1].r_offset;
14112               /* We read the low GOT_TLS (or TOC16) insn because we
14113                  need to keep the destination reg.  It may be
14114                  something other than the usual r3, and moved to r3
14115                  before the call by intervening code.  */
14116               insn1 = bfd_get_32 (input_bfd,
14117                                   contents + rel->r_offset - d_offset);
14118               if ((tls_mask & tls_gd) != 0)
14119                 {
14120                   /* IE */
14121                   insn1 &= (0x1f << 21) | (0x1f << 16);
14122                   insn1 |= 58 << 26;    /* ld */
14123                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14124                   if (offset != (bfd_vma) -1)
14125                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14126                   if ((tls_mask & TLS_EXPLICIT) == 0)
14127                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14128                               + R_PPC64_GOT_TPREL16_DS);
14129                   else
14130                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14131                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14132                 }
14133               else
14134                 {
14135                   /* LE */
14136                   insn1 &= 0x1f << 21;
14137                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14138                   insn2 = 0x38630000;   /* addi 3,3,0 */
14139                   if (tls_gd == 0)
14140                     {
14141                       /* Was an LD reloc.  */
14142                       if (toc_symndx)
14143                         sec = local_sections[toc_symndx];
14144                       for (r_symndx = 0;
14145                            r_symndx < symtab_hdr->sh_info;
14146                            r_symndx++)
14147                         if (local_sections[r_symndx] == sec)
14148                           break;
14149                       if (r_symndx >= symtab_hdr->sh_info)
14150                         r_symndx = STN_UNDEF;
14151                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14152                       if (r_symndx != STN_UNDEF)
14153                         rel->r_addend -= (local_syms[r_symndx].st_value
14154                                           + sec->output_offset
14155                                           + sec->output_section->vma);
14156                     }
14157                   else if (toc_symndx != 0)
14158                     {
14159                       r_symndx = toc_symndx;
14160                       rel->r_addend = toc_addend;
14161                     }
14162                   r_type = R_PPC64_TPREL16_HA;
14163                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14164                   if (offset != (bfd_vma) -1)
14165                     {
14166                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14167                                                     R_PPC64_TPREL16_LO);
14168                       rel[1].r_offset = offset + d_offset;
14169                       rel[1].r_addend = rel->r_addend;
14170                     }
14171                 }
14172               bfd_put_32 (input_bfd, insn1,
14173                           contents + rel->r_offset - d_offset);
14174               if (offset != (bfd_vma) -1)
14175                 bfd_put_32 (input_bfd, insn2, contents + offset);
14176               if ((tls_mask & tls_gd) == 0
14177                   && (tls_gd == 0 || toc_symndx != 0))
14178                 {
14179                   /* We changed the symbol.  Start over in order
14180                      to get h, sym, sec etc. right.  */
14181                   goto again;
14182                 }
14183             }
14184           break;
14185
14186         case R_PPC64_TLSGD:
14187           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14188               && rel + 1 < relend)
14189             {
14190               unsigned int insn2;
14191               bfd_vma offset = rel->r_offset;
14192
14193               if ((tls_mask & TLS_TPRELGD) != 0)
14194                 {
14195                   /* IE */
14196                   r_type = R_PPC64_NONE;
14197                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14198                 }
14199               else
14200                 {
14201                   /* LE */
14202                   if (toc_symndx != 0)
14203                     {
14204                       r_symndx = toc_symndx;
14205                       rel->r_addend = toc_addend;
14206                     }
14207                   r_type = R_PPC64_TPREL16_LO;
14208                   rel->r_offset = offset + d_offset;
14209                   insn2 = 0x38630000;   /* addi 3,3,0 */
14210                 }
14211               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14212               /* Zap the reloc on the _tls_get_addr call too.  */
14213               BFD_ASSERT (offset == rel[1].r_offset);
14214               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14215               bfd_put_32 (input_bfd, insn2, contents + offset);
14216               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14217                 goto again;
14218             }
14219           break;
14220
14221         case R_PPC64_TLSLD:
14222           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14223               && rel + 1 < relend)
14224             {
14225               unsigned int insn2;
14226               bfd_vma offset = rel->r_offset;
14227
14228               if (toc_symndx)
14229                 sec = local_sections[toc_symndx];
14230               for (r_symndx = 0;
14231                    r_symndx < symtab_hdr->sh_info;
14232                    r_symndx++)
14233                 if (local_sections[r_symndx] == sec)
14234                   break;
14235               if (r_symndx >= symtab_hdr->sh_info)
14236                 r_symndx = STN_UNDEF;
14237               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14238               if (r_symndx != STN_UNDEF)
14239                 rel->r_addend -= (local_syms[r_symndx].st_value
14240                                   + sec->output_offset
14241                                   + sec->output_section->vma);
14242
14243               r_type = R_PPC64_TPREL16_LO;
14244               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14245               rel->r_offset = offset + d_offset;
14246               /* Zap the reloc on the _tls_get_addr call too.  */
14247               BFD_ASSERT (offset == rel[1].r_offset);
14248               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14249               insn2 = 0x38630000;       /* addi 3,3,0 */
14250               bfd_put_32 (input_bfd, insn2, contents + offset);
14251               goto again;
14252             }
14253           break;
14254
14255         case R_PPC64_DTPMOD64:
14256           if (rel + 1 < relend
14257               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14258               && rel[1].r_offset == rel->r_offset + 8)
14259             {
14260               if ((tls_mask & TLS_GD) == 0)
14261                 {
14262                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14263                   if ((tls_mask & TLS_TPRELGD) != 0)
14264                     r_type = R_PPC64_TPREL64;
14265                   else
14266                     {
14267                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14268                       r_type = R_PPC64_NONE;
14269                     }
14270                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14271                 }
14272             }
14273           else
14274             {
14275               if ((tls_mask & TLS_LD) == 0)
14276                 {
14277                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14278                   r_type = R_PPC64_NONE;
14279                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14280                 }
14281             }
14282           break;
14283
14284         case R_PPC64_TPREL64:
14285           if ((tls_mask & TLS_TPREL) == 0)
14286             {
14287               r_type = R_PPC64_NONE;
14288               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14289             }
14290           break;
14291
14292         case R_PPC64_ENTRY:
14293           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14294           if (!bfd_link_pic (info)
14295               && !info->traditional_format
14296               && relocation + 0x80008000 <= 0xffffffff)
14297             {
14298               unsigned int insn1, insn2;
14299
14300               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14301               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14302               if ((insn1 & ~0xfffc) == LD_R2_0R12
14303                   && insn2 == ADD_R2_R2_R12)
14304                 {
14305                   bfd_put_32 (input_bfd,
14306                               LIS_R2 + PPC_HA (relocation),
14307                               contents + rel->r_offset);
14308                   bfd_put_32 (input_bfd,
14309                               ADDI_R2_R2 + PPC_LO (relocation),
14310                               contents + rel->r_offset + 4);
14311                 }
14312             }
14313           else
14314             {
14315               relocation -= (rel->r_offset
14316                              + input_section->output_offset
14317                              + input_section->output_section->vma);
14318               if (relocation + 0x80008000 <= 0xffffffff)
14319                 {
14320                   unsigned int insn1, insn2;
14321
14322                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14323                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14324                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14325                       && insn2 == ADD_R2_R2_R12)
14326                     {
14327                       bfd_put_32 (input_bfd,
14328                                   ADDIS_R2_R12 + PPC_HA (relocation),
14329                                   contents + rel->r_offset);
14330                       bfd_put_32 (input_bfd,
14331                                   ADDI_R2_R2 + PPC_LO (relocation),
14332                                   contents + rel->r_offset + 4);
14333                     }
14334                 }
14335             }
14336           break;
14337
14338         case R_PPC64_REL16_HA:
14339           /* If we are generating a non-PIC executable, edit
14340              .  0:      addis 2,12,.TOC.-0b@ha
14341              .          addi 2,2,.TOC.-0b@l
14342              used by ELFv2 global entry points to set up r2, to
14343              .          lis 2,.TOC.@ha
14344              .          addi 2,2,.TOC.@l
14345              if .TOC. is in range.  */
14346           if (!bfd_link_pic (info)
14347               && !info->traditional_format
14348               && !htab->opd_abi
14349               && rel->r_addend == d_offset
14350               && h != NULL && &h->elf == htab->elf.hgot
14351               && rel + 1 < relend
14352               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14353               && rel[1].r_offset == rel->r_offset + 4
14354               && rel[1].r_addend == rel->r_addend + 4
14355               && relocation + 0x80008000 <= 0xffffffff)
14356             {
14357               unsigned int insn1, insn2;
14358               bfd_vma offset = rel->r_offset - d_offset;
14359               insn1 = bfd_get_32 (input_bfd, contents + offset);
14360               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14361               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14362                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14363                 {
14364                   r_type = R_PPC64_ADDR16_HA;
14365                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14366                   rel->r_addend -= d_offset;
14367                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14368                   rel[1].r_addend -= d_offset + 4;
14369                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14370                 }
14371             }
14372           break;
14373         }
14374
14375       /* Handle other relocations that tweak non-addend part of insn.  */
14376       insn = 0;
14377       max_br_offset = 1 << 25;
14378       addend = rel->r_addend;
14379       reloc_dest = DEST_NORMAL;
14380       switch (r_type)
14381         {
14382         default:
14383           break;
14384
14385         case R_PPC64_TOCSAVE:
14386           if (relocation + addend == (rel->r_offset
14387                                       + input_section->output_offset
14388                                       + input_section->output_section->vma)
14389               && tocsave_find (htab, NO_INSERT,
14390                                &local_syms, rel, input_bfd))
14391             {
14392               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14393               if (insn == NOP
14394                   || insn == CROR_151515 || insn == CROR_313131)
14395                 bfd_put_32 (input_bfd,
14396                             STD_R2_0R1 + STK_TOC (htab),
14397                             contents + rel->r_offset);
14398             }
14399           break;
14400
14401           /* Branch taken prediction relocations.  */
14402         case R_PPC64_ADDR14_BRTAKEN:
14403         case R_PPC64_REL14_BRTAKEN:
14404           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14405           /* Fall through.  */
14406
14407           /* Branch not taken prediction relocations.  */
14408         case R_PPC64_ADDR14_BRNTAKEN:
14409         case R_PPC64_REL14_BRNTAKEN:
14410           insn |= bfd_get_32 (input_bfd,
14411                               contents + rel->r_offset) & ~(0x01 << 21);
14412           /* Fall through.  */
14413
14414         case R_PPC64_REL14:
14415           max_br_offset = 1 << 15;
14416           /* Fall through.  */
14417
14418         case R_PPC64_REL24:
14419           /* Calls to functions with a different TOC, such as calls to
14420              shared objects, need to alter the TOC pointer.  This is
14421              done using a linkage stub.  A REL24 branching to these
14422              linkage stubs needs to be followed by a nop, as the nop
14423              will be replaced with an instruction to restore the TOC
14424              base pointer.  */
14425           fdh = h;
14426           if (h != NULL
14427               && h->oh != NULL
14428               && h->oh->is_func_descriptor)
14429             fdh = ppc_follow_link (h->oh);
14430           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14431                                            htab);
14432           if (stub_entry != NULL
14433               && (stub_entry->stub_type == ppc_stub_plt_call
14434                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14435                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14436                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14437             {
14438               bfd_boolean can_plt_call = FALSE;
14439
14440               if (stub_entry->stub_type == ppc_stub_plt_call
14441                   && !htab->opd_abi
14442                   && htab->params->plt_localentry0 != 0
14443                   && is_elfv2_localentry0 (&h->elf))
14444                 {
14445                   /* The function doesn't use or change r2.  */
14446                   can_plt_call = TRUE;
14447                 }
14448
14449               /* All of these stubs may modify r2, so there must be a
14450                  branch and link followed by a nop.  The nop is
14451                  replaced by an insn to restore r2.  */
14452               else if (rel->r_offset + 8 <= input_section->size)
14453                 {
14454                   unsigned long br;
14455
14456                   br = bfd_get_32 (input_bfd,
14457                                    contents + rel->r_offset);
14458                   if ((br & 1) != 0)
14459                     {
14460                       unsigned long nop;
14461
14462                       nop = bfd_get_32 (input_bfd,
14463                                         contents + rel->r_offset + 4);
14464                       if (nop == NOP
14465                           || nop == CROR_151515 || nop == CROR_313131)
14466                         {
14467                           if (h != NULL
14468                               && (h == htab->tls_get_addr_fd
14469                                   || h == htab->tls_get_addr)
14470                               && htab->params->tls_get_addr_opt)
14471                             {
14472                               /* Special stub used, leave nop alone.  */
14473                             }
14474                           else
14475                             bfd_put_32 (input_bfd,
14476                                         LD_R2_0R1 + STK_TOC (htab),
14477                                         contents + rel->r_offset + 4);
14478                           can_plt_call = TRUE;
14479                         }
14480                     }
14481                 }
14482
14483               if (!can_plt_call && h != NULL)
14484                 {
14485                   const char *name = h->elf.root.root.string;
14486
14487                   if (*name == '.')
14488                     ++name;
14489
14490                   if (strncmp (name, "__libc_start_main", 17) == 0
14491                       && (name[17] == 0 || name[17] == '@'))
14492                     {
14493                       /* Allow crt1 branch to go via a toc adjusting
14494                          stub.  Other calls that never return could do
14495                          the same, if we could detect such.  */
14496                       can_plt_call = TRUE;
14497                     }
14498                 }
14499
14500               if (!can_plt_call)
14501                 {
14502                   /* g++ as of 20130507 emits self-calls without a
14503                      following nop.  This is arguably wrong since we
14504                      have conflicting information.  On the one hand a
14505                      global symbol and on the other a local call
14506                      sequence, but don't error for this special case.
14507                      It isn't possible to cheaply verify we have
14508                      exactly such a call.  Allow all calls to the same
14509                      section.  */
14510                   asection *code_sec = sec;
14511
14512                   if (get_opd_info (sec) != NULL)
14513                     {
14514                       bfd_vma off = (relocation + addend
14515                                      - sec->output_section->vma
14516                                      - sec->output_offset);
14517
14518                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14519                     }
14520                   if (code_sec == input_section)
14521                     can_plt_call = TRUE;
14522                 }
14523
14524               if (!can_plt_call)
14525                 {
14526                   if (stub_entry->stub_type == ppc_stub_plt_call
14527                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14528                     info->callbacks->einfo
14529                       /* xgettext:c-format */
14530                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14531                          "recompile with -fPIC\n"),
14532                        input_bfd, input_section, rel->r_offset, sym_name);
14533                   else
14534                     info->callbacks->einfo
14535                       /* xgettext:c-format */
14536                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14537                          "(-mcmodel=small toc adjust stub)\n"),
14538                        input_bfd, input_section, rel->r_offset, sym_name);
14539
14540                   bfd_set_error (bfd_error_bad_value);
14541                   ret = FALSE;
14542                 }
14543
14544               if (can_plt_call
14545                   && (stub_entry->stub_type == ppc_stub_plt_call
14546                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14547                 unresolved_reloc = FALSE;
14548             }
14549
14550           if ((stub_entry == NULL
14551                || stub_entry->stub_type == ppc_stub_long_branch
14552                || stub_entry->stub_type == ppc_stub_plt_branch)
14553               && get_opd_info (sec) != NULL)
14554             {
14555               /* The branch destination is the value of the opd entry. */
14556               bfd_vma off = (relocation + addend
14557                              - sec->output_section->vma
14558                              - sec->output_offset);
14559               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14560               if (dest != (bfd_vma) -1)
14561                 {
14562                   relocation = dest;
14563                   addend = 0;
14564                   reloc_dest = DEST_OPD;
14565                 }
14566             }
14567
14568           /* If the branch is out of reach we ought to have a long
14569              branch stub.  */
14570           from = (rel->r_offset
14571                   + input_section->output_offset
14572                   + input_section->output_section->vma);
14573
14574           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14575                                                   ? fdh->elf.other
14576                                                   : sym->st_other);
14577
14578           if (stub_entry != NULL
14579               && (stub_entry->stub_type == ppc_stub_long_branch
14580                   || stub_entry->stub_type == ppc_stub_plt_branch)
14581               && (r_type == R_PPC64_ADDR14_BRTAKEN
14582                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14583                   || (relocation + addend - from + max_br_offset
14584                       < 2 * max_br_offset)))
14585             /* Don't use the stub if this branch is in range.  */
14586             stub_entry = NULL;
14587
14588           if (stub_entry != NULL)
14589             {
14590               /* Munge up the value and addend so that we call the stub
14591                  rather than the procedure directly.  */
14592               asection *stub_sec = stub_entry->group->stub_sec;
14593
14594               if (stub_entry->stub_type == ppc_stub_save_res)
14595                 relocation += (stub_sec->output_offset
14596                                + stub_sec->output_section->vma
14597                                + stub_sec->size - htab->sfpr->size
14598                                - htab->sfpr->output_offset
14599                                - htab->sfpr->output_section->vma);
14600               else
14601                 relocation = (stub_entry->stub_offset
14602                               + stub_sec->output_offset
14603                               + stub_sec->output_section->vma);
14604               addend = 0;
14605               reloc_dest = DEST_STUB;
14606
14607               if ((stub_entry->stub_type == ppc_stub_plt_call
14608                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14609                   && (ALWAYS_EMIT_R2SAVE
14610                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14611                   && rel + 1 < relend
14612                   && rel[1].r_offset == rel->r_offset + 4
14613                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14614                 relocation += 4;
14615             }
14616
14617           if (insn != 0)
14618             {
14619               if (is_isa_v2)
14620                 {
14621                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14622                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14623                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14624                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14625                     insn |= 0x02 << 21;
14626                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14627                     insn |= 0x08 << 21;
14628                   else
14629                     break;
14630                 }
14631               else
14632                 {
14633                   /* Invert 'y' bit if not the default.  */
14634                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14635                     insn ^= 0x01 << 21;
14636                 }
14637
14638               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14639             }
14640
14641           /* NOP out calls to undefined weak functions.
14642              We can thus call a weak function without first
14643              checking whether the function is defined.  */
14644           else if (h != NULL
14645                    && h->elf.root.type == bfd_link_hash_undefweak
14646                    && h->elf.dynindx == -1
14647                    && r_type == R_PPC64_REL24
14648                    && relocation == 0
14649                    && addend == 0)
14650             {
14651               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14652               goto copy_reloc;
14653             }
14654           break;
14655         }
14656
14657       /* Set `addend'.  */
14658       tls_type = 0;
14659       switch (r_type)
14660         {
14661         default:
14662           /* xgettext:c-format */
14663           _bfd_error_handler (_("%pB: %s unsupported"),
14664                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14665
14666           bfd_set_error (bfd_error_bad_value);
14667           ret = FALSE;
14668           goto copy_reloc;
14669
14670         case R_PPC64_NONE:
14671         case R_PPC64_TLS:
14672         case R_PPC64_TLSGD:
14673         case R_PPC64_TLSLD:
14674         case R_PPC64_TOCSAVE:
14675         case R_PPC64_GNU_VTINHERIT:
14676         case R_PPC64_GNU_VTENTRY:
14677         case R_PPC64_ENTRY:
14678           goto copy_reloc;
14679
14680           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14681              address in the GOT as relocation value instead of the
14682              symbol's value itself.  Also, create a GOT entry for the
14683              symbol and put the symbol value there.  */
14684         case R_PPC64_GOT_TLSGD16:
14685         case R_PPC64_GOT_TLSGD16_LO:
14686         case R_PPC64_GOT_TLSGD16_HI:
14687         case R_PPC64_GOT_TLSGD16_HA:
14688           tls_type = TLS_TLS | TLS_GD;
14689           goto dogot;
14690
14691         case R_PPC64_GOT_TLSLD16:
14692         case R_PPC64_GOT_TLSLD16_LO:
14693         case R_PPC64_GOT_TLSLD16_HI:
14694         case R_PPC64_GOT_TLSLD16_HA:
14695           tls_type = TLS_TLS | TLS_LD;
14696           goto dogot;
14697
14698         case R_PPC64_GOT_TPREL16_DS:
14699         case R_PPC64_GOT_TPREL16_LO_DS:
14700         case R_PPC64_GOT_TPREL16_HI:
14701         case R_PPC64_GOT_TPREL16_HA:
14702           tls_type = TLS_TLS | TLS_TPREL;
14703           goto dogot;
14704
14705         case R_PPC64_GOT_DTPREL16_DS:
14706         case R_PPC64_GOT_DTPREL16_LO_DS:
14707         case R_PPC64_GOT_DTPREL16_HI:
14708         case R_PPC64_GOT_DTPREL16_HA:
14709           tls_type = TLS_TLS | TLS_DTPREL;
14710           goto dogot;
14711
14712         case R_PPC64_GOT16:
14713         case R_PPC64_GOT16_LO:
14714         case R_PPC64_GOT16_HI:
14715         case R_PPC64_GOT16_HA:
14716         case R_PPC64_GOT16_DS:
14717         case R_PPC64_GOT16_LO_DS:
14718         dogot:
14719           {
14720             /* Relocation is to the entry for this symbol in the global
14721                offset table.  */
14722             asection *got;
14723             bfd_vma *offp;
14724             bfd_vma off;
14725             unsigned long indx = 0;
14726             struct got_entry *ent;
14727
14728             if (tls_type == (TLS_TLS | TLS_LD)
14729                 && (h == NULL
14730                     || !h->elf.def_dynamic))
14731               ent = ppc64_tlsld_got (input_bfd);
14732             else
14733               {
14734                 if (h != NULL)
14735                   {
14736                     if (!htab->elf.dynamic_sections_created
14737                         || h->elf.dynindx == -1
14738                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14739                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14740                       /* This is actually a static link, or it is a
14741                          -Bsymbolic link and the symbol is defined
14742                          locally, or the symbol was forced to be local
14743                          because of a version file.  */
14744                       ;
14745                     else
14746                       {
14747                         indx = h->elf.dynindx;
14748                         unresolved_reloc = FALSE;
14749                       }
14750                     ent = h->elf.got.glist;
14751                   }
14752                 else
14753                   {
14754                     if (local_got_ents == NULL)
14755                       abort ();
14756                     ent = local_got_ents[r_symndx];
14757                   }
14758
14759                 for (; ent != NULL; ent = ent->next)
14760                   if (ent->addend == orig_rel.r_addend
14761                       && ent->owner == input_bfd
14762                       && ent->tls_type == tls_type)
14763                     break;
14764               }
14765
14766             if (ent == NULL)
14767               abort ();
14768             if (ent->is_indirect)
14769               ent = ent->got.ent;
14770             offp = &ent->got.offset;
14771             got = ppc64_elf_tdata (ent->owner)->got;
14772             if (got == NULL)
14773               abort ();
14774
14775             /* The offset must always be a multiple of 8.  We use the
14776                least significant bit to record whether we have already
14777                processed this entry.  */
14778             off = *offp;
14779             if ((off & 1) != 0)
14780               off &= ~1;
14781             else
14782               {
14783                 /* Generate relocs for the dynamic linker, except in
14784                    the case of TLSLD where we'll use one entry per
14785                    module.  */
14786                 asection *relgot;
14787                 bfd_boolean ifunc;
14788
14789                 *offp = off | 1;
14790                 relgot = NULL;
14791                 ifunc = (h != NULL
14792                          ? h->elf.type == STT_GNU_IFUNC
14793                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14794                 if (ifunc)
14795                   {
14796                     relgot = htab->elf.irelplt;
14797                     if (indx == 0)
14798                       htab->local_ifunc_resolver = 1;
14799                     else if (is_static_defined (&h->elf))
14800                       htab->maybe_local_ifunc_resolver = 1;
14801                   }
14802                 else if (indx != 0
14803                          || (bfd_link_pic (info)
14804                              && (h == NULL
14805                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14806                                  || (tls_type == (TLS_TLS | TLS_LD)
14807                                      && !h->elf.def_dynamic))
14808                              && !(tls_type == (TLS_TLS | TLS_TPREL)
14809                                   && bfd_link_executable (info)
14810                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14811                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14812                 if (relgot != NULL)
14813                   {
14814                     outrel.r_offset = (got->output_section->vma
14815                                        + got->output_offset
14816                                        + off);
14817                     outrel.r_addend = addend;
14818                     if (tls_type & (TLS_LD | TLS_GD))
14819                       {
14820                         outrel.r_addend = 0;
14821                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14822                         if (tls_type == (TLS_TLS | TLS_GD))
14823                           {
14824                             loc = relgot->contents;
14825                             loc += (relgot->reloc_count++
14826                                     * sizeof (Elf64_External_Rela));
14827                             bfd_elf64_swap_reloca_out (output_bfd,
14828                                                        &outrel, loc);
14829                             outrel.r_offset += 8;
14830                             outrel.r_addend = addend;
14831                             outrel.r_info
14832                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14833                           }
14834                       }
14835                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14836                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14837                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14838                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14839                     else if (indx != 0)
14840                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14841                     else
14842                       {
14843                         if (ifunc)
14844                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14845                         else
14846                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14847
14848                         /* Write the .got section contents for the sake
14849                            of prelink.  */
14850                         loc = got->contents + off;
14851                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14852                                     loc);
14853                       }
14854
14855                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14856                       {
14857                         outrel.r_addend += relocation;
14858                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14859                           {
14860                             if (htab->elf.tls_sec == NULL)
14861                               outrel.r_addend = 0;
14862                             else
14863                               outrel.r_addend -= htab->elf.tls_sec->vma;
14864                           }
14865                       }
14866                     loc = relgot->contents;
14867                     loc += (relgot->reloc_count++
14868                             * sizeof (Elf64_External_Rela));
14869                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14870                   }
14871
14872                 /* Init the .got section contents here if we're not
14873                    emitting a reloc.  */
14874                 else
14875                   {
14876                     relocation += addend;
14877                     if (tls_type != 0)
14878                       {
14879                         if (htab->elf.tls_sec == NULL)
14880                           relocation = 0;
14881                         else
14882                           {
14883                             if (tls_type & TLS_LD)
14884                               relocation = 0;
14885                             else
14886                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14887                             if (tls_type & TLS_TPREL)
14888                               relocation += DTP_OFFSET - TP_OFFSET;
14889                           }
14890
14891                         if (tls_type & (TLS_GD | TLS_LD))
14892                           {
14893                             bfd_put_64 (output_bfd, relocation,
14894                                         got->contents + off + 8);
14895                             relocation = 1;
14896                           }
14897                       }
14898                     bfd_put_64 (output_bfd, relocation,
14899                                 got->contents + off);
14900                   }
14901               }
14902
14903             if (off >= (bfd_vma) -2)
14904               abort ();
14905
14906             relocation = got->output_section->vma + got->output_offset + off;
14907             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14908           }
14909           break;
14910
14911         case R_PPC64_PLT16_HA:
14912         case R_PPC64_PLT16_HI:
14913         case R_PPC64_PLT16_LO:
14914         case R_PPC64_PLT16_LO_DS:
14915         case R_PPC64_PLT32:
14916         case R_PPC64_PLT64:
14917           /* Relocation is to the entry for this symbol in the
14918              procedure linkage table.  */
14919           {
14920             struct plt_entry **plt_list = NULL;
14921             if (h != NULL)
14922               plt_list = &h->elf.plt.plist;
14923             else if (local_got_ents != NULL)
14924               {
14925                 struct plt_entry **local_plt = (struct plt_entry **)
14926                   (local_got_ents + symtab_hdr->sh_info);
14927                 plt_list = local_plt + r_symndx;
14928               }
14929             if (plt_list)
14930               {
14931                 struct plt_entry *ent;
14932
14933                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14934                   if (ent->plt.offset != (bfd_vma) -1
14935                       && ent->addend == orig_rel.r_addend)
14936                     {
14937                       asection *plt;
14938                       bfd_vma got;
14939
14940                       plt = htab->elf.splt;
14941                       if (!htab->elf.dynamic_sections_created
14942                           || h == NULL
14943                           || h->elf.dynindx == -1)
14944                         {
14945                           if (h != NULL
14946                               ? h->elf.type == STT_GNU_IFUNC
14947                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14948                             plt = htab->elf.iplt;
14949                           else
14950                             plt = htab->pltlocal;
14951                         }
14952                       relocation = (plt->output_section->vma
14953                                     + plt->output_offset
14954                                     + ent->plt.offset);
14955                       if (r_type == R_PPC64_PLT16_HA
14956                           || r_type ==R_PPC64_PLT16_HI
14957                           || r_type ==R_PPC64_PLT16_LO
14958                           || r_type ==R_PPC64_PLT16_LO_DS)
14959                         {
14960                           got = (elf_gp (output_bfd)
14961                                  + htab->sec_info[input_section->id].toc_off);
14962                           relocation -= got;
14963                         }
14964                       addend = 0;
14965                       unresolved_reloc = FALSE;
14966                       break;
14967                     }
14968               }
14969           }
14970           break;
14971
14972         case R_PPC64_TOC:
14973           /* Relocation value is TOC base.  */
14974           relocation = TOCstart;
14975           if (r_symndx == STN_UNDEF)
14976             relocation += htab->sec_info[input_section->id].toc_off;
14977           else if (unresolved_reloc)
14978             ;
14979           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14980             relocation += htab->sec_info[sec->id].toc_off;
14981           else
14982             unresolved_reloc = TRUE;
14983           goto dodyn;
14984
14985           /* TOC16 relocs.  We want the offset relative to the TOC base,
14986              which is the address of the start of the TOC plus 0x8000.
14987              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14988              in this order.  */
14989         case R_PPC64_TOC16:
14990         case R_PPC64_TOC16_LO:
14991         case R_PPC64_TOC16_HI:
14992         case R_PPC64_TOC16_DS:
14993         case R_PPC64_TOC16_LO_DS:
14994         case R_PPC64_TOC16_HA:
14995           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14996           break;
14997
14998           /* Relocate against the beginning of the section.  */
14999         case R_PPC64_SECTOFF:
15000         case R_PPC64_SECTOFF_LO:
15001         case R_PPC64_SECTOFF_HI:
15002         case R_PPC64_SECTOFF_DS:
15003         case R_PPC64_SECTOFF_LO_DS:
15004         case R_PPC64_SECTOFF_HA:
15005           if (sec != NULL)
15006             addend -= sec->output_section->vma;
15007           break;
15008
15009         case R_PPC64_REL16:
15010         case R_PPC64_REL16_LO:
15011         case R_PPC64_REL16_HI:
15012         case R_PPC64_REL16_HA:
15013         case R_PPC64_REL16DX_HA:
15014           break;
15015
15016         case R_PPC64_REL14:
15017         case R_PPC64_REL14_BRNTAKEN:
15018         case R_PPC64_REL14_BRTAKEN:
15019         case R_PPC64_REL24:
15020           break;
15021
15022         case R_PPC64_TPREL16:
15023         case R_PPC64_TPREL16_LO:
15024         case R_PPC64_TPREL16_HI:
15025         case R_PPC64_TPREL16_HA:
15026         case R_PPC64_TPREL16_DS:
15027         case R_PPC64_TPREL16_LO_DS:
15028         case R_PPC64_TPREL16_HIGH:
15029         case R_PPC64_TPREL16_HIGHA:
15030         case R_PPC64_TPREL16_HIGHER:
15031         case R_PPC64_TPREL16_HIGHERA:
15032         case R_PPC64_TPREL16_HIGHEST:
15033         case R_PPC64_TPREL16_HIGHESTA:
15034           if (h != NULL
15035               && h->elf.root.type == bfd_link_hash_undefweak
15036               && h->elf.dynindx == -1)
15037             {
15038               /* Make this relocation against an undefined weak symbol
15039                  resolve to zero.  This is really just a tweak, since
15040                  code using weak externs ought to check that they are
15041                  defined before using them.  */
15042               bfd_byte *p = contents + rel->r_offset - d_offset;
15043
15044               insn = bfd_get_32 (input_bfd, p);
15045               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15046               if (insn != 0)
15047                 bfd_put_32 (input_bfd, insn, p);
15048               break;
15049             }
15050           if (htab->elf.tls_sec != NULL)
15051             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15052           /* The TPREL16 relocs shouldn't really be used in shared
15053              libs or with non-local symbols as that will result in
15054              DT_TEXTREL being set, but support them anyway.  */
15055           goto dodyn;
15056
15057         case R_PPC64_DTPREL16:
15058         case R_PPC64_DTPREL16_LO:
15059         case R_PPC64_DTPREL16_HI:
15060         case R_PPC64_DTPREL16_HA:
15061         case R_PPC64_DTPREL16_DS:
15062         case R_PPC64_DTPREL16_LO_DS:
15063         case R_PPC64_DTPREL16_HIGH:
15064         case R_PPC64_DTPREL16_HIGHA:
15065         case R_PPC64_DTPREL16_HIGHER:
15066         case R_PPC64_DTPREL16_HIGHERA:
15067         case R_PPC64_DTPREL16_HIGHEST:
15068         case R_PPC64_DTPREL16_HIGHESTA:
15069           if (htab->elf.tls_sec != NULL)
15070             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15071           break;
15072
15073         case R_PPC64_ADDR64_LOCAL:
15074           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15075                                               ? h->elf.other
15076                                               : sym->st_other);
15077           break;
15078
15079         case R_PPC64_DTPMOD64:
15080           relocation = 1;
15081           addend = 0;
15082           goto dodyn;
15083
15084         case R_PPC64_TPREL64:
15085           if (htab->elf.tls_sec != NULL)
15086             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15087           goto dodyn;
15088
15089         case R_PPC64_DTPREL64:
15090           if (htab->elf.tls_sec != NULL)
15091             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15092           /* Fall through.  */
15093
15094           /* Relocations that may need to be propagated if this is a
15095              dynamic object.  */
15096         case R_PPC64_REL30:
15097         case R_PPC64_REL32:
15098         case R_PPC64_REL64:
15099         case R_PPC64_ADDR14:
15100         case R_PPC64_ADDR14_BRNTAKEN:
15101         case R_PPC64_ADDR14_BRTAKEN:
15102         case R_PPC64_ADDR16:
15103         case R_PPC64_ADDR16_DS:
15104         case R_PPC64_ADDR16_HA:
15105         case R_PPC64_ADDR16_HI:
15106         case R_PPC64_ADDR16_HIGH:
15107         case R_PPC64_ADDR16_HIGHA:
15108         case R_PPC64_ADDR16_HIGHER:
15109         case R_PPC64_ADDR16_HIGHERA:
15110         case R_PPC64_ADDR16_HIGHEST:
15111         case R_PPC64_ADDR16_HIGHESTA:
15112         case R_PPC64_ADDR16_LO:
15113         case R_PPC64_ADDR16_LO_DS:
15114         case R_PPC64_ADDR24:
15115         case R_PPC64_ADDR32:
15116         case R_PPC64_ADDR64:
15117         case R_PPC64_UADDR16:
15118         case R_PPC64_UADDR32:
15119         case R_PPC64_UADDR64:
15120         dodyn:
15121           if ((input_section->flags & SEC_ALLOC) == 0)
15122             break;
15123
15124           if (NO_OPD_RELOCS && is_opd)
15125             break;
15126
15127           if (bfd_link_pic (info)
15128               ? ((h == NULL
15129                   || h->dyn_relocs != NULL)
15130                  && ((h != NULL && pc_dynrelocs (h))
15131                      || must_be_dyn_reloc (info, r_type)))
15132               : (h != NULL
15133                  ? h->dyn_relocs != NULL
15134                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15135             {
15136               bfd_boolean skip, relocate;
15137               asection *sreloc;
15138               bfd_vma out_off;
15139               long indx = 0;
15140
15141               /* When generating a dynamic object, these relocations
15142                  are copied into the output file to be resolved at run
15143                  time.  */
15144
15145               skip = FALSE;
15146               relocate = FALSE;
15147
15148               out_off = _bfd_elf_section_offset (output_bfd, info,
15149                                                  input_section, rel->r_offset);
15150               if (out_off == (bfd_vma) -1)
15151                 skip = TRUE;
15152               else if (out_off == (bfd_vma) -2)
15153                 skip = TRUE, relocate = TRUE;
15154               out_off += (input_section->output_section->vma
15155                           + input_section->output_offset);
15156               outrel.r_offset = out_off;
15157               outrel.r_addend = rel->r_addend;
15158
15159               /* Optimize unaligned reloc use.  */
15160               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15161                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15162                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15163               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15164                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15165                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15166               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15167                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15168                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15169
15170               if (skip)
15171                 memset (&outrel, 0, sizeof outrel);
15172               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15173                        && !is_opd
15174                        && r_type != R_PPC64_TOC)
15175                 {
15176                   indx = h->elf.dynindx;
15177                   BFD_ASSERT (indx != -1);
15178                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15179                 }
15180               else
15181                 {
15182                   /* This symbol is local, or marked to become local,
15183                      or this is an opd section reloc which must point
15184                      at a local function.  */
15185                   outrel.r_addend += relocation;
15186                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15187                     {
15188                       if (is_opd && h != NULL)
15189                         {
15190                           /* Lie about opd entries.  This case occurs
15191                              when building shared libraries and we
15192                              reference a function in another shared
15193                              lib.  The same thing happens for a weak
15194                              definition in an application that's
15195                              overridden by a strong definition in a
15196                              shared lib.  (I believe this is a generic
15197                              bug in binutils handling of weak syms.)
15198                              In these cases we won't use the opd
15199                              entry in this lib.  */
15200                           unresolved_reloc = FALSE;
15201                         }
15202                       if (!is_opd
15203                           && r_type == R_PPC64_ADDR64
15204                           && (h != NULL
15205                               ? h->elf.type == STT_GNU_IFUNC
15206                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15207                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15208                       else
15209                         {
15210                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15211
15212                           /* We need to relocate .opd contents for ld.so.
15213                              Prelink also wants simple and consistent rules
15214                              for relocs.  This make all RELATIVE relocs have
15215                              *r_offset equal to r_addend.  */
15216                           relocate = TRUE;
15217                         }
15218                     }
15219                   else
15220                     {
15221                       if (h != NULL
15222                           ? h->elf.type == STT_GNU_IFUNC
15223                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15224                         {
15225                           info->callbacks->einfo
15226                             /* xgettext:c-format */
15227                             (_("%H: %s for indirect "
15228                                "function `%pT' unsupported\n"),
15229                              input_bfd, input_section, rel->r_offset,
15230                              ppc64_elf_howto_table[r_type]->name,
15231                              sym_name);
15232                           ret = FALSE;
15233                         }
15234                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15235                         ;
15236                       else if (sec == NULL || sec->owner == NULL)
15237                         {
15238                           bfd_set_error (bfd_error_bad_value);
15239                           return FALSE;
15240                         }
15241                       else
15242                         {
15243                           asection *osec;
15244
15245                           osec = sec->output_section;
15246                           indx = elf_section_data (osec)->dynindx;
15247
15248                           if (indx == 0)
15249                             {
15250                               if ((osec->flags & SEC_READONLY) == 0
15251                                   && htab->elf.data_index_section != NULL)
15252                                 osec = htab->elf.data_index_section;
15253                               else
15254                                 osec = htab->elf.text_index_section;
15255                               indx = elf_section_data (osec)->dynindx;
15256                             }
15257                           BFD_ASSERT (indx != 0);
15258
15259                           /* We are turning this relocation into one
15260                              against a section symbol, so subtract out
15261                              the output section's address but not the
15262                              offset of the input section in the output
15263                              section.  */
15264                           outrel.r_addend -= osec->vma;
15265                         }
15266
15267                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15268                     }
15269                 }
15270
15271               sreloc = elf_section_data (input_section)->sreloc;
15272               if (h != NULL
15273                   ? h->elf.type == STT_GNU_IFUNC
15274                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15275                 {
15276                   sreloc = htab->elf.irelplt;
15277                   if (indx == 0)
15278                     htab->local_ifunc_resolver = 1;
15279                   else if (is_static_defined (&h->elf))
15280                     htab->maybe_local_ifunc_resolver = 1;
15281                 }
15282               if (sreloc == NULL)
15283                 abort ();
15284
15285               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15286                   >= sreloc->size)
15287                 abort ();
15288               loc = sreloc->contents;
15289               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15290               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15291
15292               /* If this reloc is against an external symbol, it will
15293                  be computed at runtime, so there's no need to do
15294                  anything now.  However, for the sake of prelink ensure
15295                  that the section contents are a known value.  */
15296               if (! relocate)
15297                 {
15298                   unresolved_reloc = FALSE;
15299                   /* The value chosen here is quite arbitrary as ld.so
15300                      ignores section contents except for the special
15301                      case of .opd where the contents might be accessed
15302                      before relocation.  Choose zero, as that won't
15303                      cause reloc overflow.  */
15304                   relocation = 0;
15305                   addend = 0;
15306                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15307                      to improve backward compatibility with older
15308                      versions of ld.  */
15309                   if (r_type == R_PPC64_ADDR64)
15310                     addend = outrel.r_addend;
15311                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15312                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15313                     addend = outrel.r_offset;
15314                 }
15315             }
15316           break;
15317
15318         case R_PPC64_COPY:
15319         case R_PPC64_GLOB_DAT:
15320         case R_PPC64_JMP_SLOT:
15321         case R_PPC64_JMP_IREL:
15322         case R_PPC64_RELATIVE:
15323           /* We shouldn't ever see these dynamic relocs in relocatable
15324              files.  */
15325           /* Fall through.  */
15326
15327         case R_PPC64_PLTGOT16:
15328         case R_PPC64_PLTGOT16_DS:
15329         case R_PPC64_PLTGOT16_HA:
15330         case R_PPC64_PLTGOT16_HI:
15331         case R_PPC64_PLTGOT16_LO:
15332         case R_PPC64_PLTGOT16_LO_DS:
15333         case R_PPC64_PLTREL32:
15334         case R_PPC64_PLTREL64:
15335           /* These ones haven't been implemented yet.  */
15336
15337           info->callbacks->einfo
15338             /* xgettext:c-format */
15339             (_("%P: %pB: %s is not supported for `%pT'\n"),
15340              input_bfd,
15341              ppc64_elf_howto_table[r_type]->name, sym_name);
15342
15343           bfd_set_error (bfd_error_invalid_operation);
15344           ret = FALSE;
15345           goto copy_reloc;
15346         }
15347
15348       /* Multi-instruction sequences that access the TOC can be
15349          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15350          to             nop;           addi rb,r2,x;  */
15351       switch (r_type)
15352         {
15353         default:
15354           break;
15355
15356         case R_PPC64_GOT_TLSLD16_HI:
15357         case R_PPC64_GOT_TLSGD16_HI:
15358         case R_PPC64_GOT_TPREL16_HI:
15359         case R_PPC64_GOT_DTPREL16_HI:
15360         case R_PPC64_GOT16_HI:
15361         case R_PPC64_TOC16_HI:
15362           /* These relocs would only be useful if building up an
15363              offset to later add to r2, perhaps in an indexed
15364              addressing mode instruction.  Don't try to optimize.
15365              Unfortunately, the possibility of someone building up an
15366              offset like this or even with the HA relocs, means that
15367              we need to check the high insn when optimizing the low
15368              insn.  */
15369           break;
15370
15371         case R_PPC64_GOT_TLSLD16_HA:
15372         case R_PPC64_GOT_TLSGD16_HA:
15373         case R_PPC64_GOT_TPREL16_HA:
15374         case R_PPC64_GOT_DTPREL16_HA:
15375         case R_PPC64_GOT16_HA:
15376         case R_PPC64_TOC16_HA:
15377           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15378               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15379             {
15380               bfd_byte *p = contents + (rel->r_offset & ~3);
15381               bfd_put_32 (input_bfd, NOP, p);
15382               goto copy_reloc;
15383             }
15384           break;
15385
15386         case R_PPC64_GOT_TLSLD16_LO:
15387         case R_PPC64_GOT_TLSGD16_LO:
15388         case R_PPC64_GOT_TPREL16_LO_DS:
15389         case R_PPC64_GOT_DTPREL16_LO_DS:
15390         case R_PPC64_GOT16_LO:
15391         case R_PPC64_GOT16_LO_DS:
15392         case R_PPC64_TOC16_LO:
15393         case R_PPC64_TOC16_LO_DS:
15394           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15395               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15396             {
15397               bfd_byte *p = contents + (rel->r_offset & ~3);
15398               insn = bfd_get_32 (input_bfd, p);
15399               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15400                 {
15401                   /* Transform addic to addi when we change reg.  */
15402                   insn &= ~((0x3f << 26) | (0x1f << 16));
15403                   insn |= (14u << 26) | (2 << 16);
15404                 }
15405               else
15406                 {
15407                   insn &= ~(0x1f << 16);
15408                   insn |= 2 << 16;
15409                 }
15410               bfd_put_32 (input_bfd, insn, p);
15411             }
15412           break;
15413
15414         case R_PPC64_TPREL16_HA:
15415           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15416             {
15417               bfd_byte *p = contents + (rel->r_offset & ~3);
15418               insn = bfd_get_32 (input_bfd, p);
15419               if ((insn & ((0x3f << 26) | 0x1f << 16))
15420                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15421                 /* xgettext:c-format */
15422                 info->callbacks->minfo
15423                   (_("%H: warning: %s unexpected insn %#x.\n"),
15424                    input_bfd, input_section, rel->r_offset,
15425                    ppc64_elf_howto_table[r_type]->name, insn);
15426               else
15427                 {
15428                   bfd_put_32 (input_bfd, NOP, p);
15429                   goto copy_reloc;
15430                 }
15431             }
15432           break;
15433
15434         case R_PPC64_TPREL16_LO:
15435         case R_PPC64_TPREL16_LO_DS:
15436           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15437             {
15438               bfd_byte *p = contents + (rel->r_offset & ~3);
15439               insn = bfd_get_32 (input_bfd, p);
15440               insn &= ~(0x1f << 16);
15441               insn |= 13 << 16;
15442               bfd_put_32 (input_bfd, insn, p);
15443             }
15444           break;
15445         }
15446
15447       /* Do any further special processing.  */
15448       switch (r_type)
15449         {
15450         default:
15451           break;
15452
15453         case R_PPC64_REL16_HA:
15454         case R_PPC64_REL16DX_HA:
15455         case R_PPC64_ADDR16_HA:
15456         case R_PPC64_ADDR16_HIGHA:
15457         case R_PPC64_ADDR16_HIGHERA:
15458         case R_PPC64_ADDR16_HIGHESTA:
15459         case R_PPC64_TOC16_HA:
15460         case R_PPC64_SECTOFF_HA:
15461         case R_PPC64_TPREL16_HA:
15462         case R_PPC64_TPREL16_HIGHA:
15463         case R_PPC64_TPREL16_HIGHERA:
15464         case R_PPC64_TPREL16_HIGHESTA:
15465         case R_PPC64_DTPREL16_HA:
15466         case R_PPC64_DTPREL16_HIGHA:
15467         case R_PPC64_DTPREL16_HIGHERA:
15468         case R_PPC64_DTPREL16_HIGHESTA:
15469           /* It's just possible that this symbol is a weak symbol
15470              that's not actually defined anywhere. In that case,
15471              'sec' would be NULL, and we should leave the symbol
15472              alone (it will be set to zero elsewhere in the link).  */
15473           if (sec == NULL)
15474             break;
15475           /* Fall through.  */
15476
15477         case R_PPC64_GOT16_HA:
15478         case R_PPC64_PLTGOT16_HA:
15479         case R_PPC64_PLT16_HA:
15480         case R_PPC64_GOT_TLSGD16_HA:
15481         case R_PPC64_GOT_TLSLD16_HA:
15482         case R_PPC64_GOT_TPREL16_HA:
15483         case R_PPC64_GOT_DTPREL16_HA:
15484           /* Add 0x10000 if sign bit in 0:15 is set.
15485              Bits 0:15 are not used.  */
15486           addend += 0x8000;
15487           break;
15488
15489         case R_PPC64_ADDR16_DS:
15490         case R_PPC64_ADDR16_LO_DS:
15491         case R_PPC64_GOT16_DS:
15492         case R_PPC64_GOT16_LO_DS:
15493         case R_PPC64_PLT16_LO_DS:
15494         case R_PPC64_SECTOFF_DS:
15495         case R_PPC64_SECTOFF_LO_DS:
15496         case R_PPC64_TOC16_DS:
15497         case R_PPC64_TOC16_LO_DS:
15498         case R_PPC64_PLTGOT16_DS:
15499         case R_PPC64_PLTGOT16_LO_DS:
15500         case R_PPC64_GOT_TPREL16_DS:
15501         case R_PPC64_GOT_TPREL16_LO_DS:
15502         case R_PPC64_GOT_DTPREL16_DS:
15503         case R_PPC64_GOT_DTPREL16_LO_DS:
15504         case R_PPC64_TPREL16_DS:
15505         case R_PPC64_TPREL16_LO_DS:
15506         case R_PPC64_DTPREL16_DS:
15507         case R_PPC64_DTPREL16_LO_DS:
15508           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15509           mask = 3;
15510           /* If this reloc is against an lq, lxv, or stxv insn, then
15511              the value must be a multiple of 16.  This is somewhat of
15512              a hack, but the "correct" way to do this by defining _DQ
15513              forms of all the _DS relocs bloats all reloc switches in
15514              this file.  It doesn't make much sense to use these
15515              relocs in data, so testing the insn should be safe.  */
15516           if ((insn & (0x3f << 26)) == (56u << 26)
15517               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15518             mask = 15;
15519           relocation += addend;
15520           addend = insn & (mask ^ 3);
15521           if ((relocation & mask) != 0)
15522             {
15523               relocation ^= relocation & mask;
15524               info->callbacks->einfo
15525                 /* xgettext:c-format */
15526                 (_("%H: error: %s not a multiple of %u\n"),
15527                  input_bfd, input_section, rel->r_offset,
15528                  ppc64_elf_howto_table[r_type]->name,
15529                  mask + 1);
15530               bfd_set_error (bfd_error_bad_value);
15531               ret = FALSE;
15532               goto copy_reloc;
15533             }
15534           break;
15535         }
15536
15537       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15538          because such sections are not SEC_ALLOC and thus ld.so will
15539          not process them.  */
15540       howto = ppc64_elf_howto_table[(int) r_type];
15541       if (unresolved_reloc
15542           && !((input_section->flags & SEC_DEBUGGING) != 0
15543                && h->elf.def_dynamic)
15544           && _bfd_elf_section_offset (output_bfd, info, input_section,
15545                                       rel->r_offset) != (bfd_vma) -1)
15546         {
15547           info->callbacks->einfo
15548             /* xgettext:c-format */
15549             (_("%H: unresolvable %s against `%pT'\n"),
15550              input_bfd, input_section, rel->r_offset,
15551              howto->name,
15552              h->elf.root.root.string);
15553           ret = FALSE;
15554         }
15555
15556       /* 16-bit fields in insns mostly have signed values, but a
15557          few insns have 16-bit unsigned values.  Really, we should
15558          have different reloc types.  */
15559       if (howto->complain_on_overflow != complain_overflow_dont
15560           && howto->dst_mask == 0xffff
15561           && (input_section->flags & SEC_CODE) != 0)
15562         {
15563           enum complain_overflow complain = complain_overflow_signed;
15564
15565           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15566           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15567             complain = complain_overflow_bitfield;
15568           else if (howto->rightshift == 0
15569                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15570                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15571                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15572                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15573                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15574                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15575             complain = complain_overflow_unsigned;
15576           if (howto->complain_on_overflow != complain)
15577             {
15578               alt_howto = *howto;
15579               alt_howto.complain_on_overflow = complain;
15580               howto = &alt_howto;
15581             }
15582         }
15583
15584       if (r_type == R_PPC64_REL16DX_HA)
15585         {
15586           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15587           if (rel->r_offset + 4 > input_section->size)
15588             r = bfd_reloc_outofrange;
15589           else
15590             {
15591               relocation += addend;
15592               relocation -= (rel->r_offset
15593                              + input_section->output_offset
15594                              + input_section->output_section->vma);
15595               relocation = (bfd_signed_vma) relocation >> 16;
15596               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15597               insn &= ~0x1fffc1;
15598               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15599               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15600               r = bfd_reloc_ok;
15601               if (relocation + 0x8000 > 0xffff)
15602                 r = bfd_reloc_overflow;
15603             }
15604         }
15605       else
15606         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15607                                       rel->r_offset, relocation, addend);
15608
15609       if (r != bfd_reloc_ok)
15610         {
15611           char *more_info = NULL;
15612           const char *reloc_name = howto->name;
15613
15614           if (reloc_dest != DEST_NORMAL)
15615             {
15616               more_info = bfd_malloc (strlen (reloc_name) + 8);
15617               if (more_info != NULL)
15618                 {
15619                   strcpy (more_info, reloc_name);
15620                   strcat (more_info, (reloc_dest == DEST_OPD
15621                                       ? " (OPD)" : " (stub)"));
15622                   reloc_name = more_info;
15623                 }
15624             }
15625
15626           if (r == bfd_reloc_overflow)
15627             {
15628               /* On code like "if (foo) foo();" don't report overflow
15629                  on a branch to zero when foo is undefined.  */
15630               if (!warned
15631                   && (reloc_dest == DEST_STUB
15632                       || !(h != NULL
15633                            && (h->elf.root.type == bfd_link_hash_undefweak
15634                                || h->elf.root.type == bfd_link_hash_undefined)
15635                            && is_branch_reloc (r_type))))
15636                 info->callbacks->reloc_overflow (info, &h->elf.root,
15637                                                  sym_name, reloc_name,
15638                                                  orig_rel.r_addend,
15639                                                  input_bfd, input_section,
15640                                                  rel->r_offset);
15641             }
15642           else
15643             {
15644               info->callbacks->einfo
15645                 /* xgettext:c-format */
15646                 (_("%H: %s against `%pT': error %d\n"),
15647                  input_bfd, input_section, rel->r_offset,
15648                  reloc_name, sym_name, (int) r);
15649               ret = FALSE;
15650             }
15651           if (more_info != NULL)
15652             free (more_info);
15653         }
15654     copy_reloc:
15655       if (wrel != rel)
15656         *wrel = *rel;
15657     }
15658
15659   if (wrel != rel)
15660     {
15661       Elf_Internal_Shdr *rel_hdr;
15662       size_t deleted = rel - wrel;
15663
15664       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15665       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15666       if (rel_hdr->sh_size == 0)
15667         {
15668           /* It is too late to remove an empty reloc section.  Leave
15669              one NONE reloc.
15670              ??? What is wrong with an empty section???  */
15671           rel_hdr->sh_size = rel_hdr->sh_entsize;
15672           deleted -= 1;
15673         }
15674       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15675       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15676       input_section->reloc_count -= deleted;
15677     }
15678
15679   /* If we're emitting relocations, then shortly after this function
15680      returns, reloc offsets and addends for this section will be
15681      adjusted.  Worse, reloc symbol indices will be for the output
15682      file rather than the input.  Save a copy of the relocs for
15683      opd_entry_value.  */
15684   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15685     {
15686       bfd_size_type amt;
15687       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15688       rel = bfd_alloc (input_bfd, amt);
15689       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15690       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15691       if (rel == NULL)
15692         return FALSE;
15693       memcpy (rel, relocs, amt);
15694     }
15695   return ret;
15696 }
15697
15698 /* Adjust the value of any local symbols in opd sections.  */
15699
15700 static int
15701 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15702                               const char *name ATTRIBUTE_UNUSED,
15703                               Elf_Internal_Sym *elfsym,
15704                               asection *input_sec,
15705                               struct elf_link_hash_entry *h)
15706 {
15707   struct _opd_sec_data *opd;
15708   long adjust;
15709   bfd_vma value;
15710
15711   if (h != NULL)
15712     return 1;
15713
15714   opd = get_opd_info (input_sec);
15715   if (opd == NULL || opd->adjust == NULL)
15716     return 1;
15717
15718   value = elfsym->st_value - input_sec->output_offset;
15719   if (!bfd_link_relocatable (info))
15720     value -= input_sec->output_section->vma;
15721
15722   adjust = opd->adjust[OPD_NDX (value)];
15723   if (adjust == -1)
15724     return 2;
15725
15726   elfsym->st_value += adjust;
15727   return 1;
15728 }
15729
15730 /* Finish up dynamic symbol handling.  We set the contents of various
15731    dynamic sections here.  */
15732
15733 static bfd_boolean
15734 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15735                                  struct bfd_link_info *info,
15736                                  struct elf_link_hash_entry *h,
15737                                  Elf_Internal_Sym *sym)
15738 {
15739   struct ppc_link_hash_table *htab;
15740   struct plt_entry *ent;
15741
15742   htab = ppc_hash_table (info);
15743   if (htab == NULL)
15744     return FALSE;
15745
15746   if (!htab->opd_abi && !h->def_regular)
15747     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15748       if (ent->plt.offset != (bfd_vma) -1)
15749         {
15750           /* Mark the symbol as undefined, rather than as
15751              defined in glink.  Leave the value if there were
15752              any relocations where pointer equality matters
15753              (this is a clue for the dynamic linker, to make
15754              function pointer comparisons work between an
15755              application and shared library), otherwise set it
15756              to zero.  */
15757           sym->st_shndx = SHN_UNDEF;
15758           if (!h->pointer_equality_needed)
15759             sym->st_value = 0;
15760           else if (!h->ref_regular_nonweak)
15761             {
15762               /* This breaks function pointer comparisons, but
15763                  that is better than breaking tests for a NULL
15764                  function pointer.  */
15765               sym->st_value = 0;
15766             }
15767           break;
15768         }
15769
15770   if (h->needs_copy)
15771     {
15772       /* This symbol needs a copy reloc.  Set it up.  */
15773       Elf_Internal_Rela rela;
15774       asection *srel;
15775       bfd_byte *loc;
15776
15777       if (h->dynindx == -1
15778           || (h->root.type != bfd_link_hash_defined
15779               && h->root.type != bfd_link_hash_defweak)
15780           || htab->elf.srelbss == NULL
15781           || htab->elf.sreldynrelro == NULL)
15782         abort ();
15783
15784       rela.r_offset = (h->root.u.def.value
15785                        + h->root.u.def.section->output_section->vma
15786                        + h->root.u.def.section->output_offset);
15787       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15788       rela.r_addend = 0;
15789       if (h->root.u.def.section == htab->elf.sdynrelro)
15790         srel = htab->elf.sreldynrelro;
15791       else
15792         srel = htab->elf.srelbss;
15793       loc = srel->contents;
15794       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15795       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15796     }
15797
15798   return TRUE;
15799 }
15800
15801 /* Used to decide how to sort relocs in an optimal manner for the
15802    dynamic linker, before writing them out.  */
15803
15804 static enum elf_reloc_type_class
15805 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15806                             const asection *rel_sec,
15807                             const Elf_Internal_Rela *rela)
15808 {
15809   enum elf_ppc64_reloc_type r_type;
15810   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15811
15812   if (rel_sec == htab->elf.irelplt)
15813     return reloc_class_ifunc;
15814
15815   r_type = ELF64_R_TYPE (rela->r_info);
15816   switch (r_type)
15817     {
15818     case R_PPC64_RELATIVE:
15819       return reloc_class_relative;
15820     case R_PPC64_JMP_SLOT:
15821       return reloc_class_plt;
15822     case R_PPC64_COPY:
15823       return reloc_class_copy;
15824     default:
15825       return reloc_class_normal;
15826     }
15827 }
15828
15829 /* Finish up the dynamic sections.  */
15830
15831 static bfd_boolean
15832 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15833                                    struct bfd_link_info *info)
15834 {
15835   struct ppc_link_hash_table *htab;
15836   bfd *dynobj;
15837   asection *sdyn;
15838
15839   htab = ppc_hash_table (info);
15840   if (htab == NULL)
15841     return FALSE;
15842
15843   dynobj = htab->elf.dynobj;
15844   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15845
15846   if (htab->elf.dynamic_sections_created)
15847     {
15848       Elf64_External_Dyn *dyncon, *dynconend;
15849
15850       if (sdyn == NULL || htab->elf.sgot == NULL)
15851         abort ();
15852
15853       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15854       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15855       for (; dyncon < dynconend; dyncon++)
15856         {
15857           Elf_Internal_Dyn dyn;
15858           asection *s;
15859
15860           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15861
15862           switch (dyn.d_tag)
15863             {
15864             default:
15865               continue;
15866
15867             case DT_PPC64_GLINK:
15868               s = htab->glink;
15869               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15870               /* We stupidly defined DT_PPC64_GLINK to be the start
15871                  of glink rather than the first entry point, which is
15872                  what ld.so needs, and now have a bigger stub to
15873                  support automatic multiple TOCs.  */
15874               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
15875               break;
15876
15877             case DT_PPC64_OPD:
15878               s = bfd_get_section_by_name (output_bfd, ".opd");
15879               if (s == NULL)
15880                 continue;
15881               dyn.d_un.d_ptr = s->vma;
15882               break;
15883
15884             case DT_PPC64_OPT:
15885               if (htab->do_multi_toc && htab->multi_toc_needed)
15886                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15887               if (htab->has_plt_localentry0)
15888                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15889               break;
15890
15891             case DT_PPC64_OPDSZ:
15892               s = bfd_get_section_by_name (output_bfd, ".opd");
15893               if (s == NULL)
15894                 continue;
15895               dyn.d_un.d_val = s->size;
15896               break;
15897
15898             case DT_PLTGOT:
15899               s = htab->elf.splt;
15900               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15901               break;
15902
15903             case DT_JMPREL:
15904               s = htab->elf.srelplt;
15905               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15906               break;
15907
15908             case DT_PLTRELSZ:
15909               dyn.d_un.d_val = htab->elf.srelplt->size;
15910               break;
15911
15912             case DT_TEXTREL:
15913               if (htab->local_ifunc_resolver)
15914                 info->callbacks->einfo
15915                   (_("%X%P: text relocations and GNU indirect "
15916                      "functions will result in a segfault at runtime\n"));
15917               else if (htab->maybe_local_ifunc_resolver)
15918                 info->callbacks->einfo
15919                   (_("%P: warning: text relocations and GNU indirect "
15920                      "functions may result in a segfault at runtime\n"));
15921               continue;
15922             }
15923
15924           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15925         }
15926     }
15927
15928   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15929       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15930     {
15931       /* Fill in the first entry in the global offset table.
15932          We use it to hold the link-time TOCbase.  */
15933       bfd_put_64 (output_bfd,
15934                   elf_gp (output_bfd) + TOC_BASE_OFF,
15935                   htab->elf.sgot->contents);
15936
15937       /* Set .got entry size.  */
15938       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15939     }
15940
15941   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15942       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15943     {
15944       /* Set .plt entry size.  */
15945       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15946         = PLT_ENTRY_SIZE (htab);
15947     }
15948
15949   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15950      brlt ourselves if emitrelocations.  */
15951   if (htab->brlt != NULL
15952       && htab->brlt->reloc_count != 0
15953       && !_bfd_elf_link_output_relocs (output_bfd,
15954                                        htab->brlt,
15955                                        elf_section_data (htab->brlt)->rela.hdr,
15956                                        elf_section_data (htab->brlt)->relocs,
15957                                        NULL))
15958     return FALSE;
15959
15960   if (htab->glink != NULL
15961       && htab->glink->reloc_count != 0
15962       && !_bfd_elf_link_output_relocs (output_bfd,
15963                                        htab->glink,
15964                                        elf_section_data (htab->glink)->rela.hdr,
15965                                        elf_section_data (htab->glink)->relocs,
15966                                        NULL))
15967     return FALSE;
15968
15969   if (htab->glink_eh_frame != NULL
15970       && htab->glink_eh_frame->size != 0)
15971     {
15972       bfd_vma val;
15973       bfd_byte *p;
15974       struct map_stub *group;
15975       size_t align = 4;
15976
15977       p = htab->glink_eh_frame->contents;
15978       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15979
15980       for (group = htab->group; group != NULL; group = group->next)
15981         if (group->stub_sec != NULL)
15982           {
15983             /* Offset to stub section.  */
15984             val = (group->stub_sec->output_section->vma
15985                    + group->stub_sec->output_offset);
15986             val -= (htab->glink_eh_frame->output_section->vma
15987                     + htab->glink_eh_frame->output_offset
15988                     + (p + 8 - htab->glink_eh_frame->contents));
15989             if (val + 0x80000000 > 0xffffffff)
15990               {
15991                 _bfd_error_handler
15992                   (_("%s offset too large for .eh_frame sdata4 encoding"),
15993                    group->stub_sec->name);
15994                 return FALSE;
15995               }
15996             bfd_put_32 (dynobj, val, p + 8);
15997             p += stub_eh_frame_size (group, align);
15998           }
15999       if (htab->glink != NULL && htab->glink->size != 0)
16000         {
16001           /* Offset to .glink.  */
16002           val = (htab->glink->output_section->vma
16003                  + htab->glink->output_offset
16004                  + 8);
16005           val -= (htab->glink_eh_frame->output_section->vma
16006                   + htab->glink_eh_frame->output_offset
16007                   + (p + 8 - htab->glink_eh_frame->contents));
16008           if (val + 0x80000000 > 0xffffffff)
16009             {
16010               _bfd_error_handler
16011                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16012                  htab->glink->name);
16013               return FALSE;
16014             }
16015           bfd_put_32 (dynobj, val, p + 8);
16016           p += (24 + align - 1) & -align;
16017         }
16018
16019       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16020           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16021                                                htab->glink_eh_frame,
16022                                                htab->glink_eh_frame->contents))
16023         return FALSE;
16024     }
16025
16026   /* We need to handle writing out multiple GOT sections ourselves,
16027      since we didn't add them to DYNOBJ.  We know dynobj is the first
16028      bfd.  */
16029   while ((dynobj = dynobj->link.next) != NULL)
16030     {
16031       asection *s;
16032
16033       if (!is_ppc64_elf (dynobj))
16034         continue;
16035
16036       s = ppc64_elf_tdata (dynobj)->got;
16037       if (s != NULL
16038           && s->size != 0
16039           && s->output_section != bfd_abs_section_ptr
16040           && !bfd_set_section_contents (output_bfd, s->output_section,
16041                                         s->contents, s->output_offset,
16042                                         s->size))
16043         return FALSE;
16044       s = ppc64_elf_tdata (dynobj)->relgot;
16045       if (s != NULL
16046           && s->size != 0
16047           && s->output_section != bfd_abs_section_ptr
16048           && !bfd_set_section_contents (output_bfd, s->output_section,
16049                                         s->contents, s->output_offset,
16050                                         s->size))
16051         return FALSE;
16052     }
16053
16054   return TRUE;
16055 }
16056
16057 #include "elf64-target.h"
16058
16059 /* FreeBSD support */
16060
16061 #undef  TARGET_LITTLE_SYM
16062 #undef  TARGET_LITTLE_NAME
16063
16064 #undef  TARGET_BIG_SYM
16065 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16066 #undef  TARGET_BIG_NAME
16067 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16068
16069 #undef  ELF_OSABI
16070 #define ELF_OSABI       ELFOSABI_FREEBSD
16071
16072 #undef  elf64_bed
16073 #define elf64_bed       elf64_powerpc_fbsd_bed
16074
16075 #include "elf64-target.h"