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      0x1000
  68 #define ELF_RELROPAGESIZE       ELF_MAXPAGESIZE
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_want_dynrelro 1
  77 #define elf_backend_can_gc_sections 1
  78 #define elf_backend_can_refcount 1
  79 #define elf_backend_rela_normal 1
  80 #define elf_backend_dtrel_excludes_plt 1
  81 #define elf_backend_default_execstack 0
  82
  83 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  84 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  85 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  86 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  87 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  88 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  89 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  90 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  91 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  92 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  93
  94 #define elf_backend_object_p                  ppc64_elf_object_p
  95 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  96 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  97 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  98 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  99 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
 100 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 101 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 102 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 103 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 104 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 105 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
 106 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 107 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 108 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 109 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 110 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 111 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 112 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 113 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 114 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 115 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 116 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 117 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 118 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 119 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 120 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 121 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 122 #define elf_backend_special_sections          ppc64_elf_special_sections
 123 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 124 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 125 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 126
 127 /* The name of the dynamic interpreter.  This is put in the .interp
 128    section.  */
 129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 130
 131 /* The size in bytes of an entry in the procedure linkage table.  */
 132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
 134
 135 /* The initial size of the plt reserved for the dynamic linker.  */
 136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 137
 138 /* Offsets to some stack save slots.  */
 139 #define STK_LR 16
 140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 141 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 142    CR save slot.  Used only by optimised __tls_get_addr call stub,
 143    relying on __tls_get_addr_opt not saving CR..  */
 144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 145
 146 /* TOC base pointers offset from start of TOC.  */
 147 #define TOC_BASE_OFF    0x8000
 148 /* TOC base alignment.  */
 149 #define TOC_BASE_ALIGN  256
 150
 151 /* Offset of tp and dtp pointers from start of TLS block.  */
 152 #define TP_OFFSET       0x7000
 153 #define DTP_OFFSET      0x8000
 154
 155 /* .plt call stub instructions.  The normal stub is like this, but
 156    sometimes the .plt entry crosses a 64k boundary and we need to
 157    insert an addi to adjust r11.  */
 158 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 159 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 160 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 161 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 162 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 163 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 164 #define BCTR            0x4e800420      /* bctr                      */
 165
 166 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 167 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 168 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 169
 170 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 171 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 172 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 173 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 174 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 175 #define BNECTR          0x4ca20420      /* bnectr+               */
 176 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 177
 178 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 179 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 180 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 181
 182 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 183 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 184 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 185
 186 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 187 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 188 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 189 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 190 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 191
 192 /* __glink_PLTresolve stub instructions.  We enter with the index in R0.  */
 193 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 194   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 195                                         /* 0:                           */
 196                                         /*  .quad plt0-1f               */
 197                                         /* __glink:                     */
 198 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 199 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 200                                         /* 1:                           */
 201 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 202                                         /*  ld %2,(0b-1b)(%11)          */
 203 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 204 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 205                                         /*  ld %12,0(%11)               */
 206                                         /*  ld %2,8(%11)                */
 207                                         /*  mtctr %12                   */
 208                                         /*  ld %11,16(%11)              */
 209                                         /*  bctr                        */
 210 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 211 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 212 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 213 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 214 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 215
 216 /* Pad with this.  */
 217 #define NOP             0x60000000
 218
 219 /* Some other nops.  */
 220 #define CROR_151515     0x4def7b82
 221 #define CROR_313131     0x4ffffb82
 222
 223 /* .glink entries for the first 32k functions are two instructions.  */
 224 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 225 #define B_DOT           0x48000000      /* b     .              */
 226
 227 /* After that, we need two instructions to load the index, followed by
 228    a branch.  */
 229 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 230 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 231
 232 /* Instructions used by the save and restore reg functions.  */
 233 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 234 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 235 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 236 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 237 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 238 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 239 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 240 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 241 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 242 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 243 #define BLR             0x4e800020      /* blr                  */
 244
 245 /* Since .opd is an array of descriptors and each entry will end up
 246    with identical R_PPC64_RELATIVE relocs, there is really no need to
 247    propagate .opd relocs;  The dynamic linker should be taught to
 248    relocate .opd without reloc entries.  */
 249 #ifndef NO_OPD_RELOCS
 250 #define NO_OPD_RELOCS 0
 251 #endif
 252
 253 #ifndef ARRAY_SIZE
 254 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 255 #endif
 256
 257 static inline int
 258 abiversion (bfd *abfd)
 259 {
 260   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 261 }
 262
 263 static inline void
 264 set_abiversion (bfd *abfd, int ver)
 265 {
 266   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 267   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 268 }
 269 \f
 270 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 271
 272 /* Relocation HOWTO's.  */
 273 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 274
 275 static reloc_howto_type ppc64_elf_howto_raw[] =
 276 {
 277   /* This reloc does nothing.  */
 278   HOWTO (R_PPC64_NONE,          /* type */
 279          0,                     /* rightshift */
 280          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          0,                     /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_dont, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_NONE",        /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0,                     /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 32 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR32,        /* type */
 294          0,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          32,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR32",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffffffff,            /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* An absolute 26 bit branch; the lower two bits must be zero.
 308      FIXME: we don't check that, we just clear them.  */
 309   HOWTO (R_PPC64_ADDR24,        /* type */
 310          0,                     /* rightshift */
 311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 312          26,                    /* bitsize */
 313          FALSE,                 /* pc_relative */
 314          0,                     /* bitpos */
 315          complain_overflow_bitfield, /* complain_on_overflow */
 316          bfd_elf_generic_reloc, /* special_function */
 317          "R_PPC64_ADDR24",      /* name */
 318          FALSE,                 /* partial_inplace */
 319          0,                     /* src_mask */
 320          0x03fffffc,            /* dst_mask */
 321          FALSE),                /* pcrel_offset */
 322
 323   /* A standard 16 bit relocation.  */
 324   HOWTO (R_PPC64_ADDR16,        /* type */
 325          0,                     /* rightshift */
 326          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          16,                    /* bitsize */
 328          FALSE,                 /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield, /* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* special_function */
 332          "R_PPC64_ADDR16",      /* name */
 333          FALSE,                 /* partial_inplace */
 334          0,                     /* src_mask */
 335          0xffff,                /* dst_mask */
 336          FALSE),                /* pcrel_offset */
 337
 338   /* A 16 bit relocation without overflow.  */
 339   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 340          0,                     /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_dont,/* complain_on_overflow */
 346          bfd_elf_generic_reloc, /* special_function */
 347          "R_PPC64_ADDR16_LO",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* Bits 16-31 of an address.  */
 354   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 355          16,                    /* rightshift */
 356          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_signed, /* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_PPC64_ADDR16_HI",   /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0xffff,                /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 369      bits, treated as a signed number, is negative.  */
 370   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 371          16,                    /* rightshift */
 372          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 373          16,                    /* bitsize */
 374          FALSE,                 /* pc_relative */
 375          0,                     /* bitpos */
 376          complain_overflow_signed, /* complain_on_overflow */
 377          ppc64_elf_ha_reloc,    /* special_function */
 378          "R_PPC64_ADDR16_HA",   /* name */
 379          FALSE,                 /* partial_inplace */
 380          0,                     /* src_mask */
 381          0xffff,                /* dst_mask */
 382          FALSE),                /* pcrel_offset */
 383
 384   /* An absolute 16 bit branch; the lower two bits must be zero.
 385      FIXME: we don't check that, we just clear them.  */
 386   HOWTO (R_PPC64_ADDR14,        /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          16,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_signed, /* complain_on_overflow */
 393          ppc64_elf_branch_reloc, /* special_function */
 394          "R_PPC64_ADDR14",      /* name */
 395          FALSE,                 /* partial_inplace */
 396          0,                     /* src_mask */
 397          0x0000fffc,            /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   /* An absolute 16 bit branch, for which bit 10 should be set to
 401      indicate that the branch is expected to be taken.  The lower two
 402      bits must be zero.  */
 403   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          FALSE,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_brtaken_reloc, /* special_function */
 411          "R_PPC64_ADDR14_BRTAKEN",/* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000fffc,            /* dst_mask */
 415          FALSE),                /* pcrel_offset */
 416
 417   /* An absolute 16 bit branch, for which bit 10 should be set to
 418      indicate that the branch is not expected to be taken.  The lower
 419      two bits must be zero.  */
 420   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 421          0,                     /* rightshift */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          FALSE,                 /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed, /* complain_on_overflow */
 427          ppc64_elf_brtaken_reloc, /* special_function */
 428          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 429          FALSE,                 /* partial_inplace */
 430          0,                     /* src_mask */
 431          0x0000fffc,            /* dst_mask */
 432          FALSE),                /* pcrel_offset */
 433
 434   /* A relative 26 bit branch; the lower two bits must be zero.  */
 435   HOWTO (R_PPC64_REL24,         /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          26,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_branch_reloc, /* special_function */
 443          "R_PPC64_REL24",       /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x03fffffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch; the lower two bits must be zero.  */
 450   HOWTO (R_PPC64_REL14,         /* type */
 451          0,                     /* rightshift */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          TRUE,                  /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_signed, /* complain_on_overflow */
 457          ppc64_elf_branch_reloc, /* special_function */
 458          "R_PPC64_REL14",       /* name */
 459          FALSE,                 /* partial_inplace */
 460          0,                     /* src_mask */
 461          0x0000fffc,            /* dst_mask */
 462          TRUE),                 /* pcrel_offset */
 463
 464   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 465      the branch is expected to be taken.  The lower two bits must be
 466      zero.  */
 467   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 468          0,                     /* rightshift */
 469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          16,                    /* bitsize */
 471          TRUE,                  /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_signed, /* complain_on_overflow */
 474          ppc64_elf_brtaken_reloc, /* special_function */
 475          "R_PPC64_REL14_BRTAKEN", /* name */
 476          FALSE,                 /* partial_inplace */
 477          0,                     /* src_mask */
 478          0x0000fffc,            /* dst_mask */
 479          TRUE),                 /* pcrel_offset */
 480
 481   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 482      the branch is not expected to be taken.  The lower two bits must
 483      be zero.  */
 484   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          TRUE,                  /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_signed, /* complain_on_overflow */
 491          ppc64_elf_brtaken_reloc, /* special_function */
 492          "R_PPC64_REL14_BRNTAKEN",/* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0x0000fffc,            /* dst_mask */
 496          TRUE),                 /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 499      symbol.  */
 500   HOWTO (R_PPC64_GOT16,         /* type */
 501          0,                     /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed, /* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16",       /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_LO,      /* type */
 517          0,                     /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_dont, /* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_LO",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 531      the symbol.  */
 532   HOWTO (R_PPC64_GOT16_HI,      /* type */
 533          16,                    /* rightshift */
 534          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 535          16,                    /* bitsize */
 536          FALSE,                 /* pc_relative */
 537          0,                     /* bitpos */
 538          complain_overflow_signed,/* complain_on_overflow */
 539          ppc64_elf_unhandled_reloc, /* special_function */
 540          "R_PPC64_GOT16_HI",    /* name */
 541          FALSE,                 /* partial_inplace */
 542          0,                     /* src_mask */
 543          0xffff,                /* dst_mask */
 544          FALSE),                /* pcrel_offset */
 545
 546   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 547      the symbol.  */
 548   HOWTO (R_PPC64_GOT16_HA,      /* type */
 549          16,                    /* rightshift */
 550          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 551          16,                    /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_signed,/* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_GOT16_HA",    /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0xffff,                /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* This is used only by the dynamic linker.  The symbol should exist
 563      both in the object being run and in some shared library.  The
 564      dynamic linker copies the data addressed by the symbol from the
 565      shared library into the object, because the object being
 566      run has to have the data at some particular address.  */
 567   HOWTO (R_PPC64_COPY,          /* type */
 568          0,                     /* rightshift */
 569          0,                     /* this one is variable size */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_COPY",        /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Like R_PPC64_ADDR64, but used when setting global offset table
 582      entries.  */
 583   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 584          0,                     /* rightshift */
 585          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 586          64,                    /* bitsize */
 587          FALSE,                 /* pc_relative */
 588          0,                     /* bitpos */
 589          complain_overflow_dont, /* complain_on_overflow */
 590          ppc64_elf_unhandled_reloc,  /* special_function */
 591          "R_PPC64_GLOB_DAT",    /* name */
 592          FALSE,                 /* partial_inplace */
 593          0,                     /* src_mask */
 594          ONES (64),             /* dst_mask */
 595          FALSE),                /* pcrel_offset */
 596
 597   /* Created by the link editor.  Marks a procedure linkage table
 598      entry for a symbol.  */
 599   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 600          0,                     /* rightshift */
 601          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          0,                     /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_dont, /* complain_on_overflow */
 606          ppc64_elf_unhandled_reloc, /* special_function */
 607          "R_PPC64_JMP_SLOT",    /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0,                     /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Used only by the dynamic linker.  When the object is run, this
 614      doubleword64 is set to the load address of the object, plus the
 615      addend.  */
 616   HOWTO (R_PPC64_RELATIVE,      /* type */
 617          0,                     /* rightshift */
 618          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 619          64,                    /* bitsize */
 620          FALSE,                 /* pc_relative */
 621          0,                     /* bitpos */
 622          complain_overflow_dont, /* complain_on_overflow */
 623          bfd_elf_generic_reloc, /* special_function */
 624          "R_PPC64_RELATIVE",    /* name */
 625          FALSE,                 /* partial_inplace */
 626          0,                     /* src_mask */
 627          ONES (64),             /* dst_mask */
 628          FALSE),                /* pcrel_offset */
 629
 630   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 631   HOWTO (R_PPC64_UADDR32,       /* type */
 632          0,                     /* rightshift */
 633          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 634          32,                    /* bitsize */
 635          FALSE,                 /* pc_relative */
 636          0,                     /* bitpos */
 637          complain_overflow_bitfield, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_UADDR32",     /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          FALSE),                /* pcrel_offset */
 644
 645   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 646   HOWTO (R_PPC64_UADDR16,       /* type */
 647          0,                     /* rightshift */
 648          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          16,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          bfd_elf_generic_reloc, /* special_function */
 654          "R_PPC64_UADDR16",     /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffff,                /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative.  */
 661   HOWTO (R_PPC64_REL32,         /* type */
 662          0,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          32,                    /* bitsize */
 665          TRUE,                  /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_signed, /* complain_on_overflow */
 668          bfd_elf_generic_reloc, /* special_function */
 669          "R_PPC64_REL32",       /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffffffff,            /* dst_mask */
 673          TRUE),                 /* pcrel_offset */
 674
 675   /* 32-bit relocation to the symbol's procedure linkage table.  */
 676   HOWTO (R_PPC64_PLT32,         /* type */
 677          0,                     /* rightshift */
 678          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          32,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_bitfield, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT32",       /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffffffff,            /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 691      FIXME: R_PPC64_PLTREL32 not supported.  */
 692   HOWTO (R_PPC64_PLTREL32,      /* type */
 693          0,                     /* rightshift */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          32,                    /* bitsize */
 696          TRUE,                  /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLTREL32",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffffffff,            /* dst_mask */
 704          TRUE),                 /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_LO,      /* type */
 709          0,                     /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_dont, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_LO",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 723      the symbol.  */
 724   HOWTO (R_PPC64_PLT16_HI,      /* type */
 725          16,                    /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_signed, /* complain_on_overflow */
 731          ppc64_elf_unhandled_reloc, /* special_function */
 732          "R_PPC64_PLT16_HI",    /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 739      the symbol.  */
 740   HOWTO (R_PPC64_PLT16_HA,      /* type */
 741          16,                    /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_signed, /* complain_on_overflow */
 747          ppc64_elf_unhandled_reloc, /* special_function */
 748          "R_PPC64_PLT16_HA",    /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF,       /* type */
 756          0,                     /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF",     /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 770   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 771          0,                     /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_dont, /* complain_on_overflow */
 777          ppc64_elf_sectoff_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_LO",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* 16-bit upper half section relative relocation.  */
 785   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 786          16,                    /* rightshift */
 787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          16,                    /* bitsize */
 789          FALSE,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_signed, /* complain_on_overflow */
 792          ppc64_elf_sectoff_reloc, /* special_function */
 793          "R_PPC64_SECTOFF_HI",  /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xffff,                /* dst_mask */
 797          FALSE),                /* pcrel_offset */
 798
 799   /* 16-bit upper half adjusted section relative relocation.  */
 800   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 801          16,                    /* rightshift */
 802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_signed, /* complain_on_overflow */
 807          ppc64_elf_sectoff_ha_reloc, /* special_function */
 808          "R_PPC64_SECTOFF_HA",  /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 815   HOWTO (R_PPC64_REL30,         /* type */
 816          2,                     /* rightshift */
 817          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          30,                    /* bitsize */
 819          TRUE,                  /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_REL30",       /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xfffffffc,            /* dst_mask */
 827          TRUE),                 /* pcrel_offset */
 828
 829   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 830
 831   /* A standard 64-bit relocation.  */
 832   HOWTO (R_PPC64_ADDR64,        /* type */
 833          0,                     /* rightshift */
 834          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 835          64,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          bfd_elf_generic_reloc, /* special_function */
 840          "R_PPC64_ADDR64",      /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          ONES (64),             /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 32-47 of an address.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 848          32,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_PPC64_ADDR16_HIGHER", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* The bits 32-47 of an address, plus 1 if the contents of the low
 862      16 bits, treated as a signed number, is negative.  */
 863   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 864          32,                    /* rightshift */
 865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          16,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          ppc64_elf_ha_reloc,    /* special_function */
 871          "R_PPC64_ADDR16_HIGHERA", /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          0xffff,                /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* The bits 48-63 of an address.  */
 878   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 879          48,                    /* rightshift */
 880          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 881          16,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_ADDR16_HIGHEST", /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          0xffff,                /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   /* The bits 48-63 of an address, plus 1 if the contents of the low
 893      16 bits, treated as a signed number, is negative.  */
 894   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 895          48,                    /* rightshift */
 896          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          16,                    /* bitsize */
 898          FALSE,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          ppc64_elf_ha_reloc,    /* special_function */
 902          "R_PPC64_ADDR16_HIGHESTA", /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          0xffff,                /* dst_mask */
 906          FALSE),                /* pcrel_offset */
 907
 908   /* Like ADDR64, but may be unaligned.  */
 909   HOWTO (R_PPC64_UADDR64,       /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          bfd_elf_generic_reloc, /* special_function */
 917          "R_PPC64_UADDR64",     /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit relative relocation.  */
 924   HOWTO (R_PPC64_REL64,         /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          bfd_elf_generic_reloc, /* special_function */
 932          "R_PPC64_REL64",       /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 64-bit relocation to the symbol's procedure linkage table.  */
 939   HOWTO (R_PPC64_PLT64,         /* type */
 940          0,                     /* rightshift */
 941          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 942          64,                    /* bitsize */
 943          FALSE,                 /* pc_relative */
 944          0,                     /* bitpos */
 945          complain_overflow_dont, /* complain_on_overflow */
 946          ppc64_elf_unhandled_reloc, /* special_function */
 947          "R_PPC64_PLT64",       /* name */
 948          FALSE,                 /* partial_inplace */
 949          0,                     /* src_mask */
 950          ONES (64),             /* dst_mask */
 951          FALSE),                /* pcrel_offset */
 952
 953   /* 64-bit PC relative relocation to the symbol's procedure linkage
 954      table.  */
 955   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 956   HOWTO (R_PPC64_PLTREL64,      /* type */
 957          0,                     /* rightshift */
 958          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 959          64,                    /* bitsize */
 960          TRUE,                  /* pc_relative */
 961          0,                     /* bitpos */
 962          complain_overflow_dont, /* complain_on_overflow */
 963          ppc64_elf_unhandled_reloc, /* special_function */
 964          "R_PPC64_PLTREL64",    /* name */
 965          FALSE,                 /* partial_inplace */
 966          0,                     /* src_mask */
 967          ONES (64),             /* dst_mask */
 968          TRUE),                 /* pcrel_offset */
 969
 970   /* 16 bit TOC-relative relocation.  */
 971
 972   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 973   HOWTO (R_PPC64_TOC16,         /* type */
 974          0,                     /* rightshift */
 975          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 976          16,                    /* bitsize */
 977          FALSE,                 /* pc_relative */
 978          0,                     /* bitpos */
 979          complain_overflow_signed, /* complain_on_overflow */
 980          ppc64_elf_toc_reloc,   /* special_function */
 981          "R_PPC64_TOC16",       /* name */
 982          FALSE,                 /* partial_inplace */
 983          0,                     /* src_mask */
 984          0xffff,                /* dst_mask */
 985          FALSE),                /* pcrel_offset */
 986
 987   /* 16 bit TOC-relative relocation without overflow.  */
 988
 989   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 990   HOWTO (R_PPC64_TOC16_LO,      /* type */
 991          0,                     /* rightshift */
 992          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 993          16,                    /* bitsize */
 994          FALSE,                 /* pc_relative */
 995          0,                     /* bitpos */
 996          complain_overflow_dont, /* complain_on_overflow */
 997          ppc64_elf_toc_reloc,   /* special_function */
 998          "R_PPC64_TOC16_LO",    /* name */
 999          FALSE,                 /* partial_inplace */
1000          0,                     /* src_mask */
1001          0xffff,                /* dst_mask */
1002          FALSE),                /* pcrel_offset */
1003
1004   /* 16 bit TOC-relative relocation, high 16 bits.  */
1005
1006   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HI,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_reloc,   /* special_function */
1015          "R_PPC64_TOC16_HI",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1022      contents of the low 16 bits, treated as a signed number, is
1023      negative.  */
1024
1025   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1026   HOWTO (R_PPC64_TOC16_HA,      /* type */
1027          16,                    /* rightshift */
1028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          16,                    /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_signed, /* complain_on_overflow */
1033          ppc64_elf_toc_ha_reloc, /* special_function */
1034          "R_PPC64_TOC16_HA",    /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0xffff,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1041
1042   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1043   HOWTO (R_PPC64_TOC,           /* type */
1044          0,                     /* rightshift */
1045          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1046          64,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_toc64_reloc, /* special_function */
1051          "R_PPC64_TOC",         /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          ONES (64),             /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_GOT16, but also informs the link editor that the
1058      value to relocate may (!) refer to a PLT entry which the link
1059      editor (a) may replace with the symbol value.  If the link editor
1060      is unable to fully resolve the symbol, it may (b) create a PLT
1061      entry and store the address to the new PLT entry in the GOT.
1062      This permits lazy resolution of function symbols at run time.
1063      The link editor may also skip all of this and just (c) emit a
1064      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1065   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1066     HOWTO (R_PPC64_PLTGOT16,    /* type */
1067          0,                     /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16",    /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1081   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1082   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1083          0,                     /* rightshift */
1084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1085          16,                    /* bitsize */
1086          FALSE,                 /* pc_relative */
1087          0,                     /* bitpos */
1088          complain_overflow_dont, /* complain_on_overflow */
1089          ppc64_elf_unhandled_reloc, /* special_function */
1090          "R_PPC64_PLTGOT16_LO", /* name */
1091          FALSE,                 /* partial_inplace */
1092          0,                     /* src_mask */
1093          0xffff,                /* dst_mask */
1094          FALSE),                /* pcrel_offset */
1095
1096   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1097   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1098   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1099          16,                    /* rightshift */
1100          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1101          16,                    /* bitsize */
1102          FALSE,                 /* pc_relative */
1103          0,                     /* bitpos */
1104          complain_overflow_signed, /* complain_on_overflow */
1105          ppc64_elf_unhandled_reloc, /* special_function */
1106          "R_PPC64_PLTGOT16_HI", /* name */
1107          FALSE,                 /* partial_inplace */
1108          0,                     /* src_mask */
1109          0xffff,                /* dst_mask */
1110          FALSE),                /* pcrel_offset */
1111
1112   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1113      1 if the contents of the low 16 bits, treated as a signed number,
1114      is negative.  */
1115   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1116   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1117          16,                    /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_signed, /* complain_on_overflow */
1123          ppc64_elf_unhandled_reloc, /* special_function */
1124          "R_PPC64_PLTGOT16_HA", /* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xffff,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          bfd_elf_generic_reloc, /* special_function */
1139          "R_PPC64_ADDR16_DS",   /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont,/* complain_on_overflow */
1153          bfd_elf_generic_reloc, /* special_function */
1154          "R_PPC64_ADDR16_LO_DS",/* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_GOT16_DS,      /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_signed, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_GOT16_DS",    /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_dont, /* complain_on_overflow */
1183          ppc64_elf_unhandled_reloc, /* special_function */
1184          "R_PPC64_GOT16_LO_DS", /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_unhandled_reloc, /* special_function */
1199          "R_PPC64_PLT16_LO_DS", /* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_sectoff_reloc, /* special_function */
1214          "R_PPC64_SECTOFF_DS",  /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_sectoff_reloc, /* special_function */
1229          "R_PPC64_SECTOFF_LO_DS",/* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1236   HOWTO (R_PPC64_TOC16_DS,      /* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_signed, /* complain_on_overflow */
1243          ppc64_elf_toc_reloc,   /* special_function */
1244          "R_PPC64_TOC16_DS",    /* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1251   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_toc_reloc,   /* special_function */
1259          "R_PPC64_TOC16_LO_DS", /* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1266   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1267   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1268          0,                     /* rightshift */
1269          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1270          16,                    /* bitsize */
1271          FALSE,                 /* pc_relative */
1272          0,                     /* bitpos */
1273          complain_overflow_signed, /* complain_on_overflow */
1274          ppc64_elf_unhandled_reloc, /* special_function */
1275          "R_PPC64_PLTGOT16_DS", /* name */
1276          FALSE,                 /* partial_inplace */
1277          0,                     /* src_mask */
1278          0xfffc,                /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1282   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1283   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1284          0,                     /* rightshift */
1285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1286          16,                    /* bitsize */
1287          FALSE,                 /* pc_relative */
1288          0,                     /* bitpos */
1289          complain_overflow_dont, /* complain_on_overflow */
1290          ppc64_elf_unhandled_reloc, /* special_function */
1291          "R_PPC64_PLTGOT16_LO_DS",/* name */
1292          FALSE,                 /* partial_inplace */
1293          0,                     /* src_mask */
1294          0xfffc,                /* dst_mask */
1295          FALSE),                /* pcrel_offset */
1296
1297   /* Marker relocs for TLS.  */
1298   HOWTO (R_PPC64_TLS,
1299          0,                     /* rightshift */
1300          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1301          32,                    /* bitsize */
1302          FALSE,                 /* pc_relative */
1303          0,                     /* bitpos */
1304          complain_overflow_dont, /* complain_on_overflow */
1305          bfd_elf_generic_reloc, /* special_function */
1306          "R_PPC64_TLS",         /* name */
1307          FALSE,                 /* partial_inplace */
1308          0,                     /* src_mask */
1309          0,                     /* dst_mask */
1310          FALSE),                /* pcrel_offset */
1311
1312   HOWTO (R_PPC64_TLSGD,
1313          0,                     /* rightshift */
1314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1315          32,                    /* bitsize */
1316          FALSE,                 /* pc_relative */
1317          0,                     /* bitpos */
1318          complain_overflow_dont, /* complain_on_overflow */
1319          bfd_elf_generic_reloc, /* special_function */
1320          "R_PPC64_TLSGD",       /* name */
1321          FALSE,                 /* partial_inplace */
1322          0,                     /* src_mask */
1323          0,                     /* dst_mask */
1324          FALSE),                /* pcrel_offset */
1325
1326   HOWTO (R_PPC64_TLSLD,
1327          0,                     /* rightshift */
1328          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          32,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          bfd_elf_generic_reloc, /* special_function */
1334          "R_PPC64_TLSLD",       /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          0,                     /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Marker reloc for optimizing r2 save in prologue rather than on
1341      each plt call stub.  */
1342   HOWTO (R_PPC64_TOCSAVE,
1343          0,                     /* rightshift */
1344          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          32,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_dont, /* complain_on_overflow */
1349          bfd_elf_generic_reloc, /* special_function */
1350          "R_PPC64_TOCSAVE",     /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          0,                     /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* Marker relocs on inline plt call instructions.  */
1357   HOWTO (R_PPC64_PLTSEQ,
1358          0,                     /* rightshift */
1359          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          32,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_dont, /* complain_on_overflow */
1364          bfd_elf_generic_reloc, /* special_function */
1365          "R_PPC64_PLTSEQ",      /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0,                     /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   HOWTO (R_PPC64_PLTCALL,
1372          0,                     /* rightshift */
1373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          32,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          bfd_elf_generic_reloc, /* special_function */
1379          "R_PPC64_PLTCALL",     /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0,                     /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Computes the load module index of the load module that contains the
1386      definition of its TLS sym.  */
1387   HOWTO (R_PPC64_DTPMOD64,
1388          0,                     /* rightshift */
1389          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          64,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_dont, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPMOD64",    /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          ONES (64),             /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Computes a dtv-relative displacement, the difference between the value
1402      of sym+add and the base address of the thread-local storage block that
1403      contains the definition of sym, minus 0x8000.  */
1404   HOWTO (R_PPC64_DTPREL64,
1405          0,                     /* rightshift */
1406          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1407          64,                    /* bitsize */
1408          FALSE,                 /* pc_relative */
1409          0,                     /* bitpos */
1410          complain_overflow_dont, /* complain_on_overflow */
1411          ppc64_elf_unhandled_reloc, /* special_function */
1412          "R_PPC64_DTPREL64",    /* name */
1413          FALSE,                 /* partial_inplace */
1414          0,                     /* src_mask */
1415          ONES (64),             /* dst_mask */
1416          FALSE),                /* pcrel_offset */
1417
1418   /* A 16 bit dtprel reloc.  */
1419   HOWTO (R_PPC64_DTPREL16,
1420          0,                     /* rightshift */
1421          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1422          16,                    /* bitsize */
1423          FALSE,                 /* pc_relative */
1424          0,                     /* bitpos */
1425          complain_overflow_signed, /* complain_on_overflow */
1426          ppc64_elf_unhandled_reloc, /* special_function */
1427          "R_PPC64_DTPREL16",    /* name */
1428          FALSE,                 /* partial_inplace */
1429          0,                     /* src_mask */
1430          0xffff,                /* dst_mask */
1431          FALSE),                /* pcrel_offset */
1432
1433   /* Like DTPREL16, but no overflow.  */
1434   HOWTO (R_PPC64_DTPREL16_LO,
1435          0,                     /* rightshift */
1436          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1437          16,                    /* bitsize */
1438          FALSE,                 /* pc_relative */
1439          0,                     /* bitpos */
1440          complain_overflow_dont, /* complain_on_overflow */
1441          ppc64_elf_unhandled_reloc, /* special_function */
1442          "R_PPC64_DTPREL16_LO", /* name */
1443          FALSE,                 /* partial_inplace */
1444          0,                     /* src_mask */
1445          0xffff,                /* dst_mask */
1446          FALSE),                /* pcrel_offset */
1447
1448   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1449   HOWTO (R_PPC64_DTPREL16_HI,
1450          16,                    /* rightshift */
1451          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1452          16,                    /* bitsize */
1453          FALSE,                 /* pc_relative */
1454          0,                     /* bitpos */
1455          complain_overflow_signed, /* complain_on_overflow */
1456          ppc64_elf_unhandled_reloc, /* special_function */
1457          "R_PPC64_DTPREL16_HI", /* name */
1458          FALSE,                 /* partial_inplace */
1459          0,                     /* src_mask */
1460          0xffff,                /* dst_mask */
1461          FALSE),                /* pcrel_offset */
1462
1463   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1464   HOWTO (R_PPC64_DTPREL16_HA,
1465          16,                    /* rightshift */
1466          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1467          16,                    /* bitsize */
1468          FALSE,                 /* pc_relative */
1469          0,                     /* bitpos */
1470          complain_overflow_signed, /* complain_on_overflow */
1471          ppc64_elf_unhandled_reloc, /* special_function */
1472          "R_PPC64_DTPREL16_HA", /* name */
1473          FALSE,                 /* partial_inplace */
1474          0,                     /* src_mask */
1475          0xffff,                /* dst_mask */
1476          FALSE),                /* pcrel_offset */
1477
1478   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1479   HOWTO (R_PPC64_DTPREL16_HIGHER,
1480          32,                    /* rightshift */
1481          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1482          16,                    /* bitsize */
1483          FALSE,                 /* pc_relative */
1484          0,                     /* bitpos */
1485          complain_overflow_dont, /* complain_on_overflow */
1486          ppc64_elf_unhandled_reloc, /* special_function */
1487          "R_PPC64_DTPREL16_HIGHER", /* name */
1488          FALSE,                 /* partial_inplace */
1489          0,                     /* src_mask */
1490          0xffff,                /* dst_mask */
1491          FALSE),                /* pcrel_offset */
1492
1493   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1494   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1495          32,                    /* rightshift */
1496          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1497          16,                    /* bitsize */
1498          FALSE,                 /* pc_relative */
1499          0,                     /* bitpos */
1500          complain_overflow_dont, /* complain_on_overflow */
1501          ppc64_elf_unhandled_reloc, /* special_function */
1502          "R_PPC64_DTPREL16_HIGHERA", /* name */
1503          FALSE,                 /* partial_inplace */
1504          0,                     /* src_mask */
1505          0xffff,                /* dst_mask */
1506          FALSE),                /* pcrel_offset */
1507
1508   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1509   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1510          48,                    /* rightshift */
1511          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          16,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_DTPREL16_HIGHEST", /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          0xffff,                /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1524   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1525          48,                    /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_dont, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like DTPREL16, but for insns with a DS field.  */
1539   HOWTO (R_PPC64_DTPREL16_DS,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_signed, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_DTPREL16_DS", /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xfffc,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like DTPREL16_DS, but no overflow.  */
1554   HOWTO (R_PPC64_DTPREL16_LO_DS,
1555          0,                     /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_dont, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_DTPREL16_LO_DS", /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xfffc,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Computes a tp-relative displacement, the difference between the value of
1569      sym+add and the value of the thread pointer (r13).  */
1570   HOWTO (R_PPC64_TPREL64,
1571          0,                     /* rightshift */
1572          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1573          64,                    /* bitsize */
1574          FALSE,                 /* pc_relative */
1575          0,                     /* bitpos */
1576          complain_overflow_dont, /* complain_on_overflow */
1577          ppc64_elf_unhandled_reloc, /* special_function */
1578          "R_PPC64_TPREL64",     /* name */
1579          FALSE,                 /* partial_inplace */
1580          0,                     /* src_mask */
1581          ONES (64),             /* dst_mask */
1582          FALSE),                /* pcrel_offset */
1583
1584   /* A 16 bit tprel reloc.  */
1585   HOWTO (R_PPC64_TPREL16,
1586          0,                     /* rightshift */
1587          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1588          16,                    /* bitsize */
1589          FALSE,                 /* pc_relative */
1590          0,                     /* bitpos */
1591          complain_overflow_signed, /* complain_on_overflow */
1592          ppc64_elf_unhandled_reloc, /* special_function */
1593          "R_PPC64_TPREL16",     /* name */
1594          FALSE,                 /* partial_inplace */
1595          0,                     /* src_mask */
1596          0xffff,                /* dst_mask */
1597          FALSE),                /* pcrel_offset */
1598
1599   /* Like TPREL16, but no overflow.  */
1600   HOWTO (R_PPC64_TPREL16_LO,
1601          0,                     /* rightshift */
1602          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1603          16,                    /* bitsize */
1604          FALSE,                 /* pc_relative */
1605          0,                     /* bitpos */
1606          complain_overflow_dont, /* complain_on_overflow */
1607          ppc64_elf_unhandled_reloc, /* special_function */
1608          "R_PPC64_TPREL16_LO",  /* name */
1609          FALSE,                 /* partial_inplace */
1610          0,                     /* src_mask */
1611          0xffff,                /* dst_mask */
1612          FALSE),                /* pcrel_offset */
1613
1614   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1615   HOWTO (R_PPC64_TPREL16_HI,
1616          16,                    /* rightshift */
1617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1618          16,                    /* bitsize */
1619          FALSE,                 /* pc_relative */
1620          0,                     /* bitpos */
1621          complain_overflow_signed, /* complain_on_overflow */
1622          ppc64_elf_unhandled_reloc, /* special_function */
1623          "R_PPC64_TPREL16_HI",  /* name */
1624          FALSE,                 /* partial_inplace */
1625          0,                     /* src_mask */
1626          0xffff,                /* dst_mask */
1627          FALSE),                /* pcrel_offset */
1628
1629   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1630   HOWTO (R_PPC64_TPREL16_HA,
1631          16,                    /* rightshift */
1632          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1633          16,                    /* bitsize */
1634          FALSE,                 /* pc_relative */
1635          0,                     /* bitpos */
1636          complain_overflow_signed, /* complain_on_overflow */
1637          ppc64_elf_unhandled_reloc, /* special_function */
1638          "R_PPC64_TPREL16_HA",  /* name */
1639          FALSE,                 /* partial_inplace */
1640          0,                     /* src_mask */
1641          0xffff,                /* dst_mask */
1642          FALSE),                /* pcrel_offset */
1643
1644   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1645   HOWTO (R_PPC64_TPREL16_HIGHER,
1646          32,                    /* rightshift */
1647          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1648          16,                    /* bitsize */
1649          FALSE,                 /* pc_relative */
1650          0,                     /* bitpos */
1651          complain_overflow_dont, /* complain_on_overflow */
1652          ppc64_elf_unhandled_reloc, /* special_function */
1653          "R_PPC64_TPREL16_HIGHER",      /* name */
1654          FALSE,                 /* partial_inplace */
1655          0,                     /* src_mask */
1656          0xffff,                /* dst_mask */
1657          FALSE),                /* pcrel_offset */
1658
1659   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1660   HOWTO (R_PPC64_TPREL16_HIGHERA,
1661          32,                    /* rightshift */
1662          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1663          16,                    /* bitsize */
1664          FALSE,                 /* pc_relative */
1665          0,                     /* bitpos */
1666          complain_overflow_dont, /* complain_on_overflow */
1667          ppc64_elf_unhandled_reloc, /* special_function */
1668          "R_PPC64_TPREL16_HIGHERA", /* name */
1669          FALSE,                 /* partial_inplace */
1670          0,                     /* src_mask */
1671          0xffff,                /* dst_mask */
1672          FALSE),                /* pcrel_offset */
1673
1674   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1675   HOWTO (R_PPC64_TPREL16_HIGHEST,
1676          48,                    /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_dont, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_TPREL16_HIGHEST", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1690   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1691          48,                    /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_dont, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_TPREL16_HIGHESTA", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like TPREL16, but for insns with a DS field.  */
1705   HOWTO (R_PPC64_TPREL16_DS,
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_TPREL16_DS",  /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xfffc,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like TPREL16_DS, but no overflow.  */
1720   HOWTO (R_PPC64_TPREL16_LO_DS,
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_TPREL16_LO_DS", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xfffc,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1736      to the first entry relative to the TOC base (r2).  */
1737   HOWTO (R_PPC64_GOT_TLSGD16,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_signed, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSGD16", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSGD16, but no overflow.  */
1752   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_dont, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSGD16_LO", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1768          16,                    /* 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_TLSGD16_HI", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1782   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1783          16,                    /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSGD16_HA", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1797      with values (sym+add)@dtpmod and zero, and computes the offset to the
1798      first entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_TLSLD16,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_TLSLD16", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xffff,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_TLSLD16, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_TLSLD16_LO", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xffff,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_TLSLD16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_TLSLD16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1859      the offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_DTPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_DTPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_DTPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_DTPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1920      offset to the entry relative to the TOC base (r2).  */
1921   HOWTO (R_PPC64_GOT_TPREL16_DS,
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          FALSE,                 /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_signed, /* complain_on_overflow */
1928          ppc64_elf_unhandled_reloc, /* special_function */
1929          "R_PPC64_GOT_TPREL16_DS", /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xfffc,                /* dst_mask */
1933          FALSE),                /* pcrel_offset */
1934
1935   /* Like GOT_TPREL16_DS, but no overflow.  */
1936   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1937          0,                     /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          FALSE,                 /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          ppc64_elf_unhandled_reloc, /* special_function */
1944          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xfffc,                /* dst_mask */
1948          FALSE),                /* pcrel_offset */
1949
1950   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1951   HOWTO (R_PPC64_GOT_TPREL16_HI,
1952          16,                    /* rightshift */
1953          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1954          16,                    /* bitsize */
1955          FALSE,                 /* pc_relative */
1956          0,                     /* bitpos */
1957          complain_overflow_signed, /* complain_on_overflow */
1958          ppc64_elf_unhandled_reloc, /* special_function */
1959          "R_PPC64_GOT_TPREL16_HI", /* name */
1960          FALSE,                 /* partial_inplace */
1961          0,                     /* src_mask */
1962          0xffff,                /* dst_mask */
1963          FALSE),                /* pcrel_offset */
1964
1965   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1966   HOWTO (R_PPC64_GOT_TPREL16_HA,
1967          16,                    /* rightshift */
1968          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1969          16,                    /* bitsize */
1970          FALSE,                 /* pc_relative */
1971          0,                     /* bitpos */
1972          complain_overflow_signed, /* complain_on_overflow */
1973          ppc64_elf_unhandled_reloc, /* special_function */
1974          "R_PPC64_GOT_TPREL16_HA", /* name */
1975          FALSE,                 /* partial_inplace */
1976          0,                     /* src_mask */
1977          0xffff,                /* dst_mask */
1978          FALSE),                /* pcrel_offset */
1979
1980   HOWTO (R_PPC64_JMP_IREL,      /* type */
1981          0,                     /* rightshift */
1982          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1983          0,                     /* bitsize */
1984          FALSE,                 /* pc_relative */
1985          0,                     /* bitpos */
1986          complain_overflow_dont, /* complain_on_overflow */
1987          ppc64_elf_unhandled_reloc, /* special_function */
1988          "R_PPC64_JMP_IREL",    /* name */
1989          FALSE,                 /* partial_inplace */
1990          0,                     /* src_mask */
1991          0,                     /* dst_mask */
1992          FALSE),                /* pcrel_offset */
1993
1994   HOWTO (R_PPC64_IRELATIVE,     /* type */
1995          0,                     /* rightshift */
1996          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1997          64,                    /* bitsize */
1998          FALSE,                 /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_dont, /* complain_on_overflow */
2001          bfd_elf_generic_reloc, /* special_function */
2002          "R_PPC64_IRELATIVE",   /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          ONES (64),             /* dst_mask */
2006          FALSE),                /* pcrel_offset */
2007
2008   /* A 16 bit relative relocation.  */
2009   HOWTO (R_PPC64_REL16,         /* type */
2010          0,                     /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          TRUE,                  /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_signed, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_REL16",       /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          TRUE),                 /* pcrel_offset */
2022
2023   /* A 16 bit relative relocation without overflow.  */
2024   HOWTO (R_PPC64_REL16_LO,      /* type */
2025          0,                     /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          TRUE,                  /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont,/* complain_on_overflow */
2031          bfd_elf_generic_reloc, /* special_function */
2032          "R_PPC64_REL16_LO",    /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          TRUE),                 /* pcrel_offset */
2037
2038   /* The high order 16 bits of a relative address.  */
2039   HOWTO (R_PPC64_REL16_HI,      /* type */
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          TRUE,                  /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_signed, /* complain_on_overflow */
2046          bfd_elf_generic_reloc, /* special_function */
2047          "R_PPC64_REL16_HI",    /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          TRUE),                 /* pcrel_offset */
2052
2053   /* The high order 16 bits of a relative address, plus 1 if the contents of
2054      the low 16 bits, treated as a signed number, is negative.  */
2055   HOWTO (R_PPC64_REL16_HA,      /* type */
2056          16,                    /* rightshift */
2057          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2058          16,                    /* bitsize */
2059          TRUE,                  /* pc_relative */
2060          0,                     /* bitpos */
2061          complain_overflow_signed, /* complain_on_overflow */
2062          ppc64_elf_ha_reloc,    /* special_function */
2063          "R_PPC64_REL16_HA",    /* name */
2064          FALSE,                 /* partial_inplace */
2065          0,                     /* src_mask */
2066          0xffff,                /* dst_mask */
2067          TRUE),                 /* pcrel_offset */
2068
2069   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2070   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2071          16,                    /* rightshift */
2072          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2073          16,                    /* bitsize */
2074          TRUE,                  /* pc_relative */
2075          0,                     /* bitpos */
2076          complain_overflow_signed, /* complain_on_overflow */
2077          ppc64_elf_ha_reloc,    /* special_function */
2078          "R_PPC64_REL16DX_HA",  /* name */
2079          FALSE,                 /* partial_inplace */
2080          0,                     /* src_mask */
2081          0x1fffc1,              /* dst_mask */
2082          TRUE),                 /* pcrel_offset */
2083
2084   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2085   HOWTO (R_PPC64_16DX_HA,       /* type */
2086          16,                    /* rightshift */
2087          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2088          16,                    /* bitsize */
2089          FALSE,                 /* pc_relative */
2090          0,                     /* bitpos */
2091          complain_overflow_signed, /* complain_on_overflow */
2092          ppc64_elf_ha_reloc,    /* special_function */
2093          "R_PPC64_16DX_HA",     /* name */
2094          FALSE,                 /* partial_inplace */
2095          0,                     /* src_mask */
2096          0x1fffc1,              /* dst_mask */
2097          FALSE),                /* pcrel_offset */
2098
2099   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2100   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2101          16,                    /* rightshift */
2102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2103          16,                    /* bitsize */
2104          FALSE,                 /* pc_relative */
2105          0,                     /* bitpos */
2106          complain_overflow_dont, /* complain_on_overflow */
2107          bfd_elf_generic_reloc, /* special_function */
2108          "R_PPC64_ADDR16_HIGH", /* name */
2109          FALSE,                 /* partial_inplace */
2110          0,                     /* src_mask */
2111          0xffff,                /* dst_mask */
2112          FALSE),                /* pcrel_offset */
2113
2114   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2115   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2116          16,                    /* rightshift */
2117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2118          16,                    /* bitsize */
2119          FALSE,                 /* pc_relative */
2120          0,                     /* bitpos */
2121          complain_overflow_dont, /* complain_on_overflow */
2122          ppc64_elf_ha_reloc,    /* special_function */
2123          "R_PPC64_ADDR16_HIGHA",        /* name */
2124          FALSE,                 /* partial_inplace */
2125          0,                     /* src_mask */
2126          0xffff,                /* dst_mask */
2127          FALSE),                /* pcrel_offset */
2128
2129   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2130   HOWTO (R_PPC64_DTPREL16_HIGH,
2131          16,                    /* rightshift */
2132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2133          16,                    /* bitsize */
2134          FALSE,                 /* pc_relative */
2135          0,                     /* bitpos */
2136          complain_overflow_dont, /* complain_on_overflow */
2137          ppc64_elf_unhandled_reloc, /* special_function */
2138          "R_PPC64_DTPREL16_HIGH", /* name */
2139          FALSE,                 /* partial_inplace */
2140          0,                     /* src_mask */
2141          0xffff,                /* dst_mask */
2142          FALSE),                /* pcrel_offset */
2143
2144   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2145   HOWTO (R_PPC64_DTPREL16_HIGHA,
2146          16,                    /* rightshift */
2147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2148          16,                    /* bitsize */
2149          FALSE,                 /* pc_relative */
2150          0,                     /* bitpos */
2151          complain_overflow_dont, /* complain_on_overflow */
2152          ppc64_elf_unhandled_reloc, /* special_function */
2153          "R_PPC64_DTPREL16_HIGHA", /* name */
2154          FALSE,                 /* partial_inplace */
2155          0,                     /* src_mask */
2156          0xffff,                /* dst_mask */
2157          FALSE),                /* pcrel_offset */
2158
2159   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2160   HOWTO (R_PPC64_TPREL16_HIGH,
2161          16,                    /* rightshift */
2162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2163          16,                    /* bitsize */
2164          FALSE,                 /* pc_relative */
2165          0,                     /* bitpos */
2166          complain_overflow_dont, /* complain_on_overflow */
2167          ppc64_elf_unhandled_reloc, /* special_function */
2168          "R_PPC64_TPREL16_HIGH",        /* name */
2169          FALSE,                 /* partial_inplace */
2170          0,                     /* src_mask */
2171          0xffff,                /* dst_mask */
2172          FALSE),                /* pcrel_offset */
2173
2174   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2175   HOWTO (R_PPC64_TPREL16_HIGHA,
2176          16,                    /* rightshift */
2177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2178          16,                    /* bitsize */
2179          FALSE,                 /* pc_relative */
2180          0,                     /* bitpos */
2181          complain_overflow_dont, /* complain_on_overflow */
2182          ppc64_elf_unhandled_reloc, /* special_function */
2183          "R_PPC64_TPREL16_HIGHA",       /* name */
2184          FALSE,                 /* partial_inplace */
2185          0,                     /* src_mask */
2186          0xffff,                /* dst_mask */
2187          FALSE),                /* pcrel_offset */
2188
2189   /* Marker reloc on ELFv2 large-model function entry.  */
2190   HOWTO (R_PPC64_ENTRY,
2191          0,                     /* rightshift */
2192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2193          32,                    /* bitsize */
2194          FALSE,                 /* pc_relative */
2195          0,                     /* bitpos */
2196          complain_overflow_dont, /* complain_on_overflow */
2197          bfd_elf_generic_reloc, /* special_function */
2198          "R_PPC64_ENTRY",       /* name */
2199          FALSE,                 /* partial_inplace */
2200          0,                     /* src_mask */
2201          0,                     /* dst_mask */
2202          FALSE),                /* pcrel_offset */
2203
2204   /* Like ADDR64, but use local entry point of function.  */
2205   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2206          0,                     /* rightshift */
2207          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2208          64,                    /* bitsize */
2209          FALSE,                 /* pc_relative */
2210          0,                     /* bitpos */
2211          complain_overflow_dont, /* complain_on_overflow */
2212          bfd_elf_generic_reloc, /* special_function */
2213          "R_PPC64_ADDR64_LOCAL", /* name */
2214          FALSE,                 /* partial_inplace */
2215          0,                     /* src_mask */
2216          ONES (64),             /* dst_mask */
2217          FALSE),                /* pcrel_offset */
2218
2219   /* GNU extension to record C++ vtable hierarchy.  */
2220   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2221          0,                     /* rightshift */
2222          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2223          0,                     /* bitsize */
2224          FALSE,                 /* pc_relative */
2225          0,                     /* bitpos */
2226          complain_overflow_dont, /* complain_on_overflow */
2227          NULL,                  /* special_function */
2228          "R_PPC64_GNU_VTINHERIT", /* name */
2229          FALSE,                 /* partial_inplace */
2230          0,                     /* src_mask */
2231          0,                     /* dst_mask */
2232          FALSE),                /* pcrel_offset */
2233
2234   /* GNU extension to record C++ vtable member usage.  */
2235   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2236          0,                     /* rightshift */
2237          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2238          0,                     /* bitsize */
2239          FALSE,                 /* pc_relative */
2240          0,                     /* bitpos */
2241          complain_overflow_dont, /* complain_on_overflow */
2242          NULL,                  /* special_function */
2243          "R_PPC64_GNU_VTENTRY", /* name */
2244          FALSE,                 /* partial_inplace */
2245          0,                     /* src_mask */
2246          0,                     /* dst_mask */
2247          FALSE),                /* pcrel_offset */
2248 };
2249
2250 \f
2251 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2252    be done.  */
2253
2254 static void
2255 ppc_howto_init (void)
2256 {
2257   unsigned int i, type;
2258
2259   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2260     {
2261       type = ppc64_elf_howto_raw[i].type;
2262       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2263       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2264     }
2265 }
2266
2267 static reloc_howto_type *
2268 ppc64_elf_reloc_type_lookup (bfd *abfd,
2269                              bfd_reloc_code_real_type code)
2270 {
2271   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2272
2273   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2274     /* Initialize howto table if needed.  */
2275     ppc_howto_init ();
2276
2277   switch (code)
2278     {
2279     default:
2280       /* xgettext:c-format */
2281       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2282       bfd_set_error (bfd_error_bad_value);
2283       return NULL;
2284
2285     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2286       break;
2287     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2288       break;
2289     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2290       break;
2291     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2292       break;
2293     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2294       break;
2295     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2296       break;
2297     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2298       break;
2299     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2300       break;
2301     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2302       break;
2303     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2304       break;
2305     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2306       break;
2307     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2308       break;
2309     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2310       break;
2311     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2312       break;
2313     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2314       break;
2315     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2316       break;
2317     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2318       break;
2319     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2320       break;
2321     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2322       break;
2323     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2324       break;
2325     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2326       break;
2327     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2328       break;
2329     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2330       break;
2331     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2332       break;
2333     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2334       break;
2335     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2336       break;
2337     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2338       break;
2339     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2340       break;
2341     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2342       break;
2343     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2344       break;
2345     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2346       break;
2347     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2348       break;
2349     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2350       break;
2351     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2352       break;
2353     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2354       break;
2355     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2356       break;
2357     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2358       break;
2359     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2360       break;
2361     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2362       break;
2363     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2364       break;
2365     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2366       break;
2367     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2368       break;
2369     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2370       break;
2371     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2372       break;
2373     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2374       break;
2375     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2376       break;
2377     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2378       break;
2379     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2380       break;
2381     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2384       break;
2385     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2386       break;
2387     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2388       break;
2389     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2390       break;
2391     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2392       break;
2393     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2394       break;
2395     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2396       break;
2397     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2398       break;
2399     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2400       break;
2401     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2402       break;
2403     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2404       break;
2405     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2406       break;
2407     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2408       break;
2409     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2410       break;
2411     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2412       break;
2413     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2414       break;
2415     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2416       break;
2417     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2418       break;
2419     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2422       break;
2423     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2426       break;
2427     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2428       break;
2429     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2430       break;
2431     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2432       break;
2433     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2436       break;
2437     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2440       break;
2441     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2442       break;
2443     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2444       break;
2445     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2446       break;
2447     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2448       break;
2449     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2450       break;
2451     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2452       break;
2453     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2454       break;
2455     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2456       break;
2457     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2458       break;
2459     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2460       break;
2461     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2462       break;
2463     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2464       break;
2465     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2466       break;
2467     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2468       break;
2469     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2470       break;
2471     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2472       break;
2473     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2474       break;
2475     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2476       break;
2477     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2478       break;
2479     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2480       break;
2481     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2482       break;
2483     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2484       break;
2485     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2486       break;
2487     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2488       break;
2489     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2490       break;
2491     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2492       break;
2493     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2494       break;
2495     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2496       break;
2497     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2498       break;
2499     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2500       break;
2501     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2502       break;
2503     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2504       break;
2505     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2506       break;
2507     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2508       break;
2509     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2510       break;
2511     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2512       break;
2513     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2514       break;
2515     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2516       break;
2517     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2518       break;
2519     }
2520
2521   return ppc64_elf_howto_table[r];
2522 };
2523
2524 static reloc_howto_type *
2525 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2526                              const char *r_name)
2527 {
2528   unsigned int i;
2529
2530   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2531     if (ppc64_elf_howto_raw[i].name != NULL
2532         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2533       return &ppc64_elf_howto_raw[i];
2534
2535
2536   return NULL;
2537 }
2538
2539 /* Set the howto pointer for a PowerPC ELF reloc.  */
2540
2541 static bfd_boolean
2542 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2543                          Elf_Internal_Rela *dst)
2544 {
2545   unsigned int type;
2546
2547   /* Initialize howto table if needed.  */
2548   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2549     ppc_howto_init ();
2550
2551   type = ELF64_R_TYPE (dst->r_info);
2552   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2553     {
2554       /* xgettext:c-format */
2555       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2556                           abfd, type);
2557       bfd_set_error (bfd_error_bad_value);
2558       return FALSE;
2559     }
2560   cache_ptr->howto = ppc64_elf_howto_table[type];
2561   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2562     {
2563       /* xgettext:c-format */
2564       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2565                           abfd, type);
2566       bfd_set_error (bfd_error_bad_value);
2567       return FALSE;
2568     }
2569
2570   return TRUE;
2571 }
2572
2573 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2574
2575 static bfd_reloc_status_type
2576 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2577                     void *data, asection *input_section,
2578                     bfd *output_bfd, char **error_message)
2579 {
2580   enum elf_ppc64_reloc_type r_type;
2581   long insn;
2582   bfd_size_type octets;
2583   bfd_vma value;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   /* Adjust the addend for sign extension of the low 16 bits.
2593      We won't actually be using the low 16 bits, so trashing them
2594      doesn't matter.  */
2595   reloc_entry->addend += 0x8000;
2596   r_type = reloc_entry->howto->type;
2597   if (r_type != R_PPC64_REL16DX_HA)
2598     return bfd_reloc_continue;
2599
2600   value = 0;
2601   if (!bfd_is_com_section (symbol->section))
2602     value = symbol->value;
2603   value += (reloc_entry->addend
2604             + symbol->section->output_offset
2605             + symbol->section->output_section->vma);
2606   value -= (reloc_entry->address
2607             + input_section->output_offset
2608             + input_section->output_section->vma);
2609   value = (bfd_signed_vma) value >> 16;
2610
2611   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2612   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2613   insn &= ~0x1fffc1;
2614   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2615   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2616   if (value + 0x8000 > 0xffff)
2617     return bfd_reloc_overflow;
2618   return bfd_reloc_ok;
2619 }
2620
2621 static bfd_reloc_status_type
2622 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2623                         void *data, asection *input_section,
2624                         bfd *output_bfd, char **error_message)
2625 {
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   if (strcmp (symbol->section->name, ".opd") == 0
2631       && (symbol->section->owner->flags & DYNAMIC) == 0)
2632     {
2633       bfd_vma dest = opd_entry_value (symbol->section,
2634                                       symbol->value + reloc_entry->addend,
2635                                       NULL, NULL, FALSE);
2636       if (dest != (bfd_vma) -1)
2637         reloc_entry->addend = dest - (symbol->value
2638                                       + symbol->section->output_section->vma
2639                                       + symbol->section->output_offset);
2640     }
2641   else
2642     {
2643       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2644
2645       if (symbol->section->owner != abfd
2646           && symbol->section->owner != NULL
2647           && abiversion (symbol->section->owner) >= 2)
2648         {
2649           unsigned int i;
2650
2651           for (i = 0; i < symbol->section->owner->symcount; ++i)
2652             {
2653               asymbol *symdef = symbol->section->owner->outsymbols[i];
2654
2655               if (strcmp (symdef->name, symbol->name) == 0)
2656                 {
2657                   elfsym = (elf_symbol_type *) symdef;
2658                   break;
2659                 }
2660             }
2661         }
2662       reloc_entry->addend
2663         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2664     }
2665   return bfd_reloc_continue;
2666 }
2667
2668 static bfd_reloc_status_type
2669 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2670                          void *data, asection *input_section,
2671                          bfd *output_bfd, char **error_message)
2672 {
2673   long insn;
2674   enum elf_ppc64_reloc_type r_type;
2675   bfd_size_type octets;
2676   /* Assume 'at' branch hints.  */
2677   bfd_boolean is_isa_v2 = TRUE;
2678
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2687   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2688   insn &= ~(0x01 << 21);
2689   r_type = reloc_entry->howto->type;
2690   if (r_type == R_PPC64_ADDR14_BRTAKEN
2691       || r_type == R_PPC64_REL14_BRTAKEN)
2692     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2693
2694   if (is_isa_v2)
2695     {
2696       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2697          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2698          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2699       if ((insn & (0x14 << 21)) == (0x04 << 21))
2700         insn |= 0x02 << 21;
2701       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2702         insn |= 0x08 << 21;
2703       else
2704         goto out;
2705     }
2706   else
2707     {
2708       bfd_vma target = 0;
2709       bfd_vma from;
2710
2711       if (!bfd_is_com_section (symbol->section))
2712         target = symbol->value;
2713       target += symbol->section->output_section->vma;
2714       target += symbol->section->output_offset;
2715       target += reloc_entry->addend;
2716
2717       from = (reloc_entry->address
2718               + input_section->output_offset
2719               + input_section->output_section->vma);
2720
2721       /* Invert 'y' bit if not the default.  */
2722       if ((bfd_signed_vma) (target - from) < 0)
2723         insn ^= 0x01 << 21;
2724     }
2725   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2726  out:
2727   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2728                                  input_section, output_bfd, error_message);
2729 }
2730
2731 static bfd_reloc_status_type
2732 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2733                          void *data, asection *input_section,
2734                          bfd *output_bfd, char **error_message)
2735 {
2736   /* If this is a relocatable link (output_bfd test tells us), just
2737      call the generic function.  Any adjustment will be done at final
2738      link time.  */
2739   if (output_bfd != NULL)
2740     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2741                                   input_section, output_bfd, error_message);
2742
2743   /* Subtract the symbol section base address.  */
2744   reloc_entry->addend -= symbol->section->output_section->vma;
2745   return bfd_reloc_continue;
2746 }
2747
2748 static bfd_reloc_status_type
2749 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2750                             void *data, asection *input_section,
2751                             bfd *output_bfd, char **error_message)
2752 {
2753   /* If this is a relocatable link (output_bfd test tells us), just
2754      call the generic function.  Any adjustment will be done at final
2755      link time.  */
2756   if (output_bfd != NULL)
2757     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2758                                   input_section, output_bfd, error_message);
2759
2760   /* Subtract the symbol section base address.  */
2761   reloc_entry->addend -= symbol->section->output_section->vma;
2762
2763   /* Adjust the addend for sign extension of the low 16 bits.  */
2764   reloc_entry->addend += 0x8000;
2765   return bfd_reloc_continue;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                      void *data, asection *input_section,
2771                      bfd *output_bfd, char **error_message)
2772 {
2773   bfd_vma TOCstart;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   /* Subtract the TOC base address.  */
2787   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2788   return bfd_reloc_continue;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                         void *data, asection *input_section,
2794                         bfd *output_bfd, char **error_message)
2795 {
2796   bfd_vma TOCstart;
2797
2798   /* If this is a relocatable link (output_bfd test tells us), just
2799      call the generic function.  Any adjustment will be done at final
2800      link time.  */
2801   if (output_bfd != NULL)
2802     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2803                                   input_section, output_bfd, error_message);
2804
2805   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2806   if (TOCstart == 0)
2807     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2808
2809   /* Subtract the TOC base address.  */
2810   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2811
2812   /* Adjust the addend for sign extension of the low 16 bits.  */
2813   reloc_entry->addend += 0x8000;
2814   return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819                        void *data, asection *input_section,
2820                        bfd *output_bfd, char **error_message)
2821 {
2822   bfd_vma TOCstart;
2823   bfd_size_type octets;
2824
2825   /* If this is a relocatable link (output_bfd test tells us), just
2826      call the generic function.  Any adjustment will be done at final
2827      link time.  */
2828   if (output_bfd != NULL)
2829     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2830                                   input_section, output_bfd, error_message);
2831
2832   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2833   if (TOCstart == 0)
2834     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2835
2836   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2837   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2838   return bfd_reloc_ok;
2839 }
2840
2841 static bfd_reloc_status_type
2842 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2843                            void *data, asection *input_section,
2844                            bfd *output_bfd, char **error_message)
2845 {
2846   /* If this is a relocatable link (output_bfd test tells us), just
2847      call the generic function.  Any adjustment will be done at final
2848      link time.  */
2849   if (output_bfd != NULL)
2850     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2851                                   input_section, output_bfd, error_message);
2852
2853   if (error_message != NULL)
2854     {
2855       static char buf[60];
2856       sprintf (buf, "generic linker can't handle %s",
2857                reloc_entry->howto->name);
2858       *error_message = buf;
2859     }
2860   return bfd_reloc_dangerous;
2861 }
2862
2863 /* Track GOT entries needed for a given symbol.  We might need more
2864    than one got entry per symbol.  */
2865 struct got_entry
2866 {
2867   struct got_entry *next;
2868
2869   /* The symbol addend that we'll be placing in the GOT.  */
2870   bfd_vma addend;
2871
2872   /* Unlike other ELF targets, we use separate GOT entries for the same
2873      symbol referenced from different input files.  This is to support
2874      automatic multiple TOC/GOT sections, where the TOC base can vary
2875      from one input file to another.  After partitioning into TOC groups
2876      we merge entries within the group.
2877
2878      Point to the BFD owning this GOT entry.  */
2879   bfd *owner;
2880
2881   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2882      TLS_TPREL or TLS_DTPREL for tls entries.  */
2883   unsigned char tls_type;
2884
2885   /* Non-zero if got.ent points to real entry.  */
2886   unsigned char is_indirect;
2887
2888   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2889   union
2890     {
2891       bfd_signed_vma refcount;
2892       bfd_vma offset;
2893       struct got_entry *ent;
2894     } got;
2895 };
2896
2897 /* The same for PLT.  */
2898 struct plt_entry
2899 {
2900   struct plt_entry *next;
2901
2902   bfd_vma addend;
2903
2904   union
2905     {
2906       bfd_signed_vma refcount;
2907       bfd_vma offset;
2908     } plt;
2909 };
2910
2911 struct ppc64_elf_obj_tdata
2912 {
2913   struct elf_obj_tdata elf;
2914
2915   /* Shortcuts to dynamic linker sections.  */
2916   asection *got;
2917   asection *relgot;
2918
2919   /* Used during garbage collection.  We attach global symbols defined
2920      on removed .opd entries to this section so that the sym is removed.  */
2921   asection *deleted_section;
2922
2923   /* TLS local dynamic got entry handling.  Support for multiple GOT
2924      sections means we potentially need one of these for each input bfd.  */
2925   struct got_entry tlsld_got;
2926
2927   union {
2928     /* A copy of relocs before they are modified for --emit-relocs.  */
2929     Elf_Internal_Rela *relocs;
2930
2931     /* Section contents.  */
2932     bfd_byte *contents;
2933   } opd;
2934
2935   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2936      the reloc to be in the range -32768 to 32767.  */
2937   unsigned int has_small_toc_reloc : 1;
2938
2939   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2940      instruction not one we handle.  */
2941   unsigned int unexpected_toc_insn : 1;
2942 };
2943
2944 #define ppc64_elf_tdata(bfd) \
2945   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2946
2947 #define ppc64_tlsld_got(bfd) \
2948   (&ppc64_elf_tdata (bfd)->tlsld_got)
2949
2950 #define is_ppc64_elf(bfd) \
2951   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2952    && elf_object_id (bfd) == PPC64_ELF_DATA)
2953
2954 /* Override the generic function because we store some extras.  */
2955
2956 static bfd_boolean
2957 ppc64_elf_mkobject (bfd *abfd)
2958 {
2959   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2960                                   PPC64_ELF_DATA);
2961 }
2962
2963 /* Fix bad default arch selected for a 64 bit input bfd when the
2964    default is 32 bit.  Also select arch based on apuinfo.  */
2965
2966 static bfd_boolean
2967 ppc64_elf_object_p (bfd *abfd)
2968 {
2969   if (!abfd->arch_info->the_default)
2970     return TRUE;
2971
2972   if (abfd->arch_info->bits_per_word == 32)
2973     {
2974       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2975
2976       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2977         {
2978           /* Relies on arch after 32 bit default being 64 bit default.  */
2979           abfd->arch_info = abfd->arch_info->next;
2980           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2981         }
2982     }
2983   return _bfd_elf_ppc_set_arch (abfd);
2984 }
2985
2986 /* Support for core dump NOTE sections.  */
2987
2988 static bfd_boolean
2989 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2990 {
2991   size_t offset, size;
2992
2993   if (note->descsz != 504)
2994     return FALSE;
2995
2996   /* pr_cursig */
2997   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2998
2999   /* pr_pid */
3000   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3001
3002   /* pr_reg */
3003   offset = 112;
3004   size = 384;
3005
3006   /* Make a ".reg/999" section.  */
3007   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3008                                           size, note->descpos + offset);
3009 }
3010
3011 static bfd_boolean
3012 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3013 {
3014   if (note->descsz != 136)
3015     return FALSE;
3016
3017   elf_tdata (abfd)->core->pid
3018     = bfd_get_32 (abfd, note->descdata + 24);
3019   elf_tdata (abfd)->core->program
3020     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3021   elf_tdata (abfd)->core->command
3022     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3023
3024   return TRUE;
3025 }
3026
3027 static char *
3028 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3029                            ...)
3030 {
3031   switch (note_type)
3032     {
3033     default:
3034       return NULL;
3035
3036     case NT_PRPSINFO:
3037       {
3038         char data[136] ATTRIBUTE_NONSTRING;
3039         va_list ap;
3040
3041         va_start (ap, note_type);
3042         memset (data, 0, sizeof (data));
3043         strncpy (data + 40, va_arg (ap, const char *), 16);
3044         DIAGNOSTIC_PUSH;
3045         /* GCC 8.1 warns about 80 equals destination size with
3046            -Wstringop-truncation:
3047            https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3048          */
3049 #if GCC_VERSION == 8001
3050         DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3051 #endif
3052         strncpy (data + 56, va_arg (ap, const char *), 80);
3053         DIAGNOSTIC_POP;
3054         va_end (ap);
3055         return elfcore_write_note (abfd, buf, bufsiz,
3056                                    "CORE", note_type, data, sizeof (data));
3057       }
3058
3059     case NT_PRSTATUS:
3060       {
3061         char data[504];
3062         va_list ap;
3063         long pid;
3064         int cursig;
3065         const void *greg;
3066
3067         va_start (ap, note_type);
3068         memset (data, 0, 112);
3069         pid = va_arg (ap, long);
3070         bfd_put_32 (abfd, pid, data + 32);
3071         cursig = va_arg (ap, int);
3072         bfd_put_16 (abfd, cursig, data + 12);
3073         greg = va_arg (ap, const void *);
3074         memcpy (data + 112, greg, 384);
3075         memset (data + 496, 0, 8);
3076         va_end (ap);
3077         return elfcore_write_note (abfd, buf, bufsiz,
3078                                    "CORE", note_type, data, sizeof (data));
3079       }
3080     }
3081 }
3082
3083 /* Add extra PPC sections.  */
3084
3085 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3086 {
3087   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3088   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3089   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3090   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3091   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3092   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3093   { NULL,                     0,  0, 0,            0 }
3094 };
3095
3096 enum _ppc64_sec_type {
3097   sec_normal = 0,
3098   sec_opd = 1,
3099   sec_toc = 2
3100 };
3101
3102 struct _ppc64_elf_section_data
3103 {
3104   struct bfd_elf_section_data elf;
3105
3106   union
3107   {
3108     /* An array with one entry for each opd function descriptor,
3109        and some spares since opd entries may be either 16 or 24 bytes.  */
3110 #define OPD_NDX(OFF) ((OFF) >> 4)
3111     struct _opd_sec_data
3112     {
3113       /* Points to the function code section for local opd entries.  */
3114       asection **func_sec;
3115
3116       /* After editing .opd, adjust references to opd local syms.  */
3117       long *adjust;
3118     } opd;
3119
3120     /* An array for toc sections, indexed by offset/8.  */
3121     struct _toc_sec_data
3122     {
3123       /* Specifies the relocation symbol index used at a given toc offset.  */
3124       unsigned *symndx;
3125
3126       /* And the relocation addend.  */
3127       bfd_vma *add;
3128     } toc;
3129   } u;
3130
3131   enum _ppc64_sec_type sec_type:2;
3132
3133   /* Flag set when small branches are detected.  Used to
3134      select suitable defaults for the stub group size.  */
3135   unsigned int has_14bit_branch:1;
3136
3137   /* Flag set when PLTCALL relocs are detected.  */
3138   unsigned int has_pltcall:1;
3139 };
3140
3141 #define ppc64_elf_section_data(sec) \
3142   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3143
3144 static bfd_boolean
3145 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3146 {
3147   if (!sec->used_by_bfd)
3148     {
3149       struct _ppc64_elf_section_data *sdata;
3150       bfd_size_type amt = sizeof (*sdata);
3151
3152       sdata = bfd_zalloc (abfd, amt);
3153       if (sdata == NULL)
3154         return FALSE;
3155       sec->used_by_bfd = sdata;
3156     }
3157
3158   return _bfd_elf_new_section_hook (abfd, sec);
3159 }
3160
3161 static struct _opd_sec_data *
3162 get_opd_info (asection * sec)
3163 {
3164   if (sec != NULL
3165       && ppc64_elf_section_data (sec) != NULL
3166       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3167     return &ppc64_elf_section_data (sec)->u.opd;
3168   return NULL;
3169 }
3170 \f
3171 /* Parameters for the qsort hook.  */
3172 static bfd_boolean synthetic_relocatable;
3173 static asection *synthetic_opd;
3174
3175 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3176
3177 static int
3178 compare_symbols (const void *ap, const void *bp)
3179 {
3180   const asymbol *a = * (const asymbol **) ap;
3181   const asymbol *b = * (const asymbol **) bp;
3182
3183   /* Section symbols first.  */
3184   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3185     return -1;
3186   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3187     return 1;
3188
3189   /* then .opd symbols.  */
3190   if (synthetic_opd != NULL)
3191     {
3192       if (strcmp (a->section->name, ".opd") == 0
3193           && strcmp (b->section->name, ".opd") != 0)
3194         return -1;
3195       if (strcmp (a->section->name, ".opd") != 0
3196           && strcmp (b->section->name, ".opd") == 0)
3197         return 1;
3198     }
3199
3200   /* then other code symbols.  */
3201   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3202       == (SEC_CODE | SEC_ALLOC)
3203       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3204          != (SEC_CODE | SEC_ALLOC))
3205     return -1;
3206
3207   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3208       != (SEC_CODE | SEC_ALLOC)
3209       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3210          == (SEC_CODE | SEC_ALLOC))
3211     return 1;
3212
3213   if (synthetic_relocatable)
3214     {
3215       if (a->section->id < b->section->id)
3216         return -1;
3217
3218       if (a->section->id > b->section->id)
3219         return 1;
3220     }
3221
3222   if (a->value + a->section->vma < b->value + b->section->vma)
3223     return -1;
3224
3225   if (a->value + a->section->vma > b->value + b->section->vma)
3226     return 1;
3227
3228   /* For syms with the same value, prefer strong dynamic global function
3229      syms over other syms.  */
3230   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3231     return -1;
3232
3233   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3234     return 1;
3235
3236   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3237     return -1;
3238
3239   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3240     return 1;
3241
3242   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3243     return -1;
3244
3245   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3246     return 1;
3247
3248   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3249     return -1;
3250
3251   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3252     return 1;
3253
3254   return a > b;
3255 }
3256
3257 /* Search SYMS for a symbol of the given VALUE.  */
3258
3259 static asymbol *
3260 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3261 {
3262   long mid;
3263
3264   if (id == (unsigned) -1)
3265     {
3266       while (lo < hi)
3267         {
3268           mid = (lo + hi) >> 1;
3269           if (syms[mid]->value + syms[mid]->section->vma < value)
3270             lo = mid + 1;
3271           else if (syms[mid]->value + syms[mid]->section->vma > value)
3272             hi = mid;
3273           else
3274             return syms[mid];
3275         }
3276     }
3277   else
3278     {
3279       while (lo < hi)
3280         {
3281           mid = (lo + hi) >> 1;
3282           if (syms[mid]->section->id < id)
3283             lo = mid + 1;
3284           else if (syms[mid]->section->id > id)
3285             hi = mid;
3286           else if (syms[mid]->value < value)
3287             lo = mid + 1;
3288           else if (syms[mid]->value > value)
3289             hi = mid;
3290           else
3291             return syms[mid];
3292         }
3293     }
3294   return NULL;
3295 }
3296
3297 static bfd_boolean
3298 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3299 {
3300   bfd_vma vma = *(bfd_vma *) ptr;
3301   return ((section->flags & SEC_ALLOC) != 0
3302           && section->vma <= vma
3303           && vma < section->vma + section->size);
3304 }
3305
3306 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3307    entry syms.  Also generate @plt symbols for the glink branch table.
3308    Returns count of synthetic symbols in RET or -1 on error.  */
3309
3310 static long
3311 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3312                                 long static_count, asymbol **static_syms,
3313                                 long dyn_count, asymbol **dyn_syms,
3314                                 asymbol **ret)
3315 {
3316   asymbol *s;
3317   size_t i, j, count;
3318   char *names;
3319   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3320   asection *opd = NULL;
3321   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3322   asymbol **syms;
3323   int abi = abiversion (abfd);
3324
3325   *ret = NULL;
3326
3327   if (abi < 2)
3328     {
3329       opd = bfd_get_section_by_name (abfd, ".opd");
3330       if (opd == NULL && abi == 1)
3331         return 0;
3332     }
3333
3334   syms = NULL;
3335   codesecsym = 0;
3336   codesecsymend = 0;
3337   secsymend = 0;
3338   opdsymend = 0;
3339   symcount = 0;
3340   if (opd != NULL)
3341     {
3342       symcount = static_count;
3343       if (!relocatable)
3344         symcount += dyn_count;
3345       if (symcount == 0)
3346         return 0;
3347
3348       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3349       if (syms == NULL)
3350         return -1;
3351
3352       if (!relocatable && static_count != 0 && dyn_count != 0)
3353         {
3354           /* Use both symbol tables.  */
3355           memcpy (syms, static_syms, static_count * sizeof (*syms));
3356           memcpy (syms + static_count, dyn_syms,
3357                   (dyn_count + 1) * sizeof (*syms));
3358         }
3359       else if (!relocatable && static_count == 0)
3360         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3361       else
3362         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3363
3364       /* Trim uninteresting symbols.  Interesting symbols are section,
3365          function, and notype symbols.  */
3366       for (i = 0, j = 0; i < symcount; ++i)
3367         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3368                                | BSF_RELC | BSF_SRELC)) == 0)
3369           syms[j++] = syms[i];
3370       symcount = j;
3371
3372       synthetic_relocatable = relocatable;
3373       synthetic_opd = opd;
3374       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3375
3376       if (!relocatable && symcount > 1)
3377         {
3378           /* Trim duplicate syms, since we may have merged the normal
3379              and dynamic symbols.  Actually, we only care about syms
3380              that have different values, so trim any with the same
3381              value.  Don't consider ifunc and ifunc resolver symbols
3382              duplicates however, because GDB wants to know whether a
3383              text symbol is an ifunc resolver.  */
3384           for (i = 1, j = 1; i < symcount; ++i)
3385             {
3386               const asymbol *s0 = syms[i - 1];
3387               const asymbol *s1 = syms[i];
3388
3389               if ((s0->value + s0->section->vma
3390                    != s1->value + s1->section->vma)
3391                   || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3392                       != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3393                 syms[j++] = syms[i];
3394             }
3395           symcount = j;
3396         }
3397
3398       i = 0;
3399       /* Note that here and in compare_symbols we can't compare opd and
3400          sym->section directly.  With separate debug info files, the
3401          symbols will be extracted from the debug file while abfd passed
3402          to this function is the real binary.  */
3403       if (strcmp (syms[i]->section->name, ".opd") == 0)
3404         ++i;
3405       codesecsym = i;
3406
3407       for (; i < symcount; ++i)
3408         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3409                                          | SEC_THREAD_LOCAL))
3410              != (SEC_CODE | SEC_ALLOC))
3411             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3412           break;
3413       codesecsymend = i;
3414
3415       for (; i < symcount; ++i)
3416         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3417           break;
3418       secsymend = i;
3419
3420       for (; i < symcount; ++i)
3421         if (strcmp (syms[i]->section->name, ".opd") != 0)
3422           break;
3423       opdsymend = i;
3424
3425       for (; i < symcount; ++i)
3426         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3427             != (SEC_CODE | SEC_ALLOC))
3428           break;
3429       symcount = i;
3430     }
3431   count = 0;
3432
3433   if (relocatable)
3434     {
3435       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3436       arelent *r;
3437       size_t size;
3438       size_t relcount;
3439
3440       if (opdsymend == secsymend)
3441         goto done;
3442
3443       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3444       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3445       if (relcount == 0)
3446         goto done;
3447
3448       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3449         {
3450           count = -1;
3451           goto done;
3452         }
3453
3454       size = 0;
3455       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3456         {
3457           asymbol *sym;
3458
3459           while (r < opd->relocation + relcount
3460                  && r->address < syms[i]->value + opd->vma)
3461             ++r;
3462
3463           if (r == opd->relocation + relcount)
3464             break;
3465
3466           if (r->address != syms[i]->value + opd->vma)
3467             continue;
3468
3469           if (r->howto->type != R_PPC64_ADDR64)
3470             continue;
3471
3472           sym = *r->sym_ptr_ptr;
3473           if (!sym_exists_at (syms, opdsymend, symcount,
3474                               sym->section->id, sym->value + r->addend))
3475             {
3476               ++count;
3477               size += sizeof (asymbol);
3478               size += strlen (syms[i]->name) + 2;
3479             }
3480         }
3481
3482       if (size == 0)
3483         goto done;
3484       s = *ret = bfd_malloc (size);
3485       if (s == NULL)
3486         {
3487           count = -1;
3488           goto done;
3489         }
3490
3491       names = (char *) (s + count);
3492
3493       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3494         {
3495           asymbol *sym;
3496
3497           while (r < opd->relocation + relcount
3498                  && r->address < syms[i]->value + opd->vma)
3499             ++r;
3500
3501           if (r == opd->relocation + relcount)
3502             break;
3503
3504           if (r->address != syms[i]->value + opd->vma)
3505             continue;
3506
3507           if (r->howto->type != R_PPC64_ADDR64)
3508             continue;
3509
3510           sym = *r->sym_ptr_ptr;
3511           if (!sym_exists_at (syms, opdsymend, symcount,
3512                               sym->section->id, sym->value + r->addend))
3513             {
3514               size_t len;
3515
3516               *s = *syms[i];
3517               s->flags |= BSF_SYNTHETIC;
3518               s->section = sym->section;
3519               s->value = sym->value + r->addend;
3520               s->name = names;
3521               *names++ = '.';
3522               len = strlen (syms[i]->name);
3523               memcpy (names, syms[i]->name, len + 1);
3524               names += len + 1;
3525               /* Have udata.p point back to the original symbol this
3526                  synthetic symbol was derived from.  */
3527               s->udata.p = syms[i];
3528               s++;
3529             }
3530         }
3531     }
3532   else
3533     {
3534       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3535       bfd_byte *contents = NULL;
3536       size_t size;
3537       size_t plt_count = 0;
3538       bfd_vma glink_vma = 0, resolv_vma = 0;
3539       asection *dynamic, *glink = NULL, *relplt = NULL;
3540       arelent *p;
3541
3542       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3543         {
3544         free_contents_and_exit_err:
3545           count = -1;
3546         free_contents_and_exit:
3547           if (contents)
3548             free (contents);
3549           goto done;
3550         }
3551
3552       size = 0;
3553       for (i = secsymend; i < opdsymend; ++i)
3554         {
3555           bfd_vma ent;
3556
3557           /* Ignore bogus symbols.  */
3558           if (syms[i]->value > opd->size - 8)
3559             continue;
3560
3561           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3562           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3563             {
3564               ++count;
3565               size += sizeof (asymbol);
3566               size += strlen (syms[i]->name) + 2;
3567             }
3568         }
3569
3570       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3571       if (dyn_count != 0
3572           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3573         {
3574           bfd_byte *dynbuf, *extdyn, *extdynend;
3575           size_t extdynsize;
3576           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3577
3578           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3579             goto free_contents_and_exit_err;
3580
3581           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3582           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3583
3584           extdyn = dynbuf;
3585           extdynend = extdyn + dynamic->size;
3586           for (; extdyn < extdynend; extdyn += extdynsize)
3587             {
3588               Elf_Internal_Dyn dyn;
3589               (*swap_dyn_in) (abfd, extdyn, &dyn);
3590
3591               if (dyn.d_tag == DT_NULL)
3592                 break;
3593
3594               if (dyn.d_tag == DT_PPC64_GLINK)
3595                 {
3596                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3597                      See comment in ppc64_elf_finish_dynamic_sections. */
3598                   glink_vma = dyn.d_un.d_val + 8 * 4;
3599                   /* The .glink section usually does not survive the final
3600                      link; search for the section (usually .text) where the
3601                      glink stubs now reside.  */
3602                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3603                                                 &glink_vma);
3604                   break;
3605                 }
3606             }
3607
3608           free (dynbuf);
3609         }
3610
3611       if (glink != NULL)
3612         {
3613           /* Determine __glink trampoline by reading the relative branch
3614              from the first glink stub.  */
3615           bfd_byte buf[4];
3616           unsigned int off = 0;
3617
3618           while (bfd_get_section_contents (abfd, glink, buf,
3619                                            glink_vma + off - glink->vma, 4))
3620             {
3621               unsigned int insn = bfd_get_32 (abfd, buf);
3622               insn ^= B_DOT;
3623               if ((insn & ~0x3fffffc) == 0)
3624                 {
3625                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3626                   break;
3627                 }
3628               off += 4;
3629               if (off > 4)
3630                 break;
3631             }
3632
3633           if (resolv_vma)
3634             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3635
3636           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3637           if (relplt != NULL)
3638             {
3639               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3640               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3641                 goto free_contents_and_exit_err;
3642
3643               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3644               size += plt_count * sizeof (asymbol);
3645
3646               p = relplt->relocation;
3647               for (i = 0; i < plt_count; i++, p++)
3648                 {
3649                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3650                   if (p->addend != 0)
3651                     size += sizeof ("+0x") - 1 + 16;
3652                 }
3653             }
3654         }
3655
3656       if (size == 0)
3657         goto free_contents_and_exit;
3658       s = *ret = bfd_malloc (size);
3659       if (s == NULL)
3660         goto free_contents_and_exit_err;
3661
3662       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3663
3664       for (i = secsymend; i < opdsymend; ++i)
3665         {
3666           bfd_vma ent;
3667
3668           if (syms[i]->value > opd->size - 8)
3669             continue;
3670
3671           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3672           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3673             {
3674               size_t lo, hi;
3675               size_t len;
3676               asection *sec = abfd->sections;
3677
3678               *s = *syms[i];
3679               lo = codesecsym;
3680               hi = codesecsymend;
3681               while (lo < hi)
3682                 {
3683                   size_t mid = (lo + hi) >> 1;
3684                   if (syms[mid]->section->vma < ent)
3685                     lo = mid + 1;
3686                   else if (syms[mid]->section->vma > ent)
3687                     hi = mid;
3688                   else
3689                     {
3690                       sec = syms[mid]->section;
3691                       break;
3692                     }
3693                 }
3694
3695               if (lo >= hi && lo > codesecsym)
3696                 sec = syms[lo - 1]->section;
3697
3698               for (; sec != NULL; sec = sec->next)
3699                 {
3700                   if (sec->vma > ent)
3701                     break;
3702                   /* SEC_LOAD may not be set if SEC is from a separate debug
3703                      info file.  */
3704                   if ((sec->flags & SEC_ALLOC) == 0)
3705                     break;
3706                   if ((sec->flags & SEC_CODE) != 0)
3707                     s->section = sec;
3708                 }
3709               s->flags |= BSF_SYNTHETIC;
3710               s->value = ent - s->section->vma;
3711               s->name = names;
3712               *names++ = '.';
3713               len = strlen (syms[i]->name);
3714               memcpy (names, syms[i]->name, len + 1);
3715               names += len + 1;
3716               /* Have udata.p point back to the original symbol this
3717                  synthetic symbol was derived from.  */
3718               s->udata.p = syms[i];
3719               s++;
3720             }
3721         }
3722       free (contents);
3723
3724       if (glink != NULL && relplt != NULL)
3725         {
3726           if (resolv_vma)
3727             {
3728               /* Add a symbol for the main glink trampoline.  */
3729               memset (s, 0, sizeof *s);
3730               s->the_bfd = abfd;
3731               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3732               s->section = glink;
3733               s->value = resolv_vma - glink->vma;
3734               s->name = names;
3735               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3736               names += sizeof ("__glink_PLTresolve");
3737               s++;
3738               count++;
3739             }
3740
3741           /* FIXME: It would be very much nicer to put sym@plt on the
3742              stub rather than on the glink branch table entry.  The
3743              objdump disassembler would then use a sensible symbol
3744              name on plt calls.  The difficulty in doing so is
3745              a) finding the stubs, and,
3746              b) matching stubs against plt entries, and,
3747              c) there can be multiple stubs for a given plt entry.
3748
3749              Solving (a) could be done by code scanning, but older
3750              ppc64 binaries used different stubs to current code.
3751              (b) is the tricky one since you need to known the toc
3752              pointer for at least one function that uses a pic stub to
3753              be able to calculate the plt address referenced.
3754              (c) means gdb would need to set multiple breakpoints (or
3755              find the glink branch itself) when setting breakpoints
3756              for pending shared library loads.  */
3757           p = relplt->relocation;
3758           for (i = 0; i < plt_count; i++, p++)
3759             {
3760               size_t len;
3761
3762               *s = **p->sym_ptr_ptr;
3763               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3764                  we are defining a symbol, ensure one of them is set.  */
3765               if ((s->flags & BSF_LOCAL) == 0)
3766                 s->flags |= BSF_GLOBAL;
3767               s->flags |= BSF_SYNTHETIC;
3768               s->section = glink;
3769               s->value = glink_vma - glink->vma;
3770               s->name = names;
3771               s->udata.p = NULL;
3772               len = strlen ((*p->sym_ptr_ptr)->name);
3773               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3774               names += len;
3775               if (p->addend != 0)
3776                 {
3777                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3778                   names += sizeof ("+0x") - 1;
3779                   bfd_sprintf_vma (abfd, names, p->addend);
3780                   names += strlen (names);
3781                 }
3782               memcpy (names, "@plt", sizeof ("@plt"));
3783               names += sizeof ("@plt");
3784               s++;
3785               if (abi < 2)
3786                 {
3787                   glink_vma += 8;
3788                   if (i >= 0x8000)
3789                     glink_vma += 4;
3790                 }
3791               else
3792                 glink_vma += 4;
3793             }
3794           count += plt_count;
3795         }
3796     }
3797
3798  done:
3799   free (syms);
3800   return count;
3801 }
3802 \f
3803 /* The following functions are specific to the ELF linker, while
3804    functions above are used generally.  Those named ppc64_elf_* are
3805    called by the main ELF linker code.  They appear in this file more
3806    or less in the order in which they are called.  eg.
3807    ppc64_elf_check_relocs is called early in the link process,
3808    ppc64_elf_finish_dynamic_sections is one of the last functions
3809    called.
3810
3811    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3812    functions have both a function code symbol and a function descriptor
3813    symbol.  A call to foo in a relocatable object file looks like:
3814
3815    .            .text
3816    .    x:
3817    .            bl      .foo
3818    .            nop
3819
3820    The function definition in another object file might be:
3821
3822    .            .section .opd
3823    .    foo:    .quad   .foo
3824    .            .quad   .TOC.@tocbase
3825    .            .quad   0
3826    .
3827    .            .text
3828    .    .foo:   blr
3829
3830    When the linker resolves the call during a static link, the branch
3831    unsurprisingly just goes to .foo and the .opd information is unused.
3832    If the function definition is in a shared library, things are a little
3833    different:  The call goes via a plt call stub, the opd information gets
3834    copied to the plt, and the linker patches the nop.
3835
3836    .    x:
3837    .            bl      .foo_stub
3838    .            ld      2,40(1)
3839    .
3840    .
3841    .    .foo_stub:
3842    .            std     2,40(1)                 # in practice, the call stub
3843    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3844    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3845    .            ld      12,0(11)
3846    .            ld      2,8(11)
3847    .            mtctr   12
3848    .            ld      11,16(11)
3849    .            bctr
3850    .
3851    .            .section .plt
3852    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3853
3854    The "reloc ()" notation is supposed to indicate that the linker emits
3855    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3856    copying.
3857
3858    What are the difficulties here?  Well, firstly, the relocations
3859    examined by the linker in check_relocs are against the function code
3860    sym .foo, while the dynamic relocation in the plt is emitted against
3861    the function descriptor symbol, foo.  Somewhere along the line, we need
3862    to carefully copy dynamic link information from one symbol to the other.
3863    Secondly, the generic part of the elf linker will make .foo a dynamic
3864    symbol as is normal for most other backends.  We need foo dynamic
3865    instead, at least for an application final link.  However, when
3866    creating a shared library containing foo, we need to have both symbols
3867    dynamic so that references to .foo are satisfied during the early
3868    stages of linking.  Otherwise the linker might decide to pull in a
3869    definition from some other object, eg. a static library.
3870
3871    Update: As of August 2004, we support a new convention.  Function
3872    calls may use the function descriptor symbol, ie. "bl foo".  This
3873    behaves exactly as "bl .foo".  */
3874
3875 /* Of those relocs that might be copied as dynamic relocs, this
3876    function selects those that must be copied when linking a shared
3877    library or PIE, even when the symbol is local.  */
3878
3879 static int
3880 must_be_dyn_reloc (struct bfd_link_info *info,
3881                    enum elf_ppc64_reloc_type r_type)
3882 {
3883   switch (r_type)
3884     {
3885     default:
3886       /* Only relative relocs can be resolved when the object load
3887          address isn't fixed.  DTPREL64 is excluded because the
3888          dynamic linker needs to differentiate global dynamic from
3889          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3890       return 1;
3891
3892     case R_PPC64_REL32:
3893     case R_PPC64_REL64:
3894     case R_PPC64_REL30:
3895       return 0;
3896
3897     case R_PPC64_TPREL16:
3898     case R_PPC64_TPREL16_LO:
3899     case R_PPC64_TPREL16_HI:
3900     case R_PPC64_TPREL16_HA:
3901     case R_PPC64_TPREL16_DS:
3902     case R_PPC64_TPREL16_LO_DS:
3903     case R_PPC64_TPREL16_HIGH:
3904     case R_PPC64_TPREL16_HIGHA:
3905     case R_PPC64_TPREL16_HIGHER:
3906     case R_PPC64_TPREL16_HIGHERA:
3907     case R_PPC64_TPREL16_HIGHEST:
3908     case R_PPC64_TPREL16_HIGHESTA:
3909     case R_PPC64_TPREL64:
3910       /* These relocations are relative but in a shared library the
3911          linker doesn't know the thread pointer base.  */
3912       return bfd_link_dll (info);
3913     }
3914 }
3915
3916 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3917    copying dynamic variables from a shared lib into an app's dynbss
3918    section, and instead use a dynamic relocation to point into the
3919    shared lib.  With code that gcc generates, it's vital that this be
3920    enabled;  In the PowerPC64 ABI, the address of a function is actually
3921    the address of a function descriptor, which resides in the .opd
3922    section.  gcc uses the descriptor directly rather than going via the
3923    GOT as some other ABI's do, which means that initialized function
3924    pointers must reference the descriptor.  Thus, a function pointer
3925    initialized to the address of a function in a shared library will
3926    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3927    redefines the function descriptor symbol to point to the copy.  This
3928    presents a problem as a plt entry for that function is also
3929    initialized from the function descriptor symbol and the copy reloc
3930    may not be initialized first.  */
3931 #define ELIMINATE_COPY_RELOCS 1
3932
3933 /* Section name for stubs is the associated section name plus this
3934    string.  */
3935 #define STUB_SUFFIX ".stub"
3936
3937 /* Linker stubs.
3938    ppc_stub_long_branch:
3939    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3940    destination, but a 24 bit branch in a stub section will reach.
3941    .    b       dest
3942
3943    ppc_stub_plt_branch:
3944    Similar to the above, but a 24 bit branch in the stub section won't
3945    reach its destination.
3946    .    addis   %r11,%r2,xxx@toc@ha
3947    .    ld      %r12,xxx@toc@l(%r11)
3948    .    mtctr   %r12
3949    .    bctr
3950
3951    ppc_stub_plt_call:
3952    Used to call a function in a shared library.  If it so happens that
3953    the plt entry referenced crosses a 64k boundary, then an extra
3954    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3955    .    std     %r2,40(%r1)
3956    .    addis   %r11,%r2,xxx@toc@ha
3957    .    ld      %r12,xxx+0@toc@l(%r11)
3958    .    mtctr   %r12
3959    .    ld      %r2,xxx+8@toc@l(%r11)
3960    .    ld      %r11,xxx+16@toc@l(%r11)
3961    .    bctr
3962
3963    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3964    code to adjust the value and save r2 to support multiple toc sections.
3965    A ppc_stub_long_branch with an r2 offset looks like:
3966    .    std     %r2,40(%r1)
3967    .    addis   %r2,%r2,off@ha
3968    .    addi    %r2,%r2,off@l
3969    .    b       dest
3970
3971    A ppc_stub_plt_branch with an r2 offset looks like:
3972    .    std     %r2,40(%r1)
3973    .    addis   %r11,%r2,xxx@toc@ha
3974    .    ld      %r12,xxx@toc@l(%r11)
3975    .    addis   %r2,%r2,off@ha
3976    .    addi    %r2,%r2,off@l
3977    .    mtctr   %r12
3978    .    bctr
3979
3980    In cases where the "addis" instruction would add zero, the "addis" is
3981    omitted and following instructions modified slightly in some cases.
3982 */
3983
3984 enum ppc_stub_type {
3985   ppc_stub_none,
3986   ppc_stub_long_branch,
3987   ppc_stub_long_branch_r2off,
3988   ppc_stub_plt_branch,
3989   ppc_stub_plt_branch_r2off,
3990   ppc_stub_plt_call,
3991   ppc_stub_plt_call_r2save,
3992   ppc_stub_global_entry,
3993   ppc_stub_save_res
3994 };
3995
3996 /* Information on stub grouping.  */
3997 struct map_stub
3998 {
3999   /* The stub section.  */
4000   asection *stub_sec;
4001   /* This is the section to which stubs in the group will be attached.  */
4002   asection *link_sec;
4003   /* Next group.  */
4004   struct map_stub *next;
4005   /* Whether to emit a copy of register save/restore functions in this
4006      group.  */
4007   int needs_save_res;
4008   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
4009      or -1u if no such stub with bctrl exists.  */
4010   unsigned int tls_get_addr_opt_bctrl;
4011 };
4012
4013 struct ppc_stub_hash_entry {
4014
4015   /* Base hash table entry structure.  */
4016   struct bfd_hash_entry root;
4017
4018   enum ppc_stub_type stub_type;
4019
4020   /* Group information.  */
4021   struct map_stub *group;
4022
4023   /* Offset within stub_sec of the beginning of this stub.  */
4024   bfd_vma stub_offset;
4025
4026   /* Given the symbol's value and its section we can determine its final
4027      value when building the stubs (so the stub knows where to jump.  */
4028   bfd_vma target_value;
4029   asection *target_section;
4030
4031   /* The symbol table entry, if any, that this was derived from.  */
4032   struct ppc_link_hash_entry *h;
4033   struct plt_entry *plt_ent;
4034
4035   /* Symbol type.  */
4036   unsigned char symtype;
4037
4038   /* Symbol st_other.  */
4039   unsigned char other;
4040 };
4041
4042 struct ppc_branch_hash_entry {
4043
4044   /* Base hash table entry structure.  */
4045   struct bfd_hash_entry root;
4046
4047   /* Offset within branch lookup table.  */
4048   unsigned int offset;
4049
4050   /* Generation marker.  */
4051   unsigned int iter;
4052 };
4053
4054 /* Used to track dynamic relocations for local symbols.  */
4055 struct ppc_dyn_relocs
4056 {
4057   struct ppc_dyn_relocs *next;
4058
4059   /* The input section of the reloc.  */
4060   asection *sec;
4061
4062   /* Total number of relocs copied for the input section.  */
4063   unsigned int count : 31;
4064
4065   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4066   unsigned int ifunc : 1;
4067 };
4068
4069 struct ppc_link_hash_entry
4070 {
4071   struct elf_link_hash_entry elf;
4072
4073   union {
4074     /* A pointer to the most recently used stub hash entry against this
4075        symbol.  */
4076     struct ppc_stub_hash_entry *stub_cache;
4077
4078     /* A pointer to the next symbol starting with a '.'  */
4079     struct ppc_link_hash_entry *next_dot_sym;
4080   } u;
4081
4082   /* Track dynamic relocs copied for this symbol.  */
4083   struct elf_dyn_relocs *dyn_relocs;
4084
4085   /* Link between function code and descriptor symbols.  */
4086   struct ppc_link_hash_entry *oh;
4087
4088   /* Flag function code and descriptor symbols.  */
4089   unsigned int is_func:1;
4090   unsigned int is_func_descriptor:1;
4091   unsigned int fake:1;
4092
4093   /* Whether global opd/toc sym has been adjusted or not.
4094      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4095      should be set for all globals defined in any opd/toc section.  */
4096   unsigned int adjust_done:1;
4097
4098   /* Set if this is an out-of-line register save/restore function,
4099      with non-standard calling convention.  */
4100   unsigned int save_res:1;
4101
4102   /* Set if a duplicate symbol with non-zero localentry is detected,
4103      even when the duplicate symbol does not provide a definition.  */
4104   unsigned int non_zero_localentry:1;
4105
4106   /* Contexts in which symbol is used in the GOT (or TOC).
4107      Bits are or'd into the mask as the corresponding relocs are
4108      encountered during check_relocs, with TLS_TLS being set when any
4109      of the other TLS bits are set.  tls_optimize clears bits when
4110      optimizing to indicate the corresponding GOT entry type is not
4111      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4112      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4113      separate flag rather than setting TPREL just for convenience in
4114      distinguishing the two cases.
4115      These flags are also kept for local symbols.  */
4116 #define TLS_TLS          1      /* Any TLS reloc.  */
4117 #define TLS_GD           2      /* GD reloc. */
4118 #define TLS_LD           4      /* LD reloc. */
4119 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4120 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4121 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4122 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4123 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4124   unsigned char tls_mask;
4125
4126   /* The above field is also used to mark function symbols.  In which
4127      case TLS_TLS will be 0.  */
4128 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4129 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4130 #define NON_GOT        256      /* local symbol plt, not stored.  */
4131 };
4132
4133 /* ppc64 ELF linker hash table.  */
4134
4135 struct ppc_link_hash_table
4136 {
4137   struct elf_link_hash_table elf;
4138
4139   /* The stub hash table.  */
4140   struct bfd_hash_table stub_hash_table;
4141
4142   /* Another hash table for plt_branch stubs.  */
4143   struct bfd_hash_table branch_hash_table;
4144
4145   /* Hash table for function prologue tocsave.  */
4146   htab_t tocsave_htab;
4147
4148   /* Various options and other info passed from the linker.  */
4149   struct ppc64_elf_params *params;
4150
4151   /* The size of sec_info below.  */
4152   unsigned int sec_info_arr_size;
4153
4154   /* Per-section array of extra section info.  Done this way rather
4155      than as part of ppc64_elf_section_data so we have the info for
4156      non-ppc64 sections.  */
4157   struct
4158   {
4159     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4160     bfd_vma toc_off;
4161
4162     union
4163     {
4164       /* The section group that this section belongs to.  */
4165       struct map_stub *group;
4166       /* A temp section list pointer.  */
4167       asection *list;
4168     } u;
4169   } *sec_info;
4170
4171   /* Linked list of groups.  */
4172   struct map_stub *group;
4173
4174   /* Temp used when calculating TOC pointers.  */
4175   bfd_vma toc_curr;
4176   bfd *toc_bfd;
4177   asection *toc_first_sec;
4178
4179   /* Used when adding symbols.  */
4180   struct ppc_link_hash_entry *dot_syms;
4181
4182   /* Shortcuts to get to dynamic linker sections.  */
4183   asection *glink;
4184   asection *global_entry;
4185   asection *sfpr;
4186   asection *pltlocal;
4187   asection *relpltlocal;
4188   asection *brlt;
4189   asection *relbrlt;
4190   asection *glink_eh_frame;
4191
4192   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4193   struct ppc_link_hash_entry *tls_get_addr;
4194   struct ppc_link_hash_entry *tls_get_addr_fd;
4195
4196   /* The size of reliplt used by got entry relocs.  */
4197   bfd_size_type got_reli_size;
4198
4199   /* Statistics.  */
4200   unsigned long stub_count[ppc_stub_global_entry];
4201
4202   /* Number of stubs against global syms.  */
4203   unsigned long stub_globals;
4204
4205   /* Set if we're linking code with function descriptors.  */
4206   unsigned int opd_abi:1;
4207
4208   /* Support for multiple toc sections.  */
4209   unsigned int do_multi_toc:1;
4210   unsigned int multi_toc_needed:1;
4211   unsigned int second_toc_pass:1;
4212   unsigned int do_toc_opt:1;
4213
4214   /* Set if tls optimization is enabled.  */
4215   unsigned int do_tls_opt:1;
4216
4217   /* Set if inline plt calls should be converted to direct calls.  */
4218   unsigned int can_convert_all_inline_plt:1;
4219
4220   /* Set on error.  */
4221   unsigned int stub_error:1;
4222
4223   /* Whether func_desc_adjust needs to be run over symbols.  */
4224   unsigned int need_func_desc_adj:1;
4225
4226   /* Whether there exist local gnu indirect function resolvers,
4227      referenced by dynamic relocations.  */
4228   unsigned int local_ifunc_resolver:1;
4229   unsigned int maybe_local_ifunc_resolver:1;
4230
4231   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4232   unsigned int has_plt_localentry0:1;
4233
4234   /* Incremented every time we size stubs.  */
4235   unsigned int stub_iteration;
4236
4237   /* Small local sym cache.  */
4238   struct sym_cache sym_cache;
4239 };
4240
4241 /* Rename some of the generic section flags to better document how they
4242    are used here.  */
4243
4244 /* Nonzero if this section has TLS related relocations.  */
4245 #define has_tls_reloc sec_flg0
4246
4247 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4248 #define has_tls_get_addr_call sec_flg1
4249
4250 /* Nonzero if this section has any toc or got relocs.  */
4251 #define has_toc_reloc sec_flg2
4252
4253 /* Nonzero if this section has a call to another section that uses
4254    the toc or got.  */
4255 #define makes_toc_func_call sec_flg3
4256
4257 /* Recursion protection when determining above flag.  */
4258 #define call_check_in_progress sec_flg4
4259 #define call_check_done sec_flg5
4260
4261 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4262
4263 #define ppc_hash_table(p) \
4264   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4265   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4266
4267 #define ppc_stub_hash_lookup(table, string, create, copy) \
4268   ((struct ppc_stub_hash_entry *) \
4269    bfd_hash_lookup ((table), (string), (create), (copy)))
4270
4271 #define ppc_branch_hash_lookup(table, string, create, copy) \
4272   ((struct ppc_branch_hash_entry *) \
4273    bfd_hash_lookup ((table), (string), (create), (copy)))
4274
4275 /* Create an entry in the stub hash table.  */
4276
4277 static struct bfd_hash_entry *
4278 stub_hash_newfunc (struct bfd_hash_entry *entry,
4279                    struct bfd_hash_table *table,
4280                    const char *string)
4281 {
4282   /* Allocate the structure if it has not already been allocated by a
4283      subclass.  */
4284   if (entry == NULL)
4285     {
4286       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4287       if (entry == NULL)
4288         return entry;
4289     }
4290
4291   /* Call the allocation method of the superclass.  */
4292   entry = bfd_hash_newfunc (entry, table, string);
4293   if (entry != NULL)
4294     {
4295       struct ppc_stub_hash_entry *eh;
4296
4297       /* Initialize the local fields.  */
4298       eh = (struct ppc_stub_hash_entry *) entry;
4299       eh->stub_type = ppc_stub_none;
4300       eh->group = NULL;
4301       eh->stub_offset = 0;
4302       eh->target_value = 0;
4303       eh->target_section = NULL;
4304       eh->h = NULL;
4305       eh->plt_ent = NULL;
4306       eh->other = 0;
4307     }
4308
4309   return entry;
4310 }
4311
4312 /* Create an entry in the branch hash table.  */
4313
4314 static struct bfd_hash_entry *
4315 branch_hash_newfunc (struct bfd_hash_entry *entry,
4316                      struct bfd_hash_table *table,
4317                      const char *string)
4318 {
4319   /* Allocate the structure if it has not already been allocated by a
4320      subclass.  */
4321   if (entry == NULL)
4322     {
4323       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4324       if (entry == NULL)
4325         return entry;
4326     }
4327
4328   /* Call the allocation method of the superclass.  */
4329   entry = bfd_hash_newfunc (entry, table, string);
4330   if (entry != NULL)
4331     {
4332       struct ppc_branch_hash_entry *eh;
4333
4334       /* Initialize the local fields.  */
4335       eh = (struct ppc_branch_hash_entry *) entry;
4336       eh->offset = 0;
4337       eh->iter = 0;
4338     }
4339
4340   return entry;
4341 }
4342
4343 /* Create an entry in a ppc64 ELF linker hash table.  */
4344
4345 static struct bfd_hash_entry *
4346 link_hash_newfunc (struct bfd_hash_entry *entry,
4347                    struct bfd_hash_table *table,
4348                    const char *string)
4349 {
4350   /* Allocate the structure if it has not already been allocated by a
4351      subclass.  */
4352   if (entry == NULL)
4353     {
4354       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4355       if (entry == NULL)
4356         return entry;
4357     }
4358
4359   /* Call the allocation method of the superclass.  */
4360   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4361   if (entry != NULL)
4362     {
4363       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4364
4365       memset (&eh->u.stub_cache, 0,
4366               (sizeof (struct ppc_link_hash_entry)
4367                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4368
4369       /* When making function calls, old ABI code references function entry
4370          points (dot symbols), while new ABI code references the function
4371          descriptor symbol.  We need to make any combination of reference and
4372          definition work together, without breaking archive linking.
4373
4374          For a defined function "foo" and an undefined call to "bar":
4375          An old object defines "foo" and ".foo", references ".bar" (possibly
4376          "bar" too).
4377          A new object defines "foo" and references "bar".
4378
4379          A new object thus has no problem with its undefined symbols being
4380          satisfied by definitions in an old object.  On the other hand, the
4381          old object won't have ".bar" satisfied by a new object.
4382
4383          Keep a list of newly added dot-symbols.  */
4384
4385       if (string[0] == '.')
4386         {
4387           struct ppc_link_hash_table *htab;
4388
4389           htab = (struct ppc_link_hash_table *) table;
4390           eh->u.next_dot_sym = htab->dot_syms;
4391           htab->dot_syms = eh;
4392         }
4393     }
4394
4395   return entry;
4396 }
4397
4398 struct tocsave_entry {
4399   asection *sec;
4400   bfd_vma offset;
4401 };
4402
4403 static hashval_t
4404 tocsave_htab_hash (const void *p)
4405 {
4406   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4407   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4408 }
4409
4410 static int
4411 tocsave_htab_eq (const void *p1, const void *p2)
4412 {
4413   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4414   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4415   return e1->sec == e2->sec && e1->offset == e2->offset;
4416 }
4417
4418 /* Destroy a ppc64 ELF linker hash table.  */
4419
4420 static void
4421 ppc64_elf_link_hash_table_free (bfd *obfd)
4422 {
4423   struct ppc_link_hash_table *htab;
4424
4425   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4426   if (htab->tocsave_htab)
4427     htab_delete (htab->tocsave_htab);
4428   bfd_hash_table_free (&htab->branch_hash_table);
4429   bfd_hash_table_free (&htab->stub_hash_table);
4430   _bfd_elf_link_hash_table_free (obfd);
4431 }
4432
4433 /* Create a ppc64 ELF linker hash table.  */
4434
4435 static struct bfd_link_hash_table *
4436 ppc64_elf_link_hash_table_create (bfd *abfd)
4437 {
4438   struct ppc_link_hash_table *htab;
4439   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4440
4441   htab = bfd_zmalloc (amt);
4442   if (htab == NULL)
4443     return NULL;
4444
4445   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4446                                       sizeof (struct ppc_link_hash_entry),
4447                                       PPC64_ELF_DATA))
4448     {
4449       free (htab);
4450       return NULL;
4451     }
4452
4453   /* Init the stub hash table too.  */
4454   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4455                             sizeof (struct ppc_stub_hash_entry)))
4456     {
4457       _bfd_elf_link_hash_table_free (abfd);
4458       return NULL;
4459     }
4460
4461   /* And the branch hash table.  */
4462   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4463                             sizeof (struct ppc_branch_hash_entry)))
4464     {
4465       bfd_hash_table_free (&htab->stub_hash_table);
4466       _bfd_elf_link_hash_table_free (abfd);
4467       return NULL;
4468     }
4469
4470   htab->tocsave_htab = htab_try_create (1024,
4471                                         tocsave_htab_hash,
4472                                         tocsave_htab_eq,
4473                                         NULL);
4474   if (htab->tocsave_htab == NULL)
4475     {
4476       ppc64_elf_link_hash_table_free (abfd);
4477       return NULL;
4478     }
4479   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4480
4481   /* Initializing two fields of the union is just cosmetic.  We really
4482      only care about glist, but when compiled on a 32-bit host the
4483      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4484      debugger inspection of these fields look nicer.  */
4485   htab->elf.init_got_refcount.refcount = 0;
4486   htab->elf.init_got_refcount.glist = NULL;
4487   htab->elf.init_plt_refcount.refcount = 0;
4488   htab->elf.init_plt_refcount.glist = NULL;
4489   htab->elf.init_got_offset.offset = 0;
4490   htab->elf.init_got_offset.glist = NULL;
4491   htab->elf.init_plt_offset.offset = 0;
4492   htab->elf.init_plt_offset.glist = NULL;
4493
4494   return &htab->elf.root;
4495 }
4496
4497 /* Create sections for linker generated code.  */
4498
4499 static bfd_boolean
4500 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4501 {
4502   struct ppc_link_hash_table *htab;
4503   flagword flags;
4504
4505   htab = ppc_hash_table (info);
4506
4507   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4508            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4509   if (htab->params->save_restore_funcs)
4510     {
4511       /* Create .sfpr for code to save and restore fp regs.  */
4512       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4513                                                        flags);
4514       if (htab->sfpr == NULL
4515           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4516         return FALSE;
4517     }
4518
4519   if (bfd_link_relocatable (info))
4520     return TRUE;
4521
4522   /* Create .glink for lazy dynamic linking support.  */
4523   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4524                                                     flags);
4525   if (htab->glink == NULL
4526       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4527     return FALSE;
4528
4529   /* The part of .glink used by global entry stubs, separate so that
4530      it can be aligned appropriately without affecting htab->glink.  */
4531   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4532                                                            flags);
4533   if (htab->global_entry == NULL
4534       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4535     return FALSE;
4536
4537   if (!info->no_ld_generated_unwind_info)
4538     {
4539       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4540                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4541       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4542                                                                  ".eh_frame",
4543                                                                  flags);
4544       if (htab->glink_eh_frame == NULL
4545           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4546         return FALSE;
4547     }
4548
4549   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4550   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4551   if (htab->elf.iplt == NULL
4552       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4553     return FALSE;
4554
4555   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4556            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4557   htab->elf.irelplt
4558     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4559   if (htab->elf.irelplt == NULL
4560       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4561     return FALSE;
4562
4563   /* Create branch lookup table for plt_branch stubs.  */
4564   flags = (SEC_ALLOC | SEC_LOAD
4565            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4566   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4567                                                    flags);
4568   if (htab->brlt == NULL
4569       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4570     return FALSE;
4571
4572   /* Local plt entries, put in .branch_lt but a separate section for
4573      convenience.  */
4574   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4575                                                        flags);
4576   if (htab->pltlocal == NULL
4577       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4578     return FALSE;
4579
4580   if (!bfd_link_pic (info))
4581     return TRUE;
4582
4583   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4584            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4585   htab->relbrlt
4586     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4587   if (htab->relbrlt == NULL
4588       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4589     return FALSE;
4590
4591   htab->relpltlocal
4592     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4593   if (htab->relpltlocal == NULL
4594       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4595     return FALSE;
4596
4597   return TRUE;
4598 }
4599
4600 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4601
4602 bfd_boolean
4603 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4604                          struct ppc64_elf_params *params)
4605 {
4606   struct ppc_link_hash_table *htab;
4607
4608   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4609
4610 /* Always hook our dynamic sections into the first bfd, which is the
4611    linker created stub bfd.  This ensures that the GOT header is at
4612    the start of the output TOC section.  */
4613   htab = ppc_hash_table (info);
4614   htab->elf.dynobj = params->stub_bfd;
4615   htab->params = params;
4616
4617   return create_linkage_sections (htab->elf.dynobj, info);
4618 }
4619
4620 /* Build a name for an entry in the stub hash table.  */
4621
4622 static char *
4623 ppc_stub_name (const asection *input_section,
4624                const asection *sym_sec,
4625                const struct ppc_link_hash_entry *h,
4626                const Elf_Internal_Rela *rel)
4627 {
4628   char *stub_name;
4629   ssize_t len;
4630
4631   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4632      offsets from a sym as a branch target?  In fact, we could
4633      probably assume the addend is always zero.  */
4634   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4635
4636   if (h)
4637     {
4638       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4639       stub_name = bfd_malloc (len);
4640       if (stub_name == NULL)
4641         return stub_name;
4642
4643       len = sprintf (stub_name, "%08x.%s+%x",
4644                      input_section->id & 0xffffffff,
4645                      h->elf.root.root.string,
4646                      (int) rel->r_addend & 0xffffffff);
4647     }
4648   else
4649     {
4650       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4651       stub_name = bfd_malloc (len);
4652       if (stub_name == NULL)
4653         return stub_name;
4654
4655       len = sprintf (stub_name, "%08x.%x:%x+%x",
4656                      input_section->id & 0xffffffff,
4657                      sym_sec->id & 0xffffffff,
4658                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4659                      (int) rel->r_addend & 0xffffffff);
4660     }
4661   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4662     stub_name[len - 2] = 0;
4663   return stub_name;
4664 }
4665
4666 /* Look up an entry in the stub hash.  Stub entries are cached because
4667    creating the stub name takes a bit of time.  */
4668
4669 static struct ppc_stub_hash_entry *
4670 ppc_get_stub_entry (const asection *input_section,
4671                     const asection *sym_sec,
4672                     struct ppc_link_hash_entry *h,
4673                     const Elf_Internal_Rela *rel,
4674                     struct ppc_link_hash_table *htab)
4675 {
4676   struct ppc_stub_hash_entry *stub_entry;
4677   struct map_stub *group;
4678
4679   /* If this input section is part of a group of sections sharing one
4680      stub section, then use the id of the first section in the group.
4681      Stub names need to include a section id, as there may well be
4682      more than one stub used to reach say, printf, and we need to
4683      distinguish between them.  */
4684   group = htab->sec_info[input_section->id].u.group;
4685   if (group == NULL)
4686     return NULL;
4687
4688   if (h != NULL && h->u.stub_cache != NULL
4689       && h->u.stub_cache->h == h
4690       && h->u.stub_cache->group == group)
4691     {
4692       stub_entry = h->u.stub_cache;
4693     }
4694   else
4695     {
4696       char *stub_name;
4697
4698       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4699       if (stub_name == NULL)
4700         return NULL;
4701
4702       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4703                                          stub_name, FALSE, FALSE);
4704       if (h != NULL)
4705         h->u.stub_cache = stub_entry;
4706
4707       free (stub_name);
4708     }
4709
4710   return stub_entry;
4711 }
4712
4713 /* Add a new stub entry to the stub hash.  Not all fields of the new
4714    stub entry are initialised.  */
4715
4716 static struct ppc_stub_hash_entry *
4717 ppc_add_stub (const char *stub_name,
4718               asection *section,
4719               struct bfd_link_info *info)
4720 {
4721   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4722   struct map_stub *group;
4723   asection *link_sec;
4724   asection *stub_sec;
4725   struct ppc_stub_hash_entry *stub_entry;
4726
4727   group = htab->sec_info[section->id].u.group;
4728   link_sec = group->link_sec;
4729   stub_sec = group->stub_sec;
4730   if (stub_sec == NULL)
4731     {
4732       size_t namelen;
4733       bfd_size_type len;
4734       char *s_name;
4735
4736       namelen = strlen (link_sec->name);
4737       len = namelen + sizeof (STUB_SUFFIX);
4738       s_name = bfd_alloc (htab->params->stub_bfd, len);
4739       if (s_name == NULL)
4740         return NULL;
4741
4742       memcpy (s_name, link_sec->name, namelen);
4743       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4744       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4745       if (stub_sec == NULL)
4746         return NULL;
4747       group->stub_sec = stub_sec;
4748     }
4749
4750   /* Enter this entry into the linker stub hash table.  */
4751   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4752                                      TRUE, FALSE);
4753   if (stub_entry == NULL)
4754     {
4755       /* xgettext:c-format */
4756       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4757                           section->owner, stub_name);
4758       return NULL;
4759     }
4760
4761   stub_entry->group = group;
4762   stub_entry->stub_offset = 0;
4763   return stub_entry;
4764 }
4765
4766 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4767    not already done.  */
4768
4769 static bfd_boolean
4770 create_got_section (bfd *abfd, struct bfd_link_info *info)
4771 {
4772   asection *got, *relgot;
4773   flagword flags;
4774   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4775
4776   if (!is_ppc64_elf (abfd))
4777     return FALSE;
4778   if (htab == NULL)
4779     return FALSE;
4780
4781   if (!htab->elf.sgot
4782       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4783     return FALSE;
4784
4785   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4786            | SEC_LINKER_CREATED);
4787
4788   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4789   if (!got
4790       || !bfd_set_section_alignment (abfd, got, 3))
4791     return FALSE;
4792
4793   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4794                                                flags | SEC_READONLY);
4795   if (!relgot
4796       || ! bfd_set_section_alignment (abfd, relgot, 3))
4797     return FALSE;
4798
4799   ppc64_elf_tdata (abfd)->got = got;
4800   ppc64_elf_tdata (abfd)->relgot = relgot;
4801   return TRUE;
4802 }
4803
4804 /* Follow indirect and warning symbol links.  */
4805
4806 static inline struct bfd_link_hash_entry *
4807 follow_link (struct bfd_link_hash_entry *h)
4808 {
4809   while (h->type == bfd_link_hash_indirect
4810          || h->type == bfd_link_hash_warning)
4811     h = h->u.i.link;
4812   return h;
4813 }
4814
4815 static inline struct elf_link_hash_entry *
4816 elf_follow_link (struct elf_link_hash_entry *h)
4817 {
4818   return (struct elf_link_hash_entry *) follow_link (&h->root);
4819 }
4820
4821 static inline struct ppc_link_hash_entry *
4822 ppc_follow_link (struct ppc_link_hash_entry *h)
4823 {
4824   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4825 }
4826
4827 /* Merge PLT info on FROM with that on TO.  */
4828
4829 static void
4830 move_plt_plist (struct ppc_link_hash_entry *from,
4831                 struct ppc_link_hash_entry *to)
4832 {
4833   if (from->elf.plt.plist != NULL)
4834     {
4835       if (to->elf.plt.plist != NULL)
4836         {
4837           struct plt_entry **entp;
4838           struct plt_entry *ent;
4839
4840           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4841             {
4842               struct plt_entry *dent;
4843
4844               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4845                 if (dent->addend == ent->addend)
4846                   {
4847                     dent->plt.refcount += ent->plt.refcount;
4848                     *entp = ent->next;
4849                     break;
4850                   }
4851               if (dent == NULL)
4852                 entp = &ent->next;
4853             }
4854           *entp = to->elf.plt.plist;
4855         }
4856
4857       to->elf.plt.plist = from->elf.plt.plist;
4858       from->elf.plt.plist = NULL;
4859     }
4860 }
4861
4862 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4863
4864 static void
4865 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4866                                 struct elf_link_hash_entry *dir,
4867                                 struct elf_link_hash_entry *ind)
4868 {
4869   struct ppc_link_hash_entry *edir, *eind;
4870
4871   edir = (struct ppc_link_hash_entry *) dir;
4872   eind = (struct ppc_link_hash_entry *) ind;
4873
4874   edir->is_func |= eind->is_func;
4875   edir->is_func_descriptor |= eind->is_func_descriptor;
4876   edir->tls_mask |= eind->tls_mask;
4877   if (eind->oh != NULL)
4878     edir->oh = ppc_follow_link (eind->oh);
4879
4880   if (edir->elf.versioned != versioned_hidden)
4881     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4882   edir->elf.ref_regular |= eind->elf.ref_regular;
4883   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4884   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4885   edir->elf.needs_plt |= eind->elf.needs_plt;
4886   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4887
4888   /* If we were called to copy over info for a weak sym, don't copy
4889      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4890      in order to simplify readonly_dynrelocs and save a field in the
4891      symbol hash entry, but that means dyn_relocs can't be used in any
4892      tests about a specific symbol, or affect other symbol flags which
4893      are then tested.  */
4894   if (eind->elf.root.type != bfd_link_hash_indirect)
4895     return;
4896
4897   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4898   if (eind->dyn_relocs != NULL)
4899     {
4900       if (edir->dyn_relocs != NULL)
4901         {
4902           struct elf_dyn_relocs **pp;
4903           struct elf_dyn_relocs *p;
4904
4905           /* Add reloc counts against the indirect sym to the direct sym
4906              list.  Merge any entries against the same section.  */
4907           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4908             {
4909               struct elf_dyn_relocs *q;
4910
4911               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4912                 if (q->sec == p->sec)
4913                   {
4914                     q->pc_count += p->pc_count;
4915                     q->count += p->count;
4916                     *pp = p->next;
4917                     break;
4918                   }
4919               if (q == NULL)
4920                 pp = &p->next;
4921             }
4922           *pp = edir->dyn_relocs;
4923         }
4924
4925       edir->dyn_relocs = eind->dyn_relocs;
4926       eind->dyn_relocs = NULL;
4927     }
4928
4929   /* Copy over got entries that we may have already seen to the
4930      symbol which just became indirect.  */
4931   if (eind->elf.got.glist != NULL)
4932     {
4933       if (edir->elf.got.glist != NULL)
4934         {
4935           struct got_entry **entp;
4936           struct got_entry *ent;
4937
4938           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4939             {
4940               struct got_entry *dent;
4941
4942               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4943                 if (dent->addend == ent->addend
4944                     && dent->owner == ent->owner
4945                     && dent->tls_type == ent->tls_type)
4946                   {
4947                     dent->got.refcount += ent->got.refcount;
4948                     *entp = ent->next;
4949                     break;
4950                   }
4951               if (dent == NULL)
4952                 entp = &ent->next;
4953             }
4954           *entp = edir->elf.got.glist;
4955         }
4956
4957       edir->elf.got.glist = eind->elf.got.glist;
4958       eind->elf.got.glist = NULL;
4959     }
4960
4961   /* And plt entries.  */
4962   move_plt_plist (eind, edir);
4963
4964   if (eind->elf.dynindx != -1)
4965     {
4966       if (edir->elf.dynindx != -1)
4967         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4968                                 edir->elf.dynstr_index);
4969       edir->elf.dynindx = eind->elf.dynindx;
4970       edir->elf.dynstr_index = eind->elf.dynstr_index;
4971       eind->elf.dynindx = -1;
4972       eind->elf.dynstr_index = 0;
4973     }
4974 }
4975
4976 /* Find the function descriptor hash entry from the given function code
4977    hash entry FH.  Link the entries via their OH fields.  */
4978
4979 static struct ppc_link_hash_entry *
4980 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4981 {
4982   struct ppc_link_hash_entry *fdh = fh->oh;
4983
4984   if (fdh == NULL)
4985     {
4986       const char *fd_name = fh->elf.root.root.string + 1;
4987
4988       fdh = (struct ppc_link_hash_entry *)
4989         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4990       if (fdh == NULL)
4991         return fdh;
4992
4993       fdh->is_func_descriptor = 1;
4994       fdh->oh = fh;
4995       fh->is_func = 1;
4996       fh->oh = fdh;
4997     }
4998
4999   fdh = ppc_follow_link (fdh);
5000   fdh->is_func_descriptor = 1;
5001   fdh->oh = fh;
5002   return fdh;
5003 }
5004
5005 /* Make a fake function descriptor sym for the undefined code sym FH.  */
5006
5007 static struct ppc_link_hash_entry *
5008 make_fdh (struct bfd_link_info *info,
5009           struct ppc_link_hash_entry *fh)
5010 {
5011   bfd *abfd = fh->elf.root.u.undef.abfd;
5012   struct bfd_link_hash_entry *bh = NULL;
5013   struct ppc_link_hash_entry *fdh;
5014   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5015                     ? BSF_WEAK
5016                     : BSF_GLOBAL);
5017
5018   if (!_bfd_generic_link_add_one_symbol (info, abfd,
5019                                          fh->elf.root.root.string + 1,
5020                                          flags, bfd_und_section_ptr, 0,
5021                                          NULL, FALSE, FALSE, &bh))
5022     return NULL;
5023
5024   fdh = (struct ppc_link_hash_entry *) bh;
5025   fdh->elf.non_elf = 0;
5026   fdh->fake = 1;
5027   fdh->is_func_descriptor = 1;
5028   fdh->oh = fh;
5029   fh->is_func = 1;
5030   fh->oh = fdh;
5031   return fdh;
5032 }
5033
5034 /* Fix function descriptor symbols defined in .opd sections to be
5035    function type.  */
5036
5037 static bfd_boolean
5038 ppc64_elf_add_symbol_hook (bfd *ibfd,
5039                            struct bfd_link_info *info,
5040                            Elf_Internal_Sym *isym,
5041                            const char **name,
5042                            flagword *flags ATTRIBUTE_UNUSED,
5043                            asection **sec,
5044                            bfd_vma *value)
5045 {
5046   if (*sec != NULL
5047       && strcmp ((*sec)->name, ".opd") == 0)
5048     {
5049       asection *code_sec;
5050
5051       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5052             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5053         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5054
5055       /* If the symbol is a function defined in .opd, and the function
5056          code is in a discarded group, let it appear to be undefined.  */
5057       if (!bfd_link_relocatable (info)
5058           && (*sec)->reloc_count != 0
5059           && opd_entry_value (*sec, *value, &code_sec, NULL,
5060                               FALSE) != (bfd_vma) -1
5061           && discarded_section (code_sec))
5062         {
5063           *sec = bfd_und_section_ptr;
5064           isym->st_shndx = SHN_UNDEF;
5065         }
5066     }
5067   else if (*sec != NULL
5068            && strcmp ((*sec)->name, ".toc") == 0
5069            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5070     {
5071       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5072       if (htab != NULL)
5073         htab->params->object_in_toc = 1;
5074     }
5075
5076   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5077     {
5078       if (abiversion (ibfd) == 0)
5079         set_abiversion (ibfd, 2);
5080       else if (abiversion (ibfd) == 1)
5081         {
5082           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5083                                 " for ABI version 1"), *name);
5084           bfd_set_error (bfd_error_bad_value);
5085           return FALSE;
5086         }
5087     }
5088
5089   return TRUE;
5090 }
5091
5092 /* Merge non-visibility st_other attributes: local entry point.  */
5093
5094 static void
5095 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5096                                   const Elf_Internal_Sym *isym,
5097                                   bfd_boolean definition,
5098                                   bfd_boolean dynamic)
5099 {
5100   if (definition && (!dynamic || !h->def_regular))
5101     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5102                 | ELF_ST_VISIBILITY (h->other));
5103 }
5104
5105 /* Hook called on merging a symbol.  We use this to clear "fake" since
5106    we now have a real symbol.  */
5107
5108 static bfd_boolean
5109 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5110                         const Elf_Internal_Sym *isym,
5111                         asection **psec ATTRIBUTE_UNUSED,
5112                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5113                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5114                         bfd *oldbfd ATTRIBUTE_UNUSED,
5115                         const asection *oldsec ATTRIBUTE_UNUSED)
5116 {
5117   ((struct ppc_link_hash_entry *) h)->fake = 0;
5118   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5119     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5120   return TRUE;
5121 }
5122
5123 /* This function makes an old ABI object reference to ".bar" cause the
5124    inclusion of a new ABI object archive that defines "bar".
5125    NAME is a symbol defined in an archive.  Return a symbol in the hash
5126    table that might be satisfied by the archive symbols.  */
5127
5128 static struct elf_link_hash_entry *
5129 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5130                                  struct bfd_link_info *info,
5131                                  const char *name)
5132 {
5133   struct elf_link_hash_entry *h;
5134   char *dot_name;
5135   size_t len;
5136
5137   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5138   if (h != NULL
5139       /* Don't return this sym if it is a fake function descriptor
5140          created by add_symbol_adjust.  */
5141       && !((struct ppc_link_hash_entry *) h)->fake)
5142     return h;
5143
5144   if (name[0] == '.')
5145     return h;
5146
5147   len = strlen (name);
5148   dot_name = bfd_alloc (abfd, len + 2);
5149   if (dot_name == NULL)
5150     return (struct elf_link_hash_entry *) -1;
5151   dot_name[0] = '.';
5152   memcpy (dot_name + 1, name, len + 1);
5153   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5154   bfd_release (abfd, dot_name);
5155   return h;
5156 }
5157
5158 /* This function satisfies all old ABI object references to ".bar" if a
5159    new ABI object defines "bar".  Well, at least, undefined dot symbols
5160    are made weak.  This stops later archive searches from including an
5161    object if we already have a function descriptor definition.  It also
5162    prevents the linker complaining about undefined symbols.
5163    We also check and correct mismatched symbol visibility here.  The
5164    most restrictive visibility of the function descriptor and the
5165    function entry symbol is used.  */
5166
5167 static bfd_boolean
5168 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5169 {
5170   struct ppc_link_hash_table *htab;
5171   struct ppc_link_hash_entry *fdh;
5172
5173   if (eh->elf.root.type == bfd_link_hash_warning)
5174     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5175
5176   if (eh->elf.root.type == bfd_link_hash_indirect)
5177     return TRUE;
5178
5179   if (eh->elf.root.root.string[0] != '.')
5180     abort ();
5181
5182   htab = ppc_hash_table (info);
5183   if (htab == NULL)
5184     return FALSE;
5185
5186   fdh = lookup_fdh (eh, htab);
5187   if (fdh == NULL
5188       && !bfd_link_relocatable (info)
5189       && (eh->elf.root.type == bfd_link_hash_undefined
5190           || eh->elf.root.type == bfd_link_hash_undefweak)
5191       && eh->elf.ref_regular)
5192     {
5193       /* Make an undefined function descriptor sym, in order to
5194          pull in an --as-needed shared lib.  Archives are handled
5195          elsewhere.  */
5196       fdh = make_fdh (info, eh);
5197       if (fdh == NULL)
5198         return FALSE;
5199     }
5200
5201   if (fdh != NULL)
5202     {
5203       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5204       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5205
5206       /* Make both descriptor and entry symbol have the most
5207          constraining visibility of either symbol.  */
5208       if (entry_vis < descr_vis)
5209         fdh->elf.other += entry_vis - descr_vis;
5210       else if (entry_vis > descr_vis)
5211         eh->elf.other += descr_vis - entry_vis;
5212
5213       /* Propagate reference flags from entry symbol to function
5214          descriptor symbol.  */
5215       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5216       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5217       fdh->elf.ref_regular |= eh->elf.ref_regular;
5218       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5219
5220       if (!fdh->elf.forced_local
5221           && fdh->elf.dynindx == -1
5222           && fdh->elf.versioned != versioned_hidden
5223           && (bfd_link_dll (info)
5224               || fdh->elf.def_dynamic
5225               || fdh->elf.ref_dynamic)
5226           && (eh->elf.ref_regular
5227               || eh->elf.def_regular))
5228         {
5229           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5230             return FALSE;
5231         }
5232     }
5233
5234   return TRUE;
5235 }
5236
5237 /* Set up opd section info and abiversion for IBFD, and process list
5238    of dot-symbols we made in link_hash_newfunc.  */
5239
5240 static bfd_boolean
5241 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5242 {
5243   struct ppc_link_hash_table *htab;
5244   struct ppc_link_hash_entry **p, *eh;
5245   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5246
5247   if (opd != NULL && opd->size != 0)
5248     {
5249       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5250       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5251
5252       if (abiversion (ibfd) == 0)
5253         set_abiversion (ibfd, 1);
5254       else if (abiversion (ibfd) >= 2)
5255         {
5256           /* xgettext:c-format */
5257           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5258                               ibfd, abiversion (ibfd));
5259           bfd_set_error (bfd_error_bad_value);
5260           return FALSE;
5261         }
5262     }
5263
5264   if (is_ppc64_elf (info->output_bfd))
5265     {
5266       /* For input files without an explicit abiversion in e_flags
5267          we should have flagged any with symbol st_other bits set
5268          as ELFv1 and above flagged those with .opd as ELFv2.
5269          Set the output abiversion if not yet set, and for any input
5270          still ambiguous, take its abiversion from the output.
5271          Differences in ABI are reported later.  */
5272       if (abiversion (info->output_bfd) == 0)
5273         set_abiversion (info->output_bfd, abiversion (ibfd));
5274       else if (abiversion (ibfd) == 0)
5275         set_abiversion (ibfd, abiversion (info->output_bfd));
5276     }
5277
5278   htab = ppc_hash_table (info);
5279   if (htab == NULL)
5280     return TRUE;
5281
5282   if (opd != NULL && opd->size != 0
5283       && (ibfd->flags & DYNAMIC) == 0
5284       && (opd->flags & SEC_RELOC) != 0
5285       && opd->reloc_count != 0
5286       && !bfd_is_abs_section (opd->output_section)
5287       && info->gc_sections)
5288     {
5289       /* Garbage collection needs some extra help with .opd sections.
5290          We don't want to necessarily keep everything referenced by
5291          relocs in .opd, as that would keep all functions.  Instead,
5292          if we reference an .opd symbol (a function descriptor), we
5293          want to keep the function code symbol's section.  This is
5294          easy for global symbols, but for local syms we need to keep
5295          information about the associated function section.  */
5296       bfd_size_type amt;
5297       asection **opd_sym_map;
5298       Elf_Internal_Shdr *symtab_hdr;
5299       Elf_Internal_Rela *relocs, *rel_end, *rel;
5300
5301       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5302       opd_sym_map = bfd_zalloc (ibfd, amt);
5303       if (opd_sym_map == NULL)
5304         return FALSE;
5305       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5306       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5307                                           info->keep_memory);
5308       if (relocs == NULL)
5309         return FALSE;
5310       symtab_hdr = &elf_symtab_hdr (ibfd);
5311       rel_end = relocs + opd->reloc_count - 1;
5312       for (rel = relocs; rel < rel_end; rel++)
5313         {
5314           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5315           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5316
5317           if (r_type == R_PPC64_ADDR64
5318               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5319               && r_symndx < symtab_hdr->sh_info)
5320             {
5321               Elf_Internal_Sym *isym;
5322               asection *s;
5323
5324               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5325               if (isym == NULL)
5326                 {
5327                   if (elf_section_data (opd)->relocs != relocs)
5328                     free (relocs);
5329                   return FALSE;
5330                 }
5331
5332               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5333               if (s != NULL && s != opd)
5334                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5335             }
5336         }
5337       if (elf_section_data (opd)->relocs != relocs)
5338         free (relocs);
5339     }
5340
5341   p = &htab->dot_syms;
5342   while ((eh = *p) != NULL)
5343     {
5344       *p = NULL;
5345       if (&eh->elf == htab->elf.hgot)
5346         ;
5347       else if (htab->elf.hgot == NULL
5348                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5349         htab->elf.hgot = &eh->elf;
5350       else if (abiversion (ibfd) <= 1)
5351         {
5352           htab->need_func_desc_adj = 1;
5353           if (!add_symbol_adjust (eh, info))
5354             return FALSE;
5355         }
5356       p = &eh->u.next_dot_sym;
5357     }
5358   return TRUE;
5359 }
5360
5361 /* Undo hash table changes when an --as-needed input file is determined
5362    not to be needed.  */
5363
5364 static bfd_boolean
5365 ppc64_elf_notice_as_needed (bfd *ibfd,
5366                             struct bfd_link_info *info,
5367                             enum notice_asneeded_action act)
5368 {
5369   if (act == notice_not_needed)
5370     {
5371       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5372
5373       if (htab == NULL)
5374         return FALSE;
5375
5376       htab->dot_syms = NULL;
5377     }
5378   return _bfd_elf_notice_as_needed (ibfd, info, act);
5379 }
5380
5381 /* If --just-symbols against a final linked binary, then assume we need
5382    toc adjusting stubs when calling functions defined there.  */
5383
5384 static void
5385 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5386 {
5387   if ((sec->flags & SEC_CODE) != 0
5388       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5389       && is_ppc64_elf (sec->owner))
5390     {
5391       if (abiversion (sec->owner) >= 2
5392           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5393         sec->has_toc_reloc = 1;
5394     }
5395   _bfd_elf_link_just_syms (sec, info);
5396 }
5397
5398 static struct plt_entry **
5399 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5400                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5401 {
5402   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5403   struct plt_entry **local_plt;
5404   unsigned char *local_got_tls_masks;
5405
5406   if (local_got_ents == NULL)
5407     {
5408       bfd_size_type size = symtab_hdr->sh_info;
5409
5410       size *= (sizeof (*local_got_ents)
5411                + sizeof (*local_plt)
5412                + sizeof (*local_got_tls_masks));
5413       local_got_ents = bfd_zalloc (abfd, size);
5414       if (local_got_ents == NULL)
5415         return NULL;
5416       elf_local_got_ents (abfd) = local_got_ents;
5417     }
5418
5419   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5420     {
5421       struct got_entry *ent;
5422
5423       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5424         if (ent->addend == r_addend
5425             && ent->owner == abfd
5426             && ent->tls_type == tls_type)
5427           break;
5428       if (ent == NULL)
5429         {
5430           bfd_size_type amt = sizeof (*ent);
5431           ent = bfd_alloc (abfd, amt);
5432           if (ent == NULL)
5433             return FALSE;
5434           ent->next = local_got_ents[r_symndx];
5435           ent->addend = r_addend;
5436           ent->owner = abfd;
5437           ent->tls_type = tls_type;
5438           ent->is_indirect = FALSE;
5439           ent->got.refcount = 0;
5440           local_got_ents[r_symndx] = ent;
5441         }
5442       ent->got.refcount += 1;
5443     }
5444
5445   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5446   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5447   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5448
5449   return local_plt + r_symndx;
5450 }
5451
5452 static bfd_boolean
5453 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5454 {
5455   struct plt_entry *ent;
5456
5457   for (ent = *plist; ent != NULL; ent = ent->next)
5458     if (ent->addend == addend)
5459       break;
5460   if (ent == NULL)
5461     {
5462       bfd_size_type amt = sizeof (*ent);
5463       ent = bfd_alloc (abfd, amt);
5464       if (ent == NULL)
5465         return FALSE;
5466       ent->next = *plist;
5467       ent->addend = addend;
5468       ent->plt.refcount = 0;
5469       *plist = ent;
5470     }
5471   ent->plt.refcount += 1;
5472   return TRUE;
5473 }
5474
5475 static bfd_boolean
5476 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5477 {
5478   return (r_type == R_PPC64_REL24
5479           || r_type == R_PPC64_REL14
5480           || r_type == R_PPC64_REL14_BRTAKEN
5481           || r_type == R_PPC64_REL14_BRNTAKEN
5482           || r_type == R_PPC64_ADDR24
5483           || r_type == R_PPC64_ADDR14
5484           || r_type == R_PPC64_ADDR14_BRTAKEN
5485           || r_type == R_PPC64_ADDR14_BRNTAKEN
5486           || r_type == R_PPC64_PLTCALL);
5487 }
5488
5489 /* Relocs on inline plt call sequence insns prior to the call.  */
5490
5491 static bfd_boolean
5492 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5493 {
5494   return (r_type == R_PPC64_PLT16_HA
5495           || r_type == R_PPC64_PLT16_HI
5496           || r_type == R_PPC64_PLT16_LO
5497           || r_type == R_PPC64_PLT16_LO_DS
5498           || r_type == R_PPC64_PLTSEQ);
5499 }
5500
5501 /* Look through the relocs for a section during the first phase, and
5502    calculate needed space in the global offset table, procedure
5503    linkage table, and dynamic reloc sections.  */
5504
5505 static bfd_boolean
5506 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5507                         asection *sec, const Elf_Internal_Rela *relocs)
5508 {
5509   struct ppc_link_hash_table *htab;
5510   Elf_Internal_Shdr *symtab_hdr;
5511   struct elf_link_hash_entry **sym_hashes;
5512   const Elf_Internal_Rela *rel;
5513   const Elf_Internal_Rela *rel_end;
5514   asection *sreloc;
5515   struct elf_link_hash_entry *tga, *dottga;
5516   bfd_boolean is_opd;
5517
5518   if (bfd_link_relocatable (info))
5519     return TRUE;
5520
5521   /* Don't do anything special with non-loaded, non-alloced sections.
5522      In particular, any relocs in such sections should not affect GOT
5523      and PLT reference counting (ie. we don't allow them to create GOT
5524      or PLT entries), there's no possibility or desire to optimize TLS
5525      relocs, and there's not much point in propagating relocs to shared
5526      libs that the dynamic linker won't relocate.  */
5527   if ((sec->flags & SEC_ALLOC) == 0)
5528     return TRUE;
5529
5530   BFD_ASSERT (is_ppc64_elf (abfd));
5531
5532   htab = ppc_hash_table (info);
5533   if (htab == NULL)
5534     return FALSE;
5535
5536   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5537                               FALSE, FALSE, TRUE);
5538   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5539                                  FALSE, FALSE, TRUE);
5540   symtab_hdr = &elf_symtab_hdr (abfd);
5541   sym_hashes = elf_sym_hashes (abfd);
5542   sreloc = NULL;
5543   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5544   rel_end = relocs + sec->reloc_count;
5545   for (rel = relocs; rel < rel_end; rel++)
5546     {
5547       unsigned long r_symndx;
5548       struct elf_link_hash_entry *h;
5549       enum elf_ppc64_reloc_type r_type;
5550       int tls_type;
5551       struct _ppc64_elf_section_data *ppc64_sec;
5552       struct plt_entry **ifunc, **plt_list;
5553
5554       r_symndx = ELF64_R_SYM (rel->r_info);
5555       if (r_symndx < symtab_hdr->sh_info)
5556         h = NULL;
5557       else
5558         {
5559           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5560           h = elf_follow_link (h);
5561
5562           if (h == htab->elf.hgot)
5563             sec->has_toc_reloc = 1;
5564         }
5565
5566       tls_type = 0;
5567       ifunc = NULL;
5568       if (h != NULL)
5569         {
5570           if (h->type == STT_GNU_IFUNC)
5571             {
5572               h->needs_plt = 1;
5573               ifunc = &h->plt.plist;
5574             }
5575         }
5576       else
5577         {
5578           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5579                                                           abfd, r_symndx);
5580           if (isym == NULL)
5581             return FALSE;
5582
5583           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5584             {
5585               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5586                                              rel->r_addend,
5587                                              NON_GOT | PLT_IFUNC);
5588               if (ifunc == NULL)
5589                 return FALSE;
5590             }
5591         }
5592
5593       r_type = ELF64_R_TYPE (rel->r_info);
5594       switch (r_type)
5595         {
5596         case R_PPC64_TLSGD:
5597         case R_PPC64_TLSLD:
5598           /* These special tls relocs tie a call to __tls_get_addr with
5599              its parameter symbol.  */
5600           if (h != NULL)
5601             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5602           else
5603             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5604                                         rel->r_addend,
5605                                         NON_GOT | TLS_TLS | TLS_MARK))
5606               return FALSE;
5607           sec->has_tls_reloc = 1;
5608           break;
5609
5610         case R_PPC64_GOT_TLSLD16:
5611         case R_PPC64_GOT_TLSLD16_LO:
5612         case R_PPC64_GOT_TLSLD16_HI:
5613         case R_PPC64_GOT_TLSLD16_HA:
5614           tls_type = TLS_TLS | TLS_LD;
5615           goto dogottls;
5616
5617         case R_PPC64_GOT_TLSGD16:
5618         case R_PPC64_GOT_TLSGD16_LO:
5619         case R_PPC64_GOT_TLSGD16_HI:
5620         case R_PPC64_GOT_TLSGD16_HA:
5621           tls_type = TLS_TLS | TLS_GD;
5622           goto dogottls;
5623
5624         case R_PPC64_GOT_TPREL16_DS:
5625         case R_PPC64_GOT_TPREL16_LO_DS:
5626         case R_PPC64_GOT_TPREL16_HI:
5627         case R_PPC64_GOT_TPREL16_HA:
5628           if (bfd_link_dll (info))
5629             info->flags |= DF_STATIC_TLS;
5630           tls_type = TLS_TLS | TLS_TPREL;
5631           goto dogottls;
5632
5633         case R_PPC64_GOT_DTPREL16_DS:
5634         case R_PPC64_GOT_DTPREL16_LO_DS:
5635         case R_PPC64_GOT_DTPREL16_HI:
5636         case R_PPC64_GOT_DTPREL16_HA:
5637           tls_type = TLS_TLS | TLS_DTPREL;
5638         dogottls:
5639           sec->has_tls_reloc = 1;
5640           /* Fall through */
5641
5642         case R_PPC64_GOT16:
5643         case R_PPC64_GOT16_DS:
5644         case R_PPC64_GOT16_HA:
5645         case R_PPC64_GOT16_HI:
5646         case R_PPC64_GOT16_LO:
5647         case R_PPC64_GOT16_LO_DS:
5648           /* This symbol requires a global offset table entry.  */
5649           sec->has_toc_reloc = 1;
5650           if (r_type == R_PPC64_GOT_TLSLD16
5651               || r_type == R_PPC64_GOT_TLSGD16
5652               || r_type == R_PPC64_GOT_TPREL16_DS
5653               || r_type == R_PPC64_GOT_DTPREL16_DS
5654               || r_type == R_PPC64_GOT16
5655               || r_type == R_PPC64_GOT16_DS)
5656             {
5657               htab->do_multi_toc = 1;
5658               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5659             }
5660
5661           if (ppc64_elf_tdata (abfd)->got == NULL
5662               && !create_got_section (abfd, info))
5663             return FALSE;
5664
5665           if (h != NULL)
5666             {
5667               struct ppc_link_hash_entry *eh;
5668               struct got_entry *ent;
5669
5670               eh = (struct ppc_link_hash_entry *) h;
5671               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5672                 if (ent->addend == rel->r_addend
5673                     && ent->owner == abfd
5674                     && ent->tls_type == tls_type)
5675                   break;
5676               if (ent == NULL)
5677                 {
5678                   bfd_size_type amt = sizeof (*ent);
5679                   ent = bfd_alloc (abfd, amt);
5680                   if (ent == NULL)
5681                     return FALSE;
5682                   ent->next = eh->elf.got.glist;
5683                   ent->addend = rel->r_addend;
5684                   ent->owner = abfd;
5685                   ent->tls_type = tls_type;
5686                   ent->is_indirect = FALSE;
5687                   ent->got.refcount = 0;
5688                   eh->elf.got.glist = ent;
5689                 }
5690               ent->got.refcount += 1;
5691               eh->tls_mask |= tls_type;
5692             }
5693           else
5694             /* This is a global offset table entry for a local symbol.  */
5695             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5696                                         rel->r_addend, tls_type))
5697               return FALSE;
5698
5699           /* We may also need a plt entry if the symbol turns out to be
5700              an ifunc.  */
5701           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5702             {
5703               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5704                 return FALSE;
5705             }
5706           break;
5707
5708         case R_PPC64_PLT16_HA:
5709         case R_PPC64_PLT16_HI:
5710         case R_PPC64_PLT16_LO:
5711         case R_PPC64_PLT16_LO_DS:
5712         case R_PPC64_PLT32:
5713         case R_PPC64_PLT64:
5714           /* This symbol requires a procedure linkage table entry.  */
5715           plt_list = ifunc;
5716           if (h != NULL)
5717             {
5718               h->needs_plt = 1;
5719               if (h->root.root.string[0] == '.'
5720                   && h->root.root.string[1] != '\0')
5721                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5722               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5723               plt_list = &h->plt.plist;
5724             }
5725           if (plt_list == NULL)
5726             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5727                                               rel->r_addend,
5728                                               NON_GOT | PLT_KEEP);
5729           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5730             return FALSE;
5731           break;
5732
5733           /* The following relocations don't need to propagate the
5734              relocation if linking a shared object since they are
5735              section relative.  */
5736         case R_PPC64_SECTOFF:
5737         case R_PPC64_SECTOFF_LO:
5738         case R_PPC64_SECTOFF_HI:
5739         case R_PPC64_SECTOFF_HA:
5740         case R_PPC64_SECTOFF_DS:
5741         case R_PPC64_SECTOFF_LO_DS:
5742         case R_PPC64_DTPREL16:
5743         case R_PPC64_DTPREL16_LO:
5744         case R_PPC64_DTPREL16_HI:
5745         case R_PPC64_DTPREL16_HA:
5746         case R_PPC64_DTPREL16_DS:
5747         case R_PPC64_DTPREL16_LO_DS:
5748         case R_PPC64_DTPREL16_HIGH:
5749         case R_PPC64_DTPREL16_HIGHA:
5750         case R_PPC64_DTPREL16_HIGHER:
5751         case R_PPC64_DTPREL16_HIGHERA:
5752         case R_PPC64_DTPREL16_HIGHEST:
5753         case R_PPC64_DTPREL16_HIGHESTA:
5754           break;
5755
5756           /* Nor do these.  */
5757         case R_PPC64_REL16:
5758         case R_PPC64_REL16_LO:
5759         case R_PPC64_REL16_HI:
5760         case R_PPC64_REL16_HA:
5761         case R_PPC64_REL16DX_HA:
5762           break;
5763
5764           /* Not supported as a dynamic relocation.  */
5765         case R_PPC64_ADDR64_LOCAL:
5766           if (bfd_link_pic (info))
5767             {
5768               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5769                 ppc_howto_init ();
5770               /* xgettext:c-format */
5771               info->callbacks->einfo (_("%H: %s reloc unsupported "
5772                                         "in shared libraries and PIEs\n"),
5773                                       abfd, sec, rel->r_offset,
5774                                       ppc64_elf_howto_table[r_type]->name);
5775               bfd_set_error (bfd_error_bad_value);
5776               return FALSE;
5777             }
5778           break;
5779
5780         case R_PPC64_TOC16:
5781         case R_PPC64_TOC16_DS:
5782           htab->do_multi_toc = 1;
5783           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5784           /* Fall through.  */
5785         case R_PPC64_TOC16_LO:
5786         case R_PPC64_TOC16_HI:
5787         case R_PPC64_TOC16_HA:
5788         case R_PPC64_TOC16_LO_DS:
5789           sec->has_toc_reloc = 1;
5790           break;
5791
5792           /* Marker reloc.  */
5793         case R_PPC64_ENTRY:
5794           break;
5795
5796           /* This relocation describes the C++ object vtable hierarchy.
5797              Reconstruct it for later use during GC.  */
5798         case R_PPC64_GNU_VTINHERIT:
5799           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5800             return FALSE;
5801           break;
5802
5803           /* This relocation describes which C++ vtable entries are actually
5804              used.  Record for later use during GC.  */
5805         case R_PPC64_GNU_VTENTRY:
5806           BFD_ASSERT (h != NULL);
5807           if (h != NULL
5808               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5809             return FALSE;
5810           break;
5811
5812         case R_PPC64_REL14:
5813         case R_PPC64_REL14_BRTAKEN:
5814         case R_PPC64_REL14_BRNTAKEN:
5815           {
5816             asection *dest = NULL;
5817
5818             /* Heuristic: If jumping outside our section, chances are
5819                we are going to need a stub.  */
5820             if (h != NULL)
5821               {
5822                 /* If the sym is weak it may be overridden later, so
5823                    don't assume we know where a weak sym lives.  */
5824                 if (h->root.type == bfd_link_hash_defined)
5825                   dest = h->root.u.def.section;
5826               }
5827             else
5828               {
5829                 Elf_Internal_Sym *isym;
5830
5831                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5832                                               abfd, r_symndx);
5833                 if (isym == NULL)
5834                   return FALSE;
5835
5836                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5837               }
5838
5839             if (dest != sec)
5840               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5841           }
5842           goto rel24;
5843
5844         case R_PPC64_PLTCALL:
5845           ppc64_elf_section_data (sec)->has_pltcall = 1;
5846           /* Fall through.  */
5847
5848         case R_PPC64_REL24:
5849         rel24:
5850           plt_list = ifunc;
5851           if (h != NULL)
5852             {
5853               h->needs_plt = 1;
5854               if (h->root.root.string[0] == '.'
5855                   && h->root.root.string[1] != '\0')
5856                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5857
5858               if (h == tga || h == dottga)
5859                 {
5860                   sec->has_tls_reloc = 1;
5861                   if (rel != relocs
5862                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5863                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5864                     /* We have a new-style __tls_get_addr call with
5865                        a marker reloc.  */
5866                     ;
5867                   else
5868                     /* Mark this section as having an old-style call.  */
5869                     sec->has_tls_get_addr_call = 1;
5870                 }
5871               plt_list = &h->plt.plist;
5872             }
5873
5874           /* We may need a .plt entry if the function this reloc
5875              refers to is in a shared lib.  */
5876           if (plt_list
5877               && !update_plt_info (abfd, plt_list, rel->r_addend))
5878             return FALSE;
5879           break;
5880
5881         case R_PPC64_ADDR14:
5882         case R_PPC64_ADDR14_BRNTAKEN:
5883         case R_PPC64_ADDR14_BRTAKEN:
5884         case R_PPC64_ADDR24:
5885           goto dodyn;
5886
5887         case R_PPC64_TPREL64:
5888           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5889           if (bfd_link_dll (info))
5890             info->flags |= DF_STATIC_TLS;
5891           goto dotlstoc;
5892
5893         case R_PPC64_DTPMOD64:
5894           if (rel + 1 < rel_end
5895               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5896               && rel[1].r_offset == rel->r_offset + 8)
5897             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5898           else
5899             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5900           goto dotlstoc;
5901
5902         case R_PPC64_DTPREL64:
5903           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5904           if (rel != relocs
5905               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5906               && rel[-1].r_offset == rel->r_offset - 8)
5907             /* This is the second reloc of a dtpmod, dtprel pair.
5908                Don't mark with TLS_DTPREL.  */
5909             goto dodyn;
5910
5911         dotlstoc:
5912           sec->has_tls_reloc = 1;
5913           if (h != NULL)
5914             {
5915               struct ppc_link_hash_entry *eh;
5916               eh = (struct ppc_link_hash_entry *) h;
5917               eh->tls_mask |= tls_type;
5918             }
5919           else
5920             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5921                                         rel->r_addend, tls_type))
5922               return FALSE;
5923
5924           ppc64_sec = ppc64_elf_section_data (sec);
5925           if (ppc64_sec->sec_type != sec_toc)
5926             {
5927               bfd_size_type amt;
5928
5929               /* One extra to simplify get_tls_mask.  */
5930               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5931               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5932               if (ppc64_sec->u.toc.symndx == NULL)
5933                 return FALSE;
5934               amt = sec->size * sizeof (bfd_vma) / 8;
5935               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5936               if (ppc64_sec->u.toc.add == NULL)
5937                 return FALSE;
5938               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5939               ppc64_sec->sec_type = sec_toc;
5940             }
5941           BFD_ASSERT (rel->r_offset % 8 == 0);
5942           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5943           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5944
5945           /* Mark the second slot of a GD or LD entry.
5946              -1 to indicate GD and -2 to indicate LD.  */
5947           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5948             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5949           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5950             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5951           goto dodyn;
5952
5953         case R_PPC64_TPREL16:
5954         case R_PPC64_TPREL16_LO:
5955         case R_PPC64_TPREL16_HI:
5956         case R_PPC64_TPREL16_HA:
5957         case R_PPC64_TPREL16_DS:
5958         case R_PPC64_TPREL16_LO_DS:
5959         case R_PPC64_TPREL16_HIGH:
5960         case R_PPC64_TPREL16_HIGHA:
5961         case R_PPC64_TPREL16_HIGHER:
5962         case R_PPC64_TPREL16_HIGHERA:
5963         case R_PPC64_TPREL16_HIGHEST:
5964         case R_PPC64_TPREL16_HIGHESTA:
5965           if (bfd_link_dll (info))
5966             info->flags |= DF_STATIC_TLS;
5967           goto dodyn;
5968
5969         case R_PPC64_ADDR64:
5970           if (is_opd
5971               && rel + 1 < rel_end
5972               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5973             {
5974               if (h != NULL)
5975                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5976             }
5977           /* Fall through.  */
5978
5979         case R_PPC64_ADDR16:
5980         case R_PPC64_ADDR16_DS:
5981         case R_PPC64_ADDR16_HA:
5982         case R_PPC64_ADDR16_HI:
5983         case R_PPC64_ADDR16_HIGH:
5984         case R_PPC64_ADDR16_HIGHA:
5985         case R_PPC64_ADDR16_HIGHER:
5986         case R_PPC64_ADDR16_HIGHERA:
5987         case R_PPC64_ADDR16_HIGHEST:
5988         case R_PPC64_ADDR16_HIGHESTA:
5989         case R_PPC64_ADDR16_LO:
5990         case R_PPC64_ADDR16_LO_DS:
5991           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5992               && rel->r_addend == 0)
5993             {
5994               /* We may need a .plt entry if this reloc refers to a
5995                  function in a shared lib.  */
5996               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5997                 return FALSE;
5998               h->pointer_equality_needed = 1;
5999             }
6000           /* Fall through.  */
6001
6002         case R_PPC64_REL30:
6003         case R_PPC64_REL32:
6004         case R_PPC64_REL64:
6005         case R_PPC64_ADDR32:
6006         case R_PPC64_UADDR16:
6007         case R_PPC64_UADDR32:
6008         case R_PPC64_UADDR64:
6009         case R_PPC64_TOC:
6010           if (h != NULL && !bfd_link_pic (info))
6011             /* We may need a copy reloc.  */
6012             h->non_got_ref = 1;
6013
6014           /* Don't propagate .opd relocs.  */
6015           if (NO_OPD_RELOCS && is_opd)
6016             break;
6017
6018           /* If we are creating a shared library, and this is a reloc
6019              against a global symbol, or a non PC relative reloc
6020              against a local symbol, then we need to copy the reloc
6021              into the shared library.  However, if we are linking with
6022              -Bsymbolic, we do not need to copy a reloc against a
6023              global symbol which is defined in an object we are
6024              including in the link (i.e., DEF_REGULAR is set).  At
6025              this point we have not seen all the input files, so it is
6026              possible that DEF_REGULAR is not set now but will be set
6027              later (it is never cleared).  In case of a weak definition,
6028              DEF_REGULAR may be cleared later by a strong definition in
6029              a shared library.  We account for that possibility below by
6030              storing information in the dyn_relocs field of the hash
6031              table entry.  A similar situation occurs when creating
6032              shared libraries and symbol visibility changes render the
6033              symbol local.
6034
6035              If on the other hand, we are creating an executable, we
6036              may need to keep relocations for symbols satisfied by a
6037              dynamic library if we manage to avoid copy relocs for the
6038              symbol.  */
6039         dodyn:
6040           if ((bfd_link_pic (info)
6041                && (must_be_dyn_reloc (info, r_type)
6042                    || (h != NULL
6043                        && (!SYMBOLIC_BIND (info, h)
6044                            || h->root.type == bfd_link_hash_defweak
6045                            || !h->def_regular))))
6046               || (ELIMINATE_COPY_RELOCS
6047                   && !bfd_link_pic (info)
6048                   && h != NULL
6049                   && (h->root.type == bfd_link_hash_defweak
6050                       || !h->def_regular))
6051               || (!bfd_link_pic (info)
6052                   && ifunc != NULL))
6053             {
6054               /* We must copy these reloc types into the output file.
6055                  Create a reloc section in dynobj and make room for
6056                  this reloc.  */
6057               if (sreloc == NULL)
6058                 {
6059                   sreloc = _bfd_elf_make_dynamic_reloc_section
6060                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6061
6062                   if (sreloc == NULL)
6063                     return FALSE;
6064                 }
6065
6066               /* If this is a global symbol, we count the number of
6067                  relocations we need for this symbol.  */
6068               if (h != NULL)
6069                 {
6070                   struct elf_dyn_relocs *p;
6071                   struct elf_dyn_relocs **head;
6072
6073                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6074                   p = *head;
6075                   if (p == NULL || p->sec != sec)
6076                     {
6077                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6078                       if (p == NULL)
6079                         return FALSE;
6080                       p->next = *head;
6081                       *head = p;
6082                       p->sec = sec;
6083                       p->count = 0;
6084                       p->pc_count = 0;
6085                     }
6086                   p->count += 1;
6087                   if (!must_be_dyn_reloc (info, r_type))
6088                     p->pc_count += 1;
6089                 }
6090               else
6091                 {
6092                   /* Track dynamic relocs needed for local syms too.
6093                      We really need local syms available to do this
6094                      easily.  Oh well.  */
6095                   struct ppc_dyn_relocs *p;
6096                   struct ppc_dyn_relocs **head;
6097                   bfd_boolean is_ifunc;
6098                   asection *s;
6099                   void *vpp;
6100                   Elf_Internal_Sym *isym;
6101
6102                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6103                                                 abfd, r_symndx);
6104                   if (isym == NULL)
6105                     return FALSE;
6106
6107                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6108                   if (s == NULL)
6109                     s = sec;
6110
6111                   vpp = &elf_section_data (s)->local_dynrel;
6112                   head = (struct ppc_dyn_relocs **) vpp;
6113                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6114                   p = *head;
6115                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6116                     p = p->next;
6117                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6118                     {
6119                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6120                       if (p == NULL)
6121                         return FALSE;
6122                       p->next = *head;
6123                       *head = p;
6124                       p->sec = sec;
6125                       p->ifunc = is_ifunc;
6126                       p->count = 0;
6127                     }
6128                   p->count += 1;
6129                 }
6130             }
6131           break;
6132
6133         default:
6134           break;
6135         }
6136     }
6137
6138   return TRUE;
6139 }
6140
6141 /* Merge backend specific data from an object file to the output
6142    object file when linking.  */
6143
6144 static bfd_boolean
6145 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6146 {
6147   bfd *obfd = info->output_bfd;
6148   unsigned long iflags, oflags;
6149
6150   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6151     return TRUE;
6152
6153   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6154     return TRUE;
6155
6156   if (!_bfd_generic_verify_endian_match (ibfd, info))
6157     return FALSE;
6158
6159   iflags = elf_elfheader (ibfd)->e_flags;
6160   oflags = elf_elfheader (obfd)->e_flags;
6161
6162   if (iflags & ~EF_PPC64_ABI)
6163     {
6164       _bfd_error_handler
6165         /* xgettext:c-format */
6166         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6167       bfd_set_error (bfd_error_bad_value);
6168       return FALSE;
6169     }
6170   else if (iflags != oflags && iflags != 0)
6171     {
6172       _bfd_error_handler
6173         /* xgettext:c-format */
6174         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6175          ibfd, iflags, oflags);
6176       bfd_set_error (bfd_error_bad_value);
6177       return FALSE;
6178     }
6179
6180   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6181
6182   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6183   return _bfd_elf_merge_object_attributes (ibfd, info);
6184 }
6185
6186 static bfd_boolean
6187 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6188 {
6189   /* Print normal ELF private data.  */
6190   _bfd_elf_print_private_bfd_data (abfd, ptr);
6191
6192   if (elf_elfheader (abfd)->e_flags != 0)
6193     {
6194       FILE *file = ptr;
6195
6196       fprintf (file, _("private flags = 0x%lx:"),
6197                elf_elfheader (abfd)->e_flags);
6198
6199       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6200         fprintf (file, _(" [abiv%ld]"),
6201                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6202       fputc ('\n', file);
6203     }
6204
6205   return TRUE;
6206 }
6207
6208 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6209    of the code entry point, and its section, which must be in the same
6210    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6211
6212 static bfd_vma
6213 opd_entry_value (asection *opd_sec,
6214                  bfd_vma offset,
6215                  asection **code_sec,
6216                  bfd_vma *code_off,
6217                  bfd_boolean in_code_sec)
6218 {
6219   bfd *opd_bfd = opd_sec->owner;
6220   Elf_Internal_Rela *relocs;
6221   Elf_Internal_Rela *lo, *hi, *look;
6222   bfd_vma val;
6223
6224   /* No relocs implies we are linking a --just-symbols object, or looking
6225      at a final linked executable with addr2line or somesuch.  */
6226   if (opd_sec->reloc_count == 0)
6227     {
6228       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6229
6230       if (contents == NULL)
6231         {
6232           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6233             return (bfd_vma) -1;
6234           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6235         }
6236
6237       /* PR 17512: file: 64b9dfbb.  */
6238       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6239         return (bfd_vma) -1;
6240
6241       val = bfd_get_64 (opd_bfd, contents + offset);
6242       if (code_sec != NULL)
6243         {
6244           asection *sec, *likely = NULL;
6245
6246           if (in_code_sec)
6247             {
6248               sec = *code_sec;
6249               if (sec->vma <= val
6250                   && val < sec->vma + sec->size)
6251                 likely = sec;
6252               else
6253                 val = -1;
6254             }
6255           else
6256             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6257               if (sec->vma <= val
6258                   && (sec->flags & SEC_LOAD) != 0
6259                   && (sec->flags & SEC_ALLOC) != 0)
6260                 likely = sec;
6261           if (likely != NULL)
6262             {
6263               *code_sec = likely;
6264               if (code_off != NULL)
6265                 *code_off = val - likely->vma;
6266             }
6267         }
6268       return val;
6269     }
6270
6271   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6272
6273   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6274   if (relocs == NULL)
6275     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6276   /* PR 17512: file: df8e1fd6.  */
6277   if (relocs == NULL)
6278     return (bfd_vma) -1;
6279
6280   /* Go find the opd reloc at the sym address.  */
6281   lo = relocs;
6282   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6283   val = (bfd_vma) -1;
6284   while (lo < hi)
6285     {
6286       look = lo + (hi - lo) / 2;
6287       if (look->r_offset < offset)
6288         lo = look + 1;
6289       else if (look->r_offset > offset)
6290         hi = look;
6291       else
6292         {
6293           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6294
6295           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6296               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6297             {
6298               unsigned long symndx = ELF64_R_SYM (look->r_info);
6299               asection *sec = NULL;
6300
6301               if (symndx >= symtab_hdr->sh_info
6302                   && elf_sym_hashes (opd_bfd) != NULL)
6303                 {
6304                   struct elf_link_hash_entry **sym_hashes;
6305                   struct elf_link_hash_entry *rh;
6306
6307                   sym_hashes = elf_sym_hashes (opd_bfd);
6308                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6309                   if (rh != NULL)
6310                     {
6311                       rh = elf_follow_link (rh);
6312                       if (rh->root.type != bfd_link_hash_defined
6313                           && rh->root.type != bfd_link_hash_defweak)
6314                         break;
6315                       if (rh->root.u.def.section->owner == opd_bfd)
6316                         {
6317                           val = rh->root.u.def.value;
6318                           sec = rh->root.u.def.section;
6319                         }
6320                     }
6321                 }
6322
6323               if (sec == NULL)
6324                 {
6325                   Elf_Internal_Sym *sym;
6326
6327                   if (symndx < symtab_hdr->sh_info)
6328                     {
6329                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6330                       if (sym == NULL)
6331                         {
6332                           size_t symcnt = symtab_hdr->sh_info;
6333                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6334                                                       symcnt, 0,
6335                                                       NULL, NULL, NULL);
6336                           if (sym == NULL)
6337                             break;
6338                           symtab_hdr->contents = (bfd_byte *) sym;
6339                         }
6340                       sym += symndx;
6341                     }
6342                   else
6343                     {
6344                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6345                                                   1, symndx,
6346                                                   NULL, NULL, NULL);
6347                       if (sym == NULL)
6348                         break;
6349                     }
6350                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6351                   if (sec == NULL)
6352                     break;
6353                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6354                   val = sym->st_value;
6355                 }
6356
6357               val += look->r_addend;
6358               if (code_off != NULL)
6359                 *code_off = val;
6360               if (code_sec != NULL)
6361                 {
6362                   if (in_code_sec && *code_sec != sec)
6363                     return -1;
6364                   else
6365                     *code_sec = sec;
6366                 }
6367               if (sec->output_section != NULL)
6368                 val += sec->output_section->vma + sec->output_offset;
6369             }
6370           break;
6371         }
6372     }
6373
6374   return val;
6375 }
6376
6377 /* If the ELF symbol SYM might be a function in SEC, return the
6378    function size and set *CODE_OFF to the function's entry point,
6379    otherwise return zero.  */
6380
6381 static bfd_size_type
6382 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6383                               bfd_vma *code_off)
6384 {
6385   bfd_size_type size;
6386
6387   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6388                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6389     return 0;
6390
6391   size = 0;
6392   if (!(sym->flags & BSF_SYNTHETIC))
6393     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6394
6395   if (strcmp (sym->section->name, ".opd") == 0)
6396     {
6397       struct _opd_sec_data *opd = get_opd_info (sym->section);
6398       bfd_vma symval = sym->value;
6399
6400       if (opd != NULL
6401           && opd->adjust != NULL
6402           && elf_section_data (sym->section)->relocs != NULL)
6403         {
6404           /* opd_entry_value will use cached relocs that have been
6405              adjusted, but with raw symbols.  That means both local
6406              and global symbols need adjusting.  */
6407           long adjust = opd->adjust[OPD_NDX (symval)];
6408           if (adjust == -1)
6409             return 0;
6410           symval += adjust;
6411         }
6412
6413       if (opd_entry_value (sym->section, symval,
6414                            &sec, code_off, TRUE) == (bfd_vma) -1)
6415         return 0;
6416       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6417          symbol.  This size has nothing to do with the code size of the
6418          function, which is what we're supposed to return, but the
6419          code size isn't available without looking up the dot-sym.
6420          However, doing that would be a waste of time particularly
6421          since elf_find_function will look at the dot-sym anyway.
6422          Now, elf_find_function will keep the largest size of any
6423          function sym found at the code address of interest, so return
6424          1 here to avoid it incorrectly caching a larger function size
6425          for a small function.  This does mean we return the wrong
6426          size for a new-ABI function of size 24, but all that does is
6427          disable caching for such functions.  */
6428       if (size == 24)
6429         size = 1;
6430     }
6431   else
6432     {
6433       if (sym->section != sec)
6434         return 0;
6435       *code_off = sym->value;
6436     }
6437   if (size == 0)
6438     size = 1;
6439   return size;
6440 }
6441
6442 /* Return true if symbol is a strong function defined in an ELFv2
6443    object with st_other localentry bits of zero, ie. its local entry
6444    point coincides with its global entry point.  */
6445
6446 static bfd_boolean
6447 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6448 {
6449   return (h != NULL
6450           && h->type == STT_FUNC
6451           && h->root.type == bfd_link_hash_defined
6452           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6453           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6454           && is_ppc64_elf (h->root.u.def.section->owner)
6455           && abiversion (h->root.u.def.section->owner) >= 2);
6456 }
6457
6458 /* Return true if symbol is defined in a regular object file.  */
6459
6460 static bfd_boolean
6461 is_static_defined (struct elf_link_hash_entry *h)
6462 {
6463   return ((h->root.type == bfd_link_hash_defined
6464            || h->root.type == bfd_link_hash_defweak)
6465           && h->root.u.def.section != NULL
6466           && h->root.u.def.section->output_section != NULL);
6467 }
6468
6469 /* If FDH is a function descriptor symbol, return the associated code
6470    entry symbol if it is defined.  Return NULL otherwise.  */
6471
6472 static struct ppc_link_hash_entry *
6473 defined_code_entry (struct ppc_link_hash_entry *fdh)
6474 {
6475   if (fdh->is_func_descriptor)
6476     {
6477       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6478       if (fh->elf.root.type == bfd_link_hash_defined
6479           || fh->elf.root.type == bfd_link_hash_defweak)
6480         return fh;
6481     }
6482   return NULL;
6483 }
6484
6485 /* If FH is a function code entry symbol, return the associated
6486    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6487
6488 static struct ppc_link_hash_entry *
6489 defined_func_desc (struct ppc_link_hash_entry *fh)
6490 {
6491   if (fh->oh != NULL
6492       && fh->oh->is_func_descriptor)
6493     {
6494       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6495       if (fdh->elf.root.type == bfd_link_hash_defined
6496           || fdh->elf.root.type == bfd_link_hash_defweak)
6497         return fdh;
6498     }
6499   return NULL;
6500 }
6501
6502 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6503
6504 /* Garbage collect sections, after first dealing with dot-symbols.  */
6505
6506 static bfd_boolean
6507 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6508 {
6509   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6510
6511   if (htab != NULL && htab->need_func_desc_adj)
6512     {
6513       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6514       htab->need_func_desc_adj = 0;
6515     }
6516   return bfd_elf_gc_sections (abfd, info);
6517 }
6518
6519 /* Mark all our entry sym sections, both opd and code section.  */
6520
6521 static void
6522 ppc64_elf_gc_keep (struct bfd_link_info *info)
6523 {
6524   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6525   struct bfd_sym_chain *sym;
6526
6527   if (htab == NULL)
6528     return;
6529
6530   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6531     {
6532       struct ppc_link_hash_entry *eh, *fh;
6533       asection *sec;
6534
6535       eh = (struct ppc_link_hash_entry *)
6536         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6537       if (eh == NULL)
6538         continue;
6539       if (eh->elf.root.type != bfd_link_hash_defined
6540           && eh->elf.root.type != bfd_link_hash_defweak)
6541         continue;
6542
6543       fh = defined_code_entry (eh);
6544       if (fh != NULL)
6545         {
6546           sec = fh->elf.root.u.def.section;
6547           sec->flags |= SEC_KEEP;
6548         }
6549       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6550                && opd_entry_value (eh->elf.root.u.def.section,
6551                                    eh->elf.root.u.def.value,
6552                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6553         sec->flags |= SEC_KEEP;
6554
6555       sec = eh->elf.root.u.def.section;
6556       sec->flags |= SEC_KEEP;
6557     }
6558 }
6559
6560 /* Mark sections containing dynamically referenced symbols.  When
6561    building shared libraries, we must assume that any visible symbol is
6562    referenced.  */
6563
6564 static bfd_boolean
6565 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6566 {
6567   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6568   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6569   struct ppc_link_hash_entry *fdh;
6570   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6571
6572   /* Dynamic linking info is on the func descriptor sym.  */
6573   fdh = defined_func_desc (eh);
6574   if (fdh != NULL)
6575     eh = fdh;
6576
6577   if ((eh->elf.root.type == bfd_link_hash_defined
6578        || eh->elf.root.type == bfd_link_hash_defweak)
6579       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6580           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6581               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6582               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6583               && (!bfd_link_executable (info)
6584                   || info->gc_keep_exported
6585                   || info->export_dynamic
6586                   || (eh->elf.dynamic
6587                       && d != NULL
6588                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6589               && (eh->elf.versioned >= versioned
6590                   || !bfd_hide_sym_by_version (info->version_info,
6591                                                eh->elf.root.root.string)))))
6592     {
6593       asection *code_sec;
6594       struct ppc_link_hash_entry *fh;
6595
6596       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6597
6598       /* Function descriptor syms cause the associated
6599          function code sym section to be marked.  */
6600       fh = defined_code_entry (eh);
6601       if (fh != NULL)
6602         {
6603           code_sec = fh->elf.root.u.def.section;
6604           code_sec->flags |= SEC_KEEP;
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                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6610         code_sec->flags |= SEC_KEEP;
6611     }
6612
6613   return TRUE;
6614 }
6615
6616 /* Return the section that should be marked against GC for a given
6617    relocation.  */
6618
6619 static asection *
6620 ppc64_elf_gc_mark_hook (asection *sec,
6621                         struct bfd_link_info *info,
6622                         Elf_Internal_Rela *rel,
6623                         struct elf_link_hash_entry *h,
6624                         Elf_Internal_Sym *sym)
6625 {
6626   asection *rsec;
6627
6628   /* Syms return NULL if we're marking .opd, so we avoid marking all
6629      function sections, as all functions are referenced in .opd.  */
6630   rsec = NULL;
6631   if (get_opd_info (sec) != NULL)
6632     return rsec;
6633
6634   if (h != NULL)
6635     {
6636       enum elf_ppc64_reloc_type r_type;
6637       struct ppc_link_hash_entry *eh, *fh, *fdh;
6638
6639       r_type = ELF64_R_TYPE (rel->r_info);
6640       switch (r_type)
6641         {
6642         case R_PPC64_GNU_VTINHERIT:
6643         case R_PPC64_GNU_VTENTRY:
6644           break;
6645
6646         default:
6647           switch (h->root.type)
6648             {
6649             case bfd_link_hash_defined:
6650             case bfd_link_hash_defweak:
6651               eh = (struct ppc_link_hash_entry *) h;
6652               fdh = defined_func_desc (eh);
6653               if (fdh != NULL)
6654                 {
6655                   /* -mcall-aixdesc code references the dot-symbol on
6656                      a call reloc.  Mark the function descriptor too
6657                      against garbage collection.  */
6658                   fdh->elf.mark = 1;
6659                   if (fdh->elf.is_weakalias)
6660                     weakdef (&fdh->elf)->mark = 1;
6661                   eh = fdh;
6662                 }
6663
6664               /* Function descriptor syms cause the associated
6665                  function code sym section to be marked.  */
6666               fh = defined_code_entry (eh);
6667               if (fh != NULL)
6668                 {
6669                   /* They also mark their opd section.  */
6670                   eh->elf.root.u.def.section->gc_mark = 1;
6671
6672                   rsec = fh->elf.root.u.def.section;
6673                 }
6674               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6675                        && opd_entry_value (eh->elf.root.u.def.section,
6676                                            eh->elf.root.u.def.value,
6677                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6678                 eh->elf.root.u.def.section->gc_mark = 1;
6679               else
6680                 rsec = h->root.u.def.section;
6681               break;
6682
6683             case bfd_link_hash_common:
6684               rsec = h->root.u.c.p->section;
6685               break;
6686
6687             default:
6688               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6689             }
6690         }
6691     }
6692   else
6693     {
6694       struct _opd_sec_data *opd;
6695
6696       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6697       opd = get_opd_info (rsec);
6698       if (opd != NULL && opd->func_sec != NULL)
6699         {
6700           rsec->gc_mark = 1;
6701
6702           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6703         }
6704     }
6705
6706   return rsec;
6707 }
6708
6709 /* The maximum size of .sfpr.  */
6710 #define SFPR_MAX (218*4)
6711
6712 struct sfpr_def_parms
6713 {
6714   const char name[12];
6715   unsigned char lo, hi;
6716   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6717   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6718 };
6719
6720 /* Auto-generate _save*, _rest* functions in .sfpr.
6721    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6722    instead.  */
6723
6724 static bfd_boolean
6725 sfpr_define (struct bfd_link_info *info,
6726              const struct sfpr_def_parms *parm,
6727              asection *stub_sec)
6728 {
6729   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6730   unsigned int i;
6731   size_t len = strlen (parm->name);
6732   bfd_boolean writing = FALSE;
6733   char sym[16];
6734
6735   if (htab == NULL)
6736     return FALSE;
6737
6738   memcpy (sym, parm->name, len);
6739   sym[len + 2] = 0;
6740
6741   for (i = parm->lo; i <= parm->hi; i++)
6742     {
6743       struct ppc_link_hash_entry *h;
6744
6745       sym[len + 0] = i / 10 + '0';
6746       sym[len + 1] = i % 10 + '0';
6747       h = (struct ppc_link_hash_entry *)
6748         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6749       if (stub_sec != NULL)
6750         {
6751           if (h != NULL
6752               && h->elf.root.type == bfd_link_hash_defined
6753               && h->elf.root.u.def.section == htab->sfpr)
6754             {
6755               struct elf_link_hash_entry *s;
6756               char buf[32];
6757               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6758               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6759               if (s == NULL)
6760                 return FALSE;
6761               if (s->root.type == bfd_link_hash_new
6762                   || (s->root.type = bfd_link_hash_defined
6763                       && s->root.u.def.section == stub_sec))
6764                 {
6765                   s->root.type = bfd_link_hash_defined;
6766                   s->root.u.def.section = stub_sec;
6767                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6768                                          + h->elf.root.u.def.value);
6769                   s->ref_regular = 1;
6770                   s->def_regular = 1;
6771                   s->ref_regular_nonweak = 1;
6772                   s->forced_local = 1;
6773                   s->non_elf = 0;
6774                   s->root.linker_def = 1;
6775                 }
6776             }
6777           continue;
6778         }
6779       if (h != NULL)
6780         {
6781           h->save_res = 1;
6782           if (!h->elf.def_regular)
6783             {
6784               h->elf.root.type = bfd_link_hash_defined;
6785               h->elf.root.u.def.section = htab->sfpr;
6786               h->elf.root.u.def.value = htab->sfpr->size;
6787               h->elf.type = STT_FUNC;
6788               h->elf.def_regular = 1;
6789               h->elf.non_elf = 0;
6790               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6791               writing = TRUE;
6792               if (htab->sfpr->contents == NULL)
6793                 {
6794                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6795                   if (htab->sfpr->contents == NULL)
6796                     return FALSE;
6797                 }
6798             }
6799         }
6800       if (writing)
6801         {
6802           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6803           if (i != parm->hi)
6804             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6805           else
6806             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6807           htab->sfpr->size = p - htab->sfpr->contents;
6808         }
6809     }
6810
6811   return TRUE;
6812 }
6813
6814 static bfd_byte *
6815 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6816 {
6817   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6818   return p + 4;
6819 }
6820
6821 static bfd_byte *
6822 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6823 {
6824   p = savegpr0 (abfd, p, r);
6825   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6826   p = p + 4;
6827   bfd_put_32 (abfd, BLR, p);
6828   return p + 4;
6829 }
6830
6831 static bfd_byte *
6832 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6833 {
6834   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6835   return p + 4;
6836 }
6837
6838 static bfd_byte *
6839 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6840 {
6841   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6842   p = p + 4;
6843   p = restgpr0 (abfd, p, r);
6844   bfd_put_32 (abfd, MTLR_R0, p);
6845   p = p + 4;
6846   if (r == 29)
6847     {
6848       p = restgpr0 (abfd, p, 30);
6849       p = restgpr0 (abfd, p, 31);
6850     }
6851   bfd_put_32 (abfd, BLR, p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6859   return p + 4;
6860 }
6861
6862 static bfd_byte *
6863 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6864 {
6865   p = savegpr1 (abfd, p, r);
6866   bfd_put_32 (abfd, BLR, p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6874   return p + 4;
6875 }
6876
6877 static bfd_byte *
6878 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6879 {
6880   p = restgpr1 (abfd, p, r);
6881   bfd_put_32 (abfd, BLR, p);
6882   return p + 4;
6883 }
6884
6885 static bfd_byte *
6886 savefpr (bfd *abfd, bfd_byte *p, int r)
6887 {
6888   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6889   return p + 4;
6890 }
6891
6892 static bfd_byte *
6893 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6894 {
6895   p = savefpr (abfd, p, r);
6896   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6897   p = p + 4;
6898   bfd_put_32 (abfd, BLR, p);
6899   return p + 4;
6900 }
6901
6902 static bfd_byte *
6903 restfpr (bfd *abfd, bfd_byte *p, int r)
6904 {
6905   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6906   return p + 4;
6907 }
6908
6909 static bfd_byte *
6910 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6911 {
6912   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6913   p = p + 4;
6914   p = restfpr (abfd, p, r);
6915   bfd_put_32 (abfd, MTLR_R0, p);
6916   p = p + 4;
6917   if (r == 29)
6918     {
6919       p = restfpr (abfd, p, 30);
6920       p = restfpr (abfd, p, 31);
6921     }
6922   bfd_put_32 (abfd, BLR, p);
6923   return p + 4;
6924 }
6925
6926 static bfd_byte *
6927 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6928 {
6929   p = savefpr (abfd, p, r);
6930   bfd_put_32 (abfd, BLR, p);
6931   return p + 4;
6932 }
6933
6934 static bfd_byte *
6935 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6936 {
6937   p = restfpr (abfd, p, r);
6938   bfd_put_32 (abfd, BLR, p);
6939   return p + 4;
6940 }
6941
6942 static bfd_byte *
6943 savevr (bfd *abfd, bfd_byte *p, int r)
6944 {
6945   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6946   p = p + 4;
6947   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6948   return p + 4;
6949 }
6950
6951 static bfd_byte *
6952 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6953 {
6954   p = savevr (abfd, p, r);
6955   bfd_put_32 (abfd, BLR, p);
6956   return p + 4;
6957 }
6958
6959 static bfd_byte *
6960 restvr (bfd *abfd, bfd_byte *p, int r)
6961 {
6962   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6963   p = p + 4;
6964   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6965   return p + 4;
6966 }
6967
6968 static bfd_byte *
6969 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6970 {
6971   p = restvr (abfd, p, r);
6972   bfd_put_32 (abfd, BLR, p);
6973   return p + 4;
6974 }
6975
6976 /* Called via elf_link_hash_traverse to transfer dynamic linking
6977    information on function code symbol entries to their corresponding
6978    function descriptor symbol entries.  */
6979
6980 static bfd_boolean
6981 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6982 {
6983   struct bfd_link_info *info;
6984   struct ppc_link_hash_table *htab;
6985   struct ppc_link_hash_entry *fh;
6986   struct ppc_link_hash_entry *fdh;
6987   bfd_boolean force_local;
6988
6989   fh = (struct ppc_link_hash_entry *) h;
6990   if (fh->elf.root.type == bfd_link_hash_indirect)
6991     return TRUE;
6992
6993   if (!fh->is_func)
6994     return TRUE;
6995
6996   if (fh->elf.root.root.string[0] != '.'
6997       || fh->elf.root.root.string[1] == '\0')
6998     return TRUE;
6999
7000   info = inf;
7001   htab = ppc_hash_table (info);
7002   if (htab == NULL)
7003     return FALSE;
7004
7005   /* Find the corresponding function descriptor symbol.  */
7006   fdh = lookup_fdh (fh, htab);
7007
7008   /* Resolve undefined references to dot-symbols as the value
7009      in the function descriptor, if we have one in a regular object.
7010      This is to satisfy cases like ".quad .foo".  Calls to functions
7011      in dynamic objects are handled elsewhere.  */
7012   if ((fh->elf.root.type == bfd_link_hash_undefined
7013        || fh->elf.root.type == bfd_link_hash_undefweak)
7014       && (fdh->elf.root.type == bfd_link_hash_defined
7015           || fdh->elf.root.type == bfd_link_hash_defweak)
7016       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7017       && opd_entry_value (fdh->elf.root.u.def.section,
7018                           fdh->elf.root.u.def.value,
7019                           &fh->elf.root.u.def.section,
7020                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7021     {
7022       fh->elf.root.type = fdh->elf.root.type;
7023       fh->elf.forced_local = 1;
7024       fh->elf.def_regular = fdh->elf.def_regular;
7025       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7026     }
7027
7028   if (!fh->elf.dynamic)
7029     {
7030       struct plt_entry *ent;
7031
7032       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7033         if (ent->plt.refcount > 0)
7034           break;
7035       if (ent == NULL)
7036         return TRUE;
7037     }
7038
7039   /* Create a descriptor as undefined if necessary.  */
7040   if (fdh == NULL
7041       && !bfd_link_executable (info)
7042       && (fh->elf.root.type == bfd_link_hash_undefined
7043           || fh->elf.root.type == bfd_link_hash_undefweak))
7044     {
7045       fdh = make_fdh (info, fh);
7046       if (fdh == NULL)
7047         return FALSE;
7048     }
7049
7050   /* We can't support overriding of symbols on a fake descriptor.  */
7051   if (fdh != NULL
7052       && fdh->fake
7053       && (fh->elf.root.type == bfd_link_hash_defined
7054           || fh->elf.root.type == bfd_link_hash_defweak))
7055     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7056
7057   /* Transfer dynamic linking information to the function descriptor.  */
7058   if (fdh != NULL)
7059     {
7060       fdh->elf.ref_regular |= fh->elf.ref_regular;
7061       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7062       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7063       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7064       fdh->elf.dynamic |= fh->elf.dynamic;
7065       fdh->elf.needs_plt |= (fh->elf.needs_plt
7066                              || fh->elf.type == STT_FUNC
7067                              || fh->elf.type == STT_GNU_IFUNC);
7068       move_plt_plist (fh, fdh);
7069
7070       if (!fdh->elf.forced_local
7071           && fh->elf.dynindx != -1)
7072         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7073           return FALSE;
7074     }
7075
7076   /* Now that the info is on the function descriptor, clear the
7077      function code sym info.  Any function code syms for which we
7078      don't have a definition in a regular file, we force local.
7079      This prevents a shared library from exporting syms that have
7080      been imported from another library.  Function code syms that
7081      are really in the library we must leave global to prevent the
7082      linker dragging in a definition from a static library.  */
7083   force_local = (!fh->elf.def_regular
7084                  || fdh == NULL
7085                  || !fdh->elf.def_regular
7086                  || fdh->elf.forced_local);
7087   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7088
7089   return TRUE;
7090 }
7091
7092 static const struct sfpr_def_parms save_res_funcs[] =
7093   {
7094     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7095     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7096     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7097     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7098     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7099     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7100     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7101     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7102     { "._savef", 14, 31, savefpr, savefpr1_tail },
7103     { "._restf", 14, 31, restfpr, restfpr1_tail },
7104     { "_savevr_", 20, 31, savevr, savevr_tail },
7105     { "_restvr_", 20, 31, restvr, restvr_tail }
7106   };
7107
7108 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7109    this hook to a) provide some gcc support functions, and b) transfer
7110    dynamic linking information gathered so far on function code symbol
7111    entries, to their corresponding function descriptor symbol entries.  */
7112
7113 static bfd_boolean
7114 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7115                             struct bfd_link_info *info)
7116 {
7117   struct ppc_link_hash_table *htab;
7118
7119   htab = ppc_hash_table (info);
7120   if (htab == NULL)
7121     return FALSE;
7122
7123   /* Provide any missing _save* and _rest* functions.  */
7124   if (htab->sfpr != NULL)
7125     {
7126       unsigned int i;
7127
7128       htab->sfpr->size = 0;
7129       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7130         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7131           return FALSE;
7132       if (htab->sfpr->size == 0)
7133         htab->sfpr->flags |= SEC_EXCLUDE;
7134     }
7135
7136   if (bfd_link_relocatable (info))
7137     return TRUE;
7138
7139   if (htab->elf.hgot != NULL)
7140     {
7141       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7142       /* Make .TOC. defined so as to prevent it being made dynamic.
7143          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7144       if (!htab->elf.hgot->def_regular
7145           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7146         {
7147           htab->elf.hgot->root.type = bfd_link_hash_defined;
7148           htab->elf.hgot->root.u.def.value = 0;
7149           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7150           htab->elf.hgot->def_regular = 1;
7151           htab->elf.hgot->root.linker_def = 1;
7152         }
7153       htab->elf.hgot->type = STT_OBJECT;
7154       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7155                                | STV_HIDDEN);
7156     }
7157
7158   if (htab->need_func_desc_adj)
7159     {
7160       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7161       htab->need_func_desc_adj = 0;
7162     }
7163
7164   return TRUE;
7165 }
7166
7167 /* Find dynamic relocs for H that apply to read-only sections.  */
7168
7169 static asection *
7170 readonly_dynrelocs (struct elf_link_hash_entry *h)
7171 {
7172   struct ppc_link_hash_entry *eh;
7173   struct elf_dyn_relocs *p;
7174
7175   eh = (struct ppc_link_hash_entry *) h;
7176   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7177     {
7178       asection *s = p->sec->output_section;
7179
7180       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7181         return p->sec;
7182     }
7183   return NULL;
7184 }
7185
7186 /* Return true if we have dynamic relocs against H or any of its weak
7187    aliases, that apply to read-only sections.  Cannot be used after
7188    size_dynamic_sections.  */
7189
7190 static bfd_boolean
7191 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7192 {
7193   struct ppc_link_hash_entry *eh;
7194
7195   eh = (struct ppc_link_hash_entry *) h;
7196   do
7197     {
7198       if (readonly_dynrelocs (&eh->elf))
7199         return TRUE;
7200       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7201     } while (eh != NULL && &eh->elf != h);
7202
7203   return FALSE;
7204 }
7205
7206 /* Return whether EH has pc-relative dynamic relocs.  */
7207
7208 static bfd_boolean
7209 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7210 {
7211   struct elf_dyn_relocs *p;
7212
7213   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7214     if (p->pc_count != 0)
7215       return TRUE;
7216   return FALSE;
7217 }
7218
7219 /* Return true if a global entry stub will be created for H.  Valid
7220    for ELFv2 before plt entries have been allocated.  */
7221
7222 static bfd_boolean
7223 global_entry_stub (struct elf_link_hash_entry *h)
7224 {
7225   struct plt_entry *pent;
7226
7227   if (!h->pointer_equality_needed
7228       || h->def_regular)
7229     return FALSE;
7230
7231   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7232     if (pent->plt.refcount > 0
7233         && pent->addend == 0)
7234       return TRUE;
7235
7236   return FALSE;
7237 }
7238
7239 /* Adjust a symbol defined by a dynamic object and referenced by a
7240    regular object.  The current definition is in some section of the
7241    dynamic object, but we're not including those sections.  We have to
7242    change the definition to something the rest of the link can
7243    understand.  */
7244
7245 static bfd_boolean
7246 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7247                                  struct elf_link_hash_entry *h)
7248 {
7249   struct ppc_link_hash_table *htab;
7250   asection *s, *srel;
7251
7252   htab = ppc_hash_table (info);
7253   if (htab == NULL)
7254     return FALSE;
7255
7256   /* Deal with function syms.  */
7257   if (h->type == STT_FUNC
7258       || h->type == STT_GNU_IFUNC
7259       || h->needs_plt)
7260     {
7261       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7262                            || SYMBOL_CALLS_LOCAL (info, h)
7263                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7264       /* Discard dyn_relocs when non-pic if we've decided that a
7265          function symbol is local and not an ifunc.  We keep dynamic
7266          relocs for ifuncs when local rather than always emitting a
7267          plt call stub for them and defining the symbol on the call
7268          stub.  We can't do that for ELFv1 anyway (a function symbol
7269          is defined on a descriptor, not code) and it can be faster at
7270          run-time due to not needing to bounce through a stub.  The
7271          dyn_relocs for ifuncs will be applied even in a static
7272          executable.  */
7273       if (!bfd_link_pic (info)
7274           && h->type != STT_GNU_IFUNC
7275           && local)
7276         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7277
7278       /* Clear procedure linkage table information for any symbol that
7279          won't need a .plt entry.  */
7280       struct plt_entry *ent;
7281       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7282         if (ent->plt.refcount > 0)
7283           break;
7284       if (ent == NULL
7285           || (h->type != STT_GNU_IFUNC
7286               && local
7287               && (htab->can_convert_all_inline_plt
7288                   || (((struct ppc_link_hash_entry *) h)->tls_mask
7289                       & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7290         {
7291           h->plt.plist = NULL;
7292           h->needs_plt = 0;
7293           h->pointer_equality_needed = 0;
7294         }
7295       else if (abiversion (info->output_bfd) >= 2)
7296         {
7297           /* Taking a function's address in a read/write section
7298              doesn't require us to define the function symbol in the
7299              executable on a global entry stub.  A dynamic reloc can
7300              be used instead.  The reason we prefer a few more dynamic
7301              relocs is that calling via a global entry stub costs a
7302              few more instructions, and pointer_equality_needed causes
7303              extra work in ld.so when resolving these symbols.  */
7304           if (global_entry_stub (h))
7305             {
7306               if (!readonly_dynrelocs (h))
7307                 {
7308                   h->pointer_equality_needed = 0;
7309                   /* If we haven't seen a branch reloc and the symbol
7310                      isn't an ifunc then we don't need a plt entry.  */
7311                   if (!h->needs_plt)
7312                     h->plt.plist = NULL;
7313                 }
7314               else if (!bfd_link_pic (info))
7315                 /* We are going to be defining the function symbol on the
7316                    plt stub, so no dyn_relocs needed when non-pic.  */
7317                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7318             }
7319
7320           /* ELFv2 function symbols can't have copy relocs.  */
7321           return TRUE;
7322         }
7323       else if (!h->needs_plt
7324                && !readonly_dynrelocs (h))
7325         {
7326           /* If we haven't seen a branch reloc and the symbol isn't an
7327              ifunc then we don't need a plt entry.  */
7328           h->plt.plist = NULL;
7329           h->pointer_equality_needed = 0;
7330           return TRUE;
7331         }
7332     }
7333   else
7334     h->plt.plist = NULL;
7335
7336   /* If this is a weak symbol, and there is a real definition, the
7337      processor independent code will have arranged for us to see the
7338      real definition first, and we can just use the same value.  */
7339   if (h->is_weakalias)
7340     {
7341       struct elf_link_hash_entry *def = weakdef (h);
7342       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7343       h->root.u.def.section = def->root.u.def.section;
7344       h->root.u.def.value = def->root.u.def.value;
7345       if (def->root.u.def.section == htab->elf.sdynbss
7346           || def->root.u.def.section == htab->elf.sdynrelro)
7347         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7348       return TRUE;
7349     }
7350
7351   /* If we are creating a shared library, we must presume that the
7352      only references to the symbol are via the global offset table.
7353      For such cases we need not do anything here; the relocations will
7354      be handled correctly by relocate_section.  */
7355   if (bfd_link_pic (info))
7356     return TRUE;
7357
7358   /* If there are no references to this symbol that do not use the
7359      GOT, we don't need to generate a copy reloc.  */
7360   if (!h->non_got_ref)
7361     return TRUE;
7362
7363   /* Don't generate a copy reloc for symbols defined in the executable.  */
7364   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7365
7366       /* If -z nocopyreloc was given, don't generate them either.  */
7367       || info->nocopyreloc
7368
7369       /* If we don't find any dynamic relocs in read-only sections, then
7370          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7371       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7372
7373       /* Protected variables do not work with .dynbss.  The copy in
7374          .dynbss won't be used by the shared library with the protected
7375          definition for the variable.  Text relocations are preferable
7376          to an incorrect program.  */
7377       || h->protected_def)
7378     return TRUE;
7379
7380   if (h->plt.plist != NULL)
7381     {
7382       /* We should never get here, but unfortunately there are versions
7383          of gcc out there that improperly (for this ABI) put initialized
7384          function pointers, vtable refs and suchlike in read-only
7385          sections.  Allow them to proceed, but warn that this might
7386          break at runtime.  */
7387       info->callbacks->einfo
7388         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7389            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7390          h->root.root.string);
7391     }
7392
7393   /* This is a reference to a symbol defined by a dynamic object which
7394      is not a function.  */
7395
7396   /* We must allocate the symbol in our .dynbss section, which will
7397      become part of the .bss section of the executable.  There will be
7398      an entry for this symbol in the .dynsym section.  The dynamic
7399      object will contain position independent code, so all references
7400      from the dynamic object to this symbol will go through the global
7401      offset table.  The dynamic linker will use the .dynsym entry to
7402      determine the address it must put in the global offset table, so
7403      both the dynamic object and the regular object will refer to the
7404      same memory location for the variable.  */
7405   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7406     {
7407       s = htab->elf.sdynrelro;
7408       srel = htab->elf.sreldynrelro;
7409     }
7410   else
7411     {
7412       s = htab->elf.sdynbss;
7413       srel = htab->elf.srelbss;
7414     }
7415   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7416     {
7417       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7418          linker to copy the initial value out of the dynamic object
7419          and into the runtime process image.  */
7420       srel->size += sizeof (Elf64_External_Rela);
7421       h->needs_copy = 1;
7422     }
7423
7424   /* We no longer want dyn_relocs.  */
7425   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7426   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7427 }
7428
7429 /* If given a function descriptor symbol, hide both the function code
7430    sym and the descriptor.  */
7431 static void
7432 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7433                        struct elf_link_hash_entry *h,
7434                        bfd_boolean force_local)
7435 {
7436   struct ppc_link_hash_entry *eh;
7437   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7438
7439   eh = (struct ppc_link_hash_entry *) h;
7440   if (eh->is_func_descriptor)
7441     {
7442       struct ppc_link_hash_entry *fh = eh->oh;
7443
7444       if (fh == NULL)
7445         {
7446           const char *p, *q;
7447           struct elf_link_hash_table *htab = elf_hash_table (info);
7448           char save;
7449
7450           /* We aren't supposed to use alloca in BFD because on
7451              systems which do not have alloca the version in libiberty
7452              calls xmalloc, which might cause the program to crash
7453              when it runs out of memory.  This function doesn't have a
7454              return status, so there's no way to gracefully return an
7455              error.  So cheat.  We know that string[-1] can be safely
7456              accessed;  It's either a string in an ELF string table,
7457              or allocated in an objalloc structure.  */
7458
7459           p = eh->elf.root.root.string - 1;
7460           save = *p;
7461           *(char *) p = '.';
7462           fh = (struct ppc_link_hash_entry *)
7463             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7464           *(char *) p = save;
7465
7466           /* Unfortunately, if it so happens that the string we were
7467              looking for was allocated immediately before this string,
7468              then we overwrote the string terminator.  That's the only
7469              reason the lookup should fail.  */
7470           if (fh == NULL)
7471             {
7472               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7473               while (q >= eh->elf.root.root.string && *q == *p)
7474                 --q, --p;
7475               if (q < eh->elf.root.root.string && *p == '.')
7476                 fh = (struct ppc_link_hash_entry *)
7477                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7478             }
7479           if (fh != NULL)
7480             {
7481               eh->oh = fh;
7482               fh->oh = eh;
7483             }
7484         }
7485       if (fh != NULL)
7486         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7487     }
7488 }
7489
7490 static bfd_boolean
7491 get_sym_h (struct elf_link_hash_entry **hp,
7492            Elf_Internal_Sym **symp,
7493            asection **symsecp,
7494            unsigned char **tls_maskp,
7495            Elf_Internal_Sym **locsymsp,
7496            unsigned long r_symndx,
7497            bfd *ibfd)
7498 {
7499   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7500
7501   if (r_symndx >= symtab_hdr->sh_info)
7502     {
7503       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7504       struct elf_link_hash_entry *h;
7505
7506       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7507       h = elf_follow_link (h);
7508
7509       if (hp != NULL)
7510         *hp = h;
7511
7512       if (symp != NULL)
7513         *symp = NULL;
7514
7515       if (symsecp != NULL)
7516         {
7517           asection *symsec = NULL;
7518           if (h->root.type == bfd_link_hash_defined
7519               || h->root.type == bfd_link_hash_defweak)
7520             symsec = h->root.u.def.section;
7521           *symsecp = symsec;
7522         }
7523
7524       if (tls_maskp != NULL)
7525         {
7526           struct ppc_link_hash_entry *eh;
7527
7528           eh = (struct ppc_link_hash_entry *) h;
7529           *tls_maskp = &eh->tls_mask;
7530         }
7531     }
7532   else
7533     {
7534       Elf_Internal_Sym *sym;
7535       Elf_Internal_Sym *locsyms = *locsymsp;
7536
7537       if (locsyms == NULL)
7538         {
7539           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7540           if (locsyms == NULL)
7541             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7542                                             symtab_hdr->sh_info,
7543                                             0, NULL, NULL, NULL);
7544           if (locsyms == NULL)
7545             return FALSE;
7546           *locsymsp = locsyms;
7547         }
7548       sym = locsyms + r_symndx;
7549
7550       if (hp != NULL)
7551         *hp = NULL;
7552
7553       if (symp != NULL)
7554         *symp = sym;
7555
7556       if (symsecp != NULL)
7557         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7558
7559       if (tls_maskp != NULL)
7560         {
7561           struct got_entry **lgot_ents;
7562           unsigned char *tls_mask;
7563
7564           tls_mask = NULL;
7565           lgot_ents = elf_local_got_ents (ibfd);
7566           if (lgot_ents != NULL)
7567             {
7568               struct plt_entry **local_plt = (struct plt_entry **)
7569                 (lgot_ents + symtab_hdr->sh_info);
7570               unsigned char *lgot_masks = (unsigned char *)
7571                 (local_plt + symtab_hdr->sh_info);
7572               tls_mask = &lgot_masks[r_symndx];
7573             }
7574           *tls_maskp = tls_mask;
7575         }
7576     }
7577   return TRUE;
7578 }
7579
7580 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7581    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7582    type suitable for optimization, and 1 otherwise.  */
7583
7584 static int
7585 get_tls_mask (unsigned char **tls_maskp,
7586               unsigned long *toc_symndx,
7587               bfd_vma *toc_addend,
7588               Elf_Internal_Sym **locsymsp,
7589               const Elf_Internal_Rela *rel,
7590               bfd *ibfd)
7591 {
7592   unsigned long r_symndx;
7593   int next_r;
7594   struct elf_link_hash_entry *h;
7595   Elf_Internal_Sym *sym;
7596   asection *sec;
7597   bfd_vma off;
7598
7599   r_symndx = ELF64_R_SYM (rel->r_info);
7600   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7601     return 0;
7602
7603   if ((*tls_maskp != NULL
7604        && (**tls_maskp & TLS_TLS) != 0
7605        && **tls_maskp != (TLS_TLS | TLS_MARK))
7606       || sec == NULL
7607       || ppc64_elf_section_data (sec) == NULL
7608       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7609     return 1;
7610
7611   /* Look inside a TOC section too.  */
7612   if (h != NULL)
7613     {
7614       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7615       off = h->root.u.def.value;
7616     }
7617   else
7618     off = sym->st_value;
7619   off += rel->r_addend;
7620   BFD_ASSERT (off % 8 == 0);
7621   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7622   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7623   if (toc_symndx != NULL)
7624     *toc_symndx = r_symndx;
7625   if (toc_addend != NULL)
7626     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7627   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7628     return 0;
7629   if ((h == NULL || is_static_defined (h))
7630       && (next_r == -1 || next_r == -2))
7631     return 1 - next_r;
7632   return 1;
7633 }
7634
7635 /* Find (or create) an entry in the tocsave hash table.  */
7636
7637 static struct tocsave_entry *
7638 tocsave_find (struct ppc_link_hash_table *htab,
7639               enum insert_option insert,
7640               Elf_Internal_Sym **local_syms,
7641               const Elf_Internal_Rela *irela,
7642               bfd *ibfd)
7643 {
7644   unsigned long r_indx;
7645   struct elf_link_hash_entry *h;
7646   Elf_Internal_Sym *sym;
7647   struct tocsave_entry ent, *p;
7648   hashval_t hash;
7649   struct tocsave_entry **slot;
7650
7651   r_indx = ELF64_R_SYM (irela->r_info);
7652   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7653     return NULL;
7654   if (ent.sec == NULL || ent.sec->output_section == NULL)
7655     {
7656       _bfd_error_handler
7657         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7658       return NULL;
7659     }
7660
7661   if (h != NULL)
7662     ent.offset = h->root.u.def.value;
7663   else
7664     ent.offset = sym->st_value;
7665   ent.offset += irela->r_addend;
7666
7667   hash = tocsave_htab_hash (&ent);
7668   slot = ((struct tocsave_entry **)
7669           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7670   if (slot == NULL)
7671     return NULL;
7672
7673   if (*slot == NULL)
7674     {
7675       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7676       if (p == NULL)
7677         return NULL;
7678       *p = ent;
7679       *slot = p;
7680     }
7681   return *slot;
7682 }
7683
7684 /* Adjust all global syms defined in opd sections.  In gcc generated
7685    code for the old ABI, these will already have been done.  */
7686
7687 static bfd_boolean
7688 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7689 {
7690   struct ppc_link_hash_entry *eh;
7691   asection *sym_sec;
7692   struct _opd_sec_data *opd;
7693
7694   if (h->root.type == bfd_link_hash_indirect)
7695     return TRUE;
7696
7697   if (h->root.type != bfd_link_hash_defined
7698       && h->root.type != bfd_link_hash_defweak)
7699     return TRUE;
7700
7701   eh = (struct ppc_link_hash_entry *) h;
7702   if (eh->adjust_done)
7703     return TRUE;
7704
7705   sym_sec = eh->elf.root.u.def.section;
7706   opd = get_opd_info (sym_sec);
7707   if (opd != NULL && opd->adjust != NULL)
7708     {
7709       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7710       if (adjust == -1)
7711         {
7712           /* This entry has been deleted.  */
7713           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7714           if (dsec == NULL)
7715             {
7716               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7717                 if (discarded_section (dsec))
7718                   {
7719                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7720                     break;
7721                   }
7722             }
7723           eh->elf.root.u.def.value = 0;
7724           eh->elf.root.u.def.section = dsec;
7725         }
7726       else
7727         eh->elf.root.u.def.value += adjust;
7728       eh->adjust_done = 1;
7729     }
7730   return TRUE;
7731 }
7732
7733 /* Handles decrementing dynamic reloc counts for the reloc specified by
7734    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7735    have already been determined.  */
7736
7737 static bfd_boolean
7738 dec_dynrel_count (bfd_vma r_info,
7739                   asection *sec,
7740                   struct bfd_link_info *info,
7741                   Elf_Internal_Sym **local_syms,
7742                   struct elf_link_hash_entry *h,
7743                   Elf_Internal_Sym *sym)
7744 {
7745   enum elf_ppc64_reloc_type r_type;
7746   asection *sym_sec = NULL;
7747
7748   /* Can this reloc be dynamic?  This switch, and later tests here
7749      should be kept in sync with the code in check_relocs.  */
7750   r_type = ELF64_R_TYPE (r_info);
7751   switch (r_type)
7752     {
7753     default:
7754       return TRUE;
7755
7756     case R_PPC64_TPREL16:
7757     case R_PPC64_TPREL16_LO:
7758     case R_PPC64_TPREL16_HI:
7759     case R_PPC64_TPREL16_HA:
7760     case R_PPC64_TPREL16_DS:
7761     case R_PPC64_TPREL16_LO_DS:
7762     case R_PPC64_TPREL16_HIGH:
7763     case R_PPC64_TPREL16_HIGHA:
7764     case R_PPC64_TPREL16_HIGHER:
7765     case R_PPC64_TPREL16_HIGHERA:
7766     case R_PPC64_TPREL16_HIGHEST:
7767     case R_PPC64_TPREL16_HIGHESTA:
7768     case R_PPC64_TPREL64:
7769     case R_PPC64_DTPMOD64:
7770     case R_PPC64_DTPREL64:
7771     case R_PPC64_ADDR64:
7772     case R_PPC64_REL30:
7773     case R_PPC64_REL32:
7774     case R_PPC64_REL64:
7775     case R_PPC64_ADDR14:
7776     case R_PPC64_ADDR14_BRNTAKEN:
7777     case R_PPC64_ADDR14_BRTAKEN:
7778     case R_PPC64_ADDR16:
7779     case R_PPC64_ADDR16_DS:
7780     case R_PPC64_ADDR16_HA:
7781     case R_PPC64_ADDR16_HI:
7782     case R_PPC64_ADDR16_HIGH:
7783     case R_PPC64_ADDR16_HIGHA:
7784     case R_PPC64_ADDR16_HIGHER:
7785     case R_PPC64_ADDR16_HIGHERA:
7786     case R_PPC64_ADDR16_HIGHEST:
7787     case R_PPC64_ADDR16_HIGHESTA:
7788     case R_PPC64_ADDR16_LO:
7789     case R_PPC64_ADDR16_LO_DS:
7790     case R_PPC64_ADDR24:
7791     case R_PPC64_ADDR32:
7792     case R_PPC64_UADDR16:
7793     case R_PPC64_UADDR32:
7794     case R_PPC64_UADDR64:
7795     case R_PPC64_TOC:
7796       break;
7797     }
7798
7799   if (local_syms != NULL)
7800     {
7801       unsigned long r_symndx;
7802       bfd *ibfd = sec->owner;
7803
7804       r_symndx = ELF64_R_SYM (r_info);
7805       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7806         return FALSE;
7807     }
7808
7809   if ((bfd_link_pic (info)
7810        && (must_be_dyn_reloc (info, r_type)
7811            || (h != NULL
7812                && (!SYMBOLIC_BIND (info, h)
7813                    || h->root.type == bfd_link_hash_defweak
7814                    || !h->def_regular))))
7815       || (ELIMINATE_COPY_RELOCS
7816           && !bfd_link_pic (info)
7817           && h != NULL
7818           && (h->root.type == bfd_link_hash_defweak
7819               || !h->def_regular)))
7820     ;
7821   else
7822     return TRUE;
7823
7824   if (h != NULL)
7825     {
7826       struct elf_dyn_relocs *p;
7827       struct elf_dyn_relocs **pp;
7828       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7829
7830       /* elf_gc_sweep may have already removed all dyn relocs associated
7831          with local syms for a given section.  Also, symbol flags are
7832          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7833          report a dynreloc miscount.  */
7834       if (*pp == NULL && info->gc_sections)
7835         return TRUE;
7836
7837       while ((p = *pp) != NULL)
7838         {
7839           if (p->sec == sec)
7840             {
7841               if (!must_be_dyn_reloc (info, r_type))
7842                 p->pc_count -= 1;
7843               p->count -= 1;
7844               if (p->count == 0)
7845                 *pp = p->next;
7846               return TRUE;
7847             }
7848           pp = &p->next;
7849         }
7850     }
7851   else
7852     {
7853       struct ppc_dyn_relocs *p;
7854       struct ppc_dyn_relocs **pp;
7855       void *vpp;
7856       bfd_boolean is_ifunc;
7857
7858       if (local_syms == NULL)
7859         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7860       if (sym_sec == NULL)
7861         sym_sec = sec;
7862
7863       vpp = &elf_section_data (sym_sec)->local_dynrel;
7864       pp = (struct ppc_dyn_relocs **) vpp;
7865
7866       if (*pp == NULL && info->gc_sections)
7867         return TRUE;
7868
7869       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7870       while ((p = *pp) != NULL)
7871         {
7872           if (p->sec == sec && p->ifunc == is_ifunc)
7873             {
7874               p->count -= 1;
7875               if (p->count == 0)
7876                 *pp = p->next;
7877               return TRUE;
7878             }
7879           pp = &p->next;
7880         }
7881     }
7882
7883   /* xgettext:c-format */
7884   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7885                       sec->owner, sec);
7886   bfd_set_error (bfd_error_bad_value);
7887   return FALSE;
7888 }
7889
7890 /* Remove unused Official Procedure Descriptor entries.  Currently we
7891    only remove those associated with functions in discarded link-once
7892    sections, or weakly defined functions that have been overridden.  It
7893    would be possible to remove many more entries for statically linked
7894    applications.  */
7895
7896 bfd_boolean
7897 ppc64_elf_edit_opd (struct bfd_link_info *info)
7898 {
7899   bfd *ibfd;
7900   bfd_boolean some_edited = FALSE;
7901   asection *need_pad = NULL;
7902   struct ppc_link_hash_table *htab;
7903
7904   htab = ppc_hash_table (info);
7905   if (htab == NULL)
7906     return FALSE;
7907
7908   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7909     {
7910       asection *sec;
7911       Elf_Internal_Rela *relstart, *rel, *relend;
7912       Elf_Internal_Shdr *symtab_hdr;
7913       Elf_Internal_Sym *local_syms;
7914       struct _opd_sec_data *opd;
7915       bfd_boolean need_edit, add_aux_fields, broken;
7916       bfd_size_type cnt_16b = 0;
7917
7918       if (!is_ppc64_elf (ibfd))
7919         continue;
7920
7921       sec = bfd_get_section_by_name (ibfd, ".opd");
7922       if (sec == NULL || sec->size == 0)
7923         continue;
7924
7925       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7926         continue;
7927
7928       if (sec->output_section == bfd_abs_section_ptr)
7929         continue;
7930
7931       /* Look through the section relocs.  */
7932       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7933         continue;
7934
7935       local_syms = NULL;
7936       symtab_hdr = &elf_symtab_hdr (ibfd);
7937
7938       /* Read the relocations.  */
7939       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7940                                             info->keep_memory);
7941       if (relstart == NULL)
7942         return FALSE;
7943
7944       /* First run through the relocs to check they are sane, and to
7945          determine whether we need to edit this opd section.  */
7946       need_edit = FALSE;
7947       broken = FALSE;
7948       need_pad = sec;
7949       relend = relstart + sec->reloc_count;
7950       for (rel = relstart; rel < relend; )
7951         {
7952           enum elf_ppc64_reloc_type r_type;
7953           unsigned long r_symndx;
7954           asection *sym_sec;
7955           struct elf_link_hash_entry *h;
7956           Elf_Internal_Sym *sym;
7957           bfd_vma offset;
7958
7959           /* .opd contains an array of 16 or 24 byte entries.  We're
7960              only interested in the reloc pointing to a function entry
7961              point.  */
7962           offset = rel->r_offset;
7963           if (rel + 1 == relend
7964               || rel[1].r_offset != offset + 8)
7965             {
7966               /* If someone messes with .opd alignment then after a
7967                  "ld -r" we might have padding in the middle of .opd.
7968                  Also, there's nothing to prevent someone putting
7969                  something silly in .opd with the assembler.  No .opd
7970                  optimization for them!  */
7971             broken_opd:
7972               _bfd_error_handler
7973                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7974               broken = TRUE;
7975               break;
7976             }
7977
7978           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7979               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7980             {
7981               _bfd_error_handler
7982                 /* xgettext:c-format */
7983                 (_("%pB: unexpected reloc type %u in .opd section"),
7984                  ibfd, r_type);
7985               broken = TRUE;
7986               break;
7987             }
7988
7989           r_symndx = ELF64_R_SYM (rel->r_info);
7990           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7991                           r_symndx, ibfd))
7992             goto error_ret;
7993
7994           if (sym_sec == NULL || sym_sec->owner == NULL)
7995             {
7996               const char *sym_name;
7997               if (h != NULL)
7998                 sym_name = h->root.root.string;
7999               else
8000                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8001                                              sym_sec);
8002
8003               _bfd_error_handler
8004                 /* xgettext:c-format */
8005                 (_("%pB: undefined sym `%s' in .opd section"),
8006                  ibfd, sym_name);
8007               broken = TRUE;
8008               break;
8009             }
8010
8011           /* opd entries are always for functions defined in the
8012              current input bfd.  If the symbol isn't defined in the
8013              input bfd, then we won't be using the function in this
8014              bfd;  It must be defined in a linkonce section in another
8015              bfd, or is weak.  It's also possible that we are
8016              discarding the function due to a linker script /DISCARD/,
8017              which we test for via the output_section.  */
8018           if (sym_sec->owner != ibfd
8019               || sym_sec->output_section == bfd_abs_section_ptr)
8020             need_edit = TRUE;
8021
8022           rel += 2;
8023           if (rel + 1 == relend
8024               || (rel + 2 < relend
8025                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8026             ++rel;
8027
8028           if (rel == relend)
8029             {
8030               if (sec->size == offset + 24)
8031                 {
8032                   need_pad = NULL;
8033                   break;
8034                 }
8035               if (sec->size == offset + 16)
8036                 {
8037                   cnt_16b++;
8038                   break;
8039                 }
8040               goto broken_opd;
8041             }
8042           else if (rel + 1 < relend
8043                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8044                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8045             {
8046               if (rel[0].r_offset == offset + 16)
8047                 cnt_16b++;
8048               else if (rel[0].r_offset != offset + 24)
8049                 goto broken_opd;
8050             }
8051           else
8052             goto broken_opd;
8053         }
8054
8055       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8056
8057       if (!broken && (need_edit || add_aux_fields))
8058         {
8059           Elf_Internal_Rela *write_rel;
8060           Elf_Internal_Shdr *rel_hdr;
8061           bfd_byte *rptr, *wptr;
8062           bfd_byte *new_contents;
8063           bfd_size_type amt;
8064
8065           new_contents = NULL;
8066           amt = OPD_NDX (sec->size) * sizeof (long);
8067           opd = &ppc64_elf_section_data (sec)->u.opd;
8068           opd->adjust = bfd_zalloc (sec->owner, amt);
8069           if (opd->adjust == NULL)
8070             return FALSE;
8071
8072           /* This seems a waste of time as input .opd sections are all
8073              zeros as generated by gcc, but I suppose there's no reason
8074              this will always be so.  We might start putting something in
8075              the third word of .opd entries.  */
8076           if ((sec->flags & SEC_IN_MEMORY) == 0)
8077             {
8078               bfd_byte *loc;
8079               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8080                 {
8081                   if (loc != NULL)
8082                     free (loc);
8083                 error_ret:
8084                   if (local_syms != NULL
8085                       && symtab_hdr->contents != (unsigned char *) local_syms)
8086                     free (local_syms);
8087                   if (elf_section_data (sec)->relocs != relstart)
8088                     free (relstart);
8089                   return FALSE;
8090                 }
8091               sec->contents = loc;
8092               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8093             }
8094
8095           elf_section_data (sec)->relocs = relstart;
8096
8097           new_contents = sec->contents;
8098           if (add_aux_fields)
8099             {
8100               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8101               if (new_contents == NULL)
8102                 return FALSE;
8103               need_pad = NULL;
8104             }
8105           wptr = new_contents;
8106           rptr = sec->contents;
8107           write_rel = relstart;
8108           for (rel = relstart; rel < relend; )
8109             {
8110               unsigned long r_symndx;
8111               asection *sym_sec;
8112               struct elf_link_hash_entry *h;
8113               struct ppc_link_hash_entry *fdh = NULL;
8114               Elf_Internal_Sym *sym;
8115               long opd_ent_size;
8116               Elf_Internal_Rela *next_rel;
8117               bfd_boolean skip;
8118
8119               r_symndx = ELF64_R_SYM (rel->r_info);
8120               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8121                               r_symndx, ibfd))
8122                 goto error_ret;
8123
8124               next_rel = rel + 2;
8125               if (next_rel + 1 == relend
8126                   || (next_rel + 2 < relend
8127                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8128                 ++next_rel;
8129
8130               /* See if the .opd entry is full 24 byte or
8131                  16 byte (with fd_aux entry overlapped with next
8132                  fd_func).  */
8133               opd_ent_size = 24;
8134               if (next_rel == relend)
8135                 {
8136                   if (sec->size == rel->r_offset + 16)
8137                     opd_ent_size = 16;
8138                 }
8139               else if (next_rel->r_offset == rel->r_offset + 16)
8140                 opd_ent_size = 16;
8141
8142               if (h != NULL
8143                   && h->root.root.string[0] == '.')
8144                 {
8145                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8146                   if (fdh != NULL)
8147                     {
8148                       fdh = ppc_follow_link (fdh);
8149                       if (fdh->elf.root.type != bfd_link_hash_defined
8150                           && fdh->elf.root.type != bfd_link_hash_defweak)
8151                         fdh = NULL;
8152                     }
8153                 }
8154
8155               skip = (sym_sec->owner != ibfd
8156                       || sym_sec->output_section == bfd_abs_section_ptr);
8157               if (skip)
8158                 {
8159                   if (fdh != NULL && sym_sec->owner == ibfd)
8160                     {
8161                       /* Arrange for the function descriptor sym
8162                          to be dropped.  */
8163                       fdh->elf.root.u.def.value = 0;
8164                       fdh->elf.root.u.def.section = sym_sec;
8165                     }
8166                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8167
8168                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8169                     rel = next_rel;
8170                   else
8171                     while (1)
8172                       {
8173                         if (!dec_dynrel_count (rel->r_info, sec, info,
8174                                                NULL, h, sym))
8175                           goto error_ret;
8176
8177                         if (++rel == next_rel)
8178                           break;
8179
8180                         r_symndx = ELF64_R_SYM (rel->r_info);
8181                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8182                                         r_symndx, ibfd))
8183                           goto error_ret;
8184                       }
8185                 }
8186               else
8187                 {
8188                   /* We'll be keeping this opd entry.  */
8189                   long adjust;
8190
8191                   if (fdh != NULL)
8192                     {
8193                       /* Redefine the function descriptor symbol to
8194                          this location in the opd section.  It is
8195                          necessary to update the value here rather
8196                          than using an array of adjustments as we do
8197                          for local symbols, because various places
8198                          in the generic ELF code use the value
8199                          stored in u.def.value.  */
8200                       fdh->elf.root.u.def.value = wptr - new_contents;
8201                       fdh->adjust_done = 1;
8202                     }
8203
8204                   /* Local syms are a bit tricky.  We could
8205                      tweak them as they can be cached, but
8206                      we'd need to look through the local syms
8207                      for the function descriptor sym which we
8208                      don't have at the moment.  So keep an
8209                      array of adjustments.  */
8210                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8211                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8212
8213                   if (wptr != rptr)
8214                     memcpy (wptr, rptr, opd_ent_size);
8215                   wptr += opd_ent_size;
8216                   if (add_aux_fields && opd_ent_size == 16)
8217                     {
8218                       memset (wptr, '\0', 8);
8219                       wptr += 8;
8220                     }
8221
8222                   /* We need to adjust any reloc offsets to point to the
8223                      new opd entries.  */
8224                   for ( ; rel != next_rel; ++rel)
8225                     {
8226                       rel->r_offset += adjust;
8227                       if (write_rel != rel)
8228                         memcpy (write_rel, rel, sizeof (*rel));
8229                       ++write_rel;
8230                     }
8231                 }
8232
8233               rptr += opd_ent_size;
8234             }
8235
8236           sec->size = wptr - new_contents;
8237           sec->reloc_count = write_rel - relstart;
8238           if (add_aux_fields)
8239             {
8240               free (sec->contents);
8241               sec->contents = new_contents;
8242             }
8243
8244           /* Fudge the header size too, as this is used later in
8245              elf_bfd_final_link if we are emitting relocs.  */
8246           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8247           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8248           some_edited = TRUE;
8249         }
8250       else if (elf_section_data (sec)->relocs != relstart)
8251         free (relstart);
8252
8253       if (local_syms != NULL
8254           && symtab_hdr->contents != (unsigned char *) local_syms)
8255         {
8256           if (!info->keep_memory)
8257             free (local_syms);
8258           else
8259             symtab_hdr->contents = (unsigned char *) local_syms;
8260         }
8261     }
8262
8263   if (some_edited)
8264     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8265
8266   /* If we are doing a final link and the last .opd entry is just 16 byte
8267      long, add a 8 byte padding after it.  */
8268   if (need_pad != NULL && !bfd_link_relocatable (info))
8269     {
8270       bfd_byte *p;
8271
8272       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8273         {
8274           BFD_ASSERT (need_pad->size > 0);
8275
8276           p = bfd_malloc (need_pad->size + 8);
8277           if (p == NULL)
8278             return FALSE;
8279
8280           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8281                                           p, 0, need_pad->size))
8282             return FALSE;
8283
8284           need_pad->contents = p;
8285           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8286         }
8287       else
8288         {
8289           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8290           if (p == NULL)
8291             return FALSE;
8292
8293           need_pad->contents = p;
8294         }
8295
8296       memset (need_pad->contents + need_pad->size, 0, 8);
8297       need_pad->size += 8;
8298     }
8299
8300   return TRUE;
8301 }
8302
8303 /* Analyze inline PLT call relocations to see whether calls to locally
8304    defined functions can be converted to direct calls.  */
8305
8306 bfd_boolean
8307 ppc64_elf_inline_plt (struct bfd_link_info *info)
8308 {
8309   struct ppc_link_hash_table *htab;
8310   bfd *ibfd;
8311   asection *sec;
8312   bfd_vma low_vma, high_vma, limit;
8313
8314   htab = ppc_hash_table (info);
8315   if (htab == NULL)
8316     return FALSE;
8317
8318   /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
8319      reduced somewhat to cater for possible stubs that might be added
8320      between the call and its destination.  */
8321   if (htab->params->group_size < 0)
8322     {
8323       limit = -htab->params->group_size;
8324       if (limit == 1)
8325         limit = 0x1e00000;
8326     }
8327   else
8328     {
8329       limit = htab->params->group_size;
8330       if (limit == 1)
8331         limit = 0x1c00000;
8332     }
8333
8334   low_vma = -1;
8335   high_vma = 0;
8336   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8337     if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8338       {
8339         if (low_vma > sec->vma)
8340           low_vma = sec->vma;
8341         if (high_vma < sec->vma + sec->size)
8342           high_vma = sec->vma + sec->size;
8343       }
8344
8345   /* If a "bl" can reach anywhere in local code sections, then we can
8346      convert all inline PLT sequences to direct calls when the symbol
8347      is local.  */
8348   if (high_vma - low_vma < limit)
8349     {
8350       htab->can_convert_all_inline_plt = 1;
8351       return TRUE;
8352     }
8353
8354   /* Otherwise, go looking through relocs for cases where a direct
8355      call won't reach.  Mark the symbol on any such reloc to disable
8356      the optimization and keep the PLT entry as it seems likely that
8357      this will be better than creating trampolines.  Note that this
8358      will disable the optimization for all inline PLT calls to a
8359      particular symbol, not just those that won't reach.  The
8360      difficulty in doing a more precise optimization is that the
8361      linker needs to make a decision depending on whether a
8362      particular R_PPC64_PLTCALL insn can be turned into a direct
8363      call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8364      the sequence, and there is nothing that ties those relocs
8365      together except their symbol.  */
8366
8367   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8368     {
8369       Elf_Internal_Shdr *symtab_hdr;
8370       Elf_Internal_Sym *local_syms;
8371
8372       if (!is_ppc64_elf (ibfd))
8373         continue;
8374
8375       local_syms = NULL;
8376       symtab_hdr = &elf_symtab_hdr (ibfd);
8377
8378       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8379         if (ppc64_elf_section_data (sec)->has_pltcall
8380             && !bfd_is_abs_section (sec->output_section))
8381           {
8382             Elf_Internal_Rela *relstart, *rel, *relend;
8383
8384             /* Read the relocations.  */
8385             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8386                                                   info->keep_memory);
8387             if (relstart == NULL)
8388               return FALSE;
8389
8390             relend = relstart + sec->reloc_count;
8391             for (rel = relstart; rel < relend; )
8392               {
8393                 enum elf_ppc64_reloc_type r_type;
8394                 unsigned long r_symndx;
8395                 asection *sym_sec;
8396                 struct elf_link_hash_entry *h;
8397                 Elf_Internal_Sym *sym;
8398                 unsigned char *tls_maskp;
8399
8400                 r_type = ELF64_R_TYPE (rel->r_info);
8401                 if (r_type != R_PPC64_PLTCALL)
8402                   continue;
8403
8404                 r_symndx = ELF64_R_SYM (rel->r_info);
8405                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8406                                 r_symndx, ibfd))
8407                   {
8408                     if (elf_section_data (sec)->relocs != relstart)
8409                       free (relstart);
8410                     if (local_syms != NULL
8411                         && symtab_hdr->contents != (unsigned char *) local_syms)
8412                       free (local_syms);
8413                     return FALSE;
8414                   }
8415
8416                 if (sym_sec != NULL && sym_sec->output_section != NULL)
8417                   {
8418                     bfd_vma from, to;
8419                     if (h != NULL)
8420                       to = h->root.u.def.value;
8421                     else
8422                       to = sym->st_value;
8423                     to += (rel->r_addend
8424                            + sym_sec->output_offset
8425                            + sym_sec->output_section->vma);
8426                     from = (rel->r_offset
8427                             + sec->output_offset
8428                             + sec->output_section->vma);
8429                     if (to - from + limit < 2 * limit)
8430                       *tls_maskp &= ~PLT_KEEP;
8431                   }
8432               }
8433             if (elf_section_data (sec)->relocs != relstart)
8434               free (relstart);
8435           }
8436
8437       if (local_syms != NULL
8438           && symtab_hdr->contents != (unsigned char *) local_syms)
8439         {
8440           if (!info->keep_memory)
8441             free (local_syms);
8442           else
8443             symtab_hdr->contents = (unsigned char *) local_syms;
8444         }
8445     }
8446
8447   return TRUE;
8448 }
8449
8450 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8451
8452 asection *
8453 ppc64_elf_tls_setup (struct bfd_link_info *info)
8454 {
8455   struct ppc_link_hash_table *htab;
8456
8457   htab = ppc_hash_table (info);
8458   if (htab == NULL)
8459     return NULL;
8460
8461   if (abiversion (info->output_bfd) == 1)
8462     htab->opd_abi = 1;
8463
8464   if (htab->params->no_multi_toc)
8465     htab->do_multi_toc = 0;
8466   else if (!htab->do_multi_toc)
8467     htab->params->no_multi_toc = 1;
8468
8469   /* Default to --no-plt-localentry, as this option can cause problems
8470      with symbol interposition.  For example, glibc libpthread.so and
8471      libc.so duplicate many pthread symbols, with a fallback
8472      implementation in libc.so.  In some cases the fallback does more
8473      work than the pthread implementation.  __pthread_condattr_destroy
8474      is one such symbol: the libpthread.so implementation is
8475      localentry:0 while the libc.so implementation is localentry:8.
8476      An app that "cleverly" uses dlopen to only load necessary
8477      libraries at runtime may omit loading libpthread.so when not
8478      running multi-threaded, which then results in the libc.so
8479      fallback symbols being used and ld.so complaining.  Now there
8480      are workarounds in ld (see non_zero_localentry) to detect the
8481      pthread situation, but that may not be the only case where
8482      --plt-localentry can cause trouble.  */
8483   if (htab->params->plt_localentry0 < 0)
8484     htab->params->plt_localentry0 = 0;
8485   if (htab->params->plt_localentry0
8486       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8487                                FALSE, FALSE, FALSE) == NULL)
8488     _bfd_error_handler
8489       (_("warning: --plt-localentry is especially dangerous without "
8490          "ld.so support to detect ABI violations"));
8491
8492   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8493                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8494                                               FALSE, FALSE, TRUE));
8495   /* Move dynamic linking info to the function descriptor sym.  */
8496   if (htab->tls_get_addr != NULL)
8497     func_desc_adjust (&htab->tls_get_addr->elf, info);
8498   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8499                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8500                                                  FALSE, FALSE, TRUE));
8501   if (htab->params->tls_get_addr_opt)
8502     {
8503       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8504
8505       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8506                                   FALSE, FALSE, TRUE);
8507       if (opt != NULL)
8508         func_desc_adjust (opt, info);
8509       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8510                                      FALSE, FALSE, TRUE);
8511       if (opt_fd != NULL
8512           && (opt_fd->root.type == bfd_link_hash_defined
8513               || opt_fd->root.type == bfd_link_hash_defweak))
8514         {
8515           /* If glibc supports an optimized __tls_get_addr call stub,
8516              signalled by the presence of __tls_get_addr_opt, and we'll
8517              be calling __tls_get_addr via a plt call stub, then
8518              make __tls_get_addr point to __tls_get_addr_opt.  */
8519           tga_fd = &htab->tls_get_addr_fd->elf;
8520           if (htab->elf.dynamic_sections_created
8521               && tga_fd != NULL
8522               && (tga_fd->type == STT_FUNC
8523                   || tga_fd->needs_plt)
8524               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8525                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8526             {
8527               struct plt_entry *ent;
8528
8529               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8530                 if (ent->plt.refcount > 0)
8531                   break;
8532               if (ent != NULL)
8533                 {
8534                   tga_fd->root.type = bfd_link_hash_indirect;
8535                   tga_fd->root.u.i.link = &opt_fd->root;
8536                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8537                   opt_fd->mark = 1;
8538                   if (opt_fd->dynindx != -1)
8539                     {
8540                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8541                       opt_fd->dynindx = -1;
8542                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8543                                               opt_fd->dynstr_index);
8544                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8545                         return NULL;
8546                     }
8547                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8548                   tga = &htab->tls_get_addr->elf;
8549                   if (opt != NULL && tga != NULL)
8550                     {
8551                       tga->root.type = bfd_link_hash_indirect;
8552                       tga->root.u.i.link = &opt->root;
8553                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8554                       opt->mark = 1;
8555                       _bfd_elf_link_hash_hide_symbol (info, opt,
8556                                                       tga->forced_local);
8557                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8558                     }
8559                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8560                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8561                   if (htab->tls_get_addr != NULL)
8562                     {
8563                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8564                       htab->tls_get_addr->is_func = 1;
8565                     }
8566                 }
8567             }
8568         }
8569       else if (htab->params->tls_get_addr_opt < 0)
8570         htab->params->tls_get_addr_opt = 0;
8571     }
8572   return _bfd_elf_tls_setup (info->output_bfd, info);
8573 }
8574
8575 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8576    HASH1 or HASH2.  */
8577
8578 static bfd_boolean
8579 branch_reloc_hash_match (const bfd *ibfd,
8580                          const Elf_Internal_Rela *rel,
8581                          const struct ppc_link_hash_entry *hash1,
8582                          const struct ppc_link_hash_entry *hash2)
8583 {
8584   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8585   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8586   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8587
8588   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8589     {
8590       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8591       struct elf_link_hash_entry *h;
8592
8593       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8594       h = elf_follow_link (h);
8595       if (h == &hash1->elf || h == &hash2->elf)
8596         return TRUE;
8597     }
8598   return FALSE;
8599 }
8600
8601 /* Run through all the TLS relocs looking for optimization
8602    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8603    a preliminary section layout so that we know the TLS segment
8604    offsets.  We can't optimize earlier because some optimizations need
8605    to know the tp offset, and we need to optimize before allocating
8606    dynamic relocations.  */
8607
8608 bfd_boolean
8609 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8610 {
8611   bfd *ibfd;
8612   asection *sec;
8613   struct ppc_link_hash_table *htab;
8614   unsigned char *toc_ref;
8615   int pass;
8616
8617   if (!bfd_link_executable (info))
8618     return TRUE;
8619
8620   htab = ppc_hash_table (info);
8621   if (htab == NULL)
8622     return FALSE;
8623
8624   /* Make two passes over the relocs.  On the first pass, mark toc
8625      entries involved with tls relocs, and check that tls relocs
8626      involved in setting up a tls_get_addr call are indeed followed by
8627      such a call.  If they are not, we can't do any tls optimization.
8628      On the second pass twiddle tls_mask flags to notify
8629      relocate_section that optimization can be done, and adjust got
8630      and plt refcounts.  */
8631   toc_ref = NULL;
8632   for (pass = 0; pass < 2; ++pass)
8633     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8634       {
8635         Elf_Internal_Sym *locsyms = NULL;
8636         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8637
8638         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8639           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8640             {
8641               Elf_Internal_Rela *relstart, *rel, *relend;
8642               bfd_boolean found_tls_get_addr_arg = 0;
8643
8644               /* Read the relocations.  */
8645               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8646                                                     info->keep_memory);
8647               if (relstart == NULL)
8648                 {
8649                   free (toc_ref);
8650                   return FALSE;
8651                 }
8652
8653               relend = relstart + sec->reloc_count;
8654               for (rel = relstart; rel < relend; rel++)
8655                 {
8656                   enum elf_ppc64_reloc_type r_type;
8657                   unsigned long r_symndx;
8658                   struct elf_link_hash_entry *h;
8659                   Elf_Internal_Sym *sym;
8660                   asection *sym_sec;
8661                   unsigned char *tls_mask;
8662                   unsigned char tls_set, tls_clear, tls_type = 0;
8663                   bfd_vma value;
8664                   bfd_boolean ok_tprel, is_local;
8665                   long toc_ref_index = 0;
8666                   int expecting_tls_get_addr = 0;
8667                   bfd_boolean ret = FALSE;
8668
8669                   r_symndx = ELF64_R_SYM (rel->r_info);
8670                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8671                                   r_symndx, ibfd))
8672                     {
8673                     err_free_rel:
8674                       if (elf_section_data (sec)->relocs != relstart)
8675                         free (relstart);
8676                       if (toc_ref != NULL)
8677                         free (toc_ref);
8678                       if (locsyms != NULL
8679                           && (elf_symtab_hdr (ibfd).contents
8680                               != (unsigned char *) locsyms))
8681                         free (locsyms);
8682                       return ret;
8683                     }
8684
8685                   if (h != NULL)
8686                     {
8687                       if (h->root.type == bfd_link_hash_defined
8688                           || h->root.type == bfd_link_hash_defweak)
8689                         value = h->root.u.def.value;
8690                       else if (h->root.type == bfd_link_hash_undefweak)
8691                         value = 0;
8692                       else
8693                         {
8694                           found_tls_get_addr_arg = 0;
8695                           continue;
8696                         }
8697                     }
8698                   else
8699                     /* Symbols referenced by TLS relocs must be of type
8700                        STT_TLS.  So no need for .opd local sym adjust.  */
8701                     value = sym->st_value;
8702
8703                   ok_tprel = FALSE;
8704                   is_local = FALSE;
8705                   if (h == NULL
8706                       || !h->def_dynamic)
8707                     {
8708                       is_local = TRUE;
8709                       if (h != NULL
8710                           && h->root.type == bfd_link_hash_undefweak)
8711                         ok_tprel = TRUE;
8712                       else if (sym_sec != NULL
8713                                && sym_sec->output_section != NULL)
8714                         {
8715                           value += sym_sec->output_offset;
8716                           value += sym_sec->output_section->vma;
8717                           value -= htab->elf.tls_sec->vma;
8718                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8719                                       < (bfd_vma) 1 << 32);
8720                         }
8721                     }
8722
8723                   r_type = ELF64_R_TYPE (rel->r_info);
8724                   /* If this section has old-style __tls_get_addr calls
8725                      without marker relocs, then check that each
8726                      __tls_get_addr call reloc is preceded by a reloc
8727                      that conceivably belongs to the __tls_get_addr arg
8728                      setup insn.  If we don't find matching arg setup
8729                      relocs, don't do any tls optimization.  */
8730                   if (pass == 0
8731                       && sec->has_tls_get_addr_call
8732                       && h != NULL
8733                       && (h == &htab->tls_get_addr->elf
8734                           || h == &htab->tls_get_addr_fd->elf)
8735                       && !found_tls_get_addr_arg
8736                       && is_branch_reloc (r_type))
8737                     {
8738                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8739                                                 "TLS optimization disabled\n"),
8740                                               ibfd, sec, rel->r_offset);
8741                       ret = TRUE;
8742                       goto err_free_rel;
8743                     }
8744
8745                   found_tls_get_addr_arg = 0;
8746                   switch (r_type)
8747                     {
8748                     case R_PPC64_GOT_TLSLD16:
8749                     case R_PPC64_GOT_TLSLD16_LO:
8750                       expecting_tls_get_addr = 1;
8751                       found_tls_get_addr_arg = 1;
8752                       /* Fall through.  */
8753
8754                     case R_PPC64_GOT_TLSLD16_HI:
8755                     case R_PPC64_GOT_TLSLD16_HA:
8756                       /* These relocs should never be against a symbol
8757                          defined in a shared lib.  Leave them alone if
8758                          that turns out to be the case.  */
8759                       if (!is_local)
8760                         continue;
8761
8762                       /* LD -> LE */
8763                       tls_set = 0;
8764                       tls_clear = TLS_LD;
8765                       tls_type = TLS_TLS | TLS_LD;
8766                       break;
8767
8768                     case R_PPC64_GOT_TLSGD16:
8769                     case R_PPC64_GOT_TLSGD16_LO:
8770                       expecting_tls_get_addr = 1;
8771                       found_tls_get_addr_arg = 1;
8772                       /* Fall through. */
8773
8774                     case R_PPC64_GOT_TLSGD16_HI:
8775                     case R_PPC64_GOT_TLSGD16_HA:
8776                       if (ok_tprel)
8777                         /* GD -> LE */
8778                         tls_set = 0;
8779                       else
8780                         /* GD -> IE */
8781                         tls_set = TLS_TLS | TLS_TPRELGD;
8782                       tls_clear = TLS_GD;
8783                       tls_type = TLS_TLS | TLS_GD;
8784                       break;
8785
8786                     case R_PPC64_GOT_TPREL16_DS:
8787                     case R_PPC64_GOT_TPREL16_LO_DS:
8788                     case R_PPC64_GOT_TPREL16_HI:
8789                     case R_PPC64_GOT_TPREL16_HA:
8790                       if (ok_tprel)
8791                         {
8792                           /* IE -> LE */
8793                           tls_set = 0;
8794                           tls_clear = TLS_TPREL;
8795                           tls_type = TLS_TLS | TLS_TPREL;
8796                           break;
8797                         }
8798                       continue;
8799
8800                     case R_PPC64_TLSGD:
8801                     case R_PPC64_TLSLD:
8802                       if (rel + 1 < relend
8803                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8804                         {
8805                           if (pass != 0
8806                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8807                             {
8808                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8809                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8810                                   r_symndx, ibfd))
8811                                 goto err_free_rel;
8812                               if (h != NULL)
8813                                 {
8814                                   struct plt_entry *ent = NULL;
8815
8816                                   for (ent = h->plt.plist;
8817                                        ent != NULL;
8818                                        ent = ent->next)
8819                                     if (ent->addend == rel[1].r_addend)
8820                                       break;
8821
8822                                   if (ent != NULL
8823                                       && ent->plt.refcount > 0)
8824                                     ent->plt.refcount -= 1;
8825                                 }
8826                             }
8827                           continue;
8828                         }
8829                       found_tls_get_addr_arg = 1;
8830                       /* Fall through.  */
8831
8832                     case R_PPC64_TLS:
8833                     case R_PPC64_TOC16:
8834                     case R_PPC64_TOC16_LO:
8835                       if (sym_sec == NULL || sym_sec != toc)
8836                         continue;
8837
8838                       /* Mark this toc entry as referenced by a TLS
8839                          code sequence.  We can do that now in the
8840                          case of R_PPC64_TLS, and after checking for
8841                          tls_get_addr for the TOC16 relocs.  */
8842                       if (toc_ref == NULL)
8843                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8844                       if (toc_ref == NULL)
8845                         goto err_free_rel;
8846
8847                       if (h != NULL)
8848                         value = h->root.u.def.value;
8849                       else
8850                         value = sym->st_value;
8851                       value += rel->r_addend;
8852                       if (value % 8 != 0)
8853                         continue;
8854                       BFD_ASSERT (value < toc->size
8855                                   && toc->output_offset % 8 == 0);
8856                       toc_ref_index = (value + toc->output_offset) / 8;
8857                       if (r_type == R_PPC64_TLS
8858                           || r_type == R_PPC64_TLSGD
8859                           || r_type == R_PPC64_TLSLD)
8860                         {
8861                           toc_ref[toc_ref_index] = 1;
8862                           continue;
8863                         }
8864
8865                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8866                         continue;
8867
8868                       tls_set = 0;
8869                       tls_clear = 0;
8870                       expecting_tls_get_addr = 2;
8871                       break;
8872
8873                     case R_PPC64_TPREL64:
8874                       if (pass == 0
8875                           || sec != toc
8876                           || toc_ref == NULL
8877                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8878                         continue;
8879                       if (ok_tprel)
8880                         {
8881                           /* IE -> LE */
8882                           tls_set = TLS_EXPLICIT;
8883                           tls_clear = TLS_TPREL;
8884                           break;
8885                         }
8886                       continue;
8887
8888                     case R_PPC64_DTPMOD64:
8889                       if (pass == 0
8890                           || sec != toc
8891                           || toc_ref == NULL
8892                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8893                         continue;
8894                       if (rel + 1 < relend
8895                           && (rel[1].r_info
8896                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8897                           && rel[1].r_offset == rel->r_offset + 8)
8898                         {
8899                           if (ok_tprel)
8900                             /* GD -> LE */
8901                             tls_set = TLS_EXPLICIT | TLS_GD;
8902                           else
8903                             /* GD -> IE */
8904                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8905                           tls_clear = TLS_GD;
8906                         }
8907                       else
8908                         {
8909                           if (!is_local)
8910                             continue;
8911
8912                           /* LD -> LE */
8913                           tls_set = TLS_EXPLICIT;
8914                           tls_clear = TLS_LD;
8915                         }
8916                       break;
8917
8918                     default:
8919                       continue;
8920                     }
8921
8922                   if (pass == 0)
8923                     {
8924                       if (!expecting_tls_get_addr
8925                           || !sec->has_tls_get_addr_call)
8926                         continue;
8927
8928                       if (rel + 1 < relend
8929                           && branch_reloc_hash_match (ibfd, rel + 1,
8930                                                       htab->tls_get_addr,
8931                                                       htab->tls_get_addr_fd))
8932                         {
8933                           if (expecting_tls_get_addr == 2)
8934                             {
8935                               /* Check for toc tls entries.  */
8936                               unsigned char *toc_tls;
8937                               int retval;
8938
8939                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8940                                                      &locsyms,
8941                                                      rel, ibfd);
8942                               if (retval == 0)
8943                                 goto err_free_rel;
8944                               if (toc_tls != NULL)
8945                                 {
8946                                   if ((*toc_tls & TLS_TLS) != 0
8947                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8948                                     found_tls_get_addr_arg = 1;
8949                                   if (retval > 1)
8950                                     toc_ref[toc_ref_index] = 1;
8951                                 }
8952                             }
8953                           continue;
8954                         }
8955
8956                       /* Uh oh, we didn't find the expected call.  We
8957                          could just mark this symbol to exclude it
8958                          from tls optimization but it's safer to skip
8959                          the entire optimization.  */
8960                       /* xgettext:c-format */
8961                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8962                                                 "TLS optimization disabled\n"),
8963                                               ibfd, sec, rel->r_offset);
8964                       ret = TRUE;
8965                       goto err_free_rel;
8966                     }
8967
8968                   /* If we don't have old-style __tls_get_addr calls
8969                      without TLSGD/TLSLD marker relocs, and we haven't
8970                      found a new-style __tls_get_addr call with a
8971                      marker for this symbol, then we either have a
8972                      broken object file or an -mlongcall style
8973                      indirect call to __tls_get_addr without a marker.
8974                      Disable optimization in this case.  */
8975                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8976                       && (tls_set & TLS_EXPLICIT) == 0
8977                       && !sec->has_tls_get_addr_call
8978                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8979                           != (TLS_TLS | TLS_MARK)))
8980                     continue;
8981
8982                   if (expecting_tls_get_addr)
8983                     {
8984                       struct plt_entry *ent = NULL;
8985
8986                       if (htab->tls_get_addr != NULL)
8987                         for (ent = htab->tls_get_addr->elf.plt.plist;
8988                              ent != NULL;
8989                              ent = ent->next)
8990                           if (ent->addend == 0)
8991                             break;
8992
8993                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
8994                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8995                              ent != NULL;
8996                              ent = ent->next)
8997                           if (ent->addend == 0)
8998                             break;
8999
9000                       if (ent != NULL
9001                           && ent->plt.refcount > 0)
9002                         ent->plt.refcount -= 1;
9003                     }
9004
9005                   if (tls_clear == 0)
9006                     continue;
9007
9008                   if ((tls_set & TLS_EXPLICIT) == 0)
9009                     {
9010                       struct got_entry *ent;
9011
9012                       /* Adjust got entry for this reloc.  */
9013                       if (h != NULL)
9014                         ent = h->got.glist;
9015                       else
9016                         ent = elf_local_got_ents (ibfd)[r_symndx];
9017
9018                       for (; ent != NULL; ent = ent->next)
9019                         if (ent->addend == rel->r_addend
9020                             && ent->owner == ibfd
9021                             && ent->tls_type == tls_type)
9022                           break;
9023                       if (ent == NULL)
9024                         abort ();
9025
9026                       if (tls_set == 0)
9027                         {
9028                           /* We managed to get rid of a got entry.  */
9029                           if (ent->got.refcount > 0)
9030                             ent->got.refcount -= 1;
9031                         }
9032                     }
9033                   else
9034                     {
9035                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
9036                          we'll lose one or two dyn relocs.  */
9037                       if (!dec_dynrel_count (rel->r_info, sec, info,
9038                                              NULL, h, sym))
9039                         return FALSE;
9040
9041                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
9042                         {
9043                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9044                                                  NULL, h, sym))
9045                             return FALSE;
9046                         }
9047                     }
9048
9049                   *tls_mask |= tls_set;
9050                   *tls_mask &= ~tls_clear;
9051                 }
9052
9053               if (elf_section_data (sec)->relocs != relstart)
9054                 free (relstart);
9055             }
9056
9057         if (locsyms != NULL
9058             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9059           {
9060             if (!info->keep_memory)
9061               free (locsyms);
9062             else
9063               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9064           }
9065       }
9066
9067   if (toc_ref != NULL)
9068     free (toc_ref);
9069   htab->do_tls_opt = 1;
9070   return TRUE;
9071 }
9072
9073 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9074    the values of any global symbols in a toc section that has been
9075    edited.  Globals in toc sections should be a rarity, so this function
9076    sets a flag if any are found in toc sections other than the one just
9077    edited, so that further hash table traversals can be avoided.  */
9078
9079 struct adjust_toc_info
9080 {
9081   asection *toc;
9082   unsigned long *skip;
9083   bfd_boolean global_toc_syms;
9084 };
9085
9086 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9087
9088 static bfd_boolean
9089 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9090 {
9091   struct ppc_link_hash_entry *eh;
9092   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9093   unsigned long i;
9094
9095   if (h->root.type != bfd_link_hash_defined
9096       && h->root.type != bfd_link_hash_defweak)
9097     return TRUE;
9098
9099   eh = (struct ppc_link_hash_entry *) h;
9100   if (eh->adjust_done)
9101     return TRUE;
9102
9103   if (eh->elf.root.u.def.section == toc_inf->toc)
9104     {
9105       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9106         i = toc_inf->toc->rawsize >> 3;
9107       else
9108         i = eh->elf.root.u.def.value >> 3;
9109
9110       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9111         {
9112           _bfd_error_handler
9113             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9114           do
9115             ++i;
9116           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9117           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9118         }
9119
9120       eh->elf.root.u.def.value -= toc_inf->skip[i];
9121       eh->adjust_done = 1;
9122     }
9123   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9124     toc_inf->global_toc_syms = TRUE;
9125
9126   return TRUE;
9127 }
9128
9129 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9130    on a _LO variety toc/got reloc.  */
9131
9132 static bfd_boolean
9133 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9134 {
9135   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9136           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9137           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9138           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9139           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9140           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9141           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9142           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9143           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9144           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9145           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9146           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9147           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9148           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9149           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9150           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9151           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9152               /* Exclude lfqu by testing reloc.  If relocs are ever
9153                  defined for the reduced D field in psq_lu then those
9154                  will need testing too.  */
9155               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9156           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9157               && (insn & 1) == 0)
9158           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9159           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9160               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9161               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9162           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9163               && (insn & 1) == 0));
9164 }
9165
9166 /* Examine all relocs referencing .toc sections in order to remove
9167    unused .toc entries.  */
9168
9169 bfd_boolean
9170 ppc64_elf_edit_toc (struct bfd_link_info *info)
9171 {
9172   bfd *ibfd;
9173   struct adjust_toc_info toc_inf;
9174   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9175
9176   htab->do_toc_opt = 1;
9177   toc_inf.global_toc_syms = TRUE;
9178   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9179     {
9180       asection *toc, *sec;
9181       Elf_Internal_Shdr *symtab_hdr;
9182       Elf_Internal_Sym *local_syms;
9183       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9184       unsigned long *skip, *drop;
9185       unsigned char *used;
9186       unsigned char *keep, last, some_unused;
9187
9188       if (!is_ppc64_elf (ibfd))
9189         continue;
9190
9191       toc = bfd_get_section_by_name (ibfd, ".toc");
9192       if (toc == NULL
9193           || toc->size == 0
9194           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9195           || discarded_section (toc))
9196         continue;
9197
9198       toc_relocs = NULL;
9199       local_syms = NULL;
9200       symtab_hdr = &elf_symtab_hdr (ibfd);
9201
9202       /* Look at sections dropped from the final link.  */
9203       skip = NULL;
9204       relstart = NULL;
9205       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9206         {
9207           if (sec->reloc_count == 0
9208               || !discarded_section (sec)
9209               || get_opd_info (sec)
9210               || (sec->flags & SEC_ALLOC) == 0
9211               || (sec->flags & SEC_DEBUGGING) != 0)
9212             continue;
9213
9214           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9215           if (relstart == NULL)
9216             goto error_ret;
9217
9218           /* Run through the relocs to see which toc entries might be
9219              unused.  */
9220           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9221             {
9222               enum elf_ppc64_reloc_type r_type;
9223               unsigned long r_symndx;
9224               asection *sym_sec;
9225               struct elf_link_hash_entry *h;
9226               Elf_Internal_Sym *sym;
9227               bfd_vma val;
9228
9229               r_type = ELF64_R_TYPE (rel->r_info);
9230               switch (r_type)
9231                 {
9232                 default:
9233                   continue;
9234
9235                 case R_PPC64_TOC16:
9236                 case R_PPC64_TOC16_LO:
9237                 case R_PPC64_TOC16_HI:
9238                 case R_PPC64_TOC16_HA:
9239                 case R_PPC64_TOC16_DS:
9240                 case R_PPC64_TOC16_LO_DS:
9241                   break;
9242                 }
9243
9244               r_symndx = ELF64_R_SYM (rel->r_info);
9245               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9246                               r_symndx, ibfd))
9247                 goto error_ret;
9248
9249               if (sym_sec != toc)
9250                 continue;
9251
9252               if (h != NULL)
9253                 val = h->root.u.def.value;
9254               else
9255                 val = sym->st_value;
9256               val += rel->r_addend;
9257
9258               if (val >= toc->size)
9259                 continue;
9260
9261               /* Anything in the toc ought to be aligned to 8 bytes.
9262                  If not, don't mark as unused.  */
9263               if (val & 7)
9264                 continue;
9265
9266               if (skip == NULL)
9267                 {
9268                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9269                   if (skip == NULL)
9270                     goto error_ret;
9271                 }
9272
9273               skip[val >> 3] = ref_from_discarded;
9274             }
9275
9276           if (elf_section_data (sec)->relocs != relstart)
9277             free (relstart);
9278         }
9279
9280       /* For largetoc loads of address constants, we can convert
9281          .  addis rx,2,addr@got@ha
9282          .  ld ry,addr@got@l(rx)
9283          to
9284          .  addis rx,2,addr@toc@ha
9285          .  addi ry,rx,addr@toc@l
9286          when addr is within 2G of the toc pointer.  This then means
9287          that the word storing "addr" in the toc is no longer needed.  */
9288
9289       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9290           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9291           && toc->reloc_count != 0)
9292         {
9293           /* Read toc relocs.  */
9294           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9295                                                   info->keep_memory);
9296           if (toc_relocs == NULL)
9297             goto error_ret;
9298
9299           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9300             {
9301               enum elf_ppc64_reloc_type r_type;
9302               unsigned long r_symndx;
9303               asection *sym_sec;
9304               struct elf_link_hash_entry *h;
9305               Elf_Internal_Sym *sym;
9306               bfd_vma val, addr;
9307
9308               r_type = ELF64_R_TYPE (rel->r_info);
9309               if (r_type != R_PPC64_ADDR64)
9310                 continue;
9311
9312               r_symndx = ELF64_R_SYM (rel->r_info);
9313               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9314                               r_symndx, ibfd))
9315                 goto error_ret;
9316
9317               if (sym_sec == NULL
9318                   || sym_sec->output_section == NULL
9319                   || discarded_section (sym_sec))
9320                 continue;
9321
9322               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9323                 continue;
9324
9325               if (h != NULL)
9326                 {
9327                   if (h->type == STT_GNU_IFUNC)
9328                     continue;
9329                   val = h->root.u.def.value;
9330                 }
9331               else
9332                 {
9333                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9334                     continue;
9335                   val = sym->st_value;
9336                 }
9337               val += rel->r_addend;
9338               val += sym_sec->output_section->vma + sym_sec->output_offset;
9339
9340               /* We don't yet know the exact toc pointer value, but we
9341                  know it will be somewhere in the toc section.  Don't
9342                  optimize if the difference from any possible toc
9343                  pointer is outside [ff..f80008000, 7fff7fff].  */
9344               addr = toc->output_section->vma + TOC_BASE_OFF;
9345               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9346                 continue;
9347
9348               addr = toc->output_section->vma + toc->output_section->rawsize;
9349               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9350                 continue;
9351
9352               if (skip == NULL)
9353                 {
9354                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9355                   if (skip == NULL)
9356                     goto error_ret;
9357                 }
9358
9359               skip[rel->r_offset >> 3]
9360                 |= can_optimize | ((rel - toc_relocs) << 2);
9361             }
9362         }
9363
9364       if (skip == NULL)
9365         continue;
9366
9367       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9368       if (used == NULL)
9369         {
9370         error_ret:
9371           if (local_syms != NULL
9372               && symtab_hdr->contents != (unsigned char *) local_syms)
9373             free (local_syms);
9374           if (sec != NULL
9375               && relstart != NULL
9376               && elf_section_data (sec)->relocs != relstart)
9377             free (relstart);
9378           if (toc_relocs != NULL
9379               && elf_section_data (toc)->relocs != toc_relocs)
9380             free (toc_relocs);
9381           if (skip != NULL)
9382             free (skip);
9383           return FALSE;
9384         }
9385
9386       /* Now check all kept sections that might reference the toc.
9387          Check the toc itself last.  */
9388       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9389                   : ibfd->sections);
9390            sec != NULL;
9391            sec = (sec == toc ? NULL
9392                   : sec->next == NULL ? toc
9393                   : sec->next == toc && toc->next ? toc->next
9394                   : sec->next))
9395         {
9396           int repeat;
9397
9398           if (sec->reloc_count == 0
9399               || discarded_section (sec)
9400               || get_opd_info (sec)
9401               || (sec->flags & SEC_ALLOC) == 0
9402               || (sec->flags & SEC_DEBUGGING) != 0)
9403             continue;
9404
9405           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9406                                                 info->keep_memory);
9407           if (relstart == NULL)
9408             {
9409               free (used);
9410               goto error_ret;
9411             }
9412
9413           /* Mark toc entries referenced as used.  */
9414           do
9415             {
9416               repeat = 0;
9417               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9418                 {
9419                   enum elf_ppc64_reloc_type r_type;
9420                   unsigned long r_symndx;
9421                   asection *sym_sec;
9422                   struct elf_link_hash_entry *h;
9423                   Elf_Internal_Sym *sym;
9424                   bfd_vma val;
9425                   enum {no_check, check_lo, check_ha} insn_check;
9426
9427                   r_type = ELF64_R_TYPE (rel->r_info);
9428                   switch (r_type)
9429                     {
9430                     default:
9431                       insn_check = no_check;
9432                       break;
9433
9434                     case R_PPC64_GOT_TLSLD16_HA:
9435                     case R_PPC64_GOT_TLSGD16_HA:
9436                     case R_PPC64_GOT_TPREL16_HA:
9437                     case R_PPC64_GOT_DTPREL16_HA:
9438                     case R_PPC64_GOT16_HA:
9439                     case R_PPC64_TOC16_HA:
9440                       insn_check = check_ha;
9441                       break;
9442
9443                     case R_PPC64_GOT_TLSLD16_LO:
9444                     case R_PPC64_GOT_TLSGD16_LO:
9445                     case R_PPC64_GOT_TPREL16_LO_DS:
9446                     case R_PPC64_GOT_DTPREL16_LO_DS:
9447                     case R_PPC64_GOT16_LO:
9448                     case R_PPC64_GOT16_LO_DS:
9449                     case R_PPC64_TOC16_LO:
9450                     case R_PPC64_TOC16_LO_DS:
9451                       insn_check = check_lo;
9452                       break;
9453                     }
9454
9455                   if (insn_check != no_check)
9456                     {
9457                       bfd_vma off = rel->r_offset & ~3;
9458                       unsigned char buf[4];
9459                       unsigned int insn;
9460
9461                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9462                         {
9463                           free (used);
9464                           goto error_ret;
9465                         }
9466                       insn = bfd_get_32 (ibfd, buf);
9467                       if (insn_check == check_lo
9468                           ? !ok_lo_toc_insn (insn, r_type)
9469                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9470                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9471                         {
9472                           char str[12];
9473
9474                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9475                           sprintf (str, "%#08x", insn);
9476                           info->callbacks->einfo
9477                             /* xgettext:c-format */
9478                             (_("%H: toc optimization is not supported for"
9479                                " %s instruction\n"),
9480                              ibfd, sec, rel->r_offset & ~3, str);
9481                         }
9482                     }
9483
9484                   switch (r_type)
9485                     {
9486                     case R_PPC64_TOC16:
9487                     case R_PPC64_TOC16_LO:
9488                     case R_PPC64_TOC16_HI:
9489                     case R_PPC64_TOC16_HA:
9490                     case R_PPC64_TOC16_DS:
9491                     case R_PPC64_TOC16_LO_DS:
9492                       /* In case we're taking addresses of toc entries.  */
9493                     case R_PPC64_ADDR64:
9494                       break;
9495
9496                     default:
9497                       continue;
9498                     }
9499
9500                   r_symndx = ELF64_R_SYM (rel->r_info);
9501                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9502                                   r_symndx, ibfd))
9503                     {
9504                       free (used);
9505                       goto error_ret;
9506                     }
9507
9508                   if (sym_sec != toc)
9509                     continue;
9510
9511                   if (h != NULL)
9512                     val = h->root.u.def.value;
9513                   else
9514                     val = sym->st_value;
9515                   val += rel->r_addend;
9516
9517                   if (val >= toc->size)
9518                     continue;
9519
9520                   if ((skip[val >> 3] & can_optimize) != 0)
9521                     {
9522                       bfd_vma off;
9523                       unsigned char opc;
9524
9525                       switch (r_type)
9526                         {
9527                         case R_PPC64_TOC16_HA:
9528                           break;
9529
9530                         case R_PPC64_TOC16_LO_DS:
9531                           off = rel->r_offset;
9532                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9533                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9534                                                          off, 1))
9535                             {
9536                               free (used);
9537                               goto error_ret;
9538                             }
9539                           if ((opc & (0x3f << 2)) == (58u << 2))
9540                             break;
9541                           /* Fall through.  */
9542
9543                         default:
9544                           /* Wrong sort of reloc, or not a ld.  We may
9545                              as well clear ref_from_discarded too.  */
9546                           skip[val >> 3] = 0;
9547                         }
9548                     }
9549
9550                   if (sec != toc)
9551                     used[val >> 3] = 1;
9552                   /* For the toc section, we only mark as used if this
9553                      entry itself isn't unused.  */
9554                   else if ((used[rel->r_offset >> 3]
9555                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9556                            && !used[val >> 3])
9557                     {
9558                       /* Do all the relocs again, to catch reference
9559                          chains.  */
9560                       repeat = 1;
9561                       used[val >> 3] = 1;
9562                     }
9563                 }
9564             }
9565           while (repeat);
9566
9567           if (elf_section_data (sec)->relocs != relstart)
9568             free (relstart);
9569         }
9570
9571       /* Merge the used and skip arrays.  Assume that TOC
9572          doublewords not appearing as either used or unused belong
9573          to an entry more than one doubleword in size.  */
9574       for (drop = skip, keep = used, last = 0, some_unused = 0;
9575            drop < skip + (toc->size + 7) / 8;
9576            ++drop, ++keep)
9577         {
9578           if (*keep)
9579             {
9580               *drop &= ~ref_from_discarded;
9581               if ((*drop & can_optimize) != 0)
9582                 some_unused = 1;
9583               last = 0;
9584             }
9585           else if ((*drop & ref_from_discarded) != 0)
9586             {
9587               some_unused = 1;
9588               last = ref_from_discarded;
9589             }
9590           else
9591             *drop = last;
9592         }
9593
9594       free (used);
9595
9596       if (some_unused)
9597         {
9598           bfd_byte *contents, *src;
9599           unsigned long off;
9600           Elf_Internal_Sym *sym;
9601           bfd_boolean local_toc_syms = FALSE;
9602
9603           /* Shuffle the toc contents, and at the same time convert the
9604              skip array from booleans into offsets.  */
9605           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9606             goto error_ret;
9607
9608           elf_section_data (toc)->this_hdr.contents = contents;
9609
9610           for (src = contents, off = 0, drop = skip;
9611                src < contents + toc->size;
9612                src += 8, ++drop)
9613             {
9614               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9615                 off += 8;
9616               else if (off != 0)
9617                 {
9618                   *drop = off;
9619                   memcpy (src - off, src, 8);
9620                 }
9621             }
9622           *drop = off;
9623           toc->rawsize = toc->size;
9624           toc->size = src - contents - off;
9625
9626           /* Adjust addends for relocs against the toc section sym,
9627              and optimize any accesses we can.  */
9628           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9629             {
9630               if (sec->reloc_count == 0
9631                   || discarded_section (sec))
9632                 continue;
9633
9634               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9635                                                     info->keep_memory);
9636               if (relstart == NULL)
9637                 goto error_ret;
9638
9639               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9640                 {
9641                   enum elf_ppc64_reloc_type r_type;
9642                   unsigned long r_symndx;
9643                   asection *sym_sec;
9644                   struct elf_link_hash_entry *h;
9645                   bfd_vma val;
9646
9647                   r_type = ELF64_R_TYPE (rel->r_info);
9648                   switch (r_type)
9649                     {
9650                     default:
9651                       continue;
9652
9653                     case R_PPC64_TOC16:
9654                     case R_PPC64_TOC16_LO:
9655                     case R_PPC64_TOC16_HI:
9656                     case R_PPC64_TOC16_HA:
9657                     case R_PPC64_TOC16_DS:
9658                     case R_PPC64_TOC16_LO_DS:
9659                     case R_PPC64_ADDR64:
9660                       break;
9661                     }
9662
9663                   r_symndx = ELF64_R_SYM (rel->r_info);
9664                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9665                                   r_symndx, ibfd))
9666                     goto error_ret;
9667
9668                   if (sym_sec != toc)
9669                     continue;
9670
9671                   if (h != NULL)
9672                     val = h->root.u.def.value;
9673                   else
9674                     {
9675                       val = sym->st_value;
9676                       if (val != 0)
9677                         local_toc_syms = TRUE;
9678                     }
9679
9680                   val += rel->r_addend;
9681
9682                   if (val > toc->rawsize)
9683                     val = toc->rawsize;
9684                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9685                     continue;
9686                   else if ((skip[val >> 3] & can_optimize) != 0)
9687                     {
9688                       Elf_Internal_Rela *tocrel
9689                         = toc_relocs + (skip[val >> 3] >> 2);
9690                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9691
9692                       switch (r_type)
9693                         {
9694                         case R_PPC64_TOC16_HA:
9695                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9696                           break;
9697
9698                         case R_PPC64_TOC16_LO_DS:
9699                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9700                           break;
9701
9702                         default:
9703                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9704                             ppc_howto_init ();
9705                           info->callbacks->einfo
9706                             /* xgettext:c-format */
9707                             (_("%H: %s references "
9708                                "optimized away TOC entry\n"),
9709                              ibfd, sec, rel->r_offset,
9710                              ppc64_elf_howto_table[r_type]->name);
9711                           bfd_set_error (bfd_error_bad_value);
9712                           goto error_ret;
9713                         }
9714                       rel->r_addend = tocrel->r_addend;
9715                       elf_section_data (sec)->relocs = relstart;
9716                       continue;
9717                     }
9718
9719                   if (h != NULL || sym->st_value != 0)
9720                     continue;
9721
9722                   rel->r_addend -= skip[val >> 3];
9723                   elf_section_data (sec)->relocs = relstart;
9724                 }
9725
9726               if (elf_section_data (sec)->relocs != relstart)
9727                 free (relstart);
9728             }
9729
9730           /* We shouldn't have local or global symbols defined in the TOC,
9731              but handle them anyway.  */
9732           if (local_syms != NULL)
9733             for (sym = local_syms;
9734                  sym < local_syms + symtab_hdr->sh_info;
9735                  ++sym)
9736               if (sym->st_value != 0
9737                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9738                 {
9739                   unsigned long i;
9740
9741                   if (sym->st_value > toc->rawsize)
9742                     i = toc->rawsize >> 3;
9743                   else
9744                     i = sym->st_value >> 3;
9745
9746                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9747                     {
9748                       if (local_toc_syms)
9749                         _bfd_error_handler
9750                           (_("%s defined on removed toc entry"),
9751                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9752                       do
9753                         ++i;
9754                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9755                       sym->st_value = (bfd_vma) i << 3;
9756                     }
9757
9758                   sym->st_value -= skip[i];
9759                   symtab_hdr->contents = (unsigned char *) local_syms;
9760                 }
9761
9762           /* Adjust any global syms defined in this toc input section.  */
9763           if (toc_inf.global_toc_syms)
9764             {
9765               toc_inf.toc = toc;
9766               toc_inf.skip = skip;
9767               toc_inf.global_toc_syms = FALSE;
9768               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9769                                       &toc_inf);
9770             }
9771
9772           if (toc->reloc_count != 0)
9773             {
9774               Elf_Internal_Shdr *rel_hdr;
9775               Elf_Internal_Rela *wrel;
9776               bfd_size_type sz;
9777
9778               /* Remove unused toc relocs, and adjust those we keep.  */
9779               if (toc_relocs == NULL)
9780                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9781                                                         info->keep_memory);
9782               if (toc_relocs == NULL)
9783                 goto error_ret;
9784
9785               wrel = toc_relocs;
9786               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9787                 if ((skip[rel->r_offset >> 3]
9788                      & (ref_from_discarded | can_optimize)) == 0)
9789                   {
9790                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9791                     wrel->r_info = rel->r_info;
9792                     wrel->r_addend = rel->r_addend;
9793                     ++wrel;
9794                   }
9795                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9796                                             &local_syms, NULL, NULL))
9797                   goto error_ret;
9798
9799               elf_section_data (toc)->relocs = toc_relocs;
9800               toc->reloc_count = wrel - toc_relocs;
9801               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9802               sz = rel_hdr->sh_entsize;
9803               rel_hdr->sh_size = toc->reloc_count * sz;
9804             }
9805         }
9806       else if (toc_relocs != NULL
9807                && elf_section_data (toc)->relocs != toc_relocs)
9808         free (toc_relocs);
9809
9810       if (local_syms != NULL
9811           && symtab_hdr->contents != (unsigned char *) local_syms)
9812         {
9813           if (!info->keep_memory)
9814             free (local_syms);
9815           else
9816             symtab_hdr->contents = (unsigned char *) local_syms;
9817         }
9818       free (skip);
9819     }
9820
9821   return TRUE;
9822 }
9823
9824 /* Return true iff input section I references the TOC using
9825    instructions limited to +/-32k offsets.  */
9826
9827 bfd_boolean
9828 ppc64_elf_has_small_toc_reloc (asection *i)
9829 {
9830   return (is_ppc64_elf (i->owner)
9831           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9832 }
9833
9834 /* Allocate space for one GOT entry.  */
9835
9836 static void
9837 allocate_got (struct elf_link_hash_entry *h,
9838               struct bfd_link_info *info,
9839               struct got_entry *gent)
9840 {
9841   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9842   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9843   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9844                  ? 16 : 8);
9845   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9846                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9847   asection *got = ppc64_elf_tdata (gent->owner)->got;
9848
9849   gent->got.offset = got->size;
9850   got->size += entsize;
9851
9852   if (h->type == STT_GNU_IFUNC)
9853     {
9854       htab->elf.irelplt->size += rentsize;
9855       htab->got_reli_size += rentsize;
9856     }
9857   else if (((bfd_link_pic (info)
9858              && !((gent->tls_type & TLS_TPREL) != 0
9859                   && bfd_link_executable (info)
9860                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9861             || (htab->elf.dynamic_sections_created
9862                 && h->dynindx != -1
9863                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9864            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9865     {
9866       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9867       relgot->size += rentsize;
9868     }
9869 }
9870
9871 /* This function merges got entries in the same toc group.  */
9872
9873 static void
9874 merge_got_entries (struct got_entry **pent)
9875 {
9876   struct got_entry *ent, *ent2;
9877
9878   for (ent = *pent; ent != NULL; ent = ent->next)
9879     if (!ent->is_indirect)
9880       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9881         if (!ent2->is_indirect
9882             && ent2->addend == ent->addend
9883             && ent2->tls_type == ent->tls_type
9884             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9885           {
9886             ent2->is_indirect = TRUE;
9887             ent2->got.ent = ent;
9888           }
9889 }
9890
9891 /* If H is undefined, make it dynamic if that makes sense.  */
9892
9893 static bfd_boolean
9894 ensure_undef_dynamic (struct bfd_link_info *info,
9895                       struct elf_link_hash_entry *h)
9896 {
9897   struct elf_link_hash_table *htab = elf_hash_table (info);
9898
9899   if (htab->dynamic_sections_created
9900       && ((info->dynamic_undefined_weak != 0
9901            && h->root.type == bfd_link_hash_undefweak)
9902           || h->root.type == bfd_link_hash_undefined)
9903       && h->dynindx == -1
9904       && !h->forced_local
9905       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9906     return bfd_elf_link_record_dynamic_symbol (info, h);
9907   return TRUE;
9908 }
9909
9910 /* Allocate space in .plt, .got and associated reloc sections for
9911    dynamic relocs.  */
9912
9913 static bfd_boolean
9914 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9915 {
9916   struct bfd_link_info *info;
9917   struct ppc_link_hash_table *htab;
9918   asection *s;
9919   struct ppc_link_hash_entry *eh;
9920   struct got_entry **pgent, *gent;
9921
9922   if (h->root.type == bfd_link_hash_indirect)
9923     return TRUE;
9924
9925   info = (struct bfd_link_info *) inf;
9926   htab = ppc_hash_table (info);
9927   if (htab == NULL)
9928     return FALSE;
9929
9930   eh = (struct ppc_link_hash_entry *) h;
9931   /* Run through the TLS GD got entries first if we're changing them
9932      to TPREL.  */
9933   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9934     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9935       if (gent->got.refcount > 0
9936           && (gent->tls_type & TLS_GD) != 0)
9937         {
9938           /* This was a GD entry that has been converted to TPREL.  If
9939              there happens to be a TPREL entry we can use that one.  */
9940           struct got_entry *ent;
9941           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9942             if (ent->got.refcount > 0
9943                 && (ent->tls_type & TLS_TPREL) != 0
9944                 && ent->addend == gent->addend
9945                 && ent->owner == gent->owner)
9946               {
9947                 gent->got.refcount = 0;
9948                 break;
9949               }
9950
9951           /* If not, then we'll be using our own TPREL entry.  */
9952           if (gent->got.refcount != 0)
9953             gent->tls_type = TLS_TLS | TLS_TPREL;
9954         }
9955
9956   /* Remove any list entry that won't generate a word in the GOT before
9957      we call merge_got_entries.  Otherwise we risk merging to empty
9958      entries.  */
9959   pgent = &h->got.glist;
9960   while ((gent = *pgent) != NULL)
9961     if (gent->got.refcount > 0)
9962       {
9963         if ((gent->tls_type & TLS_LD) != 0
9964             && !h->def_dynamic)
9965           {
9966             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9967             *pgent = gent->next;
9968           }
9969         else
9970           pgent = &gent->next;
9971       }
9972     else
9973       *pgent = gent->next;
9974
9975   if (!htab->do_multi_toc)
9976     merge_got_entries (&h->got.glist);
9977
9978   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9979     if (!gent->is_indirect)
9980       {
9981         /* Make sure this symbol is output as a dynamic symbol.  */
9982         if (!ensure_undef_dynamic (info, h))
9983           return FALSE;
9984
9985         if (!is_ppc64_elf (gent->owner))
9986           abort ();
9987
9988         allocate_got (h, info, gent);
9989       }
9990
9991   /* If no dynamic sections we can't have dynamic relocs, except for
9992      IFUNCs which are handled even in static executables.  */
9993   if (!htab->elf.dynamic_sections_created
9994       && h->type != STT_GNU_IFUNC)
9995     eh->dyn_relocs = NULL;
9996
9997   /* Discard relocs on undefined symbols that must be local.  */
9998   else if (h->root.type == bfd_link_hash_undefined
9999            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10000     eh->dyn_relocs = NULL;
10001
10002   /* Also discard relocs on undefined weak syms with non-default
10003      visibility, or when dynamic_undefined_weak says so.  */
10004   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10005     eh->dyn_relocs = NULL;
10006
10007   if (eh->dyn_relocs != NULL)
10008     {
10009       struct elf_dyn_relocs *p, **pp;
10010
10011       /* In the shared -Bsymbolic case, discard space allocated for
10012          dynamic pc-relative relocs against symbols which turn out to
10013          be defined in regular objects.  For the normal shared case,
10014          discard space for relocs that have become local due to symbol
10015          visibility changes.  */
10016
10017       if (bfd_link_pic (info))
10018         {
10019           /* Relocs that use pc_count are those that appear on a call
10020              insn, or certain REL relocs (see must_be_dyn_reloc) that
10021              can be generated via assembly.  We want calls to
10022              protected symbols to resolve directly to the function
10023              rather than going via the plt.  If people want function
10024              pointer comparisons to work as expected then they should
10025              avoid writing weird assembly.  */
10026           if (SYMBOL_CALLS_LOCAL (info, h))
10027             {
10028               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10029                 {
10030                   p->count -= p->pc_count;
10031                   p->pc_count = 0;
10032                   if (p->count == 0)
10033                     *pp = p->next;
10034                   else
10035                     pp = &p->next;
10036                 }
10037             }
10038
10039           if (eh->dyn_relocs != NULL)
10040             {
10041               /* Make sure this symbol is output as a dynamic symbol.  */
10042               if (!ensure_undef_dynamic (info, h))
10043                 return FALSE;
10044             }
10045         }
10046       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10047         {
10048           /* For the non-pic case, discard space for relocs against
10049              symbols which turn out to need copy relocs or are not
10050              dynamic.  */
10051           if (h->dynamic_adjusted
10052               && !h->def_regular
10053               && !ELF_COMMON_DEF_P (h))
10054             {
10055               /* Make sure this symbol is output as a dynamic symbol.  */
10056               if (!ensure_undef_dynamic (info, h))
10057                 return FALSE;
10058
10059               if (h->dynindx == -1)
10060                 eh->dyn_relocs = NULL;
10061             }
10062           else
10063             eh->dyn_relocs = NULL;
10064         }
10065
10066       /* Finally, allocate space.  */
10067       for (p = eh->dyn_relocs; p != NULL; p = p->next)
10068         {
10069           asection *sreloc = elf_section_data (p->sec)->sreloc;
10070           if (eh->elf.type == STT_GNU_IFUNC)
10071             sreloc = htab->elf.irelplt;
10072           sreloc->size += p->count * sizeof (Elf64_External_Rela);
10073         }
10074     }
10075
10076   /* We might need a PLT entry when the symbol
10077      a) is dynamic, or
10078      b) is an ifunc, or
10079      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10080      d) has plt16 relocs and we are linking statically.  */
10081   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10082       || h->type == STT_GNU_IFUNC
10083       || (h->needs_plt && h->dynamic_adjusted)
10084       || (h->needs_plt
10085           && h->def_regular
10086           && !htab->elf.dynamic_sections_created
10087           && !htab->can_convert_all_inline_plt
10088           && (((struct ppc_link_hash_entry *) h)->tls_mask
10089               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10090     {
10091       struct plt_entry *pent;
10092       bfd_boolean doneone = FALSE;
10093       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10094         if (pent->plt.refcount > 0)
10095           {
10096             if (!htab->elf.dynamic_sections_created
10097                 || h->dynindx == -1)
10098               {
10099                 if (h->type == STT_GNU_IFUNC)
10100                   {
10101                     s = htab->elf.iplt;
10102                     pent->plt.offset = s->size;
10103                     s->size += PLT_ENTRY_SIZE (htab);
10104                     s = htab->elf.irelplt;
10105                   }
10106                 else
10107                   {
10108                     s = htab->pltlocal;
10109                     pent->plt.offset = s->size;
10110                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10111                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10112                   }
10113               }
10114             else
10115               {
10116                 /* If this is the first .plt entry, make room for the special
10117                    first entry.  */
10118                 s = htab->elf.splt;
10119                 if (s->size == 0)
10120                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10121
10122                 pent->plt.offset = s->size;
10123
10124                 /* Make room for this entry.  */
10125                 s->size += PLT_ENTRY_SIZE (htab);
10126
10127                 /* Make room for the .glink code.  */
10128                 s = htab->glink;
10129                 if (s->size == 0)
10130                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
10131                 if (htab->opd_abi)
10132                   {
10133                     /* We need bigger stubs past index 32767.  */
10134                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10135                       s->size += 4;
10136                     s->size += 2*4;
10137                   }
10138                 else
10139                   s->size += 4;
10140
10141                 /* We also need to make an entry in the .rela.plt section.  */
10142                 s = htab->elf.srelplt;
10143               }
10144             if (s != NULL)
10145               s->size += sizeof (Elf64_External_Rela);
10146             doneone = TRUE;
10147           }
10148         else
10149           pent->plt.offset = (bfd_vma) -1;
10150       if (!doneone)
10151         {
10152           h->plt.plist = NULL;
10153           h->needs_plt = 0;
10154         }
10155     }
10156   else
10157     {
10158       h->plt.plist = NULL;
10159       h->needs_plt = 0;
10160     }
10161
10162   return TRUE;
10163 }
10164
10165 #define PPC_LO(v) ((v) & 0xffff)
10166 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10167 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10168
10169 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10170    to set up space for global entry stubs.  These are put in glink,
10171    after the branch table.  */
10172
10173 static bfd_boolean
10174 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10175 {
10176   struct bfd_link_info *info;
10177   struct ppc_link_hash_table *htab;
10178   struct plt_entry *pent;
10179   asection *s, *plt;
10180
10181   if (h->root.type == bfd_link_hash_indirect)
10182     return TRUE;
10183
10184   if (!h->pointer_equality_needed)
10185     return TRUE;
10186
10187   if (h->def_regular)
10188     return TRUE;
10189
10190   info = inf;
10191   htab = ppc_hash_table (info);
10192   if (htab == NULL)
10193     return FALSE;
10194
10195   s = htab->global_entry;
10196   plt = htab->elf.splt;
10197   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10198     if (pent->plt.offset != (bfd_vma) -1
10199         && pent->addend == 0)
10200       {
10201         /* For ELFv2, if this symbol is not defined in a regular file
10202            and we are not generating a shared library or pie, then we
10203            need to define the symbol in the executable on a call stub.
10204            This is to avoid text relocations.  */
10205         bfd_vma off, stub_align, stub_off, stub_size;
10206         unsigned int align_power;
10207
10208         stub_size = 16;
10209         stub_off = s->size;
10210         if (htab->params->plt_stub_align >= 0)
10211           align_power = htab->params->plt_stub_align;
10212         else
10213           align_power = -htab->params->plt_stub_align;
10214         /* Setting section alignment is delayed until we know it is
10215            non-empty.  Otherwise the .text output section will be
10216            aligned at least to plt_stub_align even when no global
10217            entry stubs are needed.  */
10218         if (s->alignment_power < align_power)
10219           s->alignment_power = align_power;
10220         stub_align = (bfd_vma) 1 << align_power;
10221         if (htab->params->plt_stub_align >= 0
10222             || ((((stub_off + stub_size - 1) & -stub_align)
10223                  - (stub_off & -stub_align))
10224                 > ((stub_size - 1) & -stub_align)))
10225           stub_off = (stub_off + stub_align - 1) & -stub_align;
10226         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10227         off -= stub_off + s->output_offset + s->output_section->vma;
10228         /* Note that for --plt-stub-align negative we have a possible
10229            dependency between stub offset and size.  Break that
10230            dependency by assuming the max stub size when calculating
10231            the stub offset.  */
10232         if (PPC_HA (off) == 0)
10233           stub_size -= 4;
10234         h->root.type = bfd_link_hash_defined;
10235         h->root.u.def.section = s;
10236         h->root.u.def.value = stub_off;
10237         s->size = stub_off + stub_size;
10238         break;
10239       }
10240   return TRUE;
10241 }
10242
10243 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10244    read-only sections.  */
10245
10246 static bfd_boolean
10247 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10248 {
10249   asection *sec;
10250
10251   if (h->root.type == bfd_link_hash_indirect)
10252     return TRUE;
10253
10254   sec = readonly_dynrelocs (h);
10255   if (sec != NULL)
10256     {
10257       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10258
10259       info->flags |= DF_TEXTREL;
10260       info->callbacks->minfo
10261         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10262          sec->owner, h->root.root.string, sec);
10263
10264       /* Not an error, just cut short the traversal.  */
10265       return FALSE;
10266     }
10267   return TRUE;
10268 }
10269
10270 /* Set the sizes of the dynamic sections.  */
10271
10272 static bfd_boolean
10273 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10274                                  struct bfd_link_info *info)
10275 {
10276   struct ppc_link_hash_table *htab;
10277   bfd *dynobj;
10278   asection *s;
10279   bfd_boolean relocs;
10280   bfd *ibfd;
10281   struct got_entry *first_tlsld;
10282
10283   htab = ppc_hash_table (info);
10284   if (htab == NULL)
10285     return FALSE;
10286
10287   dynobj = htab->elf.dynobj;
10288   if (dynobj == NULL)
10289     abort ();
10290
10291   if (htab->elf.dynamic_sections_created)
10292     {
10293       /* Set the contents of the .interp section to the interpreter.  */
10294       if (bfd_link_executable (info) && !info->nointerp)
10295         {
10296           s = bfd_get_linker_section (dynobj, ".interp");
10297           if (s == NULL)
10298             abort ();
10299           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10300           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10301         }
10302     }
10303
10304   /* Set up .got offsets for local syms, and space for local dynamic
10305      relocs.  */
10306   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10307     {
10308       struct got_entry **lgot_ents;
10309       struct got_entry **end_lgot_ents;
10310       struct plt_entry **local_plt;
10311       struct plt_entry **end_local_plt;
10312       unsigned char *lgot_masks;
10313       bfd_size_type locsymcount;
10314       Elf_Internal_Shdr *symtab_hdr;
10315
10316       if (!is_ppc64_elf (ibfd))
10317         continue;
10318
10319       for (s = ibfd->sections; s != NULL; s = s->next)
10320         {
10321           struct ppc_dyn_relocs *p;
10322
10323           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10324             {
10325               if (!bfd_is_abs_section (p->sec)
10326                   && bfd_is_abs_section (p->sec->output_section))
10327                 {
10328                   /* Input section has been discarded, either because
10329                      it is a copy of a linkonce section or due to
10330                      linker script /DISCARD/, so we'll be discarding
10331                      the relocs too.  */
10332                 }
10333               else if (p->count != 0)
10334                 {
10335                   asection *srel = elf_section_data (p->sec)->sreloc;
10336                   if (p->ifunc)
10337                     srel = htab->elf.irelplt;
10338                   srel->size += p->count * sizeof (Elf64_External_Rela);
10339                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10340                     info->flags |= DF_TEXTREL;
10341                 }
10342             }
10343         }
10344
10345       lgot_ents = elf_local_got_ents (ibfd);
10346       if (!lgot_ents)
10347         continue;
10348
10349       symtab_hdr = &elf_symtab_hdr (ibfd);
10350       locsymcount = symtab_hdr->sh_info;
10351       end_lgot_ents = lgot_ents + locsymcount;
10352       local_plt = (struct plt_entry **) end_lgot_ents;
10353       end_local_plt = local_plt + locsymcount;
10354       lgot_masks = (unsigned char *) end_local_plt;
10355       s = ppc64_elf_tdata (ibfd)->got;
10356       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10357         {
10358           struct got_entry **pent, *ent;
10359
10360           pent = lgot_ents;
10361           while ((ent = *pent) != NULL)
10362             if (ent->got.refcount > 0)
10363               {
10364                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10365                   {
10366                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10367                     *pent = ent->next;
10368                   }
10369                 else
10370                   {
10371                     unsigned int ent_size = 8;
10372                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10373
10374                     ent->got.offset = s->size;
10375                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10376                       {
10377                         ent_size *= 2;
10378                         rel_size *= 2;
10379                       }
10380                     s->size += ent_size;
10381                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10382                       {
10383                         htab->elf.irelplt->size += rel_size;
10384                         htab->got_reli_size += rel_size;
10385                       }
10386                     else if (bfd_link_pic (info)
10387                              && !((ent->tls_type & TLS_TPREL) != 0
10388                                   && bfd_link_executable (info)))
10389                       {
10390                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10391                         srel->size += rel_size;
10392                       }
10393                     pent = &ent->next;
10394                   }
10395               }
10396             else
10397               *pent = ent->next;
10398         }
10399
10400       /* Allocate space for plt calls to local syms.  */
10401       lgot_masks = (unsigned char *) end_local_plt;
10402       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10403         {
10404           struct plt_entry *ent;
10405
10406           for (ent = *local_plt; ent != NULL; ent = ent->next)
10407             if (ent->plt.refcount > 0)
10408               {
10409                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10410                   {
10411                     s = htab->elf.iplt;
10412                     ent->plt.offset = s->size;
10413                     s->size += PLT_ENTRY_SIZE (htab);
10414                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10415                   }
10416                 else if (htab->can_convert_all_inline_plt
10417                          || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10418                   ent->plt.offset = (bfd_vma) -1;
10419                 else
10420                   {
10421                     s = htab->pltlocal;
10422                     ent->plt.offset = s->size;
10423                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10424                     if (bfd_link_pic (info))
10425                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10426                   }
10427               }
10428             else
10429               ent->plt.offset = (bfd_vma) -1;
10430         }
10431     }
10432
10433   /* Allocate global sym .plt and .got entries, and space for global
10434      sym dynamic relocs.  */
10435   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10436
10437   if (!htab->opd_abi && !bfd_link_pic (info))
10438     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10439
10440   first_tlsld = NULL;
10441   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10442     {
10443       struct got_entry *ent;
10444
10445       if (!is_ppc64_elf (ibfd))
10446         continue;
10447
10448       ent = ppc64_tlsld_got (ibfd);
10449       if (ent->got.refcount > 0)
10450         {
10451           if (!htab->do_multi_toc && first_tlsld != NULL)
10452             {
10453               ent->is_indirect = TRUE;
10454               ent->got.ent = first_tlsld;
10455             }
10456           else
10457             {
10458               if (first_tlsld == NULL)
10459                 first_tlsld = ent;
10460               s = ppc64_elf_tdata (ibfd)->got;
10461               ent->got.offset = s->size;
10462               ent->owner = ibfd;
10463               s->size += 16;
10464               if (bfd_link_pic (info))
10465                 {
10466                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10467                   srel->size += sizeof (Elf64_External_Rela);
10468                 }
10469             }
10470         }
10471       else
10472         ent->got.offset = (bfd_vma) -1;
10473     }
10474
10475   /* We now have determined the sizes of the various dynamic sections.
10476      Allocate memory for them.  */
10477   relocs = FALSE;
10478   for (s = dynobj->sections; s != NULL; s = s->next)
10479     {
10480       if ((s->flags & SEC_LINKER_CREATED) == 0)
10481         continue;
10482
10483       if (s == htab->brlt || s == htab->relbrlt)
10484         /* These haven't been allocated yet;  don't strip.  */
10485         continue;
10486       else if (s == htab->elf.sgot
10487                || s == htab->elf.splt
10488                || s == htab->elf.iplt
10489                || s == htab->pltlocal
10490                || s == htab->glink
10491                || s == htab->global_entry
10492                || s == htab->elf.sdynbss
10493                || s == htab->elf.sdynrelro)
10494         {
10495           /* Strip this section if we don't need it; see the
10496              comment below.  */
10497         }
10498       else if (s == htab->glink_eh_frame)
10499         {
10500           if (!bfd_is_abs_section (s->output_section))
10501             /* Not sized yet.  */
10502             continue;
10503         }
10504       else if (CONST_STRNEQ (s->name, ".rela"))
10505         {
10506           if (s->size != 0)
10507             {
10508               if (s != htab->elf.srelplt)
10509                 relocs = TRUE;
10510
10511               /* We use the reloc_count field as a counter if we need
10512                  to copy relocs into the output file.  */
10513               s->reloc_count = 0;
10514             }
10515         }
10516       else
10517         {
10518           /* It's not one of our sections, so don't allocate space.  */
10519           continue;
10520         }
10521
10522       if (s->size == 0)
10523         {
10524           /* If we don't need this section, strip it from the
10525              output file.  This is mostly to handle .rela.bss and
10526              .rela.plt.  We must create both sections in
10527              create_dynamic_sections, because they must be created
10528              before the linker maps input sections to output
10529              sections.  The linker does that before
10530              adjust_dynamic_symbol is called, and it is that
10531              function which decides whether anything needs to go
10532              into these sections.  */
10533           s->flags |= SEC_EXCLUDE;
10534           continue;
10535         }
10536
10537       if (bfd_is_abs_section (s->output_section))
10538         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10539                             s->name);
10540
10541       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10542         continue;
10543
10544       /* Allocate memory for the section contents.  We use bfd_zalloc
10545          here in case unused entries are not reclaimed before the
10546          section's contents are written out.  This should not happen,
10547          but this way if it does we get a R_PPC64_NONE reloc in .rela
10548          sections instead of garbage.
10549          We also rely on the section contents being zero when writing
10550          the GOT and .dynrelro.  */
10551       s->contents = bfd_zalloc (dynobj, s->size);
10552       if (s->contents == NULL)
10553         return FALSE;
10554     }
10555
10556   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10557     {
10558       if (!is_ppc64_elf (ibfd))
10559         continue;
10560
10561       s = ppc64_elf_tdata (ibfd)->got;
10562       if (s != NULL && s != htab->elf.sgot)
10563         {
10564           if (s->size == 0)
10565             s->flags |= SEC_EXCLUDE;
10566           else
10567             {
10568               s->contents = bfd_zalloc (ibfd, s->size);
10569               if (s->contents == NULL)
10570                 return FALSE;
10571             }
10572         }
10573       s = ppc64_elf_tdata (ibfd)->relgot;
10574       if (s != NULL)
10575         {
10576           if (s->size == 0)
10577             s->flags |= SEC_EXCLUDE;
10578           else
10579             {
10580               s->contents = bfd_zalloc (ibfd, s->size);
10581               if (s->contents == NULL)
10582                 return FALSE;
10583               relocs = TRUE;
10584               s->reloc_count = 0;
10585             }
10586         }
10587     }
10588
10589   if (htab->elf.dynamic_sections_created)
10590     {
10591       bfd_boolean tls_opt;
10592
10593       /* Add some entries to the .dynamic section.  We fill in the
10594          values later, in ppc64_elf_finish_dynamic_sections, but we
10595          must add the entries now so that we get the correct size for
10596          the .dynamic section.  The DT_DEBUG entry is filled in by the
10597          dynamic linker and used by the debugger.  */
10598 #define add_dynamic_entry(TAG, VAL) \
10599   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10600
10601       if (bfd_link_executable (info))
10602         {
10603           if (!add_dynamic_entry (DT_DEBUG, 0))
10604             return FALSE;
10605         }
10606
10607       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10608         {
10609           if (!add_dynamic_entry (DT_PLTGOT, 0)
10610               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10611               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10612               || !add_dynamic_entry (DT_JMPREL, 0)
10613               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10614             return FALSE;
10615         }
10616
10617       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10618         {
10619           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10620               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10621             return FALSE;
10622         }
10623
10624       tls_opt = (htab->params->tls_get_addr_opt
10625                  && htab->tls_get_addr_fd != NULL
10626                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10627       if (tls_opt || !htab->opd_abi)
10628         {
10629           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10630             return FALSE;
10631         }
10632
10633       if (relocs)
10634         {
10635           if (!add_dynamic_entry (DT_RELA, 0)
10636               || !add_dynamic_entry (DT_RELASZ, 0)
10637               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10638             return FALSE;
10639
10640           /* If any dynamic relocs apply to a read-only section,
10641              then we need a DT_TEXTREL entry.  */
10642           if ((info->flags & DF_TEXTREL) == 0)
10643             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10644
10645           if ((info->flags & DF_TEXTREL) != 0)
10646             {
10647               if (!add_dynamic_entry (DT_TEXTREL, 0))
10648                 return FALSE;
10649             }
10650         }
10651     }
10652 #undef add_dynamic_entry
10653
10654   return TRUE;
10655 }
10656
10657 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10658
10659 static bfd_boolean
10660 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10661 {
10662   if (h->plt.plist != NULL
10663       && !h->def_regular
10664       && !h->pointer_equality_needed)
10665     return FALSE;
10666
10667   return _bfd_elf_hash_symbol (h);
10668 }
10669
10670 /* Determine the type of stub needed, if any, for a call.  */
10671
10672 static inline enum ppc_stub_type
10673 ppc_type_of_stub (asection *input_sec,
10674                   const Elf_Internal_Rela *rel,
10675                   struct ppc_link_hash_entry **hash,
10676                   struct plt_entry **plt_ent,
10677                   bfd_vma destination,
10678                   unsigned long local_off)
10679 {
10680   struct ppc_link_hash_entry *h = *hash;
10681   bfd_vma location;
10682   bfd_vma branch_offset;
10683   bfd_vma max_branch_offset;
10684   enum elf_ppc64_reloc_type r_type;
10685
10686   if (h != NULL)
10687     {
10688       struct plt_entry *ent;
10689       struct ppc_link_hash_entry *fdh = h;
10690       if (h->oh != NULL
10691           && h->oh->is_func_descriptor)
10692         {
10693           fdh = ppc_follow_link (h->oh);
10694           *hash = fdh;
10695         }
10696
10697       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10698         if (ent->addend == rel->r_addend
10699             && ent->plt.offset != (bfd_vma) -1)
10700           {
10701             *plt_ent = ent;
10702             return ppc_stub_plt_call;
10703           }
10704
10705       /* Here, we know we don't have a plt entry.  If we don't have a
10706          either a defined function descriptor or a defined entry symbol
10707          in a regular object file, then it is pointless trying to make
10708          any other type of stub.  */
10709       if (!is_static_defined (&fdh->elf)
10710           && !is_static_defined (&h->elf))
10711         return ppc_stub_none;
10712     }
10713   else if (elf_local_got_ents (input_sec->owner) != NULL)
10714     {
10715       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10716       struct plt_entry **local_plt = (struct plt_entry **)
10717         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10718       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10719
10720       if (local_plt[r_symndx] != NULL)
10721         {
10722           struct plt_entry *ent;
10723
10724           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10725             if (ent->addend == rel->r_addend
10726                 && ent->plt.offset != (bfd_vma) -1)
10727               {
10728                 *plt_ent = ent;
10729                 return ppc_stub_plt_call;
10730               }
10731         }
10732     }
10733
10734   /* Determine where the call point is.  */
10735   location = (input_sec->output_offset
10736               + input_sec->output_section->vma
10737               + rel->r_offset);
10738
10739   branch_offset = destination - location;
10740   r_type = ELF64_R_TYPE (rel->r_info);
10741
10742   /* Determine if a long branch stub is needed.  */
10743   max_branch_offset = 1 << 25;
10744   if (r_type == R_PPC64_REL14
10745       || r_type == R_PPC64_REL14_BRTAKEN
10746       || r_type == R_PPC64_REL14_BRNTAKEN)
10747     max_branch_offset = 1 << 15;
10748
10749   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10750     /* We need a stub.  Figure out whether a long_branch or plt_branch
10751        is needed later.  */
10752     return ppc_stub_long_branch;
10753
10754   return ppc_stub_none;
10755 }
10756
10757 /* With power7 weakly ordered memory model, it is possible for ld.so
10758    to update a plt entry in one thread and have another thread see a
10759    stale zero toc entry.  To avoid this we need some sort of acquire
10760    barrier in the call stub.  One solution is to make the load of the
10761    toc word seem to appear to depend on the load of the function entry
10762    word.  Another solution is to test for r2 being zero, and branch to
10763    the appropriate glink entry if so.
10764
10765    .    fake dep barrier        compare
10766    .    ld 12,xxx(2)            ld 12,xxx(2)
10767    .    mtctr 12                mtctr 12
10768    .    xor 11,12,12            ld 2,xxx+8(2)
10769    .    add 2,2,11              cmpldi 2,0
10770    .    ld 2,xxx+8(2)           bnectr+
10771    .    bctr                    b <glink_entry>
10772
10773    The solution involving the compare turns out to be faster, so
10774    that's what we use unless the branch won't reach.  */
10775
10776 #define ALWAYS_USE_FAKE_DEP 0
10777 #define ALWAYS_EMIT_R2SAVE 0
10778
10779 static inline unsigned int
10780 plt_stub_size (struct ppc_link_hash_table *htab,
10781                struct ppc_stub_hash_entry *stub_entry,
10782                bfd_vma off)
10783 {
10784   unsigned size = 12;
10785
10786   if (ALWAYS_EMIT_R2SAVE
10787       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10788     size += 4;
10789   if (PPC_HA (off) != 0)
10790     size += 4;
10791   if (htab->opd_abi)
10792     {
10793       size += 4;
10794       if (htab->params->plt_static_chain)
10795         size += 4;
10796       if (htab->params->plt_thread_safe
10797           && htab->elf.dynamic_sections_created
10798           && stub_entry->h != NULL
10799           && stub_entry->h->elf.dynindx != -1)
10800         size += 8;
10801       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10802         size += 4;
10803     }
10804   if (stub_entry->h != NULL
10805       && (stub_entry->h == htab->tls_get_addr_fd
10806           || stub_entry->h == htab->tls_get_addr)
10807       && htab->params->tls_get_addr_opt)
10808     {
10809       size += 7 * 4;
10810       if (ALWAYS_EMIT_R2SAVE
10811           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10812         size += 6 * 4;
10813     }
10814   return size;
10815 }
10816
10817 /* Depending on the sign of plt_stub_align:
10818    If positive, return the padding to align to a 2**plt_stub_align
10819    boundary.
10820    If negative, if this stub would cross fewer 2**plt_stub_align
10821    boundaries if we align, then return the padding needed to do so.  */
10822
10823 static inline unsigned int
10824 plt_stub_pad (struct ppc_link_hash_table *htab,
10825               struct ppc_stub_hash_entry *stub_entry,
10826               bfd_vma plt_off)
10827 {
10828   int stub_align;
10829   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10830   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10831
10832   if (htab->params->plt_stub_align >= 0)
10833     {
10834       stub_align = 1 << htab->params->plt_stub_align;
10835       if ((stub_off & (stub_align - 1)) != 0)
10836         return stub_align - (stub_off & (stub_align - 1));
10837       return 0;
10838     }
10839
10840   stub_align = 1 << -htab->params->plt_stub_align;
10841   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10842       > ((stub_size - 1) & -stub_align))
10843     return stub_align - (stub_off & (stub_align - 1));
10844   return 0;
10845 }
10846
10847 /* Build a .plt call stub.  */
10848
10849 static inline bfd_byte *
10850 build_plt_stub (struct ppc_link_hash_table *htab,
10851                 struct ppc_stub_hash_entry *stub_entry,
10852                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10853 {
10854   bfd *obfd = htab->params->stub_bfd;
10855   bfd_boolean plt_load_toc = htab->opd_abi;
10856   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10857   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10858                                  && htab->elf.dynamic_sections_created
10859                                  && stub_entry->h != NULL
10860                                  && stub_entry->h->elf.dynindx != -1);
10861   bfd_boolean use_fake_dep = plt_thread_safe;
10862   bfd_vma cmp_branch_off = 0;
10863
10864   if (!ALWAYS_USE_FAKE_DEP
10865       && plt_load_toc
10866       && plt_thread_safe
10867       && !((stub_entry->h == htab->tls_get_addr_fd
10868             || stub_entry->h == htab->tls_get_addr)
10869            && htab->params->tls_get_addr_opt))
10870     {
10871       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10872       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10873                           / PLT_ENTRY_SIZE (htab));
10874       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10875       bfd_vma to, from;
10876
10877       if (pltindex > 32768)
10878         glinkoff += (pltindex - 32768) * 4;
10879       to = (glinkoff
10880             + htab->glink->output_offset
10881             + htab->glink->output_section->vma);
10882       from = (p - stub_entry->group->stub_sec->contents
10883               + 4 * (ALWAYS_EMIT_R2SAVE
10884                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10885               + 4 * (PPC_HA (offset) != 0)
10886               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10887                      != PPC_HA (offset))
10888               + 4 * (plt_static_chain != 0)
10889               + 20
10890               + stub_entry->group->stub_sec->output_offset
10891               + stub_entry->group->stub_sec->output_section->vma);
10892       cmp_branch_off = to - from;
10893       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10894     }
10895
10896   if (PPC_HA (offset) != 0)
10897     {
10898       if (r != NULL)
10899         {
10900           if (ALWAYS_EMIT_R2SAVE
10901               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10902             r[0].r_offset += 4;
10903           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10904           r[1].r_offset = r[0].r_offset + 4;
10905           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10906           r[1].r_addend = r[0].r_addend;
10907           if (plt_load_toc)
10908             {
10909               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10910                 {
10911                   r[2].r_offset = r[1].r_offset + 4;
10912                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10913                   r[2].r_addend = r[0].r_addend;
10914                 }
10915               else
10916                 {
10917                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10918                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10919                   r[2].r_addend = r[0].r_addend + 8;
10920                   if (plt_static_chain)
10921                     {
10922                       r[3].r_offset = r[2].r_offset + 4;
10923                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10924                       r[3].r_addend = r[0].r_addend + 16;
10925                     }
10926                 }
10927             }
10928         }
10929       if (ALWAYS_EMIT_R2SAVE
10930           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10931         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10932       if (plt_load_toc)
10933         {
10934           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10935           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10936         }
10937       else
10938         {
10939           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10940           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10941         }
10942       if (plt_load_toc
10943           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10944         {
10945           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10946           offset = 0;
10947         }
10948       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10949       if (plt_load_toc)
10950         {
10951           if (use_fake_dep)
10952             {
10953               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10954               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10955             }
10956           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10957           if (plt_static_chain)
10958             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10959         }
10960     }
10961   else
10962     {
10963       if (r != NULL)
10964         {
10965           if (ALWAYS_EMIT_R2SAVE
10966               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10967             r[0].r_offset += 4;
10968           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10969           if (plt_load_toc)
10970             {
10971               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10972                 {
10973                   r[1].r_offset = r[0].r_offset + 4;
10974                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10975                   r[1].r_addend = r[0].r_addend;
10976                 }
10977               else
10978                 {
10979                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10980                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10981                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10982                   if (plt_static_chain)
10983                     {
10984                       r[2].r_offset = r[1].r_offset + 4;
10985                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10986                       r[2].r_addend = r[0].r_addend + 8;
10987                     }
10988                 }
10989             }
10990         }
10991       if (ALWAYS_EMIT_R2SAVE
10992           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10993         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10994       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10995       if (plt_load_toc
10996           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10997         {
10998           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10999           offset = 0;
11000         }
11001       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11002       if (plt_load_toc)
11003         {
11004           if (use_fake_dep)
11005             {
11006               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
11007               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
11008             }
11009           if (plt_static_chain)
11010             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11011           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11012         }
11013     }
11014   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11015     {
11016       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11017       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11018       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11019     }
11020   else
11021     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11022   return p;
11023 }
11024
11025 /* Build a special .plt call stub for __tls_get_addr.  */
11026
11027 #define LD_R11_0R3      0xe9630000
11028 #define LD_R12_0R3      0xe9830000
11029 #define MR_R0_R3        0x7c601b78
11030 #define CMPDI_R11_0     0x2c2b0000
11031 #define ADD_R3_R12_R13  0x7c6c6a14
11032 #define BEQLR           0x4d820020
11033 #define MR_R3_R0        0x7c030378
11034 #define STD_R11_0R1     0xf9610000
11035 #define BCTRL           0x4e800421
11036 #define LD_R11_0R1      0xe9610000
11037 #define MTLR_R11        0x7d6803a6
11038
11039 static inline bfd_byte *
11040 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11041                          struct ppc_stub_hash_entry *stub_entry,
11042                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11043 {
11044   bfd *obfd = htab->params->stub_bfd;
11045
11046   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11047   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11048   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11049   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11050   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11051   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11052   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11053   if (r != NULL)
11054     r[0].r_offset += 7 * 4;
11055   if (!ALWAYS_EMIT_R2SAVE
11056       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
11057     return build_plt_stub (htab, stub_entry, p, offset, r);
11058
11059   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11060   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11061
11062   if (r != NULL)
11063     r[0].r_offset += 2 * 4;
11064   p = build_plt_stub (htab, stub_entry, p, offset, r);
11065   bfd_put_32 (obfd, BCTRL, p - 4);
11066
11067   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11068   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11069   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11070   bfd_put_32 (obfd, BLR, p),                    p += 4;
11071
11072   return p;
11073 }
11074
11075 static Elf_Internal_Rela *
11076 get_relocs (asection *sec, int count)
11077 {
11078   Elf_Internal_Rela *relocs;
11079   struct bfd_elf_section_data *elfsec_data;
11080
11081   elfsec_data = elf_section_data (sec);
11082   relocs = elfsec_data->relocs;
11083   if (relocs == NULL)
11084     {
11085       bfd_size_type relsize;
11086       relsize = sec->reloc_count * sizeof (*relocs);
11087       relocs = bfd_alloc (sec->owner, relsize);
11088       if (relocs == NULL)
11089         return NULL;
11090       elfsec_data->relocs = relocs;
11091       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11092                                           sizeof (Elf_Internal_Shdr));
11093       if (elfsec_data->rela.hdr == NULL)
11094         return NULL;
11095       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11096                                         * sizeof (Elf64_External_Rela));
11097       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11098       sec->reloc_count = 0;
11099     }
11100   relocs += sec->reloc_count;
11101   sec->reloc_count += count;
11102   return relocs;
11103 }
11104
11105 static bfd_vma
11106 get_r2off (struct bfd_link_info *info,
11107            struct ppc_stub_hash_entry *stub_entry)
11108 {
11109   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11110   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11111
11112   if (r2off == 0)
11113     {
11114       /* Support linking -R objects.  Get the toc pointer from the
11115          opd entry.  */
11116       char buf[8];
11117       if (!htab->opd_abi)
11118         return r2off;
11119       asection *opd = stub_entry->h->elf.root.u.def.section;
11120       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11121
11122       if (strcmp (opd->name, ".opd") != 0
11123           || opd->reloc_count != 0)
11124         {
11125           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11126                                   stub_entry->h->elf.root.root.string);
11127           bfd_set_error (bfd_error_bad_value);
11128           return (bfd_vma) -1;
11129         }
11130       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11131         return (bfd_vma) -1;
11132       r2off = bfd_get_64 (opd->owner, buf);
11133       r2off -= elf_gp (info->output_bfd);
11134     }
11135   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11136   return r2off;
11137 }
11138
11139 static bfd_boolean
11140 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11141 {
11142   struct ppc_stub_hash_entry *stub_entry;
11143   struct ppc_branch_hash_entry *br_entry;
11144   struct bfd_link_info *info;
11145   struct ppc_link_hash_table *htab;
11146   bfd_byte *loc;
11147   bfd_byte *p;
11148   bfd_vma dest, off;
11149   Elf_Internal_Rela *r;
11150   asection *plt;
11151
11152   /* Massage our args to the form they really have.  */
11153   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11154   info = in_arg;
11155
11156   htab = ppc_hash_table (info);
11157   if (htab == NULL)
11158     return FALSE;
11159
11160   /* Make a note of the offset within the stubs for this entry.  */
11161   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11162   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11163
11164   htab->stub_count[stub_entry->stub_type - 1] += 1;
11165   switch (stub_entry->stub_type)
11166     {
11167     case ppc_stub_long_branch:
11168     case ppc_stub_long_branch_r2off:
11169       /* Branches are relative.  This is where we are going to.  */
11170       dest = (stub_entry->target_value
11171               + stub_entry->target_section->output_offset
11172               + stub_entry->target_section->output_section->vma);
11173       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11174       off = dest;
11175
11176       /* And this is where we are coming from.  */
11177       off -= (stub_entry->stub_offset
11178               + stub_entry->group->stub_sec->output_offset
11179               + stub_entry->group->stub_sec->output_section->vma);
11180
11181       p = loc;
11182       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11183         {
11184           bfd_vma r2off = get_r2off (info, stub_entry);
11185
11186           if (r2off == (bfd_vma) -1)
11187             {
11188               htab->stub_error = TRUE;
11189               return FALSE;
11190             }
11191           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11192           p += 4;
11193           if (PPC_HA (r2off) != 0)
11194             {
11195               bfd_put_32 (htab->params->stub_bfd,
11196                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11197               p += 4;
11198             }
11199           if (PPC_LO (r2off) != 0)
11200             {
11201               bfd_put_32 (htab->params->stub_bfd,
11202                           ADDI_R2_R2 | PPC_LO (r2off), p);
11203               p += 4;
11204             }
11205           off -= p - loc;
11206         }
11207       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11208       p += 4;
11209
11210       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11211         {
11212           _bfd_error_handler
11213             (_("long branch stub `%s' offset overflow"),
11214              stub_entry->root.string);
11215           htab->stub_error = TRUE;
11216           return FALSE;
11217         }
11218
11219       if (info->emitrelocations)
11220         {
11221           r = get_relocs (stub_entry->group->stub_sec, 1);
11222           if (r == NULL)
11223             return FALSE;
11224           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11225           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11226           r->r_addend = dest;
11227           if (stub_entry->h != NULL)
11228             {
11229               struct elf_link_hash_entry **hashes;
11230               unsigned long symndx;
11231               struct ppc_link_hash_entry *h;
11232
11233               hashes = elf_sym_hashes (htab->params->stub_bfd);
11234               if (hashes == NULL)
11235                 {
11236                   bfd_size_type hsize;
11237
11238                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11239                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11240                   if (hashes == NULL)
11241                     return FALSE;
11242                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11243                   htab->stub_globals = 1;
11244                 }
11245               symndx = htab->stub_globals++;
11246               h = stub_entry->h;
11247               hashes[symndx] = &h->elf;
11248               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11249               if (h->oh != NULL && h->oh->is_func)
11250                 h = ppc_follow_link (h->oh);
11251               if (h->elf.root.u.def.section != stub_entry->target_section)
11252                 /* H is an opd symbol.  The addend must be zero.  */
11253                 r->r_addend = 0;
11254               else
11255                 {
11256                   off = (h->elf.root.u.def.value
11257                          + h->elf.root.u.def.section->output_offset
11258                          + h->elf.root.u.def.section->output_section->vma);
11259                   r->r_addend -= off;
11260                 }
11261             }
11262         }
11263       break;
11264
11265     case ppc_stub_plt_branch:
11266     case ppc_stub_plt_branch_r2off:
11267       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11268                                          stub_entry->root.string + 9,
11269                                          FALSE, FALSE);
11270       if (br_entry == NULL)
11271         {
11272           _bfd_error_handler (_("can't find branch stub `%s'"),
11273                               stub_entry->root.string);
11274           htab->stub_error = TRUE;
11275           return FALSE;
11276         }
11277
11278       dest = (stub_entry->target_value
11279               + stub_entry->target_section->output_offset
11280               + stub_entry->target_section->output_section->vma);
11281       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11282         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11283
11284       bfd_put_64 (htab->brlt->owner, dest,
11285                   htab->brlt->contents + br_entry->offset);
11286
11287       if (br_entry->iter == htab->stub_iteration)
11288         {
11289           br_entry->iter = 0;
11290
11291           if (htab->relbrlt != NULL)
11292             {
11293               /* Create a reloc for the branch lookup table entry.  */
11294               Elf_Internal_Rela rela;
11295               bfd_byte *rl;
11296
11297               rela.r_offset = (br_entry->offset
11298                                + htab->brlt->output_offset
11299                                + htab->brlt->output_section->vma);
11300               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11301               rela.r_addend = dest;
11302
11303               rl = htab->relbrlt->contents;
11304               rl += (htab->relbrlt->reloc_count++
11305                      * sizeof (Elf64_External_Rela));
11306               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11307             }
11308           else if (info->emitrelocations)
11309             {
11310               r = get_relocs (htab->brlt, 1);
11311               if (r == NULL)
11312                 return FALSE;
11313               /* brlt, being SEC_LINKER_CREATED does not go through the
11314                  normal reloc processing.  Symbols and offsets are not
11315                  translated from input file to output file form, so
11316                  set up the offset per the output file.  */
11317               r->r_offset = (br_entry->offset
11318                              + htab->brlt->output_offset
11319                              + htab->brlt->output_section->vma);
11320               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11321               r->r_addend = dest;
11322             }
11323         }
11324
11325       dest = (br_entry->offset
11326               + htab->brlt->output_offset
11327               + htab->brlt->output_section->vma);
11328
11329       off = (dest
11330              - elf_gp (info->output_bfd)
11331              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11332
11333       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11334         {
11335           info->callbacks->einfo
11336             (_("%P: linkage table error against `%pT'\n"),
11337              stub_entry->root.string);
11338           bfd_set_error (bfd_error_bad_value);
11339           htab->stub_error = TRUE;
11340           return FALSE;
11341         }
11342
11343       if (info->emitrelocations)
11344         {
11345           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11346           if (r == NULL)
11347             return FALSE;
11348           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11349           if (bfd_big_endian (info->output_bfd))
11350             r[0].r_offset += 2;
11351           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11352             r[0].r_offset += 4;
11353           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11354           r[0].r_addend = dest;
11355           if (PPC_HA (off) != 0)
11356             {
11357               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11358               r[1].r_offset = r[0].r_offset + 4;
11359               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11360               r[1].r_addend = r[0].r_addend;
11361             }
11362         }
11363
11364       p = loc;
11365       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11366         {
11367           if (PPC_HA (off) != 0)
11368             {
11369               bfd_put_32 (htab->params->stub_bfd,
11370                           ADDIS_R12_R2 | PPC_HA (off), p);
11371               p += 4;
11372               bfd_put_32 (htab->params->stub_bfd,
11373                           LD_R12_0R12 | PPC_LO (off), p);
11374             }
11375           else
11376             bfd_put_32 (htab->params->stub_bfd,
11377                         LD_R12_0R2 | PPC_LO (off), p);
11378         }
11379       else
11380         {
11381           bfd_vma r2off = get_r2off (info, stub_entry);
11382
11383           if (r2off == (bfd_vma) -1)
11384             {
11385               htab->stub_error = TRUE;
11386               return FALSE;
11387             }
11388
11389           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11390           p += 4;
11391           if (PPC_HA (off) != 0)
11392             {
11393               bfd_put_32 (htab->params->stub_bfd,
11394                           ADDIS_R12_R2 | PPC_HA (off), p);
11395               p += 4;
11396               bfd_put_32 (htab->params->stub_bfd,
11397                           LD_R12_0R12 | PPC_LO (off), p);
11398             }
11399           else
11400             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11401
11402           if (PPC_HA (r2off) != 0)
11403             {
11404               p += 4;
11405               bfd_put_32 (htab->params->stub_bfd,
11406                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11407             }
11408           if (PPC_LO (r2off) != 0)
11409             {
11410               p += 4;
11411               bfd_put_32 (htab->params->stub_bfd,
11412                           ADDI_R2_R2 | PPC_LO (r2off), p);
11413             }
11414         }
11415       p += 4;
11416       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11417       p += 4;
11418       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11419       p += 4;
11420       break;
11421
11422     case ppc_stub_plt_call:
11423     case ppc_stub_plt_call_r2save:
11424       if (stub_entry->h != NULL
11425           && stub_entry->h->is_func_descriptor
11426           && stub_entry->h->oh != NULL)
11427         {
11428           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11429
11430           /* If the old-ABI "dot-symbol" is undefined make it weak so
11431              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11432           if (fh->elf.root.type == bfd_link_hash_undefined
11433               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11434                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11435             fh->elf.root.type = bfd_link_hash_undefweak;
11436         }
11437
11438       /* Now build the stub.  */
11439       dest = stub_entry->plt_ent->plt.offset & ~1;
11440       if (dest >= (bfd_vma) -2)
11441         abort ();
11442
11443       plt = htab->elf.splt;
11444       if (!htab->elf.dynamic_sections_created
11445           || stub_entry->h == NULL
11446           || stub_entry->h->elf.dynindx == -1)
11447         {
11448           if (stub_entry->symtype == STT_GNU_IFUNC)
11449             plt = htab->elf.iplt;
11450           else
11451             plt = htab->pltlocal;
11452         }
11453
11454       dest += plt->output_offset + plt->output_section->vma;
11455
11456       off = (dest
11457              - elf_gp (info->output_bfd)
11458              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11459
11460       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11461         {
11462           info->callbacks->einfo
11463             /* xgettext:c-format */
11464             (_("%P: linkage table error against `%pT'\n"),
11465              stub_entry->h != NULL
11466              ? stub_entry->h->elf.root.root.string
11467              : "<local sym>");
11468           bfd_set_error (bfd_error_bad_value);
11469           htab->stub_error = TRUE;
11470           return FALSE;
11471         }
11472
11473       if (htab->params->plt_stub_align != 0)
11474         {
11475           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11476
11477           stub_entry->group->stub_sec->size += pad;
11478           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11479           loc += pad;
11480         }
11481
11482       r = NULL;
11483       if (info->emitrelocations)
11484         {
11485           r = get_relocs (stub_entry->group->stub_sec,
11486                           ((PPC_HA (off) != 0)
11487                            + (htab->opd_abi
11488                               ? 2 + (htab->params->plt_static_chain
11489                                      && PPC_HA (off + 16) == PPC_HA (off))
11490                               : 1)));
11491           if (r == NULL)
11492             return FALSE;
11493           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11494           if (bfd_big_endian (info->output_bfd))
11495             r[0].r_offset += 2;
11496           r[0].r_addend = dest;
11497         }
11498       if (stub_entry->h != NULL
11499           && (stub_entry->h == htab->tls_get_addr_fd
11500               || stub_entry->h == htab->tls_get_addr)
11501           && htab->params->tls_get_addr_opt)
11502         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11503       else
11504         p = build_plt_stub (htab, stub_entry, loc, off, r);
11505       break;
11506
11507     case ppc_stub_save_res:
11508       return TRUE;
11509
11510     default:
11511       BFD_FAIL ();
11512       return FALSE;
11513     }
11514
11515   stub_entry->group->stub_sec->size += p - loc;
11516
11517   if (htab->params->emit_stub_syms)
11518     {
11519       struct elf_link_hash_entry *h;
11520       size_t len1, len2;
11521       char *name;
11522       const char *const stub_str[] = { "long_branch",
11523                                        "long_branch_r2off",
11524                                        "plt_branch",
11525                                        "plt_branch_r2off",
11526                                        "plt_call",
11527                                        "plt_call" };
11528
11529       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11530       len2 = strlen (stub_entry->root.string);
11531       name = bfd_malloc (len1 + len2 + 2);
11532       if (name == NULL)
11533         return FALSE;
11534       memcpy (name, stub_entry->root.string, 9);
11535       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11536       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11537       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11538       if (h == NULL)
11539         return FALSE;
11540       if (h->root.type == bfd_link_hash_new)
11541         {
11542           h->root.type = bfd_link_hash_defined;
11543           h->root.u.def.section = stub_entry->group->stub_sec;
11544           h->root.u.def.value = stub_entry->stub_offset;
11545           h->ref_regular = 1;
11546           h->def_regular = 1;
11547           h->ref_regular_nonweak = 1;
11548           h->forced_local = 1;
11549           h->non_elf = 0;
11550           h->root.linker_def = 1;
11551         }
11552     }
11553
11554   return TRUE;
11555 }
11556
11557 /* As above, but don't actually build the stub.  Just bump offset so
11558    we know stub section sizes, and select plt_branch stubs where
11559    long_branch stubs won't do.  */
11560
11561 static bfd_boolean
11562 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11563 {
11564   struct ppc_stub_hash_entry *stub_entry;
11565   struct bfd_link_info *info;
11566   struct ppc_link_hash_table *htab;
11567   bfd_vma off;
11568   int size;
11569
11570   /* Massage our args to the form they really have.  */
11571   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11572   info = in_arg;
11573
11574   htab = ppc_hash_table (info);
11575   if (htab == NULL)
11576     return FALSE;
11577
11578   if (stub_entry->h != NULL
11579       && stub_entry->h->save_res
11580       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11581       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11582     {
11583       /* Don't make stubs to out-of-line register save/restore
11584          functions.  Instead, emit copies of the functions.  */
11585       stub_entry->group->needs_save_res = 1;
11586       stub_entry->stub_type = ppc_stub_save_res;
11587       return TRUE;
11588     }
11589
11590   if (stub_entry->stub_type == ppc_stub_plt_call
11591       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11592     {
11593       asection *plt;
11594       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11595       if (off >= (bfd_vma) -2)
11596         abort ();
11597       plt = htab->elf.splt;
11598       if (!htab->elf.dynamic_sections_created
11599           || stub_entry->h == NULL
11600           || stub_entry->h->elf.dynindx == -1)
11601         {
11602           if (stub_entry->symtype == STT_GNU_IFUNC)
11603             plt = htab->elf.iplt;
11604           else
11605             plt = htab->pltlocal;
11606         }
11607       off += (plt->output_offset
11608               + plt->output_section->vma
11609               - elf_gp (info->output_bfd)
11610               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11611
11612       size = plt_stub_size (htab, stub_entry, off);
11613       if (stub_entry->h != NULL
11614           && (stub_entry->h == htab->tls_get_addr_fd
11615               || stub_entry->h == htab->tls_get_addr)
11616           && htab->params->tls_get_addr_opt
11617           && (ALWAYS_EMIT_R2SAVE
11618               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11619         stub_entry->group->tls_get_addr_opt_bctrl
11620           = stub_entry->group->stub_sec->size + size - 5 * 4;
11621
11622       if (htab->params->plt_stub_align)
11623         size += plt_stub_pad (htab, stub_entry, off);
11624       if (info->emitrelocations)
11625         {
11626           stub_entry->group->stub_sec->reloc_count
11627             += ((PPC_HA (off) != 0)
11628                 + (htab->opd_abi
11629                    ? 2 + (htab->params->plt_static_chain
11630                           && PPC_HA (off + 16) == PPC_HA (off))
11631                    : 1));
11632           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11633         }
11634     }
11635   else
11636     {
11637       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11638          variants.  */
11639       bfd_vma r2off = 0;
11640       bfd_vma local_off = 0;
11641
11642       off = (stub_entry->target_value
11643              + stub_entry->target_section->output_offset
11644              + stub_entry->target_section->output_section->vma);
11645       off -= (stub_entry->group->stub_sec->size
11646               + stub_entry->group->stub_sec->output_offset
11647               + stub_entry->group->stub_sec->output_section->vma);
11648
11649       /* Reset the stub type from the plt variant in case we now
11650          can reach with a shorter stub.  */
11651       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11652         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11653
11654       size = 4;
11655       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11656         {
11657           r2off = get_r2off (info, stub_entry);
11658           if (r2off == (bfd_vma) -1)
11659             {
11660               htab->stub_error = TRUE;
11661               return FALSE;
11662             }
11663           size = 8;
11664           if (PPC_HA (r2off) != 0)
11665             size += 4;
11666           if (PPC_LO (r2off) != 0)
11667             size += 4;
11668           off -= size - 4;
11669         }
11670
11671       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11672
11673       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11674          Do the same for -R objects without function descriptors.  */
11675       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11676           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11677               && r2off == 0
11678               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11679         {
11680           struct ppc_branch_hash_entry *br_entry;
11681
11682           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11683                                              stub_entry->root.string + 9,
11684                                              TRUE, FALSE);
11685           if (br_entry == NULL)
11686             {
11687               _bfd_error_handler (_("can't build branch stub `%s'"),
11688                                   stub_entry->root.string);
11689               htab->stub_error = TRUE;
11690               return FALSE;
11691             }
11692
11693           if (br_entry->iter != htab->stub_iteration)
11694             {
11695               br_entry->iter = htab->stub_iteration;
11696               br_entry->offset = htab->brlt->size;
11697               htab->brlt->size += 8;
11698
11699               if (htab->relbrlt != NULL)
11700                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11701               else if (info->emitrelocations)
11702                 {
11703                   htab->brlt->reloc_count += 1;
11704                   htab->brlt->flags |= SEC_RELOC;
11705                 }
11706             }
11707
11708           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11709           off = (br_entry->offset
11710                  + htab->brlt->output_offset
11711                  + htab->brlt->output_section->vma
11712                  - elf_gp (info->output_bfd)
11713                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11714
11715           if (info->emitrelocations)
11716             {
11717               stub_entry->group->stub_sec->reloc_count
11718                 += 1 + (PPC_HA (off) != 0);
11719               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11720             }
11721
11722           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11723             {
11724               size = 12;
11725               if (PPC_HA (off) != 0)
11726                 size = 16;
11727             }
11728           else
11729             {
11730               size = 16;
11731               if (PPC_HA (off) != 0)
11732                 size += 4;
11733
11734               if (PPC_HA (r2off) != 0)
11735                 size += 4;
11736               if (PPC_LO (r2off) != 0)
11737                 size += 4;
11738             }
11739         }
11740       else if (info->emitrelocations)
11741         {
11742           stub_entry->group->stub_sec->reloc_count += 1;
11743           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11744         }
11745     }
11746
11747   stub_entry->group->stub_sec->size += size;
11748   return TRUE;
11749 }
11750
11751 /* Set up various things so that we can make a list of input sections
11752    for each output section included in the link.  Returns -1 on error,
11753    0 when no stubs will be needed, and 1 on success.  */
11754
11755 int
11756 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11757 {
11758   unsigned int id;
11759   bfd_size_type amt;
11760   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11761
11762   if (htab == NULL)
11763     return -1;
11764
11765   htab->sec_info_arr_size = _bfd_section_id;
11766   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11767   htab->sec_info = bfd_zmalloc (amt);
11768   if (htab->sec_info == NULL)
11769     return -1;
11770
11771   /* Set toc_off for com, und, abs and ind sections.  */
11772   for (id = 0; id < 3; id++)
11773     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11774
11775   return 1;
11776 }
11777
11778 /* Set up for first pass at multitoc partitioning.  */
11779
11780 void
11781 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11782 {
11783   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11784
11785   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11786   htab->toc_bfd = NULL;
11787   htab->toc_first_sec = NULL;
11788 }
11789
11790 /* The linker repeatedly calls this function for each TOC input section
11791    and linker generated GOT section.  Group input bfds such that the toc
11792    within a group is less than 64k in size.  */
11793
11794 bfd_boolean
11795 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11796 {
11797   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11798   bfd_vma addr, off, limit;
11799
11800   if (htab == NULL)
11801     return FALSE;
11802
11803   if (!htab->second_toc_pass)
11804     {
11805       /* Keep track of the first .toc or .got section for this input bfd.  */
11806       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11807
11808       if (new_bfd)
11809         {
11810           htab->toc_bfd = isec->owner;
11811           htab->toc_first_sec = isec;
11812         }
11813
11814       addr = isec->output_offset + isec->output_section->vma;
11815       off = addr - htab->toc_curr;
11816       limit = 0x80008000;
11817       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11818         limit = 0x10000;
11819       if (off + isec->size > limit)
11820         {
11821           addr = (htab->toc_first_sec->output_offset
11822                   + htab->toc_first_sec->output_section->vma);
11823           htab->toc_curr = addr;
11824           htab->toc_curr &= -TOC_BASE_ALIGN;
11825         }
11826
11827       /* toc_curr is the base address of this toc group.  Set elf_gp
11828          for the input section to be the offset relative to the
11829          output toc base plus 0x8000.  Making the input elf_gp an
11830          offset allows us to move the toc as a whole without
11831          recalculating input elf_gp.  */
11832       off = htab->toc_curr - elf_gp (info->output_bfd);
11833       off += TOC_BASE_OFF;
11834
11835       /* Die if someone uses a linker script that doesn't keep input
11836          file .toc and .got together.  */
11837       if (new_bfd
11838           && elf_gp (isec->owner) != 0
11839           && elf_gp (isec->owner) != off)
11840         return FALSE;
11841
11842       elf_gp (isec->owner) = off;
11843       return TRUE;
11844     }
11845
11846   /* During the second pass toc_first_sec points to the start of
11847      a toc group, and toc_curr is used to track the old elf_gp.
11848      We use toc_bfd to ensure we only look at each bfd once.  */
11849   if (htab->toc_bfd == isec->owner)
11850     return TRUE;
11851   htab->toc_bfd = isec->owner;
11852
11853   if (htab->toc_first_sec == NULL
11854       || htab->toc_curr != elf_gp (isec->owner))
11855     {
11856       htab->toc_curr = elf_gp (isec->owner);
11857       htab->toc_first_sec = isec;
11858     }
11859   addr = (htab->toc_first_sec->output_offset
11860           + htab->toc_first_sec->output_section->vma);
11861   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11862   elf_gp (isec->owner) = off;
11863
11864   return TRUE;
11865 }
11866
11867 /* Called via elf_link_hash_traverse to merge GOT entries for global
11868    symbol H.  */
11869
11870 static bfd_boolean
11871 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11872 {
11873   if (h->root.type == bfd_link_hash_indirect)
11874     return TRUE;
11875
11876   merge_got_entries (&h->got.glist);
11877
11878   return TRUE;
11879 }
11880
11881 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11882    symbol H.  */
11883
11884 static bfd_boolean
11885 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11886 {
11887   struct got_entry *gent;
11888
11889   if (h->root.type == bfd_link_hash_indirect)
11890     return TRUE;
11891
11892   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11893     if (!gent->is_indirect)
11894       allocate_got (h, (struct bfd_link_info *) inf, gent);
11895   return TRUE;
11896 }
11897
11898 /* Called on the first multitoc pass after the last call to
11899    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11900    entries.  */
11901
11902 bfd_boolean
11903 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11904 {
11905   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11906   struct bfd *ibfd, *ibfd2;
11907   bfd_boolean done_something;
11908
11909   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11910
11911   if (!htab->do_multi_toc)
11912     return FALSE;
11913
11914   /* Merge global sym got entries within a toc group.  */
11915   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11916
11917   /* And tlsld_got.  */
11918   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11919     {
11920       struct got_entry *ent, *ent2;
11921
11922       if (!is_ppc64_elf (ibfd))
11923         continue;
11924
11925       ent = ppc64_tlsld_got (ibfd);
11926       if (!ent->is_indirect
11927           && ent->got.offset != (bfd_vma) -1)
11928         {
11929           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11930             {
11931               if (!is_ppc64_elf (ibfd2))
11932                 continue;
11933
11934               ent2 = ppc64_tlsld_got (ibfd2);
11935               if (!ent2->is_indirect
11936                   && ent2->got.offset != (bfd_vma) -1
11937                   && elf_gp (ibfd2) == elf_gp (ibfd))
11938                 {
11939                   ent2->is_indirect = TRUE;
11940                   ent2->got.ent = ent;
11941                 }
11942             }
11943         }
11944     }
11945
11946   /* Zap sizes of got sections.  */
11947   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11948   htab->elf.irelplt->size -= htab->got_reli_size;
11949   htab->got_reli_size = 0;
11950
11951   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11952     {
11953       asection *got, *relgot;
11954
11955       if (!is_ppc64_elf (ibfd))
11956         continue;
11957
11958       got = ppc64_elf_tdata (ibfd)->got;
11959       if (got != NULL)
11960         {
11961           got->rawsize = got->size;
11962           got->size = 0;
11963           relgot = ppc64_elf_tdata (ibfd)->relgot;
11964           relgot->rawsize = relgot->size;
11965           relgot->size = 0;
11966         }
11967     }
11968
11969   /* Now reallocate the got, local syms first.  We don't need to
11970      allocate section contents again since we never increase size.  */
11971   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11972     {
11973       struct got_entry **lgot_ents;
11974       struct got_entry **end_lgot_ents;
11975       struct plt_entry **local_plt;
11976       struct plt_entry **end_local_plt;
11977       unsigned char *lgot_masks;
11978       bfd_size_type locsymcount;
11979       Elf_Internal_Shdr *symtab_hdr;
11980       asection *s;
11981
11982       if (!is_ppc64_elf (ibfd))
11983         continue;
11984
11985       lgot_ents = elf_local_got_ents (ibfd);
11986       if (!lgot_ents)
11987         continue;
11988
11989       symtab_hdr = &elf_symtab_hdr (ibfd);
11990       locsymcount = symtab_hdr->sh_info;
11991       end_lgot_ents = lgot_ents + locsymcount;
11992       local_plt = (struct plt_entry **) end_lgot_ents;
11993       end_local_plt = local_plt + locsymcount;
11994       lgot_masks = (unsigned char *) end_local_plt;
11995       s = ppc64_elf_tdata (ibfd)->got;
11996       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11997         {
11998           struct got_entry *ent;
11999
12000           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12001             {
12002               unsigned int ent_size = 8;
12003               unsigned int rel_size = sizeof (Elf64_External_Rela);
12004
12005               ent->got.offset = s->size;
12006               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12007                 {
12008                   ent_size *= 2;
12009                   rel_size *= 2;
12010                 }
12011               s->size += ent_size;
12012               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12013                 {
12014                   htab->elf.irelplt->size += rel_size;
12015                   htab->got_reli_size += rel_size;
12016                 }
12017               else if (bfd_link_pic (info)
12018                        && !((ent->tls_type & TLS_TPREL) != 0
12019                             && bfd_link_executable (info)))
12020                 {
12021                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12022                   srel->size += rel_size;
12023                 }
12024             }
12025         }
12026     }
12027
12028   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12029
12030   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12031     {
12032       struct got_entry *ent;
12033
12034       if (!is_ppc64_elf (ibfd))
12035         continue;
12036
12037       ent = ppc64_tlsld_got (ibfd);
12038       if (!ent->is_indirect
12039           && ent->got.offset != (bfd_vma) -1)
12040         {
12041           asection *s = ppc64_elf_tdata (ibfd)->got;
12042           ent->got.offset = s->size;
12043           s->size += 16;
12044           if (bfd_link_pic (info))
12045             {
12046               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12047               srel->size += sizeof (Elf64_External_Rela);
12048             }
12049         }
12050     }
12051
12052   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12053   if (!done_something)
12054     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12055       {
12056         asection *got;
12057
12058         if (!is_ppc64_elf (ibfd))
12059           continue;
12060
12061         got = ppc64_elf_tdata (ibfd)->got;
12062         if (got != NULL)
12063           {
12064             done_something = got->rawsize != got->size;
12065             if (done_something)
12066               break;
12067           }
12068       }
12069
12070   if (done_something)
12071     (*htab->params->layout_sections_again) ();
12072
12073   /* Set up for second pass over toc sections to recalculate elf_gp
12074      on input sections.  */
12075   htab->toc_bfd = NULL;
12076   htab->toc_first_sec = NULL;
12077   htab->second_toc_pass = TRUE;
12078   return done_something;
12079 }
12080
12081 /* Called after second pass of multitoc partitioning.  */
12082
12083 void
12084 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12085 {
12086   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12087
12088   /* After the second pass, toc_curr tracks the TOC offset used
12089      for code sections below in ppc64_elf_next_input_section.  */
12090   htab->toc_curr = TOC_BASE_OFF;
12091 }
12092
12093 /* No toc references were found in ISEC.  If the code in ISEC makes no
12094    calls, then there's no need to use toc adjusting stubs when branching
12095    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12096    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12097    needed, and 2 if a cyclical call-graph was found but no other reason
12098    for a stub was detected.  If called from the top level, a return of
12099    2 means the same as a return of 0.  */
12100
12101 static int
12102 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12103 {
12104   int ret;
12105
12106   /* Mark this section as checked.  */
12107   isec->call_check_done = 1;
12108
12109   /* We know none of our code bearing sections will need toc stubs.  */
12110   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12111     return 0;
12112
12113   if (isec->size == 0)
12114     return 0;
12115
12116   if (isec->output_section == NULL)
12117     return 0;
12118
12119   ret = 0;
12120   if (isec->reloc_count != 0)
12121     {
12122       Elf_Internal_Rela *relstart, *rel;
12123       Elf_Internal_Sym *local_syms;
12124       struct ppc_link_hash_table *htab;
12125
12126       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12127                                             info->keep_memory);
12128       if (relstart == NULL)
12129         return -1;
12130
12131       /* Look for branches to outside of this section.  */
12132       local_syms = NULL;
12133       htab = ppc_hash_table (info);
12134       if (htab == NULL)
12135         return -1;
12136
12137       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12138         {
12139           enum elf_ppc64_reloc_type r_type;
12140           unsigned long r_symndx;
12141           struct elf_link_hash_entry *h;
12142           struct ppc_link_hash_entry *eh;
12143           Elf_Internal_Sym *sym;
12144           asection *sym_sec;
12145           struct _opd_sec_data *opd;
12146           bfd_vma sym_value;
12147           bfd_vma dest;
12148
12149           r_type = ELF64_R_TYPE (rel->r_info);
12150           if (r_type != R_PPC64_REL24
12151               && r_type != R_PPC64_REL14
12152               && r_type != R_PPC64_REL14_BRTAKEN
12153               && r_type != R_PPC64_REL14_BRNTAKEN
12154               && r_type != R_PPC64_PLTCALL)
12155             continue;
12156
12157           r_symndx = ELF64_R_SYM (rel->r_info);
12158           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12159                           isec->owner))
12160             {
12161               ret = -1;
12162               break;
12163             }
12164
12165           /* Calls to dynamic lib functions go through a plt call stub
12166              that uses r2.  */
12167           eh = (struct ppc_link_hash_entry *) h;
12168           if (eh != NULL
12169               && (eh->elf.plt.plist != NULL
12170                   || (eh->oh != NULL
12171                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12172             {
12173               ret = 1;
12174               break;
12175             }
12176
12177           if (sym_sec == NULL)
12178             /* Ignore other undefined symbols.  */
12179             continue;
12180
12181           /* Assume branches to other sections not included in the
12182              link need stubs too, to cover -R and absolute syms.  */
12183           if (sym_sec->output_section == NULL)
12184             {
12185               ret = 1;
12186               break;
12187             }
12188
12189           if (h == NULL)
12190             sym_value = sym->st_value;
12191           else
12192             {
12193               if (h->root.type != bfd_link_hash_defined
12194                   && h->root.type != bfd_link_hash_defweak)
12195                 abort ();
12196               sym_value = h->root.u.def.value;
12197             }
12198           sym_value += rel->r_addend;
12199
12200           /* If this branch reloc uses an opd sym, find the code section.  */
12201           opd = get_opd_info (sym_sec);
12202           if (opd != NULL)
12203             {
12204               if (h == NULL && opd->adjust != NULL)
12205                 {
12206                   long adjust;
12207
12208                   adjust = opd->adjust[OPD_NDX (sym_value)];
12209                   if (adjust == -1)
12210                     /* Assume deleted functions won't ever be called.  */
12211                     continue;
12212                   sym_value += adjust;
12213                 }
12214
12215               dest = opd_entry_value (sym_sec, sym_value,
12216                                       &sym_sec, NULL, FALSE);
12217               if (dest == (bfd_vma) -1)
12218                 continue;
12219             }
12220           else
12221             dest = (sym_value
12222                     + sym_sec->output_offset
12223                     + sym_sec->output_section->vma);
12224
12225           /* Ignore branch to self.  */
12226           if (sym_sec == isec)
12227             continue;
12228
12229           /* If the called function uses the toc, we need a stub.  */
12230           if (sym_sec->has_toc_reloc
12231               || sym_sec->makes_toc_func_call)
12232             {
12233               ret = 1;
12234               break;
12235             }
12236
12237           /* Assume any branch that needs a long branch stub might in fact
12238              need a plt_branch stub.  A plt_branch stub uses r2.  */
12239           else if (dest - (isec->output_offset
12240                            + isec->output_section->vma
12241                            + rel->r_offset) + (1 << 25)
12242                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12243                                                              ? h->other
12244                                                              : sym->st_other))
12245             {
12246               ret = 1;
12247               break;
12248             }
12249
12250           /* If calling back to a section in the process of being
12251              tested, we can't say for sure that no toc adjusting stubs
12252              are needed, so don't return zero.  */
12253           else if (sym_sec->call_check_in_progress)
12254             ret = 2;
12255
12256           /* Branches to another section that itself doesn't have any TOC
12257              references are OK.  Recursively call ourselves to check.  */
12258           else if (!sym_sec->call_check_done)
12259             {
12260               int recur;
12261
12262               /* Mark current section as indeterminate, so that other
12263                  sections that call back to current won't be marked as
12264                  known.  */
12265               isec->call_check_in_progress = 1;
12266               recur = toc_adjusting_stub_needed (info, sym_sec);
12267               isec->call_check_in_progress = 0;
12268
12269               if (recur != 0)
12270                 {
12271                   ret = recur;
12272                   if (recur != 2)
12273                     break;
12274                 }
12275             }
12276         }
12277
12278       if (local_syms != NULL
12279           && (elf_symtab_hdr (isec->owner).contents
12280               != (unsigned char *) local_syms))
12281         free (local_syms);
12282       if (elf_section_data (isec)->relocs != relstart)
12283         free (relstart);
12284     }
12285
12286   if ((ret & 1) == 0
12287       && isec->map_head.s != NULL
12288       && (strcmp (isec->output_section->name, ".init") == 0
12289           || strcmp (isec->output_section->name, ".fini") == 0))
12290     {
12291       if (isec->map_head.s->has_toc_reloc
12292           || isec->map_head.s->makes_toc_func_call)
12293         ret = 1;
12294       else if (!isec->map_head.s->call_check_done)
12295         {
12296           int recur;
12297           isec->call_check_in_progress = 1;
12298           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12299           isec->call_check_in_progress = 0;
12300           if (recur != 0)
12301             ret = recur;
12302         }
12303     }
12304
12305   if (ret == 1)
12306     isec->makes_toc_func_call = 1;
12307
12308   return ret;
12309 }
12310
12311 /* The linker repeatedly calls this function for each input section,
12312    in the order that input sections are linked into output sections.
12313    Build lists of input sections to determine groupings between which
12314    we may insert linker stubs.  */
12315
12316 bfd_boolean
12317 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12318 {
12319   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12320
12321   if (htab == NULL)
12322     return FALSE;
12323
12324   if ((isec->output_section->flags & SEC_CODE) != 0
12325       && isec->output_section->id < htab->sec_info_arr_size)
12326     {
12327       /* This happens to make the list in reverse order,
12328          which is what we want.  */
12329       htab->sec_info[isec->id].u.list
12330         = htab->sec_info[isec->output_section->id].u.list;
12331       htab->sec_info[isec->output_section->id].u.list = isec;
12332     }
12333
12334   if (htab->multi_toc_needed)
12335     {
12336       /* Analyse sections that aren't already flagged as needing a
12337          valid toc pointer.  Exclude .fixup for the linux kernel.
12338          .fixup contains branches, but only back to the function that
12339          hit an exception.  */
12340       if (!(isec->has_toc_reloc
12341             || (isec->flags & SEC_CODE) == 0
12342             || strcmp (isec->name, ".fixup") == 0
12343             || isec->call_check_done))
12344         {
12345           if (toc_adjusting_stub_needed (info, isec) < 0)
12346             return FALSE;
12347         }
12348       /* Make all sections use the TOC assigned for this object file.
12349          This will be wrong for pasted sections;  We fix that in
12350          check_pasted_section().  */
12351       if (elf_gp (isec->owner) != 0)
12352         htab->toc_curr = elf_gp (isec->owner);
12353     }
12354
12355   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12356   return TRUE;
12357 }
12358
12359 /* Check that all .init and .fini sections use the same toc, if they
12360    have toc relocs.  */
12361
12362 static bfd_boolean
12363 check_pasted_section (struct bfd_link_info *info, const char *name)
12364 {
12365   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12366
12367   if (o != NULL)
12368     {
12369       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12370       bfd_vma toc_off = 0;
12371       asection *i;
12372
12373       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12374         if (i->has_toc_reloc)
12375           {
12376             if (toc_off == 0)
12377               toc_off = htab->sec_info[i->id].toc_off;
12378             else if (toc_off != htab->sec_info[i->id].toc_off)
12379               return FALSE;
12380           }
12381
12382       if (toc_off == 0)
12383         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12384           if (i->makes_toc_func_call)
12385             {
12386               toc_off = htab->sec_info[i->id].toc_off;
12387               break;
12388             }
12389
12390       /* Make sure the whole pasted function uses the same toc offset.  */
12391       if (toc_off != 0)
12392         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12393           htab->sec_info[i->id].toc_off = toc_off;
12394     }
12395   return TRUE;
12396 }
12397
12398 bfd_boolean
12399 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12400 {
12401   return (check_pasted_section (info, ".init")
12402           & check_pasted_section (info, ".fini"));
12403 }
12404
12405 /* See whether we can group stub sections together.  Grouping stub
12406    sections may result in fewer stubs.  More importantly, we need to
12407    put all .init* and .fini* stubs at the beginning of the .init or
12408    .fini output sections respectively, because glibc splits the
12409    _init and _fini functions into multiple parts.  Putting a stub in
12410    the middle of a function is not a good idea.  */
12411
12412 static bfd_boolean
12413 group_sections (struct bfd_link_info *info,
12414                 bfd_size_type stub_group_size,
12415                 bfd_boolean stubs_always_before_branch)
12416 {
12417   struct ppc_link_hash_table *htab;
12418   asection *osec;
12419   bfd_boolean suppress_size_errors;
12420
12421   htab = ppc_hash_table (info);
12422   if (htab == NULL)
12423     return FALSE;
12424
12425   suppress_size_errors = FALSE;
12426   if (stub_group_size == 1)
12427     {
12428       /* Default values.  */
12429       if (stubs_always_before_branch)
12430         stub_group_size = 0x1e00000;
12431       else
12432         stub_group_size = 0x1c00000;
12433       suppress_size_errors = TRUE;
12434     }
12435
12436   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12437     {
12438       asection *tail;
12439
12440       if (osec->id >= htab->sec_info_arr_size)
12441         continue;
12442
12443       tail = htab->sec_info[osec->id].u.list;
12444       while (tail != NULL)
12445         {
12446           asection *curr;
12447           asection *prev;
12448           bfd_size_type total;
12449           bfd_boolean big_sec;
12450           bfd_vma curr_toc;
12451           struct map_stub *group;
12452           bfd_size_type group_size;
12453
12454           curr = tail;
12455           total = tail->size;
12456           group_size = (ppc64_elf_section_data (tail) != NULL
12457                         && ppc64_elf_section_data (tail)->has_14bit_branch
12458                         ? stub_group_size >> 10 : stub_group_size);
12459
12460           big_sec = total > group_size;
12461           if (big_sec && !suppress_size_errors)
12462             /* xgettext:c-format */
12463             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12464                                 tail->owner, tail);
12465           curr_toc = htab->sec_info[tail->id].toc_off;
12466
12467           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12468                  && ((total += curr->output_offset - prev->output_offset)
12469                      < (ppc64_elf_section_data (prev) != NULL
12470                         && ppc64_elf_section_data (prev)->has_14bit_branch
12471                         ? (group_size = stub_group_size >> 10) : group_size))
12472                  && htab->sec_info[prev->id].toc_off == curr_toc)
12473             curr = prev;
12474
12475           /* OK, the size from the start of CURR to the end is less
12476              than group_size and thus can be handled by one stub
12477              section.  (or the tail section is itself larger than
12478              group_size, in which case we may be toast.)  We should
12479              really be keeping track of the total size of stubs added
12480              here, as stubs contribute to the final output section
12481              size.  That's a little tricky, and this way will only
12482              break if stubs added make the total size more than 2^25,
12483              ie. for the default stub_group_size, if stubs total more
12484              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12485           group = bfd_alloc (curr->owner, sizeof (*group));
12486           if (group == NULL)
12487             return FALSE;
12488           group->link_sec = curr;
12489           group->stub_sec = NULL;
12490           group->needs_save_res = 0;
12491           group->tls_get_addr_opt_bctrl = -1u;
12492           group->next = htab->group;
12493           htab->group = group;
12494           do
12495             {
12496               prev = htab->sec_info[tail->id].u.list;
12497               /* Set up this stub group.  */
12498               htab->sec_info[tail->id].u.group = group;
12499             }
12500           while (tail != curr && (tail = prev) != NULL);
12501
12502           /* But wait, there's more!  Input sections up to group_size
12503              bytes before the stub section can be handled by it too.
12504              Don't do this if we have a really large section after the
12505              stubs, as adding more stubs increases the chance that
12506              branches may not reach into the stub section.  */
12507           if (!stubs_always_before_branch && !big_sec)
12508             {
12509               total = 0;
12510               while (prev != NULL
12511                      && ((total += tail->output_offset - prev->output_offset)
12512                          < (ppc64_elf_section_data (prev) != NULL
12513                             && ppc64_elf_section_data (prev)->has_14bit_branch
12514                             ? (group_size = stub_group_size >> 10) : group_size))
12515                      && htab->sec_info[prev->id].toc_off == curr_toc)
12516                 {
12517                   tail = prev;
12518                   prev = htab->sec_info[tail->id].u.list;
12519                   htab->sec_info[tail->id].u.group = group;
12520                 }
12521             }
12522           tail = prev;
12523         }
12524     }
12525   return TRUE;
12526 }
12527
12528 static const unsigned char glink_eh_frame_cie[] =
12529 {
12530   0, 0, 0, 16,                          /* length.  */
12531   0, 0, 0, 0,                           /* id.  */
12532   1,                                    /* CIE version.  */
12533   'z', 'R', 0,                          /* Augmentation string.  */
12534   4,                                    /* Code alignment.  */
12535   0x78,                                 /* Data alignment.  */
12536   65,                                   /* RA reg.  */
12537   1,                                    /* Augmentation size.  */
12538   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12539   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12540 };
12541
12542 static size_t
12543 stub_eh_frame_size (struct map_stub *group, size_t align)
12544 {
12545   size_t this_size = 17;
12546   if (group->tls_get_addr_opt_bctrl != -1u)
12547     {
12548       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12549       if (to_bctrl < 64)
12550         this_size += 1;
12551       else if (to_bctrl < 256)
12552         this_size += 2;
12553       else if (to_bctrl < 65536)
12554         this_size += 3;
12555       else
12556         this_size += 5;
12557       this_size += 6;
12558     }
12559   this_size = (this_size + align - 1) & -align;
12560   return this_size;
12561 }
12562
12563 /* Stripping output sections is normally done before dynamic section
12564    symbols have been allocated.  This function is called later, and
12565    handles cases like htab->brlt which is mapped to its own output
12566    section.  */
12567
12568 static void
12569 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12570 {
12571   if (isec->size == 0
12572       && isec->output_section->size == 0
12573       && !(isec->output_section->flags & SEC_KEEP)
12574       && !bfd_section_removed_from_list (info->output_bfd,
12575                                          isec->output_section)
12576       && elf_section_data (isec->output_section)->dynindx == 0)
12577     {
12578       isec->output_section->flags |= SEC_EXCLUDE;
12579       bfd_section_list_remove (info->output_bfd, isec->output_section);
12580       info->output_bfd->section_count--;
12581     }
12582 }
12583
12584 /* Determine and set the size of the stub section for a final link.
12585
12586    The basic idea here is to examine all the relocations looking for
12587    PC-relative calls to a target that is unreachable with a "bl"
12588    instruction.  */
12589
12590 bfd_boolean
12591 ppc64_elf_size_stubs (struct bfd_link_info *info)
12592 {
12593   bfd_size_type stub_group_size;
12594   bfd_boolean stubs_always_before_branch;
12595   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12596
12597   if (htab == NULL)
12598     return FALSE;
12599
12600   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12601     htab->params->plt_thread_safe = 1;
12602   if (!htab->opd_abi)
12603     htab->params->plt_thread_safe = 0;
12604   else if (htab->params->plt_thread_safe == -1)
12605     {
12606       static const char *const thread_starter[] =
12607         {
12608           "pthread_create",
12609           /* libstdc++ */
12610           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12611           /* librt */
12612           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12613           "mq_notify", "create_timer",
12614           /* libanl */
12615           "getaddrinfo_a",
12616           /* libgomp */
12617           "GOMP_parallel",
12618           "GOMP_parallel_start",
12619           "GOMP_parallel_loop_static",
12620           "GOMP_parallel_loop_static_start",
12621           "GOMP_parallel_loop_dynamic",
12622           "GOMP_parallel_loop_dynamic_start",
12623           "GOMP_parallel_loop_guided",
12624           "GOMP_parallel_loop_guided_start",
12625           "GOMP_parallel_loop_runtime",
12626           "GOMP_parallel_loop_runtime_start",
12627           "GOMP_parallel_sections",
12628           "GOMP_parallel_sections_start",
12629           /* libgo */
12630           "__go_go",
12631         };
12632       unsigned i;
12633
12634       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12635         {
12636           struct elf_link_hash_entry *h;
12637           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12638                                     FALSE, FALSE, TRUE);
12639           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12640           if (htab->params->plt_thread_safe)
12641             break;
12642         }
12643     }
12644   stubs_always_before_branch = htab->params->group_size < 0;
12645   if (htab->params->group_size < 0)
12646     stub_group_size = -htab->params->group_size;
12647   else
12648     stub_group_size = htab->params->group_size;
12649
12650   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12651     return FALSE;
12652
12653 #define STUB_SHRINK_ITER 20
12654   /* Loop until no stubs added.  After iteration 20 of this loop we may
12655      exit on a stub section shrinking.  This is to break out of a
12656      pathological case where adding stubs on one iteration decreases
12657      section gaps (perhaps due to alignment), which then requires
12658      fewer or smaller stubs on the next iteration.  */
12659
12660   while (1)
12661     {
12662       bfd *input_bfd;
12663       unsigned int bfd_indx;
12664       struct map_stub *group;
12665
12666       htab->stub_iteration += 1;
12667
12668       for (input_bfd = info->input_bfds, bfd_indx = 0;
12669            input_bfd != NULL;
12670            input_bfd = input_bfd->link.next, bfd_indx++)
12671         {
12672           Elf_Internal_Shdr *symtab_hdr;
12673           asection *section;
12674           Elf_Internal_Sym *local_syms = NULL;
12675
12676           if (!is_ppc64_elf (input_bfd))
12677             continue;
12678
12679           /* We'll need the symbol table in a second.  */
12680           symtab_hdr = &elf_symtab_hdr (input_bfd);
12681           if (symtab_hdr->sh_info == 0)
12682             continue;
12683
12684           /* Walk over each section attached to the input bfd.  */
12685           for (section = input_bfd->sections;
12686                section != NULL;
12687                section = section->next)
12688             {
12689               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12690
12691               /* If there aren't any relocs, then there's nothing more
12692                  to do.  */
12693               if ((section->flags & SEC_RELOC) == 0
12694                   || (section->flags & SEC_ALLOC) == 0
12695                   || (section->flags & SEC_LOAD) == 0
12696                   || (section->flags & SEC_CODE) == 0
12697                   || section->reloc_count == 0)
12698                 continue;
12699
12700               /* If this section is a link-once section that will be
12701                  discarded, then don't create any stubs.  */
12702               if (section->output_section == NULL
12703                   || section->output_section->owner != info->output_bfd)
12704                 continue;
12705
12706               /* Get the relocs.  */
12707               internal_relocs
12708                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12709                                              info->keep_memory);
12710               if (internal_relocs == NULL)
12711                 goto error_ret_free_local;
12712
12713               /* Now examine each relocation.  */
12714               irela = internal_relocs;
12715               irelaend = irela + section->reloc_count;
12716               for (; irela < irelaend; irela++)
12717                 {
12718                   enum elf_ppc64_reloc_type r_type;
12719                   unsigned int r_indx;
12720                   enum ppc_stub_type stub_type;
12721                   struct ppc_stub_hash_entry *stub_entry;
12722                   asection *sym_sec, *code_sec;
12723                   bfd_vma sym_value, code_value;
12724                   bfd_vma destination;
12725                   unsigned long local_off;
12726                   bfd_boolean ok_dest;
12727                   struct ppc_link_hash_entry *hash;
12728                   struct ppc_link_hash_entry *fdh;
12729                   struct elf_link_hash_entry *h;
12730                   Elf_Internal_Sym *sym;
12731                   char *stub_name;
12732                   const asection *id_sec;
12733                   struct _opd_sec_data *opd;
12734                   struct plt_entry *plt_ent;
12735
12736                   r_type = ELF64_R_TYPE (irela->r_info);
12737                   r_indx = ELF64_R_SYM (irela->r_info);
12738
12739                   if (r_type >= R_PPC64_max)
12740                     {
12741                       bfd_set_error (bfd_error_bad_value);
12742                       goto error_ret_free_internal;
12743                     }
12744
12745                   /* Only look for stubs on branch instructions.  */
12746                   if (r_type != R_PPC64_REL24
12747                       && r_type != R_PPC64_REL14
12748                       && r_type != R_PPC64_REL14_BRTAKEN
12749                       && r_type != R_PPC64_REL14_BRNTAKEN)
12750                     continue;
12751
12752                   /* Now determine the call target, its name, value,
12753                      section.  */
12754                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12755                                   r_indx, input_bfd))
12756                     goto error_ret_free_internal;
12757                   hash = (struct ppc_link_hash_entry *) h;
12758
12759                   ok_dest = FALSE;
12760                   fdh = NULL;
12761                   sym_value = 0;
12762                   if (hash == NULL)
12763                     {
12764                       sym_value = sym->st_value;
12765                       if (sym_sec != NULL
12766                           && sym_sec->output_section != NULL)
12767                         ok_dest = TRUE;
12768                     }
12769                   else if (hash->elf.root.type == bfd_link_hash_defined
12770                            || hash->elf.root.type == bfd_link_hash_defweak)
12771                     {
12772                       sym_value = hash->elf.root.u.def.value;
12773                       if (sym_sec->output_section != NULL)
12774                         ok_dest = TRUE;
12775                     }
12776                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12777                            || hash->elf.root.type == bfd_link_hash_undefined)
12778                     {
12779                       /* Recognise an old ABI func code entry sym, and
12780                          use the func descriptor sym instead if it is
12781                          defined.  */
12782                       if (hash->elf.root.root.string[0] == '.'
12783                           && hash->oh != NULL)
12784                         {
12785                           fdh = ppc_follow_link (hash->oh);
12786                           if (fdh->elf.root.type == bfd_link_hash_defined
12787                               || fdh->elf.root.type == bfd_link_hash_defweak)
12788                             {
12789                               sym_sec = fdh->elf.root.u.def.section;
12790                               sym_value = fdh->elf.root.u.def.value;
12791                               if (sym_sec->output_section != NULL)
12792                                 ok_dest = TRUE;
12793                             }
12794                           else
12795                             fdh = NULL;
12796                         }
12797                     }
12798                   else
12799                     {
12800                       bfd_set_error (bfd_error_bad_value);
12801                       goto error_ret_free_internal;
12802                     }
12803
12804                   destination = 0;
12805                   local_off = 0;
12806                   if (ok_dest)
12807                     {
12808                       sym_value += irela->r_addend;
12809                       destination = (sym_value
12810                                      + sym_sec->output_offset
12811                                      + sym_sec->output_section->vma);
12812                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12813                                                             ? hash->elf.other
12814                                                             : sym->st_other);
12815                     }
12816
12817                   code_sec = sym_sec;
12818                   code_value = sym_value;
12819                   opd = get_opd_info (sym_sec);
12820                   if (opd != NULL)
12821                     {
12822                       bfd_vma dest;
12823
12824                       if (hash == NULL && opd->adjust != NULL)
12825                         {
12826                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12827                           if (adjust == -1)
12828                             continue;
12829                           code_value += adjust;
12830                           sym_value += adjust;
12831                         }
12832                       dest = opd_entry_value (sym_sec, sym_value,
12833                                               &code_sec, &code_value, FALSE);
12834                       if (dest != (bfd_vma) -1)
12835                         {
12836                           destination = dest;
12837                           if (fdh != NULL)
12838                             {
12839                               /* Fixup old ABI sym to point at code
12840                                  entry.  */
12841                               hash->elf.root.type = bfd_link_hash_defweak;
12842                               hash->elf.root.u.def.section = code_sec;
12843                               hash->elf.root.u.def.value = code_value;
12844                             }
12845                         }
12846                     }
12847
12848                   /* Determine what (if any) linker stub is needed.  */
12849                   plt_ent = NULL;
12850                   stub_type = ppc_type_of_stub (section, irela, &hash,
12851                                                 &plt_ent, destination,
12852                                                 local_off);
12853
12854                   if (stub_type != ppc_stub_plt_call)
12855                     {
12856                       /* Check whether we need a TOC adjusting stub.
12857                          Since the linker pastes together pieces from
12858                          different object files when creating the
12859                          _init and _fini functions, it may be that a
12860                          call to what looks like a local sym is in
12861                          fact a call needing a TOC adjustment.  */
12862                       if (code_sec != NULL
12863                           && code_sec->output_section != NULL
12864                           && (htab->sec_info[code_sec->id].toc_off
12865                               != htab->sec_info[section->id].toc_off)
12866                           && (code_sec->has_toc_reloc
12867                               || code_sec->makes_toc_func_call))
12868                         stub_type = ppc_stub_long_branch_r2off;
12869                     }
12870
12871                   if (stub_type == ppc_stub_none)
12872                     continue;
12873
12874                   /* __tls_get_addr calls might be eliminated.  */
12875                   if (stub_type != ppc_stub_plt_call
12876                       && hash != NULL
12877                       && (hash == htab->tls_get_addr
12878                           || hash == htab->tls_get_addr_fd)
12879                       && section->has_tls_reloc
12880                       && irela != internal_relocs)
12881                     {
12882                       /* Get tls info.  */
12883                       unsigned char *tls_mask;
12884
12885                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12886                                          irela - 1, input_bfd))
12887                         goto error_ret_free_internal;
12888                       if ((*tls_mask & TLS_TLS) != 0)
12889                         continue;
12890                     }
12891
12892                   if (stub_type == ppc_stub_plt_call)
12893                     {
12894                       if (!htab->opd_abi
12895                           && htab->params->plt_localentry0 != 0
12896                           && is_elfv2_localentry0 (&hash->elf))
12897                         htab->has_plt_localentry0 = 1;
12898                       else if (irela + 1 < irelaend
12899                                && irela[1].r_offset == irela->r_offset + 4
12900                                && (ELF64_R_TYPE (irela[1].r_info)
12901                                    == R_PPC64_TOCSAVE))
12902                         {
12903                           if (!tocsave_find (htab, INSERT,
12904                                              &local_syms, irela + 1, input_bfd))
12905                             goto error_ret_free_internal;
12906                         }
12907                       else
12908                         stub_type = ppc_stub_plt_call_r2save;
12909                     }
12910
12911                   /* Support for grouping stub sections.  */
12912                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12913
12914                   /* Get the name of this stub.  */
12915                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12916                   if (!stub_name)
12917                     goto error_ret_free_internal;
12918
12919                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12920                                                      stub_name, FALSE, FALSE);
12921                   if (stub_entry != NULL)
12922                     {
12923                       /* The proper stub has already been created.  */
12924                       free (stub_name);
12925                       if (stub_type == ppc_stub_plt_call_r2save)
12926                         stub_entry->stub_type = stub_type;
12927                       continue;
12928                     }
12929
12930                   stub_entry = ppc_add_stub (stub_name, section, info);
12931                   if (stub_entry == NULL)
12932                     {
12933                       free (stub_name);
12934                     error_ret_free_internal:
12935                       if (elf_section_data (section)->relocs == NULL)
12936                         free (internal_relocs);
12937                     error_ret_free_local:
12938                       if (local_syms != NULL
12939                           && (symtab_hdr->contents
12940                               != (unsigned char *) local_syms))
12941                         free (local_syms);
12942                       return FALSE;
12943                     }
12944
12945                   stub_entry->stub_type = stub_type;
12946                   if (stub_type != ppc_stub_plt_call
12947                       && stub_type != ppc_stub_plt_call_r2save)
12948                     {
12949                       stub_entry->target_value = code_value;
12950                       stub_entry->target_section = code_sec;
12951                     }
12952                   else
12953                     {
12954                       stub_entry->target_value = sym_value;
12955                       stub_entry->target_section = sym_sec;
12956                     }
12957                   stub_entry->h = hash;
12958                   stub_entry->plt_ent = plt_ent;
12959                   stub_entry->symtype
12960                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12961                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12962
12963                   if (stub_entry->h != NULL)
12964                     htab->stub_globals += 1;
12965                 }
12966
12967               /* We're done with the internal relocs, free them.  */
12968               if (elf_section_data (section)->relocs != internal_relocs)
12969                 free (internal_relocs);
12970             }
12971
12972           if (local_syms != NULL
12973               && symtab_hdr->contents != (unsigned char *) local_syms)
12974             {
12975               if (!info->keep_memory)
12976                 free (local_syms);
12977               else
12978                 symtab_hdr->contents = (unsigned char *) local_syms;
12979             }
12980         }
12981
12982       /* We may have added some stubs.  Find out the new size of the
12983          stub sections.  */
12984       for (group = htab->group; group != NULL; group = group->next)
12985         if (group->stub_sec != NULL)
12986           {
12987             asection *stub_sec = group->stub_sec;
12988
12989             if (htab->stub_iteration <= STUB_SHRINK_ITER
12990                 || stub_sec->rawsize < stub_sec->size)
12991               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12992               stub_sec->rawsize = stub_sec->size;
12993             stub_sec->size = 0;
12994             stub_sec->reloc_count = 0;
12995             stub_sec->flags &= ~SEC_RELOC;
12996           }
12997
12998       if (htab->stub_iteration <= STUB_SHRINK_ITER
12999           || htab->brlt->rawsize < htab->brlt->size)
13000         htab->brlt->rawsize = htab->brlt->size;
13001       htab->brlt->size = 0;
13002       htab->brlt->reloc_count = 0;
13003       htab->brlt->flags &= ~SEC_RELOC;
13004       if (htab->relbrlt != NULL)
13005         htab->relbrlt->size = 0;
13006
13007       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13008
13009       for (group = htab->group; group != NULL; group = group->next)
13010         if (group->needs_save_res)
13011           group->stub_sec->size += htab->sfpr->size;
13012
13013       if (info->emitrelocations
13014           && htab->glink != NULL && htab->glink->size != 0)
13015         {
13016           htab->glink->reloc_count = 1;
13017           htab->glink->flags |= SEC_RELOC;
13018         }
13019
13020       if (htab->glink_eh_frame != NULL
13021           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13022           && htab->glink_eh_frame->output_section->size > 8)
13023         {
13024           size_t size = 0, align = 4;
13025
13026           for (group = htab->group; group != NULL; group = group->next)
13027             if (group->stub_sec != NULL)
13028               size += stub_eh_frame_size (group, align);
13029           if (htab->glink != NULL && htab->glink->size != 0)
13030             size += (24 + align - 1) & -align;
13031           if (size != 0)
13032             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13033           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13034           size = (size + align - 1) & -align;
13035           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13036           htab->glink_eh_frame->size = size;
13037         }
13038
13039       if (htab->params->plt_stub_align != 0)
13040         for (group = htab->group; group != NULL; group = group->next)
13041           if (group->stub_sec != NULL)
13042             {
13043               int align = abs (htab->params->plt_stub_align);
13044               group->stub_sec->size
13045                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13046             }
13047
13048       for (group = htab->group; group != NULL; group = group->next)
13049         if (group->stub_sec != NULL
13050             && group->stub_sec->rawsize != group->stub_sec->size
13051             && (htab->stub_iteration <= STUB_SHRINK_ITER
13052                 || group->stub_sec->rawsize < group->stub_sec->size))
13053           break;
13054
13055       if (group == NULL
13056           && (htab->brlt->rawsize == htab->brlt->size
13057               || (htab->stub_iteration > STUB_SHRINK_ITER
13058                   && htab->brlt->rawsize > htab->brlt->size))
13059           && (htab->glink_eh_frame == NULL
13060               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13061         break;
13062
13063       /* Ask the linker to do its stuff.  */
13064       (*htab->params->layout_sections_again) ();
13065     }
13066
13067   if (htab->glink_eh_frame != NULL
13068       && htab->glink_eh_frame->size != 0)
13069     {
13070       bfd_vma val;
13071       bfd_byte *p, *last_fde;
13072       size_t last_fde_len, size, align, pad;
13073       struct map_stub *group;
13074
13075       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13076       if (p == NULL)
13077         return FALSE;
13078       htab->glink_eh_frame->contents = p;
13079       last_fde = p;
13080       align = 4;
13081
13082       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13083       /* CIE length (rewrite in case little-endian).  */
13084       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13085       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13086       p += last_fde_len + 4;
13087
13088       for (group = htab->group; group != NULL; group = group->next)
13089         if (group->stub_sec != NULL)
13090           {
13091             last_fde = p;
13092             last_fde_len = stub_eh_frame_size (group, align) - 4;
13093             /* FDE length.  */
13094             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13095             p += 4;
13096             /* CIE pointer.  */
13097             val = p - htab->glink_eh_frame->contents;
13098             bfd_put_32 (htab->elf.dynobj, val, p);
13099             p += 4;
13100             /* Offset to stub section, written later.  */
13101             p += 4;
13102             /* stub section size.  */
13103             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13104             p += 4;
13105             /* Augmentation.  */
13106             p += 1;
13107             if (group->tls_get_addr_opt_bctrl != -1u)
13108               {
13109                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13110
13111                 /* This FDE needs more than just the default.
13112                    Describe __tls_get_addr_opt stub LR.  */
13113                 if (to_bctrl < 64)
13114                   *p++ = DW_CFA_advance_loc + to_bctrl;
13115                 else if (to_bctrl < 256)
13116                   {
13117                     *p++ = DW_CFA_advance_loc1;
13118                     *p++ = to_bctrl;
13119                   }
13120                 else if (to_bctrl < 65536)
13121                   {
13122                     *p++ = DW_CFA_advance_loc2;
13123                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13124                     p += 2;
13125                   }
13126                 else
13127                   {
13128                     *p++ = DW_CFA_advance_loc4;
13129                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13130                     p += 4;
13131                   }
13132                 *p++ = DW_CFA_offset_extended_sf;
13133                 *p++ = 65;
13134                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13135                 *p++ = DW_CFA_advance_loc + 4;
13136                 *p++ = DW_CFA_restore_extended;
13137                 *p++ = 65;
13138               }
13139             /* Pad.  */
13140             p = last_fde + last_fde_len + 4;
13141           }
13142       if (htab->glink != NULL && htab->glink->size != 0)
13143         {
13144           last_fde = p;
13145           last_fde_len = ((24 + align - 1) & -align) - 4;
13146           /* FDE length.  */
13147           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13148           p += 4;
13149           /* CIE pointer.  */
13150           val = p - htab->glink_eh_frame->contents;
13151           bfd_put_32 (htab->elf.dynobj, val, p);
13152           p += 4;
13153           /* Offset to .glink, written later.  */
13154           p += 4;
13155           /* .glink size.  */
13156           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13157           p += 4;
13158           /* Augmentation.  */
13159           p += 1;
13160
13161           *p++ = DW_CFA_advance_loc + 1;
13162           *p++ = DW_CFA_register;
13163           *p++ = 65;
13164           *p++ = htab->opd_abi ? 12 : 0;
13165           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13166           *p++ = DW_CFA_restore_extended;
13167           *p++ = 65;
13168           p += ((24 + align - 1) & -align) - 24;
13169         }
13170       /* Subsume any padding into the last FDE if user .eh_frame
13171          sections are aligned more than glink_eh_frame.  Otherwise any
13172          zero padding will be seen as a terminator.  */
13173       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13174       size = p - htab->glink_eh_frame->contents;
13175       pad = ((size + align - 1) & -align) - size;
13176       htab->glink_eh_frame->size = size + pad;
13177       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13178     }
13179
13180   maybe_strip_output (info, htab->brlt);
13181   if (htab->glink_eh_frame != NULL)
13182     maybe_strip_output (info, htab->glink_eh_frame);
13183
13184   return TRUE;
13185 }
13186
13187 /* Called after we have determined section placement.  If sections
13188    move, we'll be called again.  Provide a value for TOCstart.  */
13189
13190 bfd_vma
13191 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13192 {
13193   asection *s;
13194   bfd_vma TOCstart, adjust;
13195
13196   if (info != NULL)
13197     {
13198       struct elf_link_hash_entry *h;
13199       struct elf_link_hash_table *htab = elf_hash_table (info);
13200
13201       if (is_elf_hash_table (htab)
13202           && htab->hgot != NULL)
13203         h = htab->hgot;
13204       else
13205         {
13206           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13207           if (is_elf_hash_table (htab))
13208             htab->hgot = h;
13209         }
13210       if (h != NULL
13211           && h->root.type == bfd_link_hash_defined
13212           && !h->root.linker_def
13213           && (!is_elf_hash_table (htab)
13214               || h->def_regular))
13215         {
13216           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13217                       + h->root.u.def.section->output_offset
13218                       + h->root.u.def.section->output_section->vma);
13219           _bfd_set_gp_value (obfd, TOCstart);
13220           return TOCstart;
13221         }
13222     }
13223
13224   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13225      order.  The TOC starts where the first of these sections starts.  */
13226   s = bfd_get_section_by_name (obfd, ".got");
13227   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13228     s = bfd_get_section_by_name (obfd, ".toc");
13229   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13230     s = bfd_get_section_by_name (obfd, ".tocbss");
13231   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13232     s = bfd_get_section_by_name (obfd, ".plt");
13233   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13234     {
13235       /* This may happen for
13236          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13237          .toc directive
13238          o  bad linker script
13239          o --gc-sections and empty TOC sections
13240
13241          FIXME: Warn user?  */
13242
13243       /* Look for a likely section.  We probably won't even be
13244          using TOCstart.  */
13245       for (s = obfd->sections; s != NULL; s = s->next)
13246         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13247                          | SEC_EXCLUDE))
13248             == (SEC_ALLOC | SEC_SMALL_DATA))
13249           break;
13250       if (s == NULL)
13251         for (s = obfd->sections; s != NULL; s = s->next)
13252           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13253               == (SEC_ALLOC | SEC_SMALL_DATA))
13254             break;
13255       if (s == NULL)
13256         for (s = obfd->sections; s != NULL; s = s->next)
13257           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13258               == SEC_ALLOC)
13259             break;
13260       if (s == NULL)
13261         for (s = obfd->sections; s != NULL; s = s->next)
13262           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13263             break;
13264     }
13265
13266   TOCstart = 0;
13267   if (s != NULL)
13268     TOCstart = s->output_section->vma + s->output_offset;
13269
13270   /* Force alignment.  */
13271   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13272   TOCstart -= adjust;
13273   _bfd_set_gp_value (obfd, TOCstart);
13274
13275   if (info != NULL && s != NULL)
13276     {
13277       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13278
13279       if (htab != NULL)
13280         {
13281           if (htab->elf.hgot != NULL)
13282             {
13283               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13284               htab->elf.hgot->root.u.def.section = s;
13285             }
13286         }
13287       else
13288         {
13289           struct bfd_link_hash_entry *bh = NULL;
13290           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13291                                             s, TOC_BASE_OFF - adjust,
13292                                             NULL, FALSE, FALSE, &bh);
13293         }
13294     }
13295   return TOCstart;
13296 }
13297
13298 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13299    write out any global entry stubs, and PLT relocations.  */
13300
13301 static bfd_boolean
13302 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13303 {
13304   struct bfd_link_info *info;
13305   struct ppc_link_hash_table *htab;
13306   struct plt_entry *ent;
13307   asection *s;
13308
13309   if (h->root.type == bfd_link_hash_indirect)
13310     return TRUE;
13311
13312   info = inf;
13313   htab = ppc_hash_table (info);
13314   if (htab == NULL)
13315     return FALSE;
13316
13317   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13318     if (ent->plt.offset != (bfd_vma) -1)
13319       {
13320         /* This symbol has an entry in the procedure linkage
13321            table.  Set it up.  */
13322         Elf_Internal_Rela rela;
13323         asection *plt, *relplt;
13324         bfd_byte *loc;
13325
13326         if (!htab->elf.dynamic_sections_created
13327             || h->dynindx == -1)
13328           {
13329             if (!(h->def_regular
13330                   && (h->root.type == bfd_link_hash_defined
13331                       || h->root.type == bfd_link_hash_defweak)))
13332               continue;
13333             if (h->type == STT_GNU_IFUNC)
13334               {
13335                 plt = htab->elf.iplt;
13336                 relplt = htab->elf.irelplt;
13337                 htab->local_ifunc_resolver = 1;
13338                 if (htab->opd_abi)
13339                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13340                 else
13341                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13342               }
13343             else
13344               {
13345                 plt = htab->pltlocal;
13346                 if (bfd_link_pic (info))
13347                   {
13348                     relplt = htab->relpltlocal;
13349                     if (htab->opd_abi)
13350                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13351                     else
13352                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13353                   }
13354                 else
13355                   relplt = NULL;
13356               }
13357             rela.r_addend = (h->root.u.def.value
13358                              + h->root.u.def.section->output_offset
13359                              + h->root.u.def.section->output_section->vma
13360                              + ent->addend);
13361
13362             if (relplt == NULL)
13363               {
13364                 loc = plt->contents + ent->plt.offset;
13365                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13366                 if (htab->opd_abi)
13367                   {
13368                     bfd_vma toc = elf_gp (info->output_bfd);
13369                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13370                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13371                   }
13372               }
13373             else
13374               {
13375                 rela.r_offset = (plt->output_section->vma
13376                                  + plt->output_offset
13377                                  + ent->plt.offset);
13378                 loc = relplt->contents + (relplt->reloc_count++
13379                                           * sizeof (Elf64_External_Rela));
13380                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13381               }
13382           }
13383         else
13384           {
13385             rela.r_offset = (htab->elf.splt->output_section->vma
13386                              + htab->elf.splt->output_offset
13387                              + ent->plt.offset);
13388             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13389             rela.r_addend = ent->addend;
13390             loc = (htab->elf.srelplt->contents
13391                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13392                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13393             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13394               htab->maybe_local_ifunc_resolver = 1;
13395             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13396           }
13397       }
13398
13399   if (!h->pointer_equality_needed)
13400     return TRUE;
13401
13402   if (h->def_regular)
13403     return TRUE;
13404
13405   s = htab->global_entry;
13406   if (s == NULL || s->size == 0)
13407     return TRUE;
13408
13409   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13410     if (ent->plt.offset != (bfd_vma) -1
13411         && ent->addend == 0)
13412       {
13413         bfd_byte *p;
13414         asection *plt;
13415         bfd_vma off;
13416
13417         p = s->contents + h->root.u.def.value;
13418         plt = htab->elf.splt;
13419         if (!htab->elf.dynamic_sections_created
13420             || h->dynindx == -1)
13421           {
13422             if (h->type == STT_GNU_IFUNC)
13423               plt = htab->elf.iplt;
13424             else
13425               plt = htab->pltlocal;
13426           }
13427         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13428         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13429
13430         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13431           {
13432             info->callbacks->einfo
13433               (_("%P: linkage table error against `%pT'\n"),
13434                h->root.root.string);
13435             bfd_set_error (bfd_error_bad_value);
13436             htab->stub_error = TRUE;
13437           }
13438
13439         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13440         if (htab->params->emit_stub_syms)
13441           {
13442             size_t len = strlen (h->root.root.string);
13443             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13444
13445             if (name == NULL)
13446               return FALSE;
13447
13448             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13449             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13450             if (h == NULL)
13451               return FALSE;
13452             if (h->root.type == bfd_link_hash_new)
13453               {
13454                 h->root.type = bfd_link_hash_defined;
13455                 h->root.u.def.section = s;
13456                 h->root.u.def.value = p - s->contents;
13457                 h->ref_regular = 1;
13458                 h->def_regular = 1;
13459                 h->ref_regular_nonweak = 1;
13460                 h->forced_local = 1;
13461                 h->non_elf = 0;
13462                 h->root.linker_def = 1;
13463               }
13464           }
13465
13466         if (PPC_HA (off) != 0)
13467           {
13468             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13469             p += 4;
13470           }
13471         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13472         p += 4;
13473         bfd_put_32 (s->owner, MTCTR_R12, p);
13474         p += 4;
13475         bfd_put_32 (s->owner, BCTR, p);
13476         break;
13477       }
13478   return TRUE;
13479 }
13480
13481 /* Write PLT relocs for locals.  */
13482
13483 static bfd_boolean
13484 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13485 {
13486   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13487   bfd *ibfd;
13488
13489   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13490     {
13491       struct got_entry **lgot_ents, **end_lgot_ents;
13492       struct plt_entry **local_plt, **lplt, **end_local_plt;
13493       Elf_Internal_Shdr *symtab_hdr;
13494       bfd_size_type locsymcount;
13495       Elf_Internal_Sym *local_syms = NULL;
13496       struct plt_entry *ent;
13497
13498       if (!is_ppc64_elf (ibfd))
13499         continue;
13500
13501       lgot_ents = elf_local_got_ents (ibfd);
13502       if (!lgot_ents)
13503         continue;
13504
13505       symtab_hdr = &elf_symtab_hdr (ibfd);
13506       locsymcount = symtab_hdr->sh_info;
13507       end_lgot_ents = lgot_ents + locsymcount;
13508       local_plt = (struct plt_entry **) end_lgot_ents;
13509       end_local_plt = local_plt + locsymcount;
13510       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13511         for (ent = *lplt; ent != NULL; ent = ent->next)
13512           if (ent->plt.offset != (bfd_vma) -1)
13513             {
13514               Elf_Internal_Sym *sym;
13515               asection *sym_sec;
13516               asection *plt, *relplt;
13517               bfd_byte *loc;
13518               bfd_vma val;
13519
13520               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13521                               lplt - local_plt, ibfd))
13522                 {
13523                   if (local_syms != NULL
13524                       && symtab_hdr->contents != (unsigned char *) local_syms)
13525                     free (local_syms);
13526                   return FALSE;
13527                 }
13528
13529               val = sym->st_value + ent->addend;
13530               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13531               if (sym_sec != NULL && sym_sec->output_section != NULL)
13532                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13533
13534               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13535                 {
13536                   htab->local_ifunc_resolver = 1;
13537                   plt = htab->elf.iplt;
13538                   relplt = htab->elf.irelplt;
13539                 }
13540               else
13541                 {
13542                   plt = htab->pltlocal;
13543                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13544                 }
13545
13546               if (relplt == NULL)
13547                 {
13548                   loc = plt->contents + ent->plt.offset;
13549                   bfd_put_64 (info->output_bfd, val, loc);
13550                   if (htab->opd_abi)
13551                     {
13552                       bfd_vma toc = elf_gp (ibfd);
13553                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13554                     }
13555                 }
13556               else
13557                 {
13558                   Elf_Internal_Rela rela;
13559                   rela.r_offset = (ent->plt.offset
13560                                    + plt->output_offset
13561                                    + plt->output_section->vma);
13562                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13563                     {
13564                       if (htab->opd_abi)
13565                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13566                       else
13567                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13568                     }
13569                   else
13570                     {
13571                       if (htab->opd_abi)
13572                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13573                       else
13574                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13575                     }
13576                   rela.r_addend = val;
13577                   loc = relplt->contents + (relplt->reloc_count++
13578                                             * sizeof (Elf64_External_Rela));
13579                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13580                 }
13581             }
13582
13583       if (local_syms != NULL
13584           && symtab_hdr->contents != (unsigned char *) local_syms)
13585         {
13586           if (!info->keep_memory)
13587             free (local_syms);
13588           else
13589             symtab_hdr->contents = (unsigned char *) local_syms;
13590         }
13591     }
13592   return TRUE;
13593 }
13594
13595 /* Build all the stubs associated with the current output file.
13596    The stubs are kept in a hash table attached to the main linker
13597    hash table.  This function is called via gldelf64ppc_finish.  */
13598
13599 bfd_boolean
13600 ppc64_elf_build_stubs (struct bfd_link_info *info,
13601                        char **stats)
13602 {
13603   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13604   struct map_stub *group;
13605   asection *stub_sec;
13606   bfd_byte *p;
13607   int stub_sec_count = 0;
13608
13609   if (htab == NULL)
13610     return FALSE;
13611
13612   /* Allocate memory to hold the linker stubs.  */
13613   for (group = htab->group; group != NULL; group = group->next)
13614     if ((stub_sec = group->stub_sec) != NULL
13615         && stub_sec->size != 0)
13616       {
13617         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13618         if (stub_sec->contents == NULL)
13619           return FALSE;
13620         stub_sec->size = 0;
13621       }
13622
13623   if (htab->glink != NULL && htab->glink->size != 0)
13624     {
13625       unsigned int indx;
13626       bfd_vma plt0;
13627
13628       /* Build the .glink plt call stub.  */
13629       if (htab->params->emit_stub_syms)
13630         {
13631           struct elf_link_hash_entry *h;
13632           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13633                                     TRUE, FALSE, FALSE);
13634           if (h == NULL)
13635             return FALSE;
13636           if (h->root.type == bfd_link_hash_new)
13637             {
13638               h->root.type = bfd_link_hash_defined;
13639               h->root.u.def.section = htab->glink;
13640               h->root.u.def.value = 8;
13641               h->ref_regular = 1;
13642               h->def_regular = 1;
13643               h->ref_regular_nonweak = 1;
13644               h->forced_local = 1;
13645               h->non_elf = 0;
13646               h->root.linker_def = 1;
13647             }
13648         }
13649       plt0 = (htab->elf.splt->output_section->vma
13650               + htab->elf.splt->output_offset
13651               - 16);
13652       if (info->emitrelocations)
13653         {
13654           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13655           if (r == NULL)
13656             return FALSE;
13657           r->r_offset = (htab->glink->output_offset
13658                          + htab->glink->output_section->vma);
13659           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13660           r->r_addend = plt0;
13661         }
13662       p = htab->glink->contents;
13663       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13664       bfd_put_64 (htab->glink->owner, plt0, p);
13665       p += 8;
13666       if (htab->opd_abi)
13667         {
13668           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13669           p += 4;
13670           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13671           p += 4;
13672           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13673           p += 4;
13674           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13675           p += 4;
13676           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13677           p += 4;
13678           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13679           p += 4;
13680           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13681           p += 4;
13682           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13683           p += 4;
13684           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13685           p += 4;
13686           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13687           p += 4;
13688         }
13689       else
13690         {
13691           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13692           p += 4;
13693           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13694           p += 4;
13695           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13696           p += 4;
13697           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13698           p += 4;
13699           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13700           p += 4;
13701           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13702           p += 4;
13703           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13704           p += 4;
13705           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13706           p += 4;
13707           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13708           p += 4;
13709           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13710           p += 4;
13711           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13712           p += 4;
13713           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13714           p += 4;
13715           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13716           p += 4;
13717         }
13718       bfd_put_32 (htab->glink->owner, BCTR, p);
13719       p += 4;
13720       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13721
13722       /* Build the .glink lazy link call stubs.  */
13723       indx = 0;
13724       while (p < htab->glink->contents + htab->glink->size)
13725         {
13726           if (htab->opd_abi)
13727             {
13728               if (indx < 0x8000)
13729                 {
13730                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13731                   p += 4;
13732                 }
13733               else
13734                 {
13735                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13736                   p += 4;
13737                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13738                               p);
13739                   p += 4;
13740                 }
13741             }
13742           bfd_put_32 (htab->glink->owner,
13743                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13744           indx++;
13745           p += 4;
13746         }
13747     }
13748
13749   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13750   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13751
13752   if (!write_plt_relocs_for_local_syms (info))
13753     return FALSE;
13754
13755   if (htab->brlt != NULL && htab->brlt->size != 0)
13756     {
13757       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13758                                          htab->brlt->size);
13759       if (htab->brlt->contents == NULL)
13760         return FALSE;
13761     }
13762   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13763     {
13764       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13765                                             htab->relbrlt->size);
13766       if (htab->relbrlt->contents == NULL)
13767         return FALSE;
13768     }
13769
13770   /* Build the stubs as directed by the stub hash table.  */
13771   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13772
13773   for (group = htab->group; group != NULL; group = group->next)
13774     if (group->needs_save_res)
13775       group->stub_sec->size += htab->sfpr->size;
13776
13777   if (htab->relbrlt != NULL)
13778     htab->relbrlt->reloc_count = 0;
13779
13780   if (htab->params->plt_stub_align != 0)
13781     for (group = htab->group; group != NULL; group = group->next)
13782       if ((stub_sec = group->stub_sec) != NULL)
13783         {
13784           int align = abs (htab->params->plt_stub_align);
13785           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13786         }
13787
13788   for (group = htab->group; group != NULL; group = group->next)
13789     if (group->needs_save_res)
13790       {
13791         stub_sec = group->stub_sec;
13792         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13793                 htab->sfpr->contents, htab->sfpr->size);
13794         if (htab->params->emit_stub_syms)
13795           {
13796             unsigned int i;
13797
13798             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13799               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13800                 return FALSE;
13801           }
13802       }
13803
13804   for (group = htab->group; group != NULL; group = group->next)
13805     if ((stub_sec = group->stub_sec) != NULL)
13806       {
13807         stub_sec_count += 1;
13808         if (stub_sec->rawsize != stub_sec->size
13809             && (htab->stub_iteration <= STUB_SHRINK_ITER
13810                 || stub_sec->rawsize < stub_sec->size))
13811           break;
13812       }
13813
13814   if (group != NULL)
13815     {
13816       htab->stub_error = TRUE;
13817       _bfd_error_handler (_("stubs don't match calculated size"));
13818     }
13819
13820   if (htab->stub_error)
13821     return FALSE;
13822
13823   if (stats != NULL)
13824     {
13825       size_t len;
13826       *stats = bfd_malloc (500);
13827       if (*stats == NULL)
13828         return FALSE;
13829
13830       len = sprintf (*stats,
13831                      ngettext ("linker stubs in %u group\n",
13832                                "linker stubs in %u groups\n",
13833                                stub_sec_count),
13834                      stub_sec_count);
13835       sprintf (*stats + len, _("  branch       %lu\n"
13836                                "  toc adjust   %lu\n"
13837                                "  long branch  %lu\n"
13838                                "  long toc adj %lu\n"
13839                                "  plt call     %lu\n"
13840                                "  plt call toc %lu\n"
13841                                "  global entry %lu"),
13842                htab->stub_count[ppc_stub_long_branch - 1],
13843                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13844                htab->stub_count[ppc_stub_plt_branch - 1],
13845                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13846                htab->stub_count[ppc_stub_plt_call - 1],
13847                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13848                htab->stub_count[ppc_stub_global_entry - 1]);
13849     }
13850   return TRUE;
13851 }
13852
13853 /* What to do when ld finds relocations against symbols defined in
13854    discarded sections.  */
13855
13856 static unsigned int
13857 ppc64_elf_action_discarded (asection *sec)
13858 {
13859   if (strcmp (".opd", sec->name) == 0)
13860     return 0;
13861
13862   if (strcmp (".toc", sec->name) == 0)
13863     return 0;
13864
13865   if (strcmp (".toc1", sec->name) == 0)
13866     return 0;
13867
13868   return _bfd_elf_default_action_discarded (sec);
13869 }
13870
13871 /* The RELOCATE_SECTION function is called by the ELF backend linker
13872    to handle the relocations for a section.
13873
13874    The relocs are always passed as Rela structures; if the section
13875    actually uses Rel structures, the r_addend field will always be
13876    zero.
13877
13878    This function is responsible for adjust the section contents as
13879    necessary, and (if using Rela relocs and generating a
13880    relocatable output file) adjusting the reloc addend as
13881    necessary.
13882
13883    This function does not have to worry about setting the reloc
13884    address or the reloc symbol index.
13885
13886    LOCAL_SYMS is a pointer to the swapped in local symbols.
13887
13888    LOCAL_SECTIONS is an array giving the section in the input file
13889    corresponding to the st_shndx field of each local symbol.
13890
13891    The global hash table entry for the global symbols can be found
13892    via elf_sym_hashes (input_bfd).
13893
13894    When generating relocatable output, this function must handle
13895    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13896    going to be the section symbol corresponding to the output
13897    section, which means that the addend must be adjusted
13898    accordingly.  */
13899
13900 static bfd_boolean
13901 ppc64_elf_relocate_section (bfd *output_bfd,
13902                             struct bfd_link_info *info,
13903                             bfd *input_bfd,
13904                             asection *input_section,
13905                             bfd_byte *contents,
13906                             Elf_Internal_Rela *relocs,
13907                             Elf_Internal_Sym *local_syms,
13908                             asection **local_sections)
13909 {
13910   struct ppc_link_hash_table *htab;
13911   Elf_Internal_Shdr *symtab_hdr;
13912   struct elf_link_hash_entry **sym_hashes;
13913   Elf_Internal_Rela *rel;
13914   Elf_Internal_Rela *wrel;
13915   Elf_Internal_Rela *relend;
13916   Elf_Internal_Rela outrel;
13917   bfd_byte *loc;
13918   struct got_entry **local_got_ents;
13919   bfd_vma TOCstart;
13920   bfd_boolean ret = TRUE;
13921   bfd_boolean is_opd;
13922   /* Assume 'at' branch hints.  */
13923   bfd_boolean is_isa_v2 = TRUE;
13924   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13925
13926   /* Initialize howto table if needed.  */
13927   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13928     ppc_howto_init ();
13929
13930   htab = ppc_hash_table (info);
13931   if (htab == NULL)
13932     return FALSE;
13933
13934   /* Don't relocate stub sections.  */
13935   if (input_section->owner == htab->params->stub_bfd)
13936     return TRUE;
13937
13938   BFD_ASSERT (is_ppc64_elf (input_bfd));
13939
13940   local_got_ents = elf_local_got_ents (input_bfd);
13941   TOCstart = elf_gp (output_bfd);
13942   symtab_hdr = &elf_symtab_hdr (input_bfd);
13943   sym_hashes = elf_sym_hashes (input_bfd);
13944   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13945
13946   rel = wrel = relocs;
13947   relend = relocs + input_section->reloc_count;
13948   for (; rel < relend; wrel++, rel++)
13949     {
13950       enum elf_ppc64_reloc_type r_type;
13951       bfd_vma addend;
13952       bfd_reloc_status_type r;
13953       Elf_Internal_Sym *sym;
13954       asection *sec;
13955       struct elf_link_hash_entry *h_elf;
13956       struct ppc_link_hash_entry *h;
13957       struct ppc_link_hash_entry *fdh;
13958       const char *sym_name;
13959       unsigned long r_symndx, toc_symndx;
13960       bfd_vma toc_addend;
13961       unsigned char tls_mask, tls_gd, tls_type;
13962       unsigned char sym_type;
13963       bfd_vma relocation;
13964       bfd_boolean unresolved_reloc, save_unresolved_reloc;
13965       bfd_boolean warned;
13966       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13967       unsigned int insn;
13968       unsigned int mask;
13969       struct ppc_stub_hash_entry *stub_entry;
13970       bfd_vma max_br_offset;
13971       bfd_vma from;
13972       Elf_Internal_Rela orig_rel;
13973       reloc_howto_type *howto;
13974       struct reloc_howto_struct alt_howto;
13975
13976     again:
13977       orig_rel = *rel;
13978
13979       r_type = ELF64_R_TYPE (rel->r_info);
13980       r_symndx = ELF64_R_SYM (rel->r_info);
13981
13982       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13983          symbol of the previous ADDR64 reloc.  The symbol gives us the
13984          proper TOC base to use.  */
13985       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13986           && wrel != relocs
13987           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13988           && is_opd)
13989         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13990
13991       sym = NULL;
13992       sec = NULL;
13993       h_elf = NULL;
13994       sym_name = NULL;
13995       unresolved_reloc = FALSE;
13996       warned = FALSE;
13997
13998       if (r_symndx < symtab_hdr->sh_info)
13999         {
14000           /* It's a local symbol.  */
14001           struct _opd_sec_data *opd;
14002
14003           sym = local_syms + r_symndx;
14004           sec = local_sections[r_symndx];
14005           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14006           sym_type = ELF64_ST_TYPE (sym->st_info);
14007           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14008           opd = get_opd_info (sec);
14009           if (opd != NULL && opd->adjust != NULL)
14010             {
14011               long adjust = opd->adjust[OPD_NDX (sym->st_value
14012                                                  + rel->r_addend)];
14013               if (adjust == -1)
14014                 relocation = 0;
14015               else
14016                 {
14017                   /* If this is a relocation against the opd section sym
14018                      and we have edited .opd, adjust the reloc addend so
14019                      that ld -r and ld --emit-relocs output is correct.
14020                      If it is a reloc against some other .opd symbol,
14021                      then the symbol value will be adjusted later.  */
14022                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14023                     rel->r_addend += adjust;
14024                   else
14025                     relocation += adjust;
14026                 }
14027             }
14028         }
14029       else
14030         {
14031           bfd_boolean ignored;
14032
14033           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14034                                    r_symndx, symtab_hdr, sym_hashes,
14035                                    h_elf, sec, relocation,
14036                                    unresolved_reloc, warned, ignored);
14037           sym_name = h_elf->root.root.string;
14038           sym_type = h_elf->type;
14039           if (sec != NULL
14040               && sec->owner == output_bfd
14041               && strcmp (sec->name, ".opd") == 0)
14042             {
14043               /* This is a symbol defined in a linker script.  All
14044                  such are defined in output sections, even those
14045                  defined by simple assignment from a symbol defined in
14046                  an input section.  Transfer the symbol to an
14047                  appropriate input .opd section, so that a branch to
14048                  this symbol will be mapped to the location specified
14049                  by the opd entry.  */
14050               struct bfd_link_order *lo;
14051               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14052                 if (lo->type == bfd_indirect_link_order)
14053                   {
14054                     asection *isec = lo->u.indirect.section;
14055                     if (h_elf->root.u.def.value >= isec->output_offset
14056                         && h_elf->root.u.def.value < (isec->output_offset
14057                                                       + isec->size))
14058                       {
14059                         h_elf->root.u.def.value -= isec->output_offset;
14060                         h_elf->root.u.def.section = isec;
14061                         sec = isec;
14062                         break;
14063                       }
14064                   }
14065             }
14066         }
14067       h = (struct ppc_link_hash_entry *) h_elf;
14068
14069       if (sec != NULL && discarded_section (sec))
14070         {
14071           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14072                                input_bfd, input_section,
14073                                contents + rel->r_offset);
14074           wrel->r_offset = rel->r_offset;
14075           wrel->r_info = 0;
14076           wrel->r_addend = 0;
14077
14078           /* For ld -r, remove relocations in debug sections against
14079              symbols defined in discarded sections.  Not done for
14080              non-debug to preserve relocs in .eh_frame which the
14081              eh_frame editing code expects to be present.  */
14082           if (bfd_link_relocatable (info)
14083               && (input_section->flags & SEC_DEBUGGING))
14084             wrel--;
14085
14086           continue;
14087         }
14088
14089       if (bfd_link_relocatable (info))
14090         goto copy_reloc;
14091
14092       if (h != NULL && &h->elf == htab->elf.hgot)
14093         {
14094           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14095           sec = bfd_abs_section_ptr;
14096           unresolved_reloc = FALSE;
14097         }
14098
14099       /* TLS optimizations.  Replace instruction sequences and relocs
14100          based on information we collected in tls_optimize.  We edit
14101          RELOCS so that --emit-relocs will output something sensible
14102          for the final instruction stream.  */
14103       tls_mask = 0;
14104       tls_gd = 0;
14105       toc_symndx = 0;
14106       if (h != NULL)
14107         tls_mask = h->tls_mask;
14108       else if (local_got_ents != NULL)
14109         {
14110           struct plt_entry **local_plt = (struct plt_entry **)
14111             (local_got_ents + symtab_hdr->sh_info);
14112           unsigned char *lgot_masks = (unsigned char *)
14113             (local_plt + symtab_hdr->sh_info);
14114           tls_mask = lgot_masks[r_symndx];
14115         }
14116       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14117           && (r_type == R_PPC64_TLS
14118               || r_type == R_PPC64_TLSGD
14119               || r_type == R_PPC64_TLSLD))
14120         {
14121           /* Check for toc tls entries.  */
14122           unsigned char *toc_tls;
14123
14124           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14125                              &local_syms, rel, input_bfd))
14126             return FALSE;
14127
14128           if (toc_tls)
14129             tls_mask = *toc_tls;
14130         }
14131
14132       /* Check that tls relocs are used with tls syms, and non-tls
14133          relocs are used with non-tls syms.  */
14134       if (r_symndx != STN_UNDEF
14135           && r_type != R_PPC64_NONE
14136           && (h == NULL
14137               || h->elf.root.type == bfd_link_hash_defined
14138               || h->elf.root.type == bfd_link_hash_defweak)
14139           && (IS_PPC64_TLS_RELOC (r_type)
14140               != (sym_type == STT_TLS
14141                   || (sym_type == STT_SECTION
14142                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14143         {
14144           if ((tls_mask & TLS_TLS) != 0
14145               && (r_type == R_PPC64_TLS
14146                   || r_type == R_PPC64_TLSGD
14147                   || r_type == R_PPC64_TLSLD))
14148             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14149             ;
14150           else
14151             info->callbacks->einfo
14152               (!IS_PPC64_TLS_RELOC (r_type)
14153                /* xgettext:c-format */
14154                ? _("%H: %s used with TLS symbol `%pT'\n")
14155                /* xgettext:c-format */
14156                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14157                input_bfd, input_section, rel->r_offset,
14158                ppc64_elf_howto_table[r_type]->name,
14159                sym_name);
14160         }
14161
14162       /* Ensure reloc mapping code below stays sane.  */
14163       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14164           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14165           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14166           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14167           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14168           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14169           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14170           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14171           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14172           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14173         abort ();
14174
14175       switch (r_type)
14176         {
14177         default:
14178           break;
14179
14180         case R_PPC64_LO_DS_OPT:
14181           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14182           if ((insn & (0x3f << 26)) != 58u << 26)
14183             abort ();
14184           insn += (14u << 26) - (58u << 26);
14185           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14186           r_type = R_PPC64_TOC16_LO;
14187           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14188           break;
14189
14190         case R_PPC64_TOC16:
14191         case R_PPC64_TOC16_LO:
14192         case R_PPC64_TOC16_DS:
14193         case R_PPC64_TOC16_LO_DS:
14194           {
14195             /* Check for toc tls entries.  */
14196             unsigned char *toc_tls;
14197             int retval;
14198
14199             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14200                                    &local_syms, rel, input_bfd);
14201             if (retval == 0)
14202               return FALSE;
14203
14204             if (toc_tls)
14205               {
14206                 tls_mask = *toc_tls;
14207                 if (r_type == R_PPC64_TOC16_DS
14208                     || r_type == R_PPC64_TOC16_LO_DS)
14209                   {
14210                     if ((tls_mask & TLS_TLS) != 0
14211                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14212                       goto toctprel;
14213                   }
14214                 else
14215                   {
14216                     /* If we found a GD reloc pair, then we might be
14217                        doing a GD->IE transition.  */
14218                     if (retval == 2)
14219                       {
14220                         tls_gd = TLS_TPRELGD;
14221                         if ((tls_mask & TLS_TLS) != 0
14222                             && (tls_mask & TLS_GD) == 0)
14223                           goto tls_ldgd_opt;
14224                       }
14225                     else if (retval == 3)
14226                       {
14227                         if ((tls_mask & TLS_TLS) != 0
14228                             && (tls_mask & TLS_LD) == 0)
14229                           goto tls_ldgd_opt;
14230                       }
14231                   }
14232               }
14233           }
14234           break;
14235
14236         case R_PPC64_GOT_TPREL16_HI:
14237         case R_PPC64_GOT_TPREL16_HA:
14238           if ((tls_mask & TLS_TLS) != 0
14239               && (tls_mask & TLS_TPREL) == 0)
14240             {
14241               rel->r_offset -= d_offset;
14242               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14243               r_type = R_PPC64_NONE;
14244               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14245             }
14246           break;
14247
14248         case R_PPC64_GOT_TPREL16_DS:
14249         case R_PPC64_GOT_TPREL16_LO_DS:
14250           if ((tls_mask & TLS_TLS) != 0
14251               && (tls_mask & TLS_TPREL) == 0)
14252             {
14253             toctprel:
14254               insn = bfd_get_32 (input_bfd,
14255                                  contents + rel->r_offset - d_offset);
14256               insn &= 31 << 21;
14257               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14258               bfd_put_32 (input_bfd, insn,
14259                           contents + rel->r_offset - d_offset);
14260               r_type = R_PPC64_TPREL16_HA;
14261               if (toc_symndx != 0)
14262                 {
14263                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14264                   rel->r_addend = toc_addend;
14265                   /* We changed the symbol.  Start over in order to
14266                      get h, sym, sec etc. right.  */
14267                   goto again;
14268                 }
14269               else
14270                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14271             }
14272           break;
14273
14274         case R_PPC64_TLS:
14275           if ((tls_mask & TLS_TLS) != 0
14276               && (tls_mask & TLS_TPREL) == 0)
14277             {
14278               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14279               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14280               if (insn == 0)
14281                 abort ();
14282               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14283               /* Was PPC64_TLS which sits on insn boundary, now
14284                  PPC64_TPREL16_LO which is at low-order half-word.  */
14285               rel->r_offset += d_offset;
14286               r_type = R_PPC64_TPREL16_LO;
14287               if (toc_symndx != 0)
14288                 {
14289                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14290                   rel->r_addend = toc_addend;
14291                   /* We changed the symbol.  Start over in order to
14292                      get h, sym, sec etc. right.  */
14293                   goto again;
14294                 }
14295               else
14296                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14297             }
14298           break;
14299
14300         case R_PPC64_GOT_TLSGD16_HI:
14301         case R_PPC64_GOT_TLSGD16_HA:
14302           tls_gd = TLS_TPRELGD;
14303           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14304             goto tls_gdld_hi;
14305           break;
14306
14307         case R_PPC64_GOT_TLSLD16_HI:
14308         case R_PPC64_GOT_TLSLD16_HA:
14309           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14310             {
14311             tls_gdld_hi:
14312               if ((tls_mask & tls_gd) != 0)
14313                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14314                           + R_PPC64_GOT_TPREL16_DS);
14315               else
14316                 {
14317                   rel->r_offset -= d_offset;
14318                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14319                   r_type = R_PPC64_NONE;
14320                 }
14321               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14322             }
14323           break;
14324
14325         case R_PPC64_GOT_TLSGD16:
14326         case R_PPC64_GOT_TLSGD16_LO:
14327           tls_gd = TLS_TPRELGD;
14328           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14329             goto tls_ldgd_opt;
14330           break;
14331
14332         case R_PPC64_GOT_TLSLD16:
14333         case R_PPC64_GOT_TLSLD16_LO:
14334           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14335             {
14336               unsigned int insn1, insn2;
14337               bfd_vma offset;
14338
14339             tls_ldgd_opt:
14340               offset = (bfd_vma) -1;
14341               /* If not using the newer R_PPC64_TLSGD/LD to mark
14342                  __tls_get_addr calls, we must trust that the call
14343                  stays with its arg setup insns, ie. that the next
14344                  reloc is the __tls_get_addr call associated with
14345                  the current reloc.  Edit both insns.  */
14346               if (input_section->has_tls_get_addr_call
14347                   && rel + 1 < relend
14348                   && branch_reloc_hash_match (input_bfd, rel + 1,
14349                                               htab->tls_get_addr,
14350                                               htab->tls_get_addr_fd))
14351                 offset = rel[1].r_offset;
14352               /* We read the low GOT_TLS (or TOC16) insn because we
14353                  need to keep the destination reg.  It may be
14354                  something other than the usual r3, and moved to r3
14355                  before the call by intervening code.  */
14356               insn1 = bfd_get_32 (input_bfd,
14357                                   contents + rel->r_offset - d_offset);
14358               if ((tls_mask & tls_gd) != 0)
14359                 {
14360                   /* IE */
14361                   insn1 &= (0x1f << 21) | (0x1f << 16);
14362                   insn1 |= 58 << 26;    /* ld */
14363                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14364                   if (offset != (bfd_vma) -1)
14365                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14366                   if ((tls_mask & TLS_EXPLICIT) == 0)
14367                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14368                               + R_PPC64_GOT_TPREL16_DS);
14369                   else
14370                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14371                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14372                 }
14373               else
14374                 {
14375                   /* LE */
14376                   insn1 &= 0x1f << 21;
14377                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14378                   insn2 = 0x38630000;   /* addi 3,3,0 */
14379                   if (tls_gd == 0)
14380                     {
14381                       /* Was an LD reloc.  */
14382                       if (toc_symndx)
14383                         sec = local_sections[toc_symndx];
14384                       for (r_symndx = 0;
14385                            r_symndx < symtab_hdr->sh_info;
14386                            r_symndx++)
14387                         if (local_sections[r_symndx] == sec)
14388                           break;
14389                       if (r_symndx >= symtab_hdr->sh_info)
14390                         r_symndx = STN_UNDEF;
14391                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14392                       if (r_symndx != STN_UNDEF)
14393                         rel->r_addend -= (local_syms[r_symndx].st_value
14394                                           + sec->output_offset
14395                                           + sec->output_section->vma);
14396                     }
14397                   else if (toc_symndx != 0)
14398                     {
14399                       r_symndx = toc_symndx;
14400                       rel->r_addend = toc_addend;
14401                     }
14402                   r_type = R_PPC64_TPREL16_HA;
14403                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14404                   if (offset != (bfd_vma) -1)
14405                     {
14406                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14407                                                     R_PPC64_TPREL16_LO);
14408                       rel[1].r_offset = offset + d_offset;
14409                       rel[1].r_addend = rel->r_addend;
14410                     }
14411                 }
14412               bfd_put_32 (input_bfd, insn1,
14413                           contents + rel->r_offset - d_offset);
14414               if (offset != (bfd_vma) -1)
14415                 bfd_put_32 (input_bfd, insn2, contents + offset);
14416               if ((tls_mask & tls_gd) == 0
14417                   && (tls_gd == 0 || toc_symndx != 0))
14418                 {
14419                   /* We changed the symbol.  Start over in order
14420                      to get h, sym, sec etc. right.  */
14421                   goto again;
14422                 }
14423             }
14424           break;
14425
14426         case R_PPC64_TLSGD:
14427           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14428               && rel + 1 < relend)
14429             {
14430               unsigned int insn2;
14431               bfd_vma offset = rel->r_offset;
14432
14433               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14434                 {
14435                   bfd_put_32 (output_bfd, NOP, contents + offset);
14436                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14437                   break;
14438                 }
14439
14440               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14441                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14442
14443               if ((tls_mask & TLS_TPRELGD) != 0)
14444                 {
14445                   /* IE */
14446                   r_type = R_PPC64_NONE;
14447                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14448                 }
14449               else
14450                 {
14451                   /* LE */
14452                   if (toc_symndx != 0)
14453                     {
14454                       r_symndx = toc_symndx;
14455                       rel->r_addend = toc_addend;
14456                     }
14457                   r_type = R_PPC64_TPREL16_LO;
14458                   rel->r_offset = offset + d_offset;
14459                   insn2 = 0x38630000;   /* addi 3,3,0 */
14460                 }
14461               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14462               /* Zap the reloc on the _tls_get_addr call too.  */
14463               BFD_ASSERT (offset == rel[1].r_offset);
14464               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14465               bfd_put_32 (input_bfd, insn2, contents + offset);
14466               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14467                 goto again;
14468             }
14469           break;
14470
14471         case R_PPC64_TLSLD:
14472           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14473               && rel + 1 < relend)
14474             {
14475               unsigned int insn2;
14476               bfd_vma offset = rel->r_offset;
14477
14478               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14479                 {
14480                   bfd_put_32 (output_bfd, NOP, contents + offset);
14481                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14482                   break;
14483                 }
14484
14485               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14486                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14487
14488               if (toc_symndx)
14489                 sec = local_sections[toc_symndx];
14490               for (r_symndx = 0;
14491                    r_symndx < symtab_hdr->sh_info;
14492                    r_symndx++)
14493                 if (local_sections[r_symndx] == sec)
14494                   break;
14495               if (r_symndx >= symtab_hdr->sh_info)
14496                 r_symndx = STN_UNDEF;
14497               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14498               if (r_symndx != STN_UNDEF)
14499                 rel->r_addend -= (local_syms[r_symndx].st_value
14500                                   + sec->output_offset
14501                                   + sec->output_section->vma);
14502
14503               r_type = R_PPC64_TPREL16_LO;
14504               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14505               rel->r_offset = offset + d_offset;
14506               /* Zap the reloc on the _tls_get_addr call too.  */
14507               BFD_ASSERT (offset == rel[1].r_offset);
14508               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14509               insn2 = 0x38630000;       /* addi 3,3,0 */
14510               bfd_put_32 (input_bfd, insn2, contents + offset);
14511               goto again;
14512             }
14513           break;
14514
14515         case R_PPC64_DTPMOD64:
14516           if (rel + 1 < relend
14517               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14518               && rel[1].r_offset == rel->r_offset + 8)
14519             {
14520               if ((tls_mask & TLS_GD) == 0)
14521                 {
14522                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14523                   if ((tls_mask & TLS_TPRELGD) != 0)
14524                     r_type = R_PPC64_TPREL64;
14525                   else
14526                     {
14527                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14528                       r_type = R_PPC64_NONE;
14529                     }
14530                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14531                 }
14532             }
14533           else
14534             {
14535               if ((tls_mask & TLS_LD) == 0)
14536                 {
14537                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14538                   r_type = R_PPC64_NONE;
14539                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14540                 }
14541             }
14542           break;
14543
14544         case R_PPC64_TPREL64:
14545           if ((tls_mask & TLS_TPREL) == 0)
14546             {
14547               r_type = R_PPC64_NONE;
14548               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14549             }
14550           break;
14551
14552         case R_PPC64_ENTRY:
14553           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14554           if (!bfd_link_pic (info)
14555               && !info->traditional_format
14556               && relocation + 0x80008000 <= 0xffffffff)
14557             {
14558               unsigned int insn1, insn2;
14559
14560               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14561               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14562               if ((insn1 & ~0xfffc) == LD_R2_0R12
14563                   && insn2 == ADD_R2_R2_R12)
14564                 {
14565                   bfd_put_32 (input_bfd,
14566                               LIS_R2 + PPC_HA (relocation),
14567                               contents + rel->r_offset);
14568                   bfd_put_32 (input_bfd,
14569                               ADDI_R2_R2 + PPC_LO (relocation),
14570                               contents + rel->r_offset + 4);
14571                 }
14572             }
14573           else
14574             {
14575               relocation -= (rel->r_offset
14576                              + input_section->output_offset
14577                              + input_section->output_section->vma);
14578               if (relocation + 0x80008000 <= 0xffffffff)
14579                 {
14580                   unsigned int insn1, insn2;
14581
14582                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14583                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14584                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14585                       && insn2 == ADD_R2_R2_R12)
14586                     {
14587                       bfd_put_32 (input_bfd,
14588                                   ADDIS_R2_R12 + PPC_HA (relocation),
14589                                   contents + rel->r_offset);
14590                       bfd_put_32 (input_bfd,
14591                                   ADDI_R2_R2 + PPC_LO (relocation),
14592                                   contents + rel->r_offset + 4);
14593                     }
14594                 }
14595             }
14596           break;
14597
14598         case R_PPC64_REL16_HA:
14599           /* If we are generating a non-PIC executable, edit
14600              .  0:      addis 2,12,.TOC.-0b@ha
14601              .          addi 2,2,.TOC.-0b@l
14602              used by ELFv2 global entry points to set up r2, to
14603              .          lis 2,.TOC.@ha
14604              .          addi 2,2,.TOC.@l
14605              if .TOC. is in range.  */
14606           if (!bfd_link_pic (info)
14607               && !info->traditional_format
14608               && !htab->opd_abi
14609               && rel->r_addend == d_offset
14610               && h != NULL && &h->elf == htab->elf.hgot
14611               && rel + 1 < relend
14612               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14613               && rel[1].r_offset == rel->r_offset + 4
14614               && rel[1].r_addend == rel->r_addend + 4
14615               && relocation + 0x80008000 <= 0xffffffff)
14616             {
14617               unsigned int insn1, insn2;
14618               bfd_vma offset = rel->r_offset - d_offset;
14619               insn1 = bfd_get_32 (input_bfd, contents + offset);
14620               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14621               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14622                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14623                 {
14624                   r_type = R_PPC64_ADDR16_HA;
14625                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14626                   rel->r_addend -= d_offset;
14627                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14628                   rel[1].r_addend -= d_offset + 4;
14629                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14630                 }
14631             }
14632           break;
14633         }
14634
14635       /* Handle other relocations that tweak non-addend part of insn.  */
14636       insn = 0;
14637       max_br_offset = 1 << 25;
14638       addend = rel->r_addend;
14639       reloc_dest = DEST_NORMAL;
14640       switch (r_type)
14641         {
14642         default:
14643           break;
14644
14645         case R_PPC64_TOCSAVE:
14646           if (relocation + addend == (rel->r_offset
14647                                       + input_section->output_offset
14648                                       + input_section->output_section->vma)
14649               && tocsave_find (htab, NO_INSERT,
14650                                &local_syms, rel, input_bfd))
14651             {
14652               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14653               if (insn == NOP
14654                   || insn == CROR_151515 || insn == CROR_313131)
14655                 bfd_put_32 (input_bfd,
14656                             STD_R2_0R1 + STK_TOC (htab),
14657                             contents + rel->r_offset);
14658             }
14659           break;
14660
14661           /* Branch taken prediction relocations.  */
14662         case R_PPC64_ADDR14_BRTAKEN:
14663         case R_PPC64_REL14_BRTAKEN:
14664           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14665           /* Fall through.  */
14666
14667           /* Branch not taken prediction relocations.  */
14668         case R_PPC64_ADDR14_BRNTAKEN:
14669         case R_PPC64_REL14_BRNTAKEN:
14670           insn |= bfd_get_32 (input_bfd,
14671                               contents + rel->r_offset) & ~(0x01 << 21);
14672           /* Fall through.  */
14673
14674         case R_PPC64_REL14:
14675           max_br_offset = 1 << 15;
14676           /* Fall through.  */
14677
14678         case R_PPC64_REL24:
14679         case R_PPC64_PLTCALL:
14680           /* Calls to functions with a different TOC, such as calls to
14681              shared objects, need to alter the TOC pointer.  This is
14682              done using a linkage stub.  A REL24 branching to these
14683              linkage stubs needs to be followed by a nop, as the nop
14684              will be replaced with an instruction to restore the TOC
14685              base pointer.  */
14686           fdh = h;
14687           if (h != NULL
14688               && h->oh != NULL
14689               && h->oh->is_func_descriptor)
14690             fdh = ppc_follow_link (h->oh);
14691           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14692                                            htab);
14693           if (r_type == R_PPC64_PLTCALL
14694               && stub_entry != NULL
14695               && (stub_entry->stub_type == ppc_stub_plt_call
14696                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14697             stub_entry = NULL;
14698
14699           if (stub_entry != NULL
14700               && (stub_entry->stub_type == ppc_stub_plt_call
14701                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14702                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14703                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14704             {
14705               bfd_boolean can_plt_call = FALSE;
14706
14707               if (stub_entry->stub_type == ppc_stub_plt_call
14708                   && !htab->opd_abi
14709                   && htab->params->plt_localentry0 != 0
14710                   && is_elfv2_localentry0 (&h->elf))
14711                 {
14712                   /* The function doesn't use or change r2.  */
14713                   can_plt_call = TRUE;
14714                 }
14715
14716               /* All of these stubs may modify r2, so there must be a
14717                  branch and link followed by a nop.  The nop is
14718                  replaced by an insn to restore r2.  */
14719               else if (rel->r_offset + 8 <= input_section->size)
14720                 {
14721                   unsigned long br;
14722
14723                   br = bfd_get_32 (input_bfd,
14724                                    contents + rel->r_offset);
14725                   if ((br & 1) != 0)
14726                     {
14727                       unsigned long nop;
14728
14729                       nop = bfd_get_32 (input_bfd,
14730                                         contents + rel->r_offset + 4);
14731                       if (nop == LD_R2_0R1 + STK_TOC (htab))
14732                         can_plt_call = TRUE;
14733                       else if (nop == NOP
14734                                || nop == CROR_151515
14735                                || nop == CROR_313131)
14736                         {
14737                           if (h != NULL
14738                               && (h == htab->tls_get_addr_fd
14739                                   || h == htab->tls_get_addr)
14740                               && htab->params->tls_get_addr_opt)
14741                             {
14742                               /* Special stub used, leave nop alone.  */
14743                             }
14744                           else
14745                             bfd_put_32 (input_bfd,
14746                                         LD_R2_0R1 + STK_TOC (htab),
14747                                         contents + rel->r_offset + 4);
14748                           can_plt_call = TRUE;
14749                         }
14750                     }
14751                 }
14752
14753               if (!can_plt_call && h != NULL)
14754                 {
14755                   const char *name = h->elf.root.root.string;
14756
14757                   if (*name == '.')
14758                     ++name;
14759
14760                   if (strncmp (name, "__libc_start_main", 17) == 0
14761                       && (name[17] == 0 || name[17] == '@'))
14762                     {
14763                       /* Allow crt1 branch to go via a toc adjusting
14764                          stub.  Other calls that never return could do
14765                          the same, if we could detect such.  */
14766                       can_plt_call = TRUE;
14767                     }
14768                 }
14769
14770               if (!can_plt_call)
14771                 {
14772                   /* g++ as of 20130507 emits self-calls without a
14773                      following nop.  This is arguably wrong since we
14774                      have conflicting information.  On the one hand a
14775                      global symbol and on the other a local call
14776                      sequence, but don't error for this special case.
14777                      It isn't possible to cheaply verify we have
14778                      exactly such a call.  Allow all calls to the same
14779                      section.  */
14780                   asection *code_sec = sec;
14781
14782                   if (get_opd_info (sec) != NULL)
14783                     {
14784                       bfd_vma off = (relocation + addend
14785                                      - sec->output_section->vma
14786                                      - sec->output_offset);
14787
14788                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14789                     }
14790                   if (code_sec == input_section)
14791                     can_plt_call = TRUE;
14792                 }
14793
14794               if (!can_plt_call)
14795                 {
14796                   if (stub_entry->stub_type == ppc_stub_plt_call
14797                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14798                     info->callbacks->einfo
14799                       /* xgettext:c-format */
14800                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14801                          "recompile with -fPIC\n"),
14802                        input_bfd, input_section, rel->r_offset, sym_name);
14803                   else
14804                     info->callbacks->einfo
14805                       /* xgettext:c-format */
14806                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14807                          "(-mcmodel=small toc adjust stub)\n"),
14808                        input_bfd, input_section, rel->r_offset, sym_name);
14809
14810                   bfd_set_error (bfd_error_bad_value);
14811                   ret = FALSE;
14812                 }
14813
14814               if (can_plt_call
14815                   && (stub_entry->stub_type == ppc_stub_plt_call
14816                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14817                 unresolved_reloc = FALSE;
14818             }
14819
14820           if ((stub_entry == NULL
14821                || stub_entry->stub_type == ppc_stub_long_branch
14822                || stub_entry->stub_type == ppc_stub_plt_branch)
14823               && get_opd_info (sec) != NULL)
14824             {
14825               /* The branch destination is the value of the opd entry. */
14826               bfd_vma off = (relocation + addend
14827                              - sec->output_section->vma
14828                              - sec->output_offset);
14829               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14830               if (dest != (bfd_vma) -1)
14831                 {
14832                   relocation = dest;
14833                   addend = 0;
14834                   reloc_dest = DEST_OPD;
14835                 }
14836             }
14837
14838           /* If the branch is out of reach we ought to have a long
14839              branch stub.  */
14840           from = (rel->r_offset
14841                   + input_section->output_offset
14842                   + input_section->output_section->vma);
14843
14844           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14845                                                   ? fdh->elf.other
14846                                                   : sym->st_other);
14847
14848           if (stub_entry != NULL
14849               && (stub_entry->stub_type == ppc_stub_long_branch
14850                   || stub_entry->stub_type == ppc_stub_plt_branch)
14851               && (r_type == R_PPC64_ADDR14_BRTAKEN
14852                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14853                   || (relocation + addend - from + max_br_offset
14854                       < 2 * max_br_offset)))
14855             /* Don't use the stub if this branch is in range.  */
14856             stub_entry = NULL;
14857
14858           if (stub_entry != NULL)
14859             {
14860               /* Munge up the value and addend so that we call the stub
14861                  rather than the procedure directly.  */
14862               asection *stub_sec = stub_entry->group->stub_sec;
14863
14864               if (stub_entry->stub_type == ppc_stub_save_res)
14865                 relocation += (stub_sec->output_offset
14866                                + stub_sec->output_section->vma
14867                                + stub_sec->size - htab->sfpr->size
14868                                - htab->sfpr->output_offset
14869                                - htab->sfpr->output_section->vma);
14870               else
14871                 relocation = (stub_entry->stub_offset
14872                               + stub_sec->output_offset
14873                               + stub_sec->output_section->vma);
14874               addend = 0;
14875               reloc_dest = DEST_STUB;
14876
14877               if ((stub_entry->stub_type == ppc_stub_plt_call
14878                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14879                   && (ALWAYS_EMIT_R2SAVE
14880                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14881                   && rel + 1 < relend
14882                   && rel[1].r_offset == rel->r_offset + 4
14883                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14884                 relocation += 4;
14885             }
14886
14887           if (insn != 0)
14888             {
14889               if (is_isa_v2)
14890                 {
14891                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14892                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14893                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14894                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14895                     insn |= 0x02 << 21;
14896                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14897                     insn |= 0x08 << 21;
14898                   else
14899                     break;
14900                 }
14901               else
14902                 {
14903                   /* Invert 'y' bit if not the default.  */
14904                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14905                     insn ^= 0x01 << 21;
14906                 }
14907
14908               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14909             }
14910
14911           /* NOP out calls to undefined weak functions.
14912              We can thus call a weak function without first
14913              checking whether the function is defined.  */
14914           else if (h != NULL
14915                    && h->elf.root.type == bfd_link_hash_undefweak
14916                    && h->elf.dynindx == -1
14917                    && r_type == R_PPC64_REL24
14918                    && relocation == 0
14919                    && addend == 0)
14920             {
14921               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14922               goto copy_reloc;
14923             }
14924           break;
14925         }
14926
14927       /* Set `addend'.  */
14928       tls_type = 0;
14929       save_unresolved_reloc = unresolved_reloc;
14930       switch (r_type)
14931         {
14932         default:
14933           /* xgettext:c-format */
14934           _bfd_error_handler (_("%pB: %s unsupported"),
14935                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14936
14937           bfd_set_error (bfd_error_bad_value);
14938           ret = FALSE;
14939           goto copy_reloc;
14940
14941         case R_PPC64_NONE:
14942         case R_PPC64_TLS:
14943         case R_PPC64_TLSGD:
14944         case R_PPC64_TLSLD:
14945         case R_PPC64_TOCSAVE:
14946         case R_PPC64_GNU_VTINHERIT:
14947         case R_PPC64_GNU_VTENTRY:
14948         case R_PPC64_ENTRY:
14949           goto copy_reloc;
14950
14951           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14952              address in the GOT as relocation value instead of the
14953              symbol's value itself.  Also, create a GOT entry for the
14954              symbol and put the symbol value there.  */
14955         case R_PPC64_GOT_TLSGD16:
14956         case R_PPC64_GOT_TLSGD16_LO:
14957         case R_PPC64_GOT_TLSGD16_HI:
14958         case R_PPC64_GOT_TLSGD16_HA:
14959           tls_type = TLS_TLS | TLS_GD;
14960           goto dogot;
14961
14962         case R_PPC64_GOT_TLSLD16:
14963         case R_PPC64_GOT_TLSLD16_LO:
14964         case R_PPC64_GOT_TLSLD16_HI:
14965         case R_PPC64_GOT_TLSLD16_HA:
14966           tls_type = TLS_TLS | TLS_LD;
14967           goto dogot;
14968
14969         case R_PPC64_GOT_TPREL16_DS:
14970         case R_PPC64_GOT_TPREL16_LO_DS:
14971         case R_PPC64_GOT_TPREL16_HI:
14972         case R_PPC64_GOT_TPREL16_HA:
14973           tls_type = TLS_TLS | TLS_TPREL;
14974           goto dogot;
14975
14976         case R_PPC64_GOT_DTPREL16_DS:
14977         case R_PPC64_GOT_DTPREL16_LO_DS:
14978         case R_PPC64_GOT_DTPREL16_HI:
14979         case R_PPC64_GOT_DTPREL16_HA:
14980           tls_type = TLS_TLS | TLS_DTPREL;
14981           goto dogot;
14982
14983         case R_PPC64_GOT16:
14984         case R_PPC64_GOT16_LO:
14985         case R_PPC64_GOT16_HI:
14986         case R_PPC64_GOT16_HA:
14987         case R_PPC64_GOT16_DS:
14988         case R_PPC64_GOT16_LO_DS:
14989         dogot:
14990           {
14991             /* Relocation is to the entry for this symbol in the global
14992                offset table.  */
14993             asection *got;
14994             bfd_vma *offp;
14995             bfd_vma off;
14996             unsigned long indx = 0;
14997             struct got_entry *ent;
14998
14999             if (tls_type == (TLS_TLS | TLS_LD)
15000                 && (h == NULL
15001                     || !h->elf.def_dynamic))
15002               ent = ppc64_tlsld_got (input_bfd);
15003             else
15004               {
15005                 if (h != NULL)
15006                   {
15007                     if (!htab->elf.dynamic_sections_created
15008                         || h->elf.dynindx == -1
15009                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15010                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15011                       /* This is actually a static link, or it is a
15012                          -Bsymbolic link and the symbol is defined
15013                          locally, or the symbol was forced to be local
15014                          because of a version file.  */
15015                       ;
15016                     else
15017                       {
15018                         indx = h->elf.dynindx;
15019                         unresolved_reloc = FALSE;
15020                       }
15021                     ent = h->elf.got.glist;
15022                   }
15023                 else
15024                   {
15025                     if (local_got_ents == NULL)
15026                       abort ();
15027                     ent = local_got_ents[r_symndx];
15028                   }
15029
15030                 for (; ent != NULL; ent = ent->next)
15031                   if (ent->addend == orig_rel.r_addend
15032                       && ent->owner == input_bfd
15033                       && ent->tls_type == tls_type)
15034                     break;
15035               }
15036
15037             if (ent == NULL)
15038               abort ();
15039             if (ent->is_indirect)
15040               ent = ent->got.ent;
15041             offp = &ent->got.offset;
15042             got = ppc64_elf_tdata (ent->owner)->got;
15043             if (got == NULL)
15044               abort ();
15045
15046             /* The offset must always be a multiple of 8.  We use the
15047                least significant bit to record whether we have already
15048                processed this entry.  */
15049             off = *offp;
15050             if ((off & 1) != 0)
15051               off &= ~1;
15052             else
15053               {
15054                 /* Generate relocs for the dynamic linker, except in
15055                    the case of TLSLD where we'll use one entry per
15056                    module.  */
15057                 asection *relgot;
15058                 bfd_boolean ifunc;
15059
15060                 *offp = off | 1;
15061                 relgot = NULL;
15062                 ifunc = (h != NULL
15063                          ? h->elf.type == STT_GNU_IFUNC
15064                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15065                 if (ifunc)
15066                   {
15067                     relgot = htab->elf.irelplt;
15068                     if (indx == 0)
15069                       htab->local_ifunc_resolver = 1;
15070                     else if (is_static_defined (&h->elf))
15071                       htab->maybe_local_ifunc_resolver = 1;
15072                   }
15073                 else if (indx != 0
15074                          || (bfd_link_pic (info)
15075                              && (h == NULL
15076                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15077                                  || (tls_type == (TLS_TLS | TLS_LD)
15078                                      && !h->elf.def_dynamic))
15079                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15080                                   && bfd_link_executable (info)
15081                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15082                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15083                 if (relgot != NULL)
15084                   {
15085                     outrel.r_offset = (got->output_section->vma
15086                                        + got->output_offset
15087                                        + off);
15088                     outrel.r_addend = addend;
15089                     if (tls_type & (TLS_LD | TLS_GD))
15090                       {
15091                         outrel.r_addend = 0;
15092                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15093                         if (tls_type == (TLS_TLS | TLS_GD))
15094                           {
15095                             loc = relgot->contents;
15096                             loc += (relgot->reloc_count++
15097                                     * sizeof (Elf64_External_Rela));
15098                             bfd_elf64_swap_reloca_out (output_bfd,
15099                                                        &outrel, loc);
15100                             outrel.r_offset += 8;
15101                             outrel.r_addend = addend;
15102                             outrel.r_info
15103                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15104                           }
15105                       }
15106                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15107                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15108                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15109                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15110                     else if (indx != 0)
15111                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15112                     else
15113                       {
15114                         if (ifunc)
15115                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15116                         else
15117                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15118
15119                         /* Write the .got section contents for the sake
15120                            of prelink.  */
15121                         loc = got->contents + off;
15122                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15123                                     loc);
15124                       }
15125
15126                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15127                       {
15128                         outrel.r_addend += relocation;
15129                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15130                           {
15131                             if (htab->elf.tls_sec == NULL)
15132                               outrel.r_addend = 0;
15133                             else
15134                               outrel.r_addend -= htab->elf.tls_sec->vma;
15135                           }
15136                       }
15137                     loc = relgot->contents;
15138                     loc += (relgot->reloc_count++
15139                             * sizeof (Elf64_External_Rela));
15140                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15141                   }
15142
15143                 /* Init the .got section contents here if we're not
15144                    emitting a reloc.  */
15145                 else
15146                   {
15147                     relocation += addend;
15148                     if (tls_type != 0)
15149                       {
15150                         if (htab->elf.tls_sec == NULL)
15151                           relocation = 0;
15152                         else
15153                           {
15154                             if (tls_type & TLS_LD)
15155                               relocation = 0;
15156                             else
15157                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15158                             if (tls_type & TLS_TPREL)
15159                               relocation += DTP_OFFSET - TP_OFFSET;
15160                           }
15161
15162                         if (tls_type & (TLS_GD | TLS_LD))
15163                           {
15164                             bfd_put_64 (output_bfd, relocation,
15165                                         got->contents + off + 8);
15166                             relocation = 1;
15167                           }
15168                       }
15169                     bfd_put_64 (output_bfd, relocation,
15170                                 got->contents + off);
15171                   }
15172               }
15173
15174             if (off >= (bfd_vma) -2)
15175               abort ();
15176
15177             relocation = got->output_section->vma + got->output_offset + off;
15178             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15179           }
15180           break;
15181
15182         case R_PPC64_PLT16_HA:
15183         case R_PPC64_PLT16_HI:
15184         case R_PPC64_PLT16_LO:
15185         case R_PPC64_PLT16_LO_DS:
15186         case R_PPC64_PLT32:
15187         case R_PPC64_PLT64:
15188         case R_PPC64_PLTSEQ:
15189         case R_PPC64_PLTCALL:
15190           /* Relocation is to the entry for this symbol in the
15191              procedure linkage table.  */
15192           unresolved_reloc = TRUE;
15193           {
15194             struct plt_entry **plt_list = NULL;
15195             if (h != NULL)
15196               plt_list = &h->elf.plt.plist;
15197             else if (local_got_ents != NULL)
15198               {
15199                 struct plt_entry **local_plt = (struct plt_entry **)
15200                   (local_got_ents + symtab_hdr->sh_info);
15201                 plt_list = local_plt + r_symndx;
15202               }
15203             if (plt_list)
15204               {
15205                 struct plt_entry *ent;
15206
15207                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15208                   if (ent->plt.offset != (bfd_vma) -1
15209                       && ent->addend == orig_rel.r_addend)
15210                     {
15211                       asection *plt;
15212                       bfd_vma got;
15213
15214                       plt = htab->elf.splt;
15215                       if (!htab->elf.dynamic_sections_created
15216                           || h == NULL
15217                           || h->elf.dynindx == -1)
15218                         {
15219                           if (h != NULL
15220                               ? h->elf.type == STT_GNU_IFUNC
15221                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15222                             plt = htab->elf.iplt;
15223                           else
15224                             plt = htab->pltlocal;
15225                         }
15226                       relocation = (plt->output_section->vma
15227                                     + plt->output_offset
15228                                     + ent->plt.offset);
15229                       if (r_type == R_PPC64_PLT16_HA
15230                           || r_type ==R_PPC64_PLT16_HI
15231                           || r_type ==R_PPC64_PLT16_LO
15232                           || r_type ==R_PPC64_PLT16_LO_DS)
15233                         {
15234                           got = (elf_gp (output_bfd)
15235                                  + htab->sec_info[input_section->id].toc_off);
15236                           relocation -= got;
15237                         }
15238                       addend = 0;
15239                       unresolved_reloc = FALSE;
15240                       break;
15241                     }
15242               }
15243           }
15244           break;
15245
15246         case R_PPC64_TOC:
15247           /* Relocation value is TOC base.  */
15248           relocation = TOCstart;
15249           if (r_symndx == STN_UNDEF)
15250             relocation += htab->sec_info[input_section->id].toc_off;
15251           else if (unresolved_reloc)
15252             ;
15253           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15254             relocation += htab->sec_info[sec->id].toc_off;
15255           else
15256             unresolved_reloc = TRUE;
15257           goto dodyn;
15258
15259           /* TOC16 relocs.  We want the offset relative to the TOC base,
15260              which is the address of the start of the TOC plus 0x8000.
15261              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15262              in this order.  */
15263         case R_PPC64_TOC16:
15264         case R_PPC64_TOC16_LO:
15265         case R_PPC64_TOC16_HI:
15266         case R_PPC64_TOC16_DS:
15267         case R_PPC64_TOC16_LO_DS:
15268         case R_PPC64_TOC16_HA:
15269           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15270           break;
15271
15272           /* Relocate against the beginning of the section.  */
15273         case R_PPC64_SECTOFF:
15274         case R_PPC64_SECTOFF_LO:
15275         case R_PPC64_SECTOFF_HI:
15276         case R_PPC64_SECTOFF_DS:
15277         case R_PPC64_SECTOFF_LO_DS:
15278         case R_PPC64_SECTOFF_HA:
15279           if (sec != NULL)
15280             addend -= sec->output_section->vma;
15281           break;
15282
15283         case R_PPC64_REL16:
15284         case R_PPC64_REL16_LO:
15285         case R_PPC64_REL16_HI:
15286         case R_PPC64_REL16_HA:
15287         case R_PPC64_REL16DX_HA:
15288           break;
15289
15290         case R_PPC64_REL14:
15291         case R_PPC64_REL14_BRNTAKEN:
15292         case R_PPC64_REL14_BRTAKEN:
15293         case R_PPC64_REL24:
15294           break;
15295
15296         case R_PPC64_TPREL16:
15297         case R_PPC64_TPREL16_LO:
15298         case R_PPC64_TPREL16_HI:
15299         case R_PPC64_TPREL16_HA:
15300         case R_PPC64_TPREL16_DS:
15301         case R_PPC64_TPREL16_LO_DS:
15302         case R_PPC64_TPREL16_HIGH:
15303         case R_PPC64_TPREL16_HIGHA:
15304         case R_PPC64_TPREL16_HIGHER:
15305         case R_PPC64_TPREL16_HIGHERA:
15306         case R_PPC64_TPREL16_HIGHEST:
15307         case R_PPC64_TPREL16_HIGHESTA:
15308           if (h != NULL
15309               && h->elf.root.type == bfd_link_hash_undefweak
15310               && h->elf.dynindx == -1)
15311             {
15312               /* Make this relocation against an undefined weak symbol
15313                  resolve to zero.  This is really just a tweak, since
15314                  code using weak externs ought to check that they are
15315                  defined before using them.  */
15316               bfd_byte *p = contents + rel->r_offset - d_offset;
15317
15318               insn = bfd_get_32 (input_bfd, p);
15319               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15320               if (insn != 0)
15321                 bfd_put_32 (input_bfd, insn, p);
15322               break;
15323             }
15324           if (htab->elf.tls_sec != NULL)
15325             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15326           /* The TPREL16 relocs shouldn't really be used in shared
15327              libs or with non-local symbols as that will result in
15328              DT_TEXTREL being set, but support them anyway.  */
15329           goto dodyn;
15330
15331         case R_PPC64_DTPREL16:
15332         case R_PPC64_DTPREL16_LO:
15333         case R_PPC64_DTPREL16_HI:
15334         case R_PPC64_DTPREL16_HA:
15335         case R_PPC64_DTPREL16_DS:
15336         case R_PPC64_DTPREL16_LO_DS:
15337         case R_PPC64_DTPREL16_HIGH:
15338         case R_PPC64_DTPREL16_HIGHA:
15339         case R_PPC64_DTPREL16_HIGHER:
15340         case R_PPC64_DTPREL16_HIGHERA:
15341         case R_PPC64_DTPREL16_HIGHEST:
15342         case R_PPC64_DTPREL16_HIGHESTA:
15343           if (htab->elf.tls_sec != NULL)
15344             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15345           break;
15346
15347         case R_PPC64_ADDR64_LOCAL:
15348           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15349                                               ? h->elf.other
15350                                               : sym->st_other);
15351           break;
15352
15353         case R_PPC64_DTPMOD64:
15354           relocation = 1;
15355           addend = 0;
15356           goto dodyn;
15357
15358         case R_PPC64_TPREL64:
15359           if (htab->elf.tls_sec != NULL)
15360             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15361           goto dodyn;
15362
15363         case R_PPC64_DTPREL64:
15364           if (htab->elf.tls_sec != NULL)
15365             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15366           /* Fall through.  */
15367
15368           /* Relocations that may need to be propagated if this is a
15369              dynamic object.  */
15370         case R_PPC64_REL30:
15371         case R_PPC64_REL32:
15372         case R_PPC64_REL64:
15373         case R_PPC64_ADDR14:
15374         case R_PPC64_ADDR14_BRNTAKEN:
15375         case R_PPC64_ADDR14_BRTAKEN:
15376         case R_PPC64_ADDR16:
15377         case R_PPC64_ADDR16_DS:
15378         case R_PPC64_ADDR16_HA:
15379         case R_PPC64_ADDR16_HI:
15380         case R_PPC64_ADDR16_HIGH:
15381         case R_PPC64_ADDR16_HIGHA:
15382         case R_PPC64_ADDR16_HIGHER:
15383         case R_PPC64_ADDR16_HIGHERA:
15384         case R_PPC64_ADDR16_HIGHEST:
15385         case R_PPC64_ADDR16_HIGHESTA:
15386         case R_PPC64_ADDR16_LO:
15387         case R_PPC64_ADDR16_LO_DS:
15388         case R_PPC64_ADDR24:
15389         case R_PPC64_ADDR32:
15390         case R_PPC64_ADDR64:
15391         case R_PPC64_UADDR16:
15392         case R_PPC64_UADDR32:
15393         case R_PPC64_UADDR64:
15394         dodyn:
15395           if ((input_section->flags & SEC_ALLOC) == 0)
15396             break;
15397
15398           if (NO_OPD_RELOCS && is_opd)
15399             break;
15400
15401           if (bfd_link_pic (info)
15402               ? ((h == NULL
15403                   || h->dyn_relocs != NULL)
15404                  && ((h != NULL && pc_dynrelocs (h))
15405                      || must_be_dyn_reloc (info, r_type)))
15406               : (h != NULL
15407                  ? h->dyn_relocs != NULL
15408                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15409             {
15410               bfd_boolean skip, relocate;
15411               asection *sreloc;
15412               bfd_vma out_off;
15413               long indx = 0;
15414
15415               /* When generating a dynamic object, these relocations
15416                  are copied into the output file to be resolved at run
15417                  time.  */
15418
15419               skip = FALSE;
15420               relocate = FALSE;
15421
15422               out_off = _bfd_elf_section_offset (output_bfd, info,
15423                                                  input_section, rel->r_offset);
15424               if (out_off == (bfd_vma) -1)
15425                 skip = TRUE;
15426               else if (out_off == (bfd_vma) -2)
15427                 skip = TRUE, relocate = TRUE;
15428               out_off += (input_section->output_section->vma
15429                           + input_section->output_offset);
15430               outrel.r_offset = out_off;
15431               outrel.r_addend = rel->r_addend;
15432
15433               /* Optimize unaligned reloc use.  */
15434               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15435                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15436                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15437               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15438                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15439                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15440               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15441                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15442                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15443
15444               if (skip)
15445                 memset (&outrel, 0, sizeof outrel);
15446               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15447                        && !is_opd
15448                        && r_type != R_PPC64_TOC)
15449                 {
15450                   indx = h->elf.dynindx;
15451                   BFD_ASSERT (indx != -1);
15452                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15453                 }
15454               else
15455                 {
15456                   /* This symbol is local, or marked to become local,
15457                      or this is an opd section reloc which must point
15458                      at a local function.  */
15459                   outrel.r_addend += relocation;
15460                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15461                     {
15462                       if (is_opd && h != NULL)
15463                         {
15464                           /* Lie about opd entries.  This case occurs
15465                              when building shared libraries and we
15466                              reference a function in another shared
15467                              lib.  The same thing happens for a weak
15468                              definition in an application that's
15469                              overridden by a strong definition in a
15470                              shared lib.  (I believe this is a generic
15471                              bug in binutils handling of weak syms.)
15472                              In these cases we won't use the opd
15473                              entry in this lib.  */
15474                           unresolved_reloc = FALSE;
15475                         }
15476                       if (!is_opd
15477                           && r_type == R_PPC64_ADDR64
15478                           && (h != NULL
15479                               ? h->elf.type == STT_GNU_IFUNC
15480                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15481                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15482                       else
15483                         {
15484                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15485
15486                           /* We need to relocate .opd contents for ld.so.
15487                              Prelink also wants simple and consistent rules
15488                              for relocs.  This make all RELATIVE relocs have
15489                              *r_offset equal to r_addend.  */
15490                           relocate = TRUE;
15491                         }
15492                     }
15493                   else
15494                     {
15495                       if (h != NULL
15496                           ? h->elf.type == STT_GNU_IFUNC
15497                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15498                         {
15499                           info->callbacks->einfo
15500                             /* xgettext:c-format */
15501                             (_("%H: %s for indirect "
15502                                "function `%pT' unsupported\n"),
15503                              input_bfd, input_section, rel->r_offset,
15504                              ppc64_elf_howto_table[r_type]->name,
15505                              sym_name);
15506                           ret = FALSE;
15507                         }
15508                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15509                         ;
15510                       else if (sec == NULL || sec->owner == NULL)
15511                         {
15512                           bfd_set_error (bfd_error_bad_value);
15513                           return FALSE;
15514                         }
15515                       else
15516                         {
15517                           asection *osec;
15518
15519                           osec = sec->output_section;
15520                           indx = elf_section_data (osec)->dynindx;
15521
15522                           if (indx == 0)
15523                             {
15524                               if ((osec->flags & SEC_READONLY) == 0
15525                                   && htab->elf.data_index_section != NULL)
15526                                 osec = htab->elf.data_index_section;
15527                               else
15528                                 osec = htab->elf.text_index_section;
15529                               indx = elf_section_data (osec)->dynindx;
15530                             }
15531                           BFD_ASSERT (indx != 0);
15532
15533                           /* We are turning this relocation into one
15534                              against a section symbol, so subtract out
15535                              the output section's address but not the
15536                              offset of the input section in the output
15537                              section.  */
15538                           outrel.r_addend -= osec->vma;
15539                         }
15540
15541                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15542                     }
15543                 }
15544
15545               sreloc = elf_section_data (input_section)->sreloc;
15546               if (h != NULL
15547                   ? h->elf.type == STT_GNU_IFUNC
15548                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15549                 {
15550                   sreloc = htab->elf.irelplt;
15551                   if (indx == 0)
15552                     htab->local_ifunc_resolver = 1;
15553                   else if (is_static_defined (&h->elf))
15554                     htab->maybe_local_ifunc_resolver = 1;
15555                 }
15556               if (sreloc == NULL)
15557                 abort ();
15558
15559               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15560                   >= sreloc->size)
15561                 abort ();
15562               loc = sreloc->contents;
15563               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15564               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15565
15566               /* If this reloc is against an external symbol, it will
15567                  be computed at runtime, so there's no need to do
15568                  anything now.  However, for the sake of prelink ensure
15569                  that the section contents are a known value.  */
15570               if (! relocate)
15571                 {
15572                   unresolved_reloc = FALSE;
15573                   /* The value chosen here is quite arbitrary as ld.so
15574                      ignores section contents except for the special
15575                      case of .opd where the contents might be accessed
15576                      before relocation.  Choose zero, as that won't
15577                      cause reloc overflow.  */
15578                   relocation = 0;
15579                   addend = 0;
15580                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15581                      to improve backward compatibility with older
15582                      versions of ld.  */
15583                   if (r_type == R_PPC64_ADDR64)
15584                     addend = outrel.r_addend;
15585                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15586                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15587                     addend = outrel.r_offset;
15588                 }
15589             }
15590           break;
15591
15592         case R_PPC64_COPY:
15593         case R_PPC64_GLOB_DAT:
15594         case R_PPC64_JMP_SLOT:
15595         case R_PPC64_JMP_IREL:
15596         case R_PPC64_RELATIVE:
15597           /* We shouldn't ever see these dynamic relocs in relocatable
15598              files.  */
15599           /* Fall through.  */
15600
15601         case R_PPC64_PLTGOT16:
15602         case R_PPC64_PLTGOT16_DS:
15603         case R_PPC64_PLTGOT16_HA:
15604         case R_PPC64_PLTGOT16_HI:
15605         case R_PPC64_PLTGOT16_LO:
15606         case R_PPC64_PLTGOT16_LO_DS:
15607         case R_PPC64_PLTREL32:
15608         case R_PPC64_PLTREL64:
15609           /* These ones haven't been implemented yet.  */
15610
15611           info->callbacks->einfo
15612             /* xgettext:c-format */
15613             (_("%P: %pB: %s is not supported for `%pT'\n"),
15614              input_bfd,
15615              ppc64_elf_howto_table[r_type]->name, sym_name);
15616
15617           bfd_set_error (bfd_error_invalid_operation);
15618           ret = FALSE;
15619           goto copy_reloc;
15620         }
15621
15622       /* Multi-instruction sequences that access the TOC can be
15623          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15624          to             nop;           addi rb,r2,x;  */
15625       switch (r_type)
15626         {
15627         default:
15628           break;
15629
15630         case R_PPC64_GOT_TLSLD16_HI:
15631         case R_PPC64_GOT_TLSGD16_HI:
15632         case R_PPC64_GOT_TPREL16_HI:
15633         case R_PPC64_GOT_DTPREL16_HI:
15634         case R_PPC64_GOT16_HI:
15635         case R_PPC64_TOC16_HI:
15636           /* These relocs would only be useful if building up an
15637              offset to later add to r2, perhaps in an indexed
15638              addressing mode instruction.  Don't try to optimize.
15639              Unfortunately, the possibility of someone building up an
15640              offset like this or even with the HA relocs, means that
15641              we need to check the high insn when optimizing the low
15642              insn.  */
15643           break;
15644
15645         case R_PPC64_PLTCALL:
15646           if (unresolved_reloc)
15647             {
15648               /* No plt entry.  Make this into a direct call.  */
15649               bfd_byte *p = contents + rel->r_offset;
15650               insn = bfd_get_32 (input_bfd, p);
15651               insn &= 1;
15652               bfd_put_32 (input_bfd, B_DOT | insn, p);
15653               bfd_put_32 (input_bfd, NOP, p + 4);
15654               unresolved_reloc = save_unresolved_reloc;
15655               r_type = R_PPC64_REL24;
15656             }
15657           break;
15658
15659         case R_PPC64_PLTSEQ:
15660           if (unresolved_reloc)
15661             {
15662               unresolved_reloc = FALSE;
15663               goto nop_it;
15664             }
15665           break;
15666
15667         case R_PPC64_PLT16_HA:
15668           if (unresolved_reloc)
15669             {
15670               unresolved_reloc = FALSE;
15671               goto nop_it;
15672             }
15673           /* Fall through.  */
15674         case R_PPC64_GOT_TLSLD16_HA:
15675         case R_PPC64_GOT_TLSGD16_HA:
15676         case R_PPC64_GOT_TPREL16_HA:
15677         case R_PPC64_GOT_DTPREL16_HA:
15678         case R_PPC64_GOT16_HA:
15679         case R_PPC64_TOC16_HA:
15680           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15681               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15682             {
15683               bfd_byte *p;
15684             nop_it:
15685               p = contents + (rel->r_offset & ~3);
15686               bfd_put_32 (input_bfd, NOP, p);
15687               goto copy_reloc;
15688             }
15689           break;
15690
15691         case R_PPC64_PLT16_LO:
15692         case R_PPC64_PLT16_LO_DS:
15693           if (unresolved_reloc)
15694             {
15695               unresolved_reloc = FALSE;
15696               goto nop_it;
15697             }
15698           /* Fall through.  */
15699         case R_PPC64_GOT_TLSLD16_LO:
15700         case R_PPC64_GOT_TLSGD16_LO:
15701         case R_PPC64_GOT_TPREL16_LO_DS:
15702         case R_PPC64_GOT_DTPREL16_LO_DS:
15703         case R_PPC64_GOT16_LO:
15704         case R_PPC64_GOT16_LO_DS:
15705         case R_PPC64_TOC16_LO:
15706         case R_PPC64_TOC16_LO_DS:
15707           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15708               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15709             {
15710               bfd_byte *p = contents + (rel->r_offset & ~3);
15711               insn = bfd_get_32 (input_bfd, p);
15712               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15713                 {
15714                   /* Transform addic to addi when we change reg.  */
15715                   insn &= ~((0x3f << 26) | (0x1f << 16));
15716                   insn |= (14u << 26) | (2 << 16);
15717                 }
15718               else
15719                 {
15720                   insn &= ~(0x1f << 16);
15721                   insn |= 2 << 16;
15722                 }
15723               bfd_put_32 (input_bfd, insn, p);
15724             }
15725           break;
15726
15727         case R_PPC64_TPREL16_HA:
15728           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15729             {
15730               bfd_byte *p = contents + (rel->r_offset & ~3);
15731               insn = bfd_get_32 (input_bfd, p);
15732               if ((insn & ((0x3f << 26) | 0x1f << 16))
15733                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15734                 /* xgettext:c-format */
15735                 info->callbacks->minfo
15736                   (_("%H: warning: %s unexpected insn %#x.\n"),
15737                    input_bfd, input_section, rel->r_offset,
15738                    ppc64_elf_howto_table[r_type]->name, insn);
15739               else
15740                 {
15741                   bfd_put_32 (input_bfd, NOP, p);
15742                   goto copy_reloc;
15743                 }
15744             }
15745           break;
15746
15747         case R_PPC64_TPREL16_LO:
15748         case R_PPC64_TPREL16_LO_DS:
15749           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15750             {
15751               bfd_byte *p = contents + (rel->r_offset & ~3);
15752               insn = bfd_get_32 (input_bfd, p);
15753               insn &= ~(0x1f << 16);
15754               insn |= 13 << 16;
15755               bfd_put_32 (input_bfd, insn, p);
15756             }
15757           break;
15758         }
15759
15760       /* Do any further special processing.  */
15761       switch (r_type)
15762         {
15763         default:
15764           break;
15765
15766         case R_PPC64_REL16_HA:
15767         case R_PPC64_REL16DX_HA:
15768         case R_PPC64_ADDR16_HA:
15769         case R_PPC64_ADDR16_HIGHA:
15770         case R_PPC64_ADDR16_HIGHERA:
15771         case R_PPC64_ADDR16_HIGHESTA:
15772         case R_PPC64_TOC16_HA:
15773         case R_PPC64_SECTOFF_HA:
15774         case R_PPC64_TPREL16_HA:
15775         case R_PPC64_TPREL16_HIGHA:
15776         case R_PPC64_TPREL16_HIGHERA:
15777         case R_PPC64_TPREL16_HIGHESTA:
15778         case R_PPC64_DTPREL16_HA:
15779         case R_PPC64_DTPREL16_HIGHA:
15780         case R_PPC64_DTPREL16_HIGHERA:
15781         case R_PPC64_DTPREL16_HIGHESTA:
15782           /* It's just possible that this symbol is a weak symbol
15783              that's not actually defined anywhere. In that case,
15784              'sec' would be NULL, and we should leave the symbol
15785              alone (it will be set to zero elsewhere in the link).  */
15786           if (sec == NULL)
15787             break;
15788           /* Fall through.  */
15789
15790         case R_PPC64_GOT16_HA:
15791         case R_PPC64_PLTGOT16_HA:
15792         case R_PPC64_PLT16_HA:
15793         case R_PPC64_GOT_TLSGD16_HA:
15794         case R_PPC64_GOT_TLSLD16_HA:
15795         case R_PPC64_GOT_TPREL16_HA:
15796         case R_PPC64_GOT_DTPREL16_HA:
15797           /* Add 0x10000 if sign bit in 0:15 is set.
15798              Bits 0:15 are not used.  */
15799           addend += 0x8000;
15800           break;
15801
15802         case R_PPC64_ADDR16_DS:
15803         case R_PPC64_ADDR16_LO_DS:
15804         case R_PPC64_GOT16_DS:
15805         case R_PPC64_GOT16_LO_DS:
15806         case R_PPC64_PLT16_LO_DS:
15807         case R_PPC64_SECTOFF_DS:
15808         case R_PPC64_SECTOFF_LO_DS:
15809         case R_PPC64_TOC16_DS:
15810         case R_PPC64_TOC16_LO_DS:
15811         case R_PPC64_PLTGOT16_DS:
15812         case R_PPC64_PLTGOT16_LO_DS:
15813         case R_PPC64_GOT_TPREL16_DS:
15814         case R_PPC64_GOT_TPREL16_LO_DS:
15815         case R_PPC64_GOT_DTPREL16_DS:
15816         case R_PPC64_GOT_DTPREL16_LO_DS:
15817         case R_PPC64_TPREL16_DS:
15818         case R_PPC64_TPREL16_LO_DS:
15819         case R_PPC64_DTPREL16_DS:
15820         case R_PPC64_DTPREL16_LO_DS:
15821           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15822           mask = 3;
15823           /* If this reloc is against an lq, lxv, or stxv insn, then
15824              the value must be a multiple of 16.  This is somewhat of
15825              a hack, but the "correct" way to do this by defining _DQ
15826              forms of all the _DS relocs bloats all reloc switches in
15827              this file.  It doesn't make much sense to use these
15828              relocs in data, so testing the insn should be safe.  */
15829           if ((insn & (0x3f << 26)) == (56u << 26)
15830               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15831             mask = 15;
15832           relocation += addend;
15833           addend = insn & (mask ^ 3);
15834           if ((relocation & mask) != 0)
15835             {
15836               relocation ^= relocation & mask;
15837               info->callbacks->einfo
15838                 /* xgettext:c-format */
15839                 (_("%H: error: %s not a multiple of %u\n"),
15840                  input_bfd, input_section, rel->r_offset,
15841                  ppc64_elf_howto_table[r_type]->name,
15842                  mask + 1);
15843               bfd_set_error (bfd_error_bad_value);
15844               ret = FALSE;
15845               goto copy_reloc;
15846             }
15847           break;
15848         }
15849
15850       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15851          because such sections are not SEC_ALLOC and thus ld.so will
15852          not process them.  */
15853       howto = ppc64_elf_howto_table[(int) r_type];
15854       if (unresolved_reloc
15855           && !((input_section->flags & SEC_DEBUGGING) != 0
15856                && h->elf.def_dynamic)
15857           && _bfd_elf_section_offset (output_bfd, info, input_section,
15858                                       rel->r_offset) != (bfd_vma) -1)
15859         {
15860           info->callbacks->einfo
15861             /* xgettext:c-format */
15862             (_("%H: unresolvable %s against `%pT'\n"),
15863              input_bfd, input_section, rel->r_offset,
15864              howto->name,
15865              h->elf.root.root.string);
15866           ret = FALSE;
15867         }
15868
15869       /* 16-bit fields in insns mostly have signed values, but a
15870          few insns have 16-bit unsigned values.  Really, we should
15871          have different reloc types.  */
15872       if (howto->complain_on_overflow != complain_overflow_dont
15873           && howto->dst_mask == 0xffff
15874           && (input_section->flags & SEC_CODE) != 0)
15875         {
15876           enum complain_overflow complain = complain_overflow_signed;
15877
15878           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15879           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15880             complain = complain_overflow_bitfield;
15881           else if (howto->rightshift == 0
15882                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15883                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15884                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15885                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15886                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15887                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15888             complain = complain_overflow_unsigned;
15889           if (howto->complain_on_overflow != complain)
15890             {
15891               alt_howto = *howto;
15892               alt_howto.complain_on_overflow = complain;
15893               howto = &alt_howto;
15894             }
15895         }
15896
15897       if (r_type == R_PPC64_REL16DX_HA)
15898         {
15899           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15900           if (rel->r_offset + 4 > input_section->size)
15901             r = bfd_reloc_outofrange;
15902           else
15903             {
15904               relocation += addend;
15905               relocation -= (rel->r_offset
15906                              + input_section->output_offset
15907                              + input_section->output_section->vma);
15908               relocation = (bfd_signed_vma) relocation >> 16;
15909               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15910               insn &= ~0x1fffc1;
15911               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15912               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15913               r = bfd_reloc_ok;
15914               if (relocation + 0x8000 > 0xffff)
15915                 r = bfd_reloc_overflow;
15916             }
15917         }
15918       else
15919         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15920                                       rel->r_offset, relocation, addend);
15921
15922       if (r != bfd_reloc_ok)
15923         {
15924           char *more_info = NULL;
15925           const char *reloc_name = howto->name;
15926
15927           if (reloc_dest != DEST_NORMAL)
15928             {
15929               more_info = bfd_malloc (strlen (reloc_name) + 8);
15930               if (more_info != NULL)
15931                 {
15932                   strcpy (more_info, reloc_name);
15933                   strcat (more_info, (reloc_dest == DEST_OPD
15934                                       ? " (OPD)" : " (stub)"));
15935                   reloc_name = more_info;
15936                 }
15937             }
15938
15939           if (r == bfd_reloc_overflow)
15940             {
15941               /* On code like "if (foo) foo();" don't report overflow
15942                  on a branch to zero when foo is undefined.  */
15943               if (!warned
15944                   && (reloc_dest == DEST_STUB
15945                       || !(h != NULL
15946                            && (h->elf.root.type == bfd_link_hash_undefweak
15947                                || h->elf.root.type == bfd_link_hash_undefined)
15948                            && is_branch_reloc (r_type))))
15949                 info->callbacks->reloc_overflow (info, &h->elf.root,
15950                                                  sym_name, reloc_name,
15951                                                  orig_rel.r_addend,
15952                                                  input_bfd, input_section,
15953                                                  rel->r_offset);
15954             }
15955           else
15956             {
15957               info->callbacks->einfo
15958                 /* xgettext:c-format */
15959                 (_("%H: %s against `%pT': error %d\n"),
15960                  input_bfd, input_section, rel->r_offset,
15961                  reloc_name, sym_name, (int) r);
15962               ret = FALSE;
15963             }
15964           if (more_info != NULL)
15965             free (more_info);
15966         }
15967     copy_reloc:
15968       if (wrel != rel)
15969         *wrel = *rel;
15970     }
15971
15972   if (wrel != rel)
15973     {
15974       Elf_Internal_Shdr *rel_hdr;
15975       size_t deleted = rel - wrel;
15976
15977       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15978       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15979       if (rel_hdr->sh_size == 0)
15980         {
15981           /* It is too late to remove an empty reloc section.  Leave
15982              one NONE reloc.
15983              ??? What is wrong with an empty section???  */
15984           rel_hdr->sh_size = rel_hdr->sh_entsize;
15985           deleted -= 1;
15986         }
15987       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15988       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15989       input_section->reloc_count -= deleted;
15990     }
15991
15992   /* If we're emitting relocations, then shortly after this function
15993      returns, reloc offsets and addends for this section will be
15994      adjusted.  Worse, reloc symbol indices will be for the output
15995      file rather than the input.  Save a copy of the relocs for
15996      opd_entry_value.  */
15997   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15998     {
15999       bfd_size_type amt;
16000       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16001       rel = bfd_alloc (input_bfd, amt);
16002       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16003       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16004       if (rel == NULL)
16005         return FALSE;
16006       memcpy (rel, relocs, amt);
16007     }
16008   return ret;
16009 }
16010
16011 /* Adjust the value of any local symbols in opd sections.  */
16012
16013 static int
16014 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16015                               const char *name ATTRIBUTE_UNUSED,
16016                               Elf_Internal_Sym *elfsym,
16017                               asection *input_sec,
16018                               struct elf_link_hash_entry *h)
16019 {
16020   struct _opd_sec_data *opd;
16021   long adjust;
16022   bfd_vma value;
16023
16024   if (h != NULL)
16025     return 1;
16026
16027   opd = get_opd_info (input_sec);
16028   if (opd == NULL || opd->adjust == NULL)
16029     return 1;
16030
16031   value = elfsym->st_value - input_sec->output_offset;
16032   if (!bfd_link_relocatable (info))
16033     value -= input_sec->output_section->vma;
16034
16035   adjust = opd->adjust[OPD_NDX (value)];
16036   if (adjust == -1)
16037     return 2;
16038
16039   elfsym->st_value += adjust;
16040   return 1;
16041 }
16042
16043 /* Finish up dynamic symbol handling.  We set the contents of various
16044    dynamic sections here.  */
16045
16046 static bfd_boolean
16047 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16048                                  struct bfd_link_info *info,
16049                                  struct elf_link_hash_entry *h,
16050                                  Elf_Internal_Sym *sym)
16051 {
16052   struct ppc_link_hash_table *htab;
16053   struct plt_entry *ent;
16054
16055   htab = ppc_hash_table (info);
16056   if (htab == NULL)
16057     return FALSE;
16058
16059   if (!htab->opd_abi && !h->def_regular)
16060     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16061       if (ent->plt.offset != (bfd_vma) -1)
16062         {
16063           /* Mark the symbol as undefined, rather than as
16064              defined in glink.  Leave the value if there were
16065              any relocations where pointer equality matters
16066              (this is a clue for the dynamic linker, to make
16067              function pointer comparisons work between an
16068              application and shared library), otherwise set it
16069              to zero.  */
16070           sym->st_shndx = SHN_UNDEF;
16071           if (!h->pointer_equality_needed)
16072             sym->st_value = 0;
16073           else if (!h->ref_regular_nonweak)
16074             {
16075               /* This breaks function pointer comparisons, but
16076                  that is better than breaking tests for a NULL
16077                  function pointer.  */
16078               sym->st_value = 0;
16079             }
16080           break;
16081         }
16082
16083   if (h->needs_copy)
16084     {
16085       /* This symbol needs a copy reloc.  Set it up.  */
16086       Elf_Internal_Rela rela;
16087       asection *srel;
16088       bfd_byte *loc;
16089
16090       if (h->dynindx == -1
16091           || (h->root.type != bfd_link_hash_defined
16092               && h->root.type != bfd_link_hash_defweak)
16093           || htab->elf.srelbss == NULL
16094           || htab->elf.sreldynrelro == NULL)
16095         abort ();
16096
16097       rela.r_offset = (h->root.u.def.value
16098                        + h->root.u.def.section->output_section->vma
16099                        + h->root.u.def.section->output_offset);
16100       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16101       rela.r_addend = 0;
16102       if (h->root.u.def.section == htab->elf.sdynrelro)
16103         srel = htab->elf.sreldynrelro;
16104       else
16105         srel = htab->elf.srelbss;
16106       loc = srel->contents;
16107       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16108       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16109     }
16110
16111   return TRUE;
16112 }
16113
16114 /* Used to decide how to sort relocs in an optimal manner for the
16115    dynamic linker, before writing them out.  */
16116
16117 static enum elf_reloc_type_class
16118 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16119                             const asection *rel_sec,
16120                             const Elf_Internal_Rela *rela)
16121 {
16122   enum elf_ppc64_reloc_type r_type;
16123   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16124
16125   if (rel_sec == htab->elf.irelplt)
16126     return reloc_class_ifunc;
16127
16128   r_type = ELF64_R_TYPE (rela->r_info);
16129   switch (r_type)
16130     {
16131     case R_PPC64_RELATIVE:
16132       return reloc_class_relative;
16133     case R_PPC64_JMP_SLOT:
16134       return reloc_class_plt;
16135     case R_PPC64_COPY:
16136       return reloc_class_copy;
16137     default:
16138       return reloc_class_normal;
16139     }
16140 }
16141
16142 /* Finish up the dynamic sections.  */
16143
16144 static bfd_boolean
16145 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16146                                    struct bfd_link_info *info)
16147 {
16148   struct ppc_link_hash_table *htab;
16149   bfd *dynobj;
16150   asection *sdyn;
16151
16152   htab = ppc_hash_table (info);
16153   if (htab == NULL)
16154     return FALSE;
16155
16156   dynobj = htab->elf.dynobj;
16157   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16158
16159   if (htab->elf.dynamic_sections_created)
16160     {
16161       Elf64_External_Dyn *dyncon, *dynconend;
16162
16163       if (sdyn == NULL || htab->elf.sgot == NULL)
16164         abort ();
16165
16166       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16167       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16168       for (; dyncon < dynconend; dyncon++)
16169         {
16170           Elf_Internal_Dyn dyn;
16171           asection *s;
16172
16173           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16174
16175           switch (dyn.d_tag)
16176             {
16177             default:
16178               continue;
16179
16180             case DT_PPC64_GLINK:
16181               s = htab->glink;
16182               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16183               /* We stupidly defined DT_PPC64_GLINK to be the start
16184                  of glink rather than the first entry point, which is
16185                  what ld.so needs, and now have a bigger stub to
16186                  support automatic multiple TOCs.  */
16187               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16188               break;
16189
16190             case DT_PPC64_OPD:
16191               s = bfd_get_section_by_name (output_bfd, ".opd");
16192               if (s == NULL)
16193                 continue;
16194               dyn.d_un.d_ptr = s->vma;
16195               break;
16196
16197             case DT_PPC64_OPT:
16198               if (htab->do_multi_toc && htab->multi_toc_needed)
16199                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16200               if (htab->has_plt_localentry0)
16201                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16202               break;
16203
16204             case DT_PPC64_OPDSZ:
16205               s = bfd_get_section_by_name (output_bfd, ".opd");
16206               if (s == NULL)
16207                 continue;
16208               dyn.d_un.d_val = s->size;
16209               break;
16210
16211             case DT_PLTGOT:
16212               s = htab->elf.splt;
16213               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16214               break;
16215
16216             case DT_JMPREL:
16217               s = htab->elf.srelplt;
16218               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16219               break;
16220
16221             case DT_PLTRELSZ:
16222               dyn.d_un.d_val = htab->elf.srelplt->size;
16223               break;
16224
16225             case DT_TEXTREL:
16226               if (htab->local_ifunc_resolver)
16227                 info->callbacks->einfo
16228                   (_("%X%P: text relocations and GNU indirect "
16229                      "functions will result in a segfault at runtime\n"));
16230               else if (htab->maybe_local_ifunc_resolver)
16231                 info->callbacks->einfo
16232                   (_("%P: warning: text relocations and GNU indirect "
16233                      "functions may result in a segfault at runtime\n"));
16234               continue;
16235             }
16236
16237           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16238         }
16239     }
16240
16241   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16242       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16243     {
16244       /* Fill in the first entry in the global offset table.
16245          We use it to hold the link-time TOCbase.  */
16246       bfd_put_64 (output_bfd,
16247                   elf_gp (output_bfd) + TOC_BASE_OFF,
16248                   htab->elf.sgot->contents);
16249
16250       /* Set .got entry size.  */
16251       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16252     }
16253
16254   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16255       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16256     {
16257       /* Set .plt entry size.  */
16258       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16259         = PLT_ENTRY_SIZE (htab);
16260     }
16261
16262   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16263      brlt ourselves if emitrelocations.  */
16264   if (htab->brlt != NULL
16265       && htab->brlt->reloc_count != 0
16266       && !_bfd_elf_link_output_relocs (output_bfd,
16267                                        htab->brlt,
16268                                        elf_section_data (htab->brlt)->rela.hdr,
16269                                        elf_section_data (htab->brlt)->relocs,
16270                                        NULL))
16271     return FALSE;
16272
16273   if (htab->glink != NULL
16274       && htab->glink->reloc_count != 0
16275       && !_bfd_elf_link_output_relocs (output_bfd,
16276                                        htab->glink,
16277                                        elf_section_data (htab->glink)->rela.hdr,
16278                                        elf_section_data (htab->glink)->relocs,
16279                                        NULL))
16280     return FALSE;
16281
16282   if (htab->glink_eh_frame != NULL
16283       && htab->glink_eh_frame->size != 0)
16284     {
16285       bfd_vma val;
16286       bfd_byte *p;
16287       struct map_stub *group;
16288       size_t align = 4;
16289
16290       p = htab->glink_eh_frame->contents;
16291       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16292
16293       for (group = htab->group; group != NULL; group = group->next)
16294         if (group->stub_sec != NULL)
16295           {
16296             /* Offset to stub section.  */
16297             val = (group->stub_sec->output_section->vma
16298                    + group->stub_sec->output_offset);
16299             val -= (htab->glink_eh_frame->output_section->vma
16300                     + htab->glink_eh_frame->output_offset
16301                     + (p + 8 - htab->glink_eh_frame->contents));
16302             if (val + 0x80000000 > 0xffffffff)
16303               {
16304                 _bfd_error_handler
16305                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16306                    group->stub_sec->name);
16307                 return FALSE;
16308               }
16309             bfd_put_32 (dynobj, val, p + 8);
16310             p += stub_eh_frame_size (group, align);
16311           }
16312       if (htab->glink != NULL && htab->glink->size != 0)
16313         {
16314           /* Offset to .glink.  */
16315           val = (htab->glink->output_section->vma
16316                  + htab->glink->output_offset
16317                  + 8);
16318           val -= (htab->glink_eh_frame->output_section->vma
16319                   + htab->glink_eh_frame->output_offset
16320                   + (p + 8 - htab->glink_eh_frame->contents));
16321           if (val + 0x80000000 > 0xffffffff)
16322             {
16323               _bfd_error_handler
16324                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16325                  htab->glink->name);
16326               return FALSE;
16327             }
16328           bfd_put_32 (dynobj, val, p + 8);
16329           p += (24 + align - 1) & -align;
16330         }
16331
16332       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16333           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16334                                                htab->glink_eh_frame,
16335                                                htab->glink_eh_frame->contents))
16336         return FALSE;
16337     }
16338
16339   /* We need to handle writing out multiple GOT sections ourselves,
16340      since we didn't add them to DYNOBJ.  We know dynobj is the first
16341      bfd.  */
16342   while ((dynobj = dynobj->link.next) != NULL)
16343     {
16344       asection *s;
16345
16346       if (!is_ppc64_elf (dynobj))
16347         continue;
16348
16349       s = ppc64_elf_tdata (dynobj)->got;
16350       if (s != NULL
16351           && s->size != 0
16352           && s->output_section != bfd_abs_section_ptr
16353           && !bfd_set_section_contents (output_bfd, s->output_section,
16354                                         s->contents, s->output_offset,
16355                                         s->size))
16356         return FALSE;
16357       s = ppc64_elf_tdata (dynobj)->relgot;
16358       if (s != NULL
16359           && s->size != 0
16360           && s->output_section != bfd_abs_section_ptr
16361           && !bfd_set_section_contents (output_bfd, s->output_section,
16362                                         s->contents, s->output_offset,
16363                                         s->size))
16364         return FALSE;
16365     }
16366
16367   return TRUE;
16368 }
16369
16370 #include "elf64-target.h"
16371
16372 /* FreeBSD support */
16373
16374 #undef  TARGET_LITTLE_SYM
16375 #undef  TARGET_LITTLE_NAME
16376
16377 #undef  TARGET_BIG_SYM
16378 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16379 #undef  TARGET_BIG_NAME
16380 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16381
16382 #undef  ELF_OSABI
16383 #define ELF_OSABI       ELFOSABI_FREEBSD
16384
16385 #undef  elf64_bed
16386 #define elf64_bed       elf64_powerpc_fbsd_bed
16387
16388 #include "elf64-target.h"