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         strncpy (data + 56, va_arg (ap, const char *), 80);
3045         va_end (ap);
3046         return elfcore_write_note (abfd, buf, bufsiz,
3047                                    "CORE", note_type, data, sizeof (data));
3048       }
3049
3050     case NT_PRSTATUS:
3051       {
3052         char data[504];
3053         va_list ap;
3054         long pid;
3055         int cursig;
3056         const void *greg;
3057
3058         va_start (ap, note_type);
3059         memset (data, 0, 112);
3060         pid = va_arg (ap, long);
3061         bfd_put_32 (abfd, pid, data + 32);
3062         cursig = va_arg (ap, int);
3063         bfd_put_16 (abfd, cursig, data + 12);
3064         greg = va_arg (ap, const void *);
3065         memcpy (data + 112, greg, 384);
3066         memset (data + 496, 0, 8);
3067         va_end (ap);
3068         return elfcore_write_note (abfd, buf, bufsiz,
3069                                    "CORE", note_type, data, sizeof (data));
3070       }
3071     }
3072 }
3073
3074 /* Add extra PPC sections.  */
3075
3076 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3077 {
3078   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3079   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3080   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3081   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3082   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3083   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3084   { NULL,                     0,  0, 0,            0 }
3085 };
3086
3087 enum _ppc64_sec_type {
3088   sec_normal = 0,
3089   sec_opd = 1,
3090   sec_toc = 2
3091 };
3092
3093 struct _ppc64_elf_section_data
3094 {
3095   struct bfd_elf_section_data elf;
3096
3097   union
3098   {
3099     /* An array with one entry for each opd function descriptor,
3100        and some spares since opd entries may be either 16 or 24 bytes.  */
3101 #define OPD_NDX(OFF) ((OFF) >> 4)
3102     struct _opd_sec_data
3103     {
3104       /* Points to the function code section for local opd entries.  */
3105       asection **func_sec;
3106
3107       /* After editing .opd, adjust references to opd local syms.  */
3108       long *adjust;
3109     } opd;
3110
3111     /* An array for toc sections, indexed by offset/8.  */
3112     struct _toc_sec_data
3113     {
3114       /* Specifies the relocation symbol index used at a given toc offset.  */
3115       unsigned *symndx;
3116
3117       /* And the relocation addend.  */
3118       bfd_vma *add;
3119     } toc;
3120   } u;
3121
3122   enum _ppc64_sec_type sec_type:2;
3123
3124   /* Flag set when small branches are detected.  Used to
3125      select suitable defaults for the stub group size.  */
3126   unsigned int has_14bit_branch:1;
3127
3128   /* Flag set when PLTCALL relocs are detected.  */
3129   unsigned int has_pltcall:1;
3130 };
3131
3132 #define ppc64_elf_section_data(sec) \
3133   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3134
3135 static bfd_boolean
3136 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3137 {
3138   if (!sec->used_by_bfd)
3139     {
3140       struct _ppc64_elf_section_data *sdata;
3141       bfd_size_type amt = sizeof (*sdata);
3142
3143       sdata = bfd_zalloc (abfd, amt);
3144       if (sdata == NULL)
3145         return FALSE;
3146       sec->used_by_bfd = sdata;
3147     }
3148
3149   return _bfd_elf_new_section_hook (abfd, sec);
3150 }
3151
3152 static struct _opd_sec_data *
3153 get_opd_info (asection * sec)
3154 {
3155   if (sec != NULL
3156       && ppc64_elf_section_data (sec) != NULL
3157       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3158     return &ppc64_elf_section_data (sec)->u.opd;
3159   return NULL;
3160 }
3161 \f
3162 /* Parameters for the qsort hook.  */
3163 static bfd_boolean synthetic_relocatable;
3164 static asection *synthetic_opd;
3165
3166 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3167
3168 static int
3169 compare_symbols (const void *ap, const void *bp)
3170 {
3171   const asymbol *a = * (const asymbol **) ap;
3172   const asymbol *b = * (const asymbol **) bp;
3173
3174   /* Section symbols first.  */
3175   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3176     return -1;
3177   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3178     return 1;
3179
3180   /* then .opd symbols.  */
3181   if (synthetic_opd != NULL)
3182     {
3183       if (strcmp (a->section->name, ".opd") == 0
3184           && strcmp (b->section->name, ".opd") != 0)
3185         return -1;
3186       if (strcmp (a->section->name, ".opd") != 0
3187           && strcmp (b->section->name, ".opd") == 0)
3188         return 1;
3189     }
3190
3191   /* then other code symbols.  */
3192   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3193       == (SEC_CODE | SEC_ALLOC)
3194       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195          != (SEC_CODE | SEC_ALLOC))
3196     return -1;
3197
3198   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3199       != (SEC_CODE | SEC_ALLOC)
3200       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3201          == (SEC_CODE | SEC_ALLOC))
3202     return 1;
3203
3204   if (synthetic_relocatable)
3205     {
3206       if (a->section->id < b->section->id)
3207         return -1;
3208
3209       if (a->section->id > b->section->id)
3210         return 1;
3211     }
3212
3213   if (a->value + a->section->vma < b->value + b->section->vma)
3214     return -1;
3215
3216   if (a->value + a->section->vma > b->value + b->section->vma)
3217     return 1;
3218
3219   /* For syms with the same value, prefer strong dynamic global function
3220      syms over other syms.  */
3221   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3222     return -1;
3223
3224   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3225     return 1;
3226
3227   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3228     return -1;
3229
3230   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3231     return 1;
3232
3233   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3234     return -1;
3235
3236   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3237     return 1;
3238
3239   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3240     return -1;
3241
3242   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3243     return 1;
3244
3245   return a > b;
3246 }
3247
3248 /* Search SYMS for a symbol of the given VALUE.  */
3249
3250 static asymbol *
3251 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3252 {
3253   long mid;
3254
3255   if (id == (unsigned) -1)
3256     {
3257       while (lo < hi)
3258         {
3259           mid = (lo + hi) >> 1;
3260           if (syms[mid]->value + syms[mid]->section->vma < value)
3261             lo = mid + 1;
3262           else if (syms[mid]->value + syms[mid]->section->vma > value)
3263             hi = mid;
3264           else
3265             return syms[mid];
3266         }
3267     }
3268   else
3269     {
3270       while (lo < hi)
3271         {
3272           mid = (lo + hi) >> 1;
3273           if (syms[mid]->section->id < id)
3274             lo = mid + 1;
3275           else if (syms[mid]->section->id > id)
3276             hi = mid;
3277           else if (syms[mid]->value < value)
3278             lo = mid + 1;
3279           else if (syms[mid]->value > value)
3280             hi = mid;
3281           else
3282             return syms[mid];
3283         }
3284     }
3285   return NULL;
3286 }
3287
3288 static bfd_boolean
3289 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3290 {
3291   bfd_vma vma = *(bfd_vma *) ptr;
3292   return ((section->flags & SEC_ALLOC) != 0
3293           && section->vma <= vma
3294           && vma < section->vma + section->size);
3295 }
3296
3297 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3298    entry syms.  Also generate @plt symbols for the glink branch table.
3299    Returns count of synthetic symbols in RET or -1 on error.  */
3300
3301 static long
3302 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3303                                 long static_count, asymbol **static_syms,
3304                                 long dyn_count, asymbol **dyn_syms,
3305                                 asymbol **ret)
3306 {
3307   asymbol *s;
3308   size_t i, j, count;
3309   char *names;
3310   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3311   asection *opd = NULL;
3312   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3313   asymbol **syms;
3314   int abi = abiversion (abfd);
3315
3316   *ret = NULL;
3317
3318   if (abi < 2)
3319     {
3320       opd = bfd_get_section_by_name (abfd, ".opd");
3321       if (opd == NULL && abi == 1)
3322         return 0;
3323     }
3324
3325   syms = NULL;
3326   codesecsym = 0;
3327   codesecsymend = 0;
3328   secsymend = 0;
3329   opdsymend = 0;
3330   symcount = 0;
3331   if (opd != NULL)
3332     {
3333       symcount = static_count;
3334       if (!relocatable)
3335         symcount += dyn_count;
3336       if (symcount == 0)
3337         return 0;
3338
3339       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3340       if (syms == NULL)
3341         return -1;
3342
3343       if (!relocatable && static_count != 0 && dyn_count != 0)
3344         {
3345           /* Use both symbol tables.  */
3346           memcpy (syms, static_syms, static_count * sizeof (*syms));
3347           memcpy (syms + static_count, dyn_syms,
3348                   (dyn_count + 1) * sizeof (*syms));
3349         }
3350       else if (!relocatable && static_count == 0)
3351         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3352       else
3353         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3354
3355       /* Trim uninteresting symbols.  Interesting symbols are section,
3356          function, and notype symbols.  */
3357       for (i = 0, j = 0; i < symcount; ++i)
3358         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3359                                | BSF_RELC | BSF_SRELC)) == 0)
3360           syms[j++] = syms[i];
3361       symcount = j;
3362
3363       synthetic_relocatable = relocatable;
3364       synthetic_opd = opd;
3365       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3366
3367       if (!relocatable && symcount > 1)
3368         {
3369           /* Trim duplicate syms, since we may have merged the normal
3370              and dynamic symbols.  Actually, we only care about syms
3371              that have different values, so trim any with the same
3372              value.  Don't consider ifunc and ifunc resolver symbols
3373              duplicates however, because GDB wants to know whether a
3374              text symbol is an ifunc resolver.  */
3375           for (i = 1, j = 1; i < symcount; ++i)
3376             {
3377               const asymbol *s0 = syms[i - 1];
3378               const asymbol *s1 = syms[i];
3379
3380               if ((s0->value + s0->section->vma
3381                    != s1->value + s1->section->vma)
3382                   || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3383                       != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3384                 syms[j++] = syms[i];
3385             }
3386           symcount = j;
3387         }
3388
3389       i = 0;
3390       /* Note that here and in compare_symbols we can't compare opd and
3391          sym->section directly.  With separate debug info files, the
3392          symbols will be extracted from the debug file while abfd passed
3393          to this function is the real binary.  */
3394       if (strcmp (syms[i]->section->name, ".opd") == 0)
3395         ++i;
3396       codesecsym = i;
3397
3398       for (; i < symcount; ++i)
3399         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3400                                          | SEC_THREAD_LOCAL))
3401              != (SEC_CODE | SEC_ALLOC))
3402             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3403           break;
3404       codesecsymend = i;
3405
3406       for (; i < symcount; ++i)
3407         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3408           break;
3409       secsymend = i;
3410
3411       for (; i < symcount; ++i)
3412         if (strcmp (syms[i]->section->name, ".opd") != 0)
3413           break;
3414       opdsymend = i;
3415
3416       for (; i < symcount; ++i)
3417         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3418             != (SEC_CODE | SEC_ALLOC))
3419           break;
3420       symcount = i;
3421     }
3422   count = 0;
3423
3424   if (relocatable)
3425     {
3426       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3427       arelent *r;
3428       size_t size;
3429       size_t relcount;
3430
3431       if (opdsymend == secsymend)
3432         goto done;
3433
3434       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3435       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3436       if (relcount == 0)
3437         goto done;
3438
3439       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3440         {
3441           count = -1;
3442           goto done;
3443         }
3444
3445       size = 0;
3446       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3447         {
3448           asymbol *sym;
3449
3450           while (r < opd->relocation + relcount
3451                  && r->address < syms[i]->value + opd->vma)
3452             ++r;
3453
3454           if (r == opd->relocation + relcount)
3455             break;
3456
3457           if (r->address != syms[i]->value + opd->vma)
3458             continue;
3459
3460           if (r->howto->type != R_PPC64_ADDR64)
3461             continue;
3462
3463           sym = *r->sym_ptr_ptr;
3464           if (!sym_exists_at (syms, opdsymend, symcount,
3465                               sym->section->id, sym->value + r->addend))
3466             {
3467               ++count;
3468               size += sizeof (asymbol);
3469               size += strlen (syms[i]->name) + 2;
3470             }
3471         }
3472
3473       if (size == 0)
3474         goto done;
3475       s = *ret = bfd_malloc (size);
3476       if (s == NULL)
3477         {
3478           count = -1;
3479           goto done;
3480         }
3481
3482       names = (char *) (s + count);
3483
3484       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3485         {
3486           asymbol *sym;
3487
3488           while (r < opd->relocation + relcount
3489                  && r->address < syms[i]->value + opd->vma)
3490             ++r;
3491
3492           if (r == opd->relocation + relcount)
3493             break;
3494
3495           if (r->address != syms[i]->value + opd->vma)
3496             continue;
3497
3498           if (r->howto->type != R_PPC64_ADDR64)
3499             continue;
3500
3501           sym = *r->sym_ptr_ptr;
3502           if (!sym_exists_at (syms, opdsymend, symcount,
3503                               sym->section->id, sym->value + r->addend))
3504             {
3505               size_t len;
3506
3507               *s = *syms[i];
3508               s->flags |= BSF_SYNTHETIC;
3509               s->section = sym->section;
3510               s->value = sym->value + r->addend;
3511               s->name = names;
3512               *names++ = '.';
3513               len = strlen (syms[i]->name);
3514               memcpy (names, syms[i]->name, len + 1);
3515               names += len + 1;
3516               /* Have udata.p point back to the original symbol this
3517                  synthetic symbol was derived from.  */
3518               s->udata.p = syms[i];
3519               s++;
3520             }
3521         }
3522     }
3523   else
3524     {
3525       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3526       bfd_byte *contents = NULL;
3527       size_t size;
3528       size_t plt_count = 0;
3529       bfd_vma glink_vma = 0, resolv_vma = 0;
3530       asection *dynamic, *glink = NULL, *relplt = NULL;
3531       arelent *p;
3532
3533       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3534         {
3535         free_contents_and_exit_err:
3536           count = -1;
3537         free_contents_and_exit:
3538           if (contents)
3539             free (contents);
3540           goto done;
3541         }
3542
3543       size = 0;
3544       for (i = secsymend; i < opdsymend; ++i)
3545         {
3546           bfd_vma ent;
3547
3548           /* Ignore bogus symbols.  */
3549           if (syms[i]->value > opd->size - 8)
3550             continue;
3551
3552           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3553           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3554             {
3555               ++count;
3556               size += sizeof (asymbol);
3557               size += strlen (syms[i]->name) + 2;
3558             }
3559         }
3560
3561       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3562       if (dyn_count != 0
3563           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3564         {
3565           bfd_byte *dynbuf, *extdyn, *extdynend;
3566           size_t extdynsize;
3567           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3568
3569           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3570             goto free_contents_and_exit_err;
3571
3572           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3573           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3574
3575           extdyn = dynbuf;
3576           extdynend = extdyn + dynamic->size;
3577           for (; extdyn < extdynend; extdyn += extdynsize)
3578             {
3579               Elf_Internal_Dyn dyn;
3580               (*swap_dyn_in) (abfd, extdyn, &dyn);
3581
3582               if (dyn.d_tag == DT_NULL)
3583                 break;
3584
3585               if (dyn.d_tag == DT_PPC64_GLINK)
3586                 {
3587                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3588                      See comment in ppc64_elf_finish_dynamic_sections. */
3589                   glink_vma = dyn.d_un.d_val + 8 * 4;
3590                   /* The .glink section usually does not survive the final
3591                      link; search for the section (usually .text) where the
3592                      glink stubs now reside.  */
3593                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3594                                                 &glink_vma);
3595                   break;
3596                 }
3597             }
3598
3599           free (dynbuf);
3600         }
3601
3602       if (glink != NULL)
3603         {
3604           /* Determine __glink trampoline by reading the relative branch
3605              from the first glink stub.  */
3606           bfd_byte buf[4];
3607           unsigned int off = 0;
3608
3609           while (bfd_get_section_contents (abfd, glink, buf,
3610                                            glink_vma + off - glink->vma, 4))
3611             {
3612               unsigned int insn = bfd_get_32 (abfd, buf);
3613               insn ^= B_DOT;
3614               if ((insn & ~0x3fffffc) == 0)
3615                 {
3616                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3617                   break;
3618                 }
3619               off += 4;
3620               if (off > 4)
3621                 break;
3622             }
3623
3624           if (resolv_vma)
3625             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3626
3627           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3628           if (relplt != NULL)
3629             {
3630               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3631               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3632                 goto free_contents_and_exit_err;
3633
3634               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3635               size += plt_count * sizeof (asymbol);
3636
3637               p = relplt->relocation;
3638               for (i = 0; i < plt_count; i++, p++)
3639                 {
3640                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3641                   if (p->addend != 0)
3642                     size += sizeof ("+0x") - 1 + 16;
3643                 }
3644             }
3645         }
3646
3647       if (size == 0)
3648         goto free_contents_and_exit;
3649       s = *ret = bfd_malloc (size);
3650       if (s == NULL)
3651         goto free_contents_and_exit_err;
3652
3653       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3654
3655       for (i = secsymend; i < opdsymend; ++i)
3656         {
3657           bfd_vma ent;
3658
3659           if (syms[i]->value > opd->size - 8)
3660             continue;
3661
3662           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3663           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3664             {
3665               size_t lo, hi;
3666               size_t len;
3667               asection *sec = abfd->sections;
3668
3669               *s = *syms[i];
3670               lo = codesecsym;
3671               hi = codesecsymend;
3672               while (lo < hi)
3673                 {
3674                   size_t mid = (lo + hi) >> 1;
3675                   if (syms[mid]->section->vma < ent)
3676                     lo = mid + 1;
3677                   else if (syms[mid]->section->vma > ent)
3678                     hi = mid;
3679                   else
3680                     {
3681                       sec = syms[mid]->section;
3682                       break;
3683                     }
3684                 }
3685
3686               if (lo >= hi && lo > codesecsym)
3687                 sec = syms[lo - 1]->section;
3688
3689               for (; sec != NULL; sec = sec->next)
3690                 {
3691                   if (sec->vma > ent)
3692                     break;
3693                   /* SEC_LOAD may not be set if SEC is from a separate debug
3694                      info file.  */
3695                   if ((sec->flags & SEC_ALLOC) == 0)
3696                     break;
3697                   if ((sec->flags & SEC_CODE) != 0)
3698                     s->section = sec;
3699                 }
3700               s->flags |= BSF_SYNTHETIC;
3701               s->value = ent - s->section->vma;
3702               s->name = names;
3703               *names++ = '.';
3704               len = strlen (syms[i]->name);
3705               memcpy (names, syms[i]->name, len + 1);
3706               names += len + 1;
3707               /* Have udata.p point back to the original symbol this
3708                  synthetic symbol was derived from.  */
3709               s->udata.p = syms[i];
3710               s++;
3711             }
3712         }
3713       free (contents);
3714
3715       if (glink != NULL && relplt != NULL)
3716         {
3717           if (resolv_vma)
3718             {
3719               /* Add a symbol for the main glink trampoline.  */
3720               memset (s, 0, sizeof *s);
3721               s->the_bfd = abfd;
3722               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3723               s->section = glink;
3724               s->value = resolv_vma - glink->vma;
3725               s->name = names;
3726               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3727               names += sizeof ("__glink_PLTresolve");
3728               s++;
3729               count++;
3730             }
3731
3732           /* FIXME: It would be very much nicer to put sym@plt on the
3733              stub rather than on the glink branch table entry.  The
3734              objdump disassembler would then use a sensible symbol
3735              name on plt calls.  The difficulty in doing so is
3736              a) finding the stubs, and,
3737              b) matching stubs against plt entries, and,
3738              c) there can be multiple stubs for a given plt entry.
3739
3740              Solving (a) could be done by code scanning, but older
3741              ppc64 binaries used different stubs to current code.
3742              (b) is the tricky one since you need to known the toc
3743              pointer for at least one function that uses a pic stub to
3744              be able to calculate the plt address referenced.
3745              (c) means gdb would need to set multiple breakpoints (or
3746              find the glink branch itself) when setting breakpoints
3747              for pending shared library loads.  */
3748           p = relplt->relocation;
3749           for (i = 0; i < plt_count; i++, p++)
3750             {
3751               size_t len;
3752
3753               *s = **p->sym_ptr_ptr;
3754               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3755                  we are defining a symbol, ensure one of them is set.  */
3756               if ((s->flags & BSF_LOCAL) == 0)
3757                 s->flags |= BSF_GLOBAL;
3758               s->flags |= BSF_SYNTHETIC;
3759               s->section = glink;
3760               s->value = glink_vma - glink->vma;
3761               s->name = names;
3762               s->udata.p = NULL;
3763               len = strlen ((*p->sym_ptr_ptr)->name);
3764               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3765               names += len;
3766               if (p->addend != 0)
3767                 {
3768                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3769                   names += sizeof ("+0x") - 1;
3770                   bfd_sprintf_vma (abfd, names, p->addend);
3771                   names += strlen (names);
3772                 }
3773               memcpy (names, "@plt", sizeof ("@plt"));
3774               names += sizeof ("@plt");
3775               s++;
3776               if (abi < 2)
3777                 {
3778                   glink_vma += 8;
3779                   if (i >= 0x8000)
3780                     glink_vma += 4;
3781                 }
3782               else
3783                 glink_vma += 4;
3784             }
3785           count += plt_count;
3786         }
3787     }
3788
3789  done:
3790   free (syms);
3791   return count;
3792 }
3793 \f
3794 /* The following functions are specific to the ELF linker, while
3795    functions above are used generally.  Those named ppc64_elf_* are
3796    called by the main ELF linker code.  They appear in this file more
3797    or less in the order in which they are called.  eg.
3798    ppc64_elf_check_relocs is called early in the link process,
3799    ppc64_elf_finish_dynamic_sections is one of the last functions
3800    called.
3801
3802    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3803    functions have both a function code symbol and a function descriptor
3804    symbol.  A call to foo in a relocatable object file looks like:
3805
3806    .            .text
3807    .    x:
3808    .            bl      .foo
3809    .            nop
3810
3811    The function definition in another object file might be:
3812
3813    .            .section .opd
3814    .    foo:    .quad   .foo
3815    .            .quad   .TOC.@tocbase
3816    .            .quad   0
3817    .
3818    .            .text
3819    .    .foo:   blr
3820
3821    When the linker resolves the call during a static link, the branch
3822    unsurprisingly just goes to .foo and the .opd information is unused.
3823    If the function definition is in a shared library, things are a little
3824    different:  The call goes via a plt call stub, the opd information gets
3825    copied to the plt, and the linker patches the nop.
3826
3827    .    x:
3828    .            bl      .foo_stub
3829    .            ld      2,40(1)
3830    .
3831    .
3832    .    .foo_stub:
3833    .            std     2,40(1)                 # in practice, the call stub
3834    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3835    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3836    .            ld      12,0(11)
3837    .            ld      2,8(11)
3838    .            mtctr   12
3839    .            ld      11,16(11)
3840    .            bctr
3841    .
3842    .            .section .plt
3843    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3844
3845    The "reloc ()" notation is supposed to indicate that the linker emits
3846    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3847    copying.
3848
3849    What are the difficulties here?  Well, firstly, the relocations
3850    examined by the linker in check_relocs are against the function code
3851    sym .foo, while the dynamic relocation in the plt is emitted against
3852    the function descriptor symbol, foo.  Somewhere along the line, we need
3853    to carefully copy dynamic link information from one symbol to the other.
3854    Secondly, the generic part of the elf linker will make .foo a dynamic
3855    symbol as is normal for most other backends.  We need foo dynamic
3856    instead, at least for an application final link.  However, when
3857    creating a shared library containing foo, we need to have both symbols
3858    dynamic so that references to .foo are satisfied during the early
3859    stages of linking.  Otherwise the linker might decide to pull in a
3860    definition from some other object, eg. a static library.
3861
3862    Update: As of August 2004, we support a new convention.  Function
3863    calls may use the function descriptor symbol, ie. "bl foo".  This
3864    behaves exactly as "bl .foo".  */
3865
3866 /* Of those relocs that might be copied as dynamic relocs, this
3867    function selects those that must be copied when linking a shared
3868    library or PIE, even when the symbol is local.  */
3869
3870 static int
3871 must_be_dyn_reloc (struct bfd_link_info *info,
3872                    enum elf_ppc64_reloc_type r_type)
3873 {
3874   switch (r_type)
3875     {
3876     default:
3877       /* Only relative relocs can be resolved when the object load
3878          address isn't fixed.  DTPREL64 is excluded because the
3879          dynamic linker needs to differentiate global dynamic from
3880          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3881       return 1;
3882
3883     case R_PPC64_REL32:
3884     case R_PPC64_REL64:
3885     case R_PPC64_REL30:
3886       return 0;
3887
3888     case R_PPC64_TPREL16:
3889     case R_PPC64_TPREL16_LO:
3890     case R_PPC64_TPREL16_HI:
3891     case R_PPC64_TPREL16_HA:
3892     case R_PPC64_TPREL16_DS:
3893     case R_PPC64_TPREL16_LO_DS:
3894     case R_PPC64_TPREL16_HIGH:
3895     case R_PPC64_TPREL16_HIGHA:
3896     case R_PPC64_TPREL16_HIGHER:
3897     case R_PPC64_TPREL16_HIGHERA:
3898     case R_PPC64_TPREL16_HIGHEST:
3899     case R_PPC64_TPREL16_HIGHESTA:
3900     case R_PPC64_TPREL64:
3901       /* These relocations are relative but in a shared library the
3902          linker doesn't know the thread pointer base.  */
3903       return bfd_link_dll (info);
3904     }
3905 }
3906
3907 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3908    copying dynamic variables from a shared lib into an app's dynbss
3909    section, and instead use a dynamic relocation to point into the
3910    shared lib.  With code that gcc generates, it's vital that this be
3911    enabled;  In the PowerPC64 ABI, the address of a function is actually
3912    the address of a function descriptor, which resides in the .opd
3913    section.  gcc uses the descriptor directly rather than going via the
3914    GOT as some other ABI's do, which means that initialized function
3915    pointers must reference the descriptor.  Thus, a function pointer
3916    initialized to the address of a function in a shared library will
3917    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3918    redefines the function descriptor symbol to point to the copy.  This
3919    presents a problem as a plt entry for that function is also
3920    initialized from the function descriptor symbol and the copy reloc
3921    may not be initialized first.  */
3922 #define ELIMINATE_COPY_RELOCS 1
3923
3924 /* Section name for stubs is the associated section name plus this
3925    string.  */
3926 #define STUB_SUFFIX ".stub"
3927
3928 /* Linker stubs.
3929    ppc_stub_long_branch:
3930    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3931    destination, but a 24 bit branch in a stub section will reach.
3932    .    b       dest
3933
3934    ppc_stub_plt_branch:
3935    Similar to the above, but a 24 bit branch in the stub section won't
3936    reach its destination.
3937    .    addis   %r11,%r2,xxx@toc@ha
3938    .    ld      %r12,xxx@toc@l(%r11)
3939    .    mtctr   %r12
3940    .    bctr
3941
3942    ppc_stub_plt_call:
3943    Used to call a function in a shared library.  If it so happens that
3944    the plt entry referenced crosses a 64k boundary, then an extra
3945    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3946    .    std     %r2,40(%r1)
3947    .    addis   %r11,%r2,xxx@toc@ha
3948    .    ld      %r12,xxx+0@toc@l(%r11)
3949    .    mtctr   %r12
3950    .    ld      %r2,xxx+8@toc@l(%r11)
3951    .    ld      %r11,xxx+16@toc@l(%r11)
3952    .    bctr
3953
3954    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3955    code to adjust the value and save r2 to support multiple toc sections.
3956    A ppc_stub_long_branch with an r2 offset looks like:
3957    .    std     %r2,40(%r1)
3958    .    addis   %r2,%r2,off@ha
3959    .    addi    %r2,%r2,off@l
3960    .    b       dest
3961
3962    A ppc_stub_plt_branch with an r2 offset looks like:
3963    .    std     %r2,40(%r1)
3964    .    addis   %r11,%r2,xxx@toc@ha
3965    .    ld      %r12,xxx@toc@l(%r11)
3966    .    addis   %r2,%r2,off@ha
3967    .    addi    %r2,%r2,off@l
3968    .    mtctr   %r12
3969    .    bctr
3970
3971    In cases where the "addis" instruction would add zero, the "addis" is
3972    omitted and following instructions modified slightly in some cases.
3973 */
3974
3975 enum ppc_stub_type {
3976   ppc_stub_none,
3977   ppc_stub_long_branch,
3978   ppc_stub_long_branch_r2off,
3979   ppc_stub_plt_branch,
3980   ppc_stub_plt_branch_r2off,
3981   ppc_stub_plt_call,
3982   ppc_stub_plt_call_r2save,
3983   ppc_stub_global_entry,
3984   ppc_stub_save_res
3985 };
3986
3987 /* Information on stub grouping.  */
3988 struct map_stub
3989 {
3990   /* The stub section.  */
3991   asection *stub_sec;
3992   /* This is the section to which stubs in the group will be attached.  */
3993   asection *link_sec;
3994   /* Next group.  */
3995   struct map_stub *next;
3996   /* Whether to emit a copy of register save/restore functions in this
3997      group.  */
3998   int needs_save_res;
3999   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
4000      or -1u if no such stub with bctrl exists.  */
4001   unsigned int tls_get_addr_opt_bctrl;
4002 };
4003
4004 struct ppc_stub_hash_entry {
4005
4006   /* Base hash table entry structure.  */
4007   struct bfd_hash_entry root;
4008
4009   enum ppc_stub_type stub_type;
4010
4011   /* Group information.  */
4012   struct map_stub *group;
4013
4014   /* Offset within stub_sec of the beginning of this stub.  */
4015   bfd_vma stub_offset;
4016
4017   /* Given the symbol's value and its section we can determine its final
4018      value when building the stubs (so the stub knows where to jump.  */
4019   bfd_vma target_value;
4020   asection *target_section;
4021
4022   /* The symbol table entry, if any, that this was derived from.  */
4023   struct ppc_link_hash_entry *h;
4024   struct plt_entry *plt_ent;
4025
4026   /* Symbol type.  */
4027   unsigned char symtype;
4028
4029   /* Symbol st_other.  */
4030   unsigned char other;
4031 };
4032
4033 struct ppc_branch_hash_entry {
4034
4035   /* Base hash table entry structure.  */
4036   struct bfd_hash_entry root;
4037
4038   /* Offset within branch lookup table.  */
4039   unsigned int offset;
4040
4041   /* Generation marker.  */
4042   unsigned int iter;
4043 };
4044
4045 /* Used to track dynamic relocations for local symbols.  */
4046 struct ppc_dyn_relocs
4047 {
4048   struct ppc_dyn_relocs *next;
4049
4050   /* The input section of the reloc.  */
4051   asection *sec;
4052
4053   /* Total number of relocs copied for the input section.  */
4054   unsigned int count : 31;
4055
4056   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4057   unsigned int ifunc : 1;
4058 };
4059
4060 struct ppc_link_hash_entry
4061 {
4062   struct elf_link_hash_entry elf;
4063
4064   union {
4065     /* A pointer to the most recently used stub hash entry against this
4066        symbol.  */
4067     struct ppc_stub_hash_entry *stub_cache;
4068
4069     /* A pointer to the next symbol starting with a '.'  */
4070     struct ppc_link_hash_entry *next_dot_sym;
4071   } u;
4072
4073   /* Track dynamic relocs copied for this symbol.  */
4074   struct elf_dyn_relocs *dyn_relocs;
4075
4076   /* Link between function code and descriptor symbols.  */
4077   struct ppc_link_hash_entry *oh;
4078
4079   /* Flag function code and descriptor symbols.  */
4080   unsigned int is_func:1;
4081   unsigned int is_func_descriptor:1;
4082   unsigned int fake:1;
4083
4084   /* Whether global opd/toc sym has been adjusted or not.
4085      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4086      should be set for all globals defined in any opd/toc section.  */
4087   unsigned int adjust_done:1;
4088
4089   /* Set if this is an out-of-line register save/restore function,
4090      with non-standard calling convention.  */
4091   unsigned int save_res:1;
4092
4093   /* Set if a duplicate symbol with non-zero localentry is detected,
4094      even when the duplicate symbol does not provide a definition.  */
4095   unsigned int non_zero_localentry:1;
4096
4097   /* Contexts in which symbol is used in the GOT (or TOC).
4098      Bits are or'd into the mask as the corresponding relocs are
4099      encountered during check_relocs, with TLS_TLS being set when any
4100      of the other TLS bits are set.  tls_optimize clears bits when
4101      optimizing to indicate the corresponding GOT entry type is not
4102      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4103      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4104      separate flag rather than setting TPREL just for convenience in
4105      distinguishing the two cases.
4106      These flags are also kept for local symbols.  */
4107 #define TLS_TLS          1      /* Any TLS reloc.  */
4108 #define TLS_GD           2      /* GD reloc. */
4109 #define TLS_LD           4      /* LD reloc. */
4110 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4111 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4112 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4113 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4114 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4115   unsigned char tls_mask;
4116
4117   /* The above field is also used to mark function symbols.  In which
4118      case TLS_TLS will be 0.  */
4119 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4120 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4121 #define NON_GOT        256      /* local symbol plt, not stored.  */
4122 };
4123
4124 /* ppc64 ELF linker hash table.  */
4125
4126 struct ppc_link_hash_table
4127 {
4128   struct elf_link_hash_table elf;
4129
4130   /* The stub hash table.  */
4131   struct bfd_hash_table stub_hash_table;
4132
4133   /* Another hash table for plt_branch stubs.  */
4134   struct bfd_hash_table branch_hash_table;
4135
4136   /* Hash table for function prologue tocsave.  */
4137   htab_t tocsave_htab;
4138
4139   /* Various options and other info passed from the linker.  */
4140   struct ppc64_elf_params *params;
4141
4142   /* The size of sec_info below.  */
4143   unsigned int sec_info_arr_size;
4144
4145   /* Per-section array of extra section info.  Done this way rather
4146      than as part of ppc64_elf_section_data so we have the info for
4147      non-ppc64 sections.  */
4148   struct
4149   {
4150     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4151     bfd_vma toc_off;
4152
4153     union
4154     {
4155       /* The section group that this section belongs to.  */
4156       struct map_stub *group;
4157       /* A temp section list pointer.  */
4158       asection *list;
4159     } u;
4160   } *sec_info;
4161
4162   /* Linked list of groups.  */
4163   struct map_stub *group;
4164
4165   /* Temp used when calculating TOC pointers.  */
4166   bfd_vma toc_curr;
4167   bfd *toc_bfd;
4168   asection *toc_first_sec;
4169
4170   /* Used when adding symbols.  */
4171   struct ppc_link_hash_entry *dot_syms;
4172
4173   /* Shortcuts to get to dynamic linker sections.  */
4174   asection *glink;
4175   asection *global_entry;
4176   asection *sfpr;
4177   asection *pltlocal;
4178   asection *relpltlocal;
4179   asection *brlt;
4180   asection *relbrlt;
4181   asection *glink_eh_frame;
4182
4183   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4184   struct ppc_link_hash_entry *tls_get_addr;
4185   struct ppc_link_hash_entry *tls_get_addr_fd;
4186
4187   /* The size of reliplt used by got entry relocs.  */
4188   bfd_size_type got_reli_size;
4189
4190   /* Statistics.  */
4191   unsigned long stub_count[ppc_stub_global_entry];
4192
4193   /* Number of stubs against global syms.  */
4194   unsigned long stub_globals;
4195
4196   /* Set if we're linking code with function descriptors.  */
4197   unsigned int opd_abi:1;
4198
4199   /* Support for multiple toc sections.  */
4200   unsigned int do_multi_toc:1;
4201   unsigned int multi_toc_needed:1;
4202   unsigned int second_toc_pass:1;
4203   unsigned int do_toc_opt:1;
4204
4205   /* Set if tls optimization is enabled.  */
4206   unsigned int do_tls_opt:1;
4207
4208   /* Set if inline plt calls should be converted to direct calls.  */
4209   unsigned int can_convert_all_inline_plt:1;
4210
4211   /* Set on error.  */
4212   unsigned int stub_error:1;
4213
4214   /* Whether func_desc_adjust needs to be run over symbols.  */
4215   unsigned int need_func_desc_adj:1;
4216
4217   /* Whether there exist local gnu indirect function resolvers,
4218      referenced by dynamic relocations.  */
4219   unsigned int local_ifunc_resolver:1;
4220   unsigned int maybe_local_ifunc_resolver:1;
4221
4222   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4223   unsigned int has_plt_localentry0:1;
4224
4225   /* Incremented every time we size stubs.  */
4226   unsigned int stub_iteration;
4227
4228   /* Small local sym cache.  */
4229   struct sym_cache sym_cache;
4230 };
4231
4232 /* Rename some of the generic section flags to better document how they
4233    are used here.  */
4234
4235 /* Nonzero if this section has TLS related relocations.  */
4236 #define has_tls_reloc sec_flg0
4237
4238 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4239 #define has_tls_get_addr_call sec_flg1
4240
4241 /* Nonzero if this section has any toc or got relocs.  */
4242 #define has_toc_reloc sec_flg2
4243
4244 /* Nonzero if this section has a call to another section that uses
4245    the toc or got.  */
4246 #define makes_toc_func_call sec_flg3
4247
4248 /* Recursion protection when determining above flag.  */
4249 #define call_check_in_progress sec_flg4
4250 #define call_check_done sec_flg5
4251
4252 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4253
4254 #define ppc_hash_table(p) \
4255   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4256   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4257
4258 #define ppc_stub_hash_lookup(table, string, create, copy) \
4259   ((struct ppc_stub_hash_entry *) \
4260    bfd_hash_lookup ((table), (string), (create), (copy)))
4261
4262 #define ppc_branch_hash_lookup(table, string, create, copy) \
4263   ((struct ppc_branch_hash_entry *) \
4264    bfd_hash_lookup ((table), (string), (create), (copy)))
4265
4266 /* Create an entry in the stub hash table.  */
4267
4268 static struct bfd_hash_entry *
4269 stub_hash_newfunc (struct bfd_hash_entry *entry,
4270                    struct bfd_hash_table *table,
4271                    const char *string)
4272 {
4273   /* Allocate the structure if it has not already been allocated by a
4274      subclass.  */
4275   if (entry == NULL)
4276     {
4277       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4278       if (entry == NULL)
4279         return entry;
4280     }
4281
4282   /* Call the allocation method of the superclass.  */
4283   entry = bfd_hash_newfunc (entry, table, string);
4284   if (entry != NULL)
4285     {
4286       struct ppc_stub_hash_entry *eh;
4287
4288       /* Initialize the local fields.  */
4289       eh = (struct ppc_stub_hash_entry *) entry;
4290       eh->stub_type = ppc_stub_none;
4291       eh->group = NULL;
4292       eh->stub_offset = 0;
4293       eh->target_value = 0;
4294       eh->target_section = NULL;
4295       eh->h = NULL;
4296       eh->plt_ent = NULL;
4297       eh->other = 0;
4298     }
4299
4300   return entry;
4301 }
4302
4303 /* Create an entry in the branch hash table.  */
4304
4305 static struct bfd_hash_entry *
4306 branch_hash_newfunc (struct bfd_hash_entry *entry,
4307                      struct bfd_hash_table *table,
4308                      const char *string)
4309 {
4310   /* Allocate the structure if it has not already been allocated by a
4311      subclass.  */
4312   if (entry == NULL)
4313     {
4314       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4315       if (entry == NULL)
4316         return entry;
4317     }
4318
4319   /* Call the allocation method of the superclass.  */
4320   entry = bfd_hash_newfunc (entry, table, string);
4321   if (entry != NULL)
4322     {
4323       struct ppc_branch_hash_entry *eh;
4324
4325       /* Initialize the local fields.  */
4326       eh = (struct ppc_branch_hash_entry *) entry;
4327       eh->offset = 0;
4328       eh->iter = 0;
4329     }
4330
4331   return entry;
4332 }
4333
4334 /* Create an entry in a ppc64 ELF linker hash table.  */
4335
4336 static struct bfd_hash_entry *
4337 link_hash_newfunc (struct bfd_hash_entry *entry,
4338                    struct bfd_hash_table *table,
4339                    const char *string)
4340 {
4341   /* Allocate the structure if it has not already been allocated by a
4342      subclass.  */
4343   if (entry == NULL)
4344     {
4345       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4346       if (entry == NULL)
4347         return entry;
4348     }
4349
4350   /* Call the allocation method of the superclass.  */
4351   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4352   if (entry != NULL)
4353     {
4354       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4355
4356       memset (&eh->u.stub_cache, 0,
4357               (sizeof (struct ppc_link_hash_entry)
4358                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4359
4360       /* When making function calls, old ABI code references function entry
4361          points (dot symbols), while new ABI code references the function
4362          descriptor symbol.  We need to make any combination of reference and
4363          definition work together, without breaking archive linking.
4364
4365          For a defined function "foo" and an undefined call to "bar":
4366          An old object defines "foo" and ".foo", references ".bar" (possibly
4367          "bar" too).
4368          A new object defines "foo" and references "bar".
4369
4370          A new object thus has no problem with its undefined symbols being
4371          satisfied by definitions in an old object.  On the other hand, the
4372          old object won't have ".bar" satisfied by a new object.
4373
4374          Keep a list of newly added dot-symbols.  */
4375
4376       if (string[0] == '.')
4377         {
4378           struct ppc_link_hash_table *htab;
4379
4380           htab = (struct ppc_link_hash_table *) table;
4381           eh->u.next_dot_sym = htab->dot_syms;
4382           htab->dot_syms = eh;
4383         }
4384     }
4385
4386   return entry;
4387 }
4388
4389 struct tocsave_entry {
4390   asection *sec;
4391   bfd_vma offset;
4392 };
4393
4394 static hashval_t
4395 tocsave_htab_hash (const void *p)
4396 {
4397   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4398   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4399 }
4400
4401 static int
4402 tocsave_htab_eq (const void *p1, const void *p2)
4403 {
4404   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4405   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4406   return e1->sec == e2->sec && e1->offset == e2->offset;
4407 }
4408
4409 /* Destroy a ppc64 ELF linker hash table.  */
4410
4411 static void
4412 ppc64_elf_link_hash_table_free (bfd *obfd)
4413 {
4414   struct ppc_link_hash_table *htab;
4415
4416   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4417   if (htab->tocsave_htab)
4418     htab_delete (htab->tocsave_htab);
4419   bfd_hash_table_free (&htab->branch_hash_table);
4420   bfd_hash_table_free (&htab->stub_hash_table);
4421   _bfd_elf_link_hash_table_free (obfd);
4422 }
4423
4424 /* Create a ppc64 ELF linker hash table.  */
4425
4426 static struct bfd_link_hash_table *
4427 ppc64_elf_link_hash_table_create (bfd *abfd)
4428 {
4429   struct ppc_link_hash_table *htab;
4430   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4431
4432   htab = bfd_zmalloc (amt);
4433   if (htab == NULL)
4434     return NULL;
4435
4436   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4437                                       sizeof (struct ppc_link_hash_entry),
4438                                       PPC64_ELF_DATA))
4439     {
4440       free (htab);
4441       return NULL;
4442     }
4443
4444   /* Init the stub hash table too.  */
4445   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4446                             sizeof (struct ppc_stub_hash_entry)))
4447     {
4448       _bfd_elf_link_hash_table_free (abfd);
4449       return NULL;
4450     }
4451
4452   /* And the branch hash table.  */
4453   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4454                             sizeof (struct ppc_branch_hash_entry)))
4455     {
4456       bfd_hash_table_free (&htab->stub_hash_table);
4457       _bfd_elf_link_hash_table_free (abfd);
4458       return NULL;
4459     }
4460
4461   htab->tocsave_htab = htab_try_create (1024,
4462                                         tocsave_htab_hash,
4463                                         tocsave_htab_eq,
4464                                         NULL);
4465   if (htab->tocsave_htab == NULL)
4466     {
4467       ppc64_elf_link_hash_table_free (abfd);
4468       return NULL;
4469     }
4470   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4471
4472   /* Initializing two fields of the union is just cosmetic.  We really
4473      only care about glist, but when compiled on a 32-bit host the
4474      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4475      debugger inspection of these fields look nicer.  */
4476   htab->elf.init_got_refcount.refcount = 0;
4477   htab->elf.init_got_refcount.glist = NULL;
4478   htab->elf.init_plt_refcount.refcount = 0;
4479   htab->elf.init_plt_refcount.glist = NULL;
4480   htab->elf.init_got_offset.offset = 0;
4481   htab->elf.init_got_offset.glist = NULL;
4482   htab->elf.init_plt_offset.offset = 0;
4483   htab->elf.init_plt_offset.glist = NULL;
4484
4485   return &htab->elf.root;
4486 }
4487
4488 /* Create sections for linker generated code.  */
4489
4490 static bfd_boolean
4491 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4492 {
4493   struct ppc_link_hash_table *htab;
4494   flagword flags;
4495
4496   htab = ppc_hash_table (info);
4497
4498   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4499            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4500   if (htab->params->save_restore_funcs)
4501     {
4502       /* Create .sfpr for code to save and restore fp regs.  */
4503       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4504                                                        flags);
4505       if (htab->sfpr == NULL
4506           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4507         return FALSE;
4508     }
4509
4510   if (bfd_link_relocatable (info))
4511     return TRUE;
4512
4513   /* Create .glink for lazy dynamic linking support.  */
4514   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4515                                                     flags);
4516   if (htab->glink == NULL
4517       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4518     return FALSE;
4519
4520   /* The part of .glink used by global entry stubs, separate so that
4521      it can be aligned appropriately without affecting htab->glink.  */
4522   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4523                                                            flags);
4524   if (htab->global_entry == NULL
4525       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4526     return FALSE;
4527
4528   if (!info->no_ld_generated_unwind_info)
4529     {
4530       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4531                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4532       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4533                                                                  ".eh_frame",
4534                                                                  flags);
4535       if (htab->glink_eh_frame == NULL
4536           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4537         return FALSE;
4538     }
4539
4540   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4541   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4542   if (htab->elf.iplt == NULL
4543       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4544     return FALSE;
4545
4546   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4547            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4548   htab->elf.irelplt
4549     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4550   if (htab->elf.irelplt == NULL
4551       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4552     return FALSE;
4553
4554   /* Create branch lookup table for plt_branch stubs.  */
4555   flags = (SEC_ALLOC | SEC_LOAD
4556            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4557   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4558                                                    flags);
4559   if (htab->brlt == NULL
4560       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4561     return FALSE;
4562
4563   /* Local plt entries, put in .branch_lt but a separate section for
4564      convenience.  */
4565   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4566                                                        flags);
4567   if (htab->pltlocal == NULL
4568       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4569     return FALSE;
4570
4571   if (!bfd_link_pic (info))
4572     return TRUE;
4573
4574   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4575            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4576   htab->relbrlt
4577     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4578   if (htab->relbrlt == NULL
4579       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4580     return FALSE;
4581
4582   htab->relpltlocal
4583     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4584   if (htab->relpltlocal == NULL
4585       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4586     return FALSE;
4587
4588   return TRUE;
4589 }
4590
4591 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4592
4593 bfd_boolean
4594 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4595                          struct ppc64_elf_params *params)
4596 {
4597   struct ppc_link_hash_table *htab;
4598
4599   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4600
4601 /* Always hook our dynamic sections into the first bfd, which is the
4602    linker created stub bfd.  This ensures that the GOT header is at
4603    the start of the output TOC section.  */
4604   htab = ppc_hash_table (info);
4605   htab->elf.dynobj = params->stub_bfd;
4606   htab->params = params;
4607
4608   return create_linkage_sections (htab->elf.dynobj, info);
4609 }
4610
4611 /* Build a name for an entry in the stub hash table.  */
4612
4613 static char *
4614 ppc_stub_name (const asection *input_section,
4615                const asection *sym_sec,
4616                const struct ppc_link_hash_entry *h,
4617                const Elf_Internal_Rela *rel)
4618 {
4619   char *stub_name;
4620   ssize_t len;
4621
4622   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4623      offsets from a sym as a branch target?  In fact, we could
4624      probably assume the addend is always zero.  */
4625   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4626
4627   if (h)
4628     {
4629       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4630       stub_name = bfd_malloc (len);
4631       if (stub_name == NULL)
4632         return stub_name;
4633
4634       len = sprintf (stub_name, "%08x.%s+%x",
4635                      input_section->id & 0xffffffff,
4636                      h->elf.root.root.string,
4637                      (int) rel->r_addend & 0xffffffff);
4638     }
4639   else
4640     {
4641       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4642       stub_name = bfd_malloc (len);
4643       if (stub_name == NULL)
4644         return stub_name;
4645
4646       len = sprintf (stub_name, "%08x.%x:%x+%x",
4647                      input_section->id & 0xffffffff,
4648                      sym_sec->id & 0xffffffff,
4649                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4650                      (int) rel->r_addend & 0xffffffff);
4651     }
4652   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4653     stub_name[len - 2] = 0;
4654   return stub_name;
4655 }
4656
4657 /* Look up an entry in the stub hash.  Stub entries are cached because
4658    creating the stub name takes a bit of time.  */
4659
4660 static struct ppc_stub_hash_entry *
4661 ppc_get_stub_entry (const asection *input_section,
4662                     const asection *sym_sec,
4663                     struct ppc_link_hash_entry *h,
4664                     const Elf_Internal_Rela *rel,
4665                     struct ppc_link_hash_table *htab)
4666 {
4667   struct ppc_stub_hash_entry *stub_entry;
4668   struct map_stub *group;
4669
4670   /* If this input section is part of a group of sections sharing one
4671      stub section, then use the id of the first section in the group.
4672      Stub names need to include a section id, as there may well be
4673      more than one stub used to reach say, printf, and we need to
4674      distinguish between them.  */
4675   group = htab->sec_info[input_section->id].u.group;
4676   if (group == NULL)
4677     return NULL;
4678
4679   if (h != NULL && h->u.stub_cache != NULL
4680       && h->u.stub_cache->h == h
4681       && h->u.stub_cache->group == group)
4682     {
4683       stub_entry = h->u.stub_cache;
4684     }
4685   else
4686     {
4687       char *stub_name;
4688
4689       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4690       if (stub_name == NULL)
4691         return NULL;
4692
4693       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4694                                          stub_name, FALSE, FALSE);
4695       if (h != NULL)
4696         h->u.stub_cache = stub_entry;
4697
4698       free (stub_name);
4699     }
4700
4701   return stub_entry;
4702 }
4703
4704 /* Add a new stub entry to the stub hash.  Not all fields of the new
4705    stub entry are initialised.  */
4706
4707 static struct ppc_stub_hash_entry *
4708 ppc_add_stub (const char *stub_name,
4709               asection *section,
4710               struct bfd_link_info *info)
4711 {
4712   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4713   struct map_stub *group;
4714   asection *link_sec;
4715   asection *stub_sec;
4716   struct ppc_stub_hash_entry *stub_entry;
4717
4718   group = htab->sec_info[section->id].u.group;
4719   link_sec = group->link_sec;
4720   stub_sec = group->stub_sec;
4721   if (stub_sec == NULL)
4722     {
4723       size_t namelen;
4724       bfd_size_type len;
4725       char *s_name;
4726
4727       namelen = strlen (link_sec->name);
4728       len = namelen + sizeof (STUB_SUFFIX);
4729       s_name = bfd_alloc (htab->params->stub_bfd, len);
4730       if (s_name == NULL)
4731         return NULL;
4732
4733       memcpy (s_name, link_sec->name, namelen);
4734       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4735       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4736       if (stub_sec == NULL)
4737         return NULL;
4738       group->stub_sec = stub_sec;
4739     }
4740
4741   /* Enter this entry into the linker stub hash table.  */
4742   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4743                                      TRUE, FALSE);
4744   if (stub_entry == NULL)
4745     {
4746       /* xgettext:c-format */
4747       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4748                           section->owner, stub_name);
4749       return NULL;
4750     }
4751
4752   stub_entry->group = group;
4753   stub_entry->stub_offset = 0;
4754   return stub_entry;
4755 }
4756
4757 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4758    not already done.  */
4759
4760 static bfd_boolean
4761 create_got_section (bfd *abfd, struct bfd_link_info *info)
4762 {
4763   asection *got, *relgot;
4764   flagword flags;
4765   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4766
4767   if (!is_ppc64_elf (abfd))
4768     return FALSE;
4769   if (htab == NULL)
4770     return FALSE;
4771
4772   if (!htab->elf.sgot
4773       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4774     return FALSE;
4775
4776   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4777            | SEC_LINKER_CREATED);
4778
4779   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4780   if (!got
4781       || !bfd_set_section_alignment (abfd, got, 3))
4782     return FALSE;
4783
4784   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4785                                                flags | SEC_READONLY);
4786   if (!relgot
4787       || ! bfd_set_section_alignment (abfd, relgot, 3))
4788     return FALSE;
4789
4790   ppc64_elf_tdata (abfd)->got = got;
4791   ppc64_elf_tdata (abfd)->relgot = relgot;
4792   return TRUE;
4793 }
4794
4795 /* Follow indirect and warning symbol links.  */
4796
4797 static inline struct bfd_link_hash_entry *
4798 follow_link (struct bfd_link_hash_entry *h)
4799 {
4800   while (h->type == bfd_link_hash_indirect
4801          || h->type == bfd_link_hash_warning)
4802     h = h->u.i.link;
4803   return h;
4804 }
4805
4806 static inline struct elf_link_hash_entry *
4807 elf_follow_link (struct elf_link_hash_entry *h)
4808 {
4809   return (struct elf_link_hash_entry *) follow_link (&h->root);
4810 }
4811
4812 static inline struct ppc_link_hash_entry *
4813 ppc_follow_link (struct ppc_link_hash_entry *h)
4814 {
4815   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4816 }
4817
4818 /* Merge PLT info on FROM with that on TO.  */
4819
4820 static void
4821 move_plt_plist (struct ppc_link_hash_entry *from,
4822                 struct ppc_link_hash_entry *to)
4823 {
4824   if (from->elf.plt.plist != NULL)
4825     {
4826       if (to->elf.plt.plist != NULL)
4827         {
4828           struct plt_entry **entp;
4829           struct plt_entry *ent;
4830
4831           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4832             {
4833               struct plt_entry *dent;
4834
4835               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4836                 if (dent->addend == ent->addend)
4837                   {
4838                     dent->plt.refcount += ent->plt.refcount;
4839                     *entp = ent->next;
4840                     break;
4841                   }
4842               if (dent == NULL)
4843                 entp = &ent->next;
4844             }
4845           *entp = to->elf.plt.plist;
4846         }
4847
4848       to->elf.plt.plist = from->elf.plt.plist;
4849       from->elf.plt.plist = NULL;
4850     }
4851 }
4852
4853 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4854
4855 static void
4856 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4857                                 struct elf_link_hash_entry *dir,
4858                                 struct elf_link_hash_entry *ind)
4859 {
4860   struct ppc_link_hash_entry *edir, *eind;
4861
4862   edir = (struct ppc_link_hash_entry *) dir;
4863   eind = (struct ppc_link_hash_entry *) ind;
4864
4865   edir->is_func |= eind->is_func;
4866   edir->is_func_descriptor |= eind->is_func_descriptor;
4867   edir->tls_mask |= eind->tls_mask;
4868   if (eind->oh != NULL)
4869     edir->oh = ppc_follow_link (eind->oh);
4870
4871   if (edir->elf.versioned != versioned_hidden)
4872     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4873   edir->elf.ref_regular |= eind->elf.ref_regular;
4874   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4875   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4876   edir->elf.needs_plt |= eind->elf.needs_plt;
4877   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4878
4879   /* If we were called to copy over info for a weak sym, don't copy
4880      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4881      in order to simplify readonly_dynrelocs and save a field in the
4882      symbol hash entry, but that means dyn_relocs can't be used in any
4883      tests about a specific symbol, or affect other symbol flags which
4884      are then tested.  */
4885   if (eind->elf.root.type != bfd_link_hash_indirect)
4886     return;
4887
4888   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4889   if (eind->dyn_relocs != NULL)
4890     {
4891       if (edir->dyn_relocs != NULL)
4892         {
4893           struct elf_dyn_relocs **pp;
4894           struct elf_dyn_relocs *p;
4895
4896           /* Add reloc counts against the indirect sym to the direct sym
4897              list.  Merge any entries against the same section.  */
4898           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4899             {
4900               struct elf_dyn_relocs *q;
4901
4902               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4903                 if (q->sec == p->sec)
4904                   {
4905                     q->pc_count += p->pc_count;
4906                     q->count += p->count;
4907                     *pp = p->next;
4908                     break;
4909                   }
4910               if (q == NULL)
4911                 pp = &p->next;
4912             }
4913           *pp = edir->dyn_relocs;
4914         }
4915
4916       edir->dyn_relocs = eind->dyn_relocs;
4917       eind->dyn_relocs = NULL;
4918     }
4919
4920   /* Copy over got entries that we may have already seen to the
4921      symbol which just became indirect.  */
4922   if (eind->elf.got.glist != NULL)
4923     {
4924       if (edir->elf.got.glist != NULL)
4925         {
4926           struct got_entry **entp;
4927           struct got_entry *ent;
4928
4929           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4930             {
4931               struct got_entry *dent;
4932
4933               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4934                 if (dent->addend == ent->addend
4935                     && dent->owner == ent->owner
4936                     && dent->tls_type == ent->tls_type)
4937                   {
4938                     dent->got.refcount += ent->got.refcount;
4939                     *entp = ent->next;
4940                     break;
4941                   }
4942               if (dent == NULL)
4943                 entp = &ent->next;
4944             }
4945           *entp = edir->elf.got.glist;
4946         }
4947
4948       edir->elf.got.glist = eind->elf.got.glist;
4949       eind->elf.got.glist = NULL;
4950     }
4951
4952   /* And plt entries.  */
4953   move_plt_plist (eind, edir);
4954
4955   if (eind->elf.dynindx != -1)
4956     {
4957       if (edir->elf.dynindx != -1)
4958         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4959                                 edir->elf.dynstr_index);
4960       edir->elf.dynindx = eind->elf.dynindx;
4961       edir->elf.dynstr_index = eind->elf.dynstr_index;
4962       eind->elf.dynindx = -1;
4963       eind->elf.dynstr_index = 0;
4964     }
4965 }
4966
4967 /* Find the function descriptor hash entry from the given function code
4968    hash entry FH.  Link the entries via their OH fields.  */
4969
4970 static struct ppc_link_hash_entry *
4971 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4972 {
4973   struct ppc_link_hash_entry *fdh = fh->oh;
4974
4975   if (fdh == NULL)
4976     {
4977       const char *fd_name = fh->elf.root.root.string + 1;
4978
4979       fdh = (struct ppc_link_hash_entry *)
4980         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4981       if (fdh == NULL)
4982         return fdh;
4983
4984       fdh->is_func_descriptor = 1;
4985       fdh->oh = fh;
4986       fh->is_func = 1;
4987       fh->oh = fdh;
4988     }
4989
4990   fdh = ppc_follow_link (fdh);
4991   fdh->is_func_descriptor = 1;
4992   fdh->oh = fh;
4993   return fdh;
4994 }
4995
4996 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4997
4998 static struct ppc_link_hash_entry *
4999 make_fdh (struct bfd_link_info *info,
5000           struct ppc_link_hash_entry *fh)
5001 {
5002   bfd *abfd = fh->elf.root.u.undef.abfd;
5003   struct bfd_link_hash_entry *bh = NULL;
5004   struct ppc_link_hash_entry *fdh;
5005   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5006                     ? BSF_WEAK
5007                     : BSF_GLOBAL);
5008
5009   if (!_bfd_generic_link_add_one_symbol (info, abfd,
5010                                          fh->elf.root.root.string + 1,
5011                                          flags, bfd_und_section_ptr, 0,
5012                                          NULL, FALSE, FALSE, &bh))
5013     return NULL;
5014
5015   fdh = (struct ppc_link_hash_entry *) bh;
5016   fdh->elf.non_elf = 0;
5017   fdh->fake = 1;
5018   fdh->is_func_descriptor = 1;
5019   fdh->oh = fh;
5020   fh->is_func = 1;
5021   fh->oh = fdh;
5022   return fdh;
5023 }
5024
5025 /* Fix function descriptor symbols defined in .opd sections to be
5026    function type.  */
5027
5028 static bfd_boolean
5029 ppc64_elf_add_symbol_hook (bfd *ibfd,
5030                            struct bfd_link_info *info,
5031                            Elf_Internal_Sym *isym,
5032                            const char **name,
5033                            flagword *flags ATTRIBUTE_UNUSED,
5034                            asection **sec,
5035                            bfd_vma *value)
5036 {
5037   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5038       && (ibfd->flags & DYNAMIC) == 0
5039       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5040     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
5041
5042   if (*sec != NULL
5043       && strcmp ((*sec)->name, ".opd") == 0)
5044     {
5045       asection *code_sec;
5046
5047       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5048             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5049         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5050
5051       /* If the symbol is a function defined in .opd, and the function
5052          code is in a discarded group, let it appear to be undefined.  */
5053       if (!bfd_link_relocatable (info)
5054           && (*sec)->reloc_count != 0
5055           && opd_entry_value (*sec, *value, &code_sec, NULL,
5056                               FALSE) != (bfd_vma) -1
5057           && discarded_section (code_sec))
5058         {
5059           *sec = bfd_und_section_ptr;
5060           isym->st_shndx = SHN_UNDEF;
5061         }
5062     }
5063   else if (*sec != NULL
5064            && strcmp ((*sec)->name, ".toc") == 0
5065            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5066     {
5067       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5068       if (htab != NULL)
5069         htab->params->object_in_toc = 1;
5070     }
5071
5072   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5073     {
5074       if (abiversion (ibfd) == 0)
5075         set_abiversion (ibfd, 2);
5076       else if (abiversion (ibfd) == 1)
5077         {
5078           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5079                                 " for ABI version 1"), *name);
5080           bfd_set_error (bfd_error_bad_value);
5081           return FALSE;
5082         }
5083     }
5084
5085   return TRUE;
5086 }
5087
5088 /* Merge non-visibility st_other attributes: local entry point.  */
5089
5090 static void
5091 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5092                                   const Elf_Internal_Sym *isym,
5093                                   bfd_boolean definition,
5094                                   bfd_boolean dynamic)
5095 {
5096   if (definition && (!dynamic || !h->def_regular))
5097     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5098                 | ELF_ST_VISIBILITY (h->other));
5099 }
5100
5101 /* Hook called on merging a symbol.  We use this to clear "fake" since
5102    we now have a real symbol.  */
5103
5104 static bfd_boolean
5105 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5106                         const Elf_Internal_Sym *isym,
5107                         asection **psec ATTRIBUTE_UNUSED,
5108                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5109                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5110                         bfd *oldbfd ATTRIBUTE_UNUSED,
5111                         const asection *oldsec ATTRIBUTE_UNUSED)
5112 {
5113   ((struct ppc_link_hash_entry *) h)->fake = 0;
5114   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5115     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5116   return TRUE;
5117 }
5118
5119 /* This function makes an old ABI object reference to ".bar" cause the
5120    inclusion of a new ABI object archive that defines "bar".
5121    NAME is a symbol defined in an archive.  Return a symbol in the hash
5122    table that might be satisfied by the archive symbols.  */
5123
5124 static struct elf_link_hash_entry *
5125 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5126                                  struct bfd_link_info *info,
5127                                  const char *name)
5128 {
5129   struct elf_link_hash_entry *h;
5130   char *dot_name;
5131   size_t len;
5132
5133   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5134   if (h != NULL
5135       /* Don't return this sym if it is a fake function descriptor
5136          created by add_symbol_adjust.  */
5137       && !((struct ppc_link_hash_entry *) h)->fake)
5138     return h;
5139
5140   if (name[0] == '.')
5141     return h;
5142
5143   len = strlen (name);
5144   dot_name = bfd_alloc (abfd, len + 2);
5145   if (dot_name == NULL)
5146     return (struct elf_link_hash_entry *) -1;
5147   dot_name[0] = '.';
5148   memcpy (dot_name + 1, name, len + 1);
5149   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5150   bfd_release (abfd, dot_name);
5151   return h;
5152 }
5153
5154 /* This function satisfies all old ABI object references to ".bar" if a
5155    new ABI object defines "bar".  Well, at least, undefined dot symbols
5156    are made weak.  This stops later archive searches from including an
5157    object if we already have a function descriptor definition.  It also
5158    prevents the linker complaining about undefined symbols.
5159    We also check and correct mismatched symbol visibility here.  The
5160    most restrictive visibility of the function descriptor and the
5161    function entry symbol is used.  */
5162
5163 static bfd_boolean
5164 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5165 {
5166   struct ppc_link_hash_table *htab;
5167   struct ppc_link_hash_entry *fdh;
5168
5169   if (eh->elf.root.type == bfd_link_hash_warning)
5170     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5171
5172   if (eh->elf.root.type == bfd_link_hash_indirect)
5173     return TRUE;
5174
5175   if (eh->elf.root.root.string[0] != '.')
5176     abort ();
5177
5178   htab = ppc_hash_table (info);
5179   if (htab == NULL)
5180     return FALSE;
5181
5182   fdh = lookup_fdh (eh, htab);
5183   if (fdh == NULL
5184       && !bfd_link_relocatable (info)
5185       && (eh->elf.root.type == bfd_link_hash_undefined
5186           || eh->elf.root.type == bfd_link_hash_undefweak)
5187       && eh->elf.ref_regular)
5188     {
5189       /* Make an undefined function descriptor sym, in order to
5190          pull in an --as-needed shared lib.  Archives are handled
5191          elsewhere.  */
5192       fdh = make_fdh (info, eh);
5193       if (fdh == NULL)
5194         return FALSE;
5195     }
5196
5197   if (fdh != NULL)
5198     {
5199       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5200       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5201
5202       /* Make both descriptor and entry symbol have the most
5203          constraining visibility of either symbol.  */
5204       if (entry_vis < descr_vis)
5205         fdh->elf.other += entry_vis - descr_vis;
5206       else if (entry_vis > descr_vis)
5207         eh->elf.other += descr_vis - entry_vis;
5208
5209       /* Propagate reference flags from entry symbol to function
5210          descriptor symbol.  */
5211       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5212       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5213       fdh->elf.ref_regular |= eh->elf.ref_regular;
5214       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5215
5216       if (!fdh->elf.forced_local
5217           && fdh->elf.dynindx == -1
5218           && fdh->elf.versioned != versioned_hidden
5219           && (bfd_link_dll (info)
5220               || fdh->elf.def_dynamic
5221               || fdh->elf.ref_dynamic)
5222           && (eh->elf.ref_regular
5223               || eh->elf.def_regular))
5224         {
5225           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5226             return FALSE;
5227         }
5228     }
5229
5230   return TRUE;
5231 }
5232
5233 /* Set up opd section info and abiversion for IBFD, and process list
5234    of dot-symbols we made in link_hash_newfunc.  */
5235
5236 static bfd_boolean
5237 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5238 {
5239   struct ppc_link_hash_table *htab;
5240   struct ppc_link_hash_entry **p, *eh;
5241   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5242
5243   if (opd != NULL && opd->size != 0)
5244     {
5245       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5246       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5247
5248       if (abiversion (ibfd) == 0)
5249         set_abiversion (ibfd, 1);
5250       else if (abiversion (ibfd) >= 2)
5251         {
5252           /* xgettext:c-format */
5253           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5254                               ibfd, abiversion (ibfd));
5255           bfd_set_error (bfd_error_bad_value);
5256           return FALSE;
5257         }
5258     }
5259
5260   if (is_ppc64_elf (info->output_bfd))
5261     {
5262       /* For input files without an explicit abiversion in e_flags
5263          we should have flagged any with symbol st_other bits set
5264          as ELFv1 and above flagged those with .opd as ELFv2.
5265          Set the output abiversion if not yet set, and for any input
5266          still ambiguous, take its abiversion from the output.
5267          Differences in ABI are reported later.  */
5268       if (abiversion (info->output_bfd) == 0)
5269         set_abiversion (info->output_bfd, abiversion (ibfd));
5270       else if (abiversion (ibfd) == 0)
5271         set_abiversion (ibfd, abiversion (info->output_bfd));
5272     }
5273
5274   htab = ppc_hash_table (info);
5275   if (htab == NULL)
5276     return TRUE;
5277
5278   if (opd != NULL && opd->size != 0
5279       && (ibfd->flags & DYNAMIC) == 0
5280       && (opd->flags & SEC_RELOC) != 0
5281       && opd->reloc_count != 0
5282       && !bfd_is_abs_section (opd->output_section)
5283       && info->gc_sections)
5284     {
5285       /* Garbage collection needs some extra help with .opd sections.
5286          We don't want to necessarily keep everything referenced by
5287          relocs in .opd, as that would keep all functions.  Instead,
5288          if we reference an .opd symbol (a function descriptor), we
5289          want to keep the function code symbol's section.  This is
5290          easy for global symbols, but for local syms we need to keep
5291          information about the associated function section.  */
5292       bfd_size_type amt;
5293       asection **opd_sym_map;
5294       Elf_Internal_Shdr *symtab_hdr;
5295       Elf_Internal_Rela *relocs, *rel_end, *rel;
5296
5297       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5298       opd_sym_map = bfd_zalloc (ibfd, amt);
5299       if (opd_sym_map == NULL)
5300         return FALSE;
5301       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5302       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5303                                           info->keep_memory);
5304       if (relocs == NULL)
5305         return FALSE;
5306       symtab_hdr = &elf_symtab_hdr (ibfd);
5307       rel_end = relocs + opd->reloc_count - 1;
5308       for (rel = relocs; rel < rel_end; rel++)
5309         {
5310           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5311           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5312
5313           if (r_type == R_PPC64_ADDR64
5314               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5315               && r_symndx < symtab_hdr->sh_info)
5316             {
5317               Elf_Internal_Sym *isym;
5318               asection *s;
5319
5320               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5321               if (isym == NULL)
5322                 {
5323                   if (elf_section_data (opd)->relocs != relocs)
5324                     free (relocs);
5325                   return FALSE;
5326                 }
5327
5328               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5329               if (s != NULL && s != opd)
5330                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5331             }
5332         }
5333       if (elf_section_data (opd)->relocs != relocs)
5334         free (relocs);
5335     }
5336
5337   p = &htab->dot_syms;
5338   while ((eh = *p) != NULL)
5339     {
5340       *p = NULL;
5341       if (&eh->elf == htab->elf.hgot)
5342         ;
5343       else if (htab->elf.hgot == NULL
5344                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5345         htab->elf.hgot = &eh->elf;
5346       else if (abiversion (ibfd) <= 1)
5347         {
5348           htab->need_func_desc_adj = 1;
5349           if (!add_symbol_adjust (eh, info))
5350             return FALSE;
5351         }
5352       p = &eh->u.next_dot_sym;
5353     }
5354   return TRUE;
5355 }
5356
5357 /* Undo hash table changes when an --as-needed input file is determined
5358    not to be needed.  */
5359
5360 static bfd_boolean
5361 ppc64_elf_notice_as_needed (bfd *ibfd,
5362                             struct bfd_link_info *info,
5363                             enum notice_asneeded_action act)
5364 {
5365   if (act == notice_not_needed)
5366     {
5367       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5368
5369       if (htab == NULL)
5370         return FALSE;
5371
5372       htab->dot_syms = NULL;
5373     }
5374   return _bfd_elf_notice_as_needed (ibfd, info, act);
5375 }
5376
5377 /* If --just-symbols against a final linked binary, then assume we need
5378    toc adjusting stubs when calling functions defined there.  */
5379
5380 static void
5381 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5382 {
5383   if ((sec->flags & SEC_CODE) != 0
5384       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5385       && is_ppc64_elf (sec->owner))
5386     {
5387       if (abiversion (sec->owner) >= 2
5388           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5389         sec->has_toc_reloc = 1;
5390     }
5391   _bfd_elf_link_just_syms (sec, info);
5392 }
5393
5394 static struct plt_entry **
5395 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5396                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5397 {
5398   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5399   struct plt_entry **local_plt;
5400   unsigned char *local_got_tls_masks;
5401
5402   if (local_got_ents == NULL)
5403     {
5404       bfd_size_type size = symtab_hdr->sh_info;
5405
5406       size *= (sizeof (*local_got_ents)
5407                + sizeof (*local_plt)
5408                + sizeof (*local_got_tls_masks));
5409       local_got_ents = bfd_zalloc (abfd, size);
5410       if (local_got_ents == NULL)
5411         return NULL;
5412       elf_local_got_ents (abfd) = local_got_ents;
5413     }
5414
5415   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5416     {
5417       struct got_entry *ent;
5418
5419       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5420         if (ent->addend == r_addend
5421             && ent->owner == abfd
5422             && ent->tls_type == tls_type)
5423           break;
5424       if (ent == NULL)
5425         {
5426           bfd_size_type amt = sizeof (*ent);
5427           ent = bfd_alloc (abfd, amt);
5428           if (ent == NULL)
5429             return FALSE;
5430           ent->next = local_got_ents[r_symndx];
5431           ent->addend = r_addend;
5432           ent->owner = abfd;
5433           ent->tls_type = tls_type;
5434           ent->is_indirect = FALSE;
5435           ent->got.refcount = 0;
5436           local_got_ents[r_symndx] = ent;
5437         }
5438       ent->got.refcount += 1;
5439     }
5440
5441   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5442   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5443   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5444
5445   return local_plt + r_symndx;
5446 }
5447
5448 static bfd_boolean
5449 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5450 {
5451   struct plt_entry *ent;
5452
5453   for (ent = *plist; ent != NULL; ent = ent->next)
5454     if (ent->addend == addend)
5455       break;
5456   if (ent == NULL)
5457     {
5458       bfd_size_type amt = sizeof (*ent);
5459       ent = bfd_alloc (abfd, amt);
5460       if (ent == NULL)
5461         return FALSE;
5462       ent->next = *plist;
5463       ent->addend = addend;
5464       ent->plt.refcount = 0;
5465       *plist = ent;
5466     }
5467   ent->plt.refcount += 1;
5468   return TRUE;
5469 }
5470
5471 static bfd_boolean
5472 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5473 {
5474   return (r_type == R_PPC64_REL24
5475           || r_type == R_PPC64_REL14
5476           || r_type == R_PPC64_REL14_BRTAKEN
5477           || r_type == R_PPC64_REL14_BRNTAKEN
5478           || r_type == R_PPC64_ADDR24
5479           || r_type == R_PPC64_ADDR14
5480           || r_type == R_PPC64_ADDR14_BRTAKEN
5481           || r_type == R_PPC64_ADDR14_BRNTAKEN
5482           || r_type == R_PPC64_PLTCALL);
5483 }
5484
5485 /* Relocs on inline plt call sequence insns prior to the call.  */
5486
5487 static bfd_boolean
5488 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5489 {
5490   return (r_type == R_PPC64_PLT16_HA
5491           || r_type == R_PPC64_PLT16_HI
5492           || r_type == R_PPC64_PLT16_LO
5493           || r_type == R_PPC64_PLT16_LO_DS
5494           || r_type == R_PPC64_PLTSEQ);
5495 }
5496
5497 /* Look through the relocs for a section during the first phase, and
5498    calculate needed space in the global offset table, procedure
5499    linkage table, and dynamic reloc sections.  */
5500
5501 static bfd_boolean
5502 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5503                         asection *sec, const Elf_Internal_Rela *relocs)
5504 {
5505   struct ppc_link_hash_table *htab;
5506   Elf_Internal_Shdr *symtab_hdr;
5507   struct elf_link_hash_entry **sym_hashes;
5508   const Elf_Internal_Rela *rel;
5509   const Elf_Internal_Rela *rel_end;
5510   asection *sreloc;
5511   struct elf_link_hash_entry *tga, *dottga;
5512   bfd_boolean is_opd;
5513
5514   if (bfd_link_relocatable (info))
5515     return TRUE;
5516
5517   /* Don't do anything special with non-loaded, non-alloced sections.
5518      In particular, any relocs in such sections should not affect GOT
5519      and PLT reference counting (ie. we don't allow them to create GOT
5520      or PLT entries), there's no possibility or desire to optimize TLS
5521      relocs, and there's not much point in propagating relocs to shared
5522      libs that the dynamic linker won't relocate.  */
5523   if ((sec->flags & SEC_ALLOC) == 0)
5524     return TRUE;
5525
5526   BFD_ASSERT (is_ppc64_elf (abfd));
5527
5528   htab = ppc_hash_table (info);
5529   if (htab == NULL)
5530     return FALSE;
5531
5532   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5533                               FALSE, FALSE, TRUE);
5534   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5535                                  FALSE, FALSE, TRUE);
5536   symtab_hdr = &elf_symtab_hdr (abfd);
5537   sym_hashes = elf_sym_hashes (abfd);
5538   sreloc = NULL;
5539   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5540   rel_end = relocs + sec->reloc_count;
5541   for (rel = relocs; rel < rel_end; rel++)
5542     {
5543       unsigned long r_symndx;
5544       struct elf_link_hash_entry *h;
5545       enum elf_ppc64_reloc_type r_type;
5546       int tls_type;
5547       struct _ppc64_elf_section_data *ppc64_sec;
5548       struct plt_entry **ifunc, **plt_list;
5549
5550       r_symndx = ELF64_R_SYM (rel->r_info);
5551       if (r_symndx < symtab_hdr->sh_info)
5552         h = NULL;
5553       else
5554         {
5555           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5556           h = elf_follow_link (h);
5557
5558           if (h == htab->elf.hgot)
5559             sec->has_toc_reloc = 1;
5560         }
5561
5562       tls_type = 0;
5563       ifunc = NULL;
5564       if (h != NULL)
5565         {
5566           if (h->type == STT_GNU_IFUNC)
5567             {
5568               h->needs_plt = 1;
5569               ifunc = &h->plt.plist;
5570             }
5571         }
5572       else
5573         {
5574           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5575                                                           abfd, r_symndx);
5576           if (isym == NULL)
5577             return FALSE;
5578
5579           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5580             {
5581               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5582                                              rel->r_addend,
5583                                              NON_GOT | PLT_IFUNC);
5584               if (ifunc == NULL)
5585                 return FALSE;
5586             }
5587         }
5588
5589       r_type = ELF64_R_TYPE (rel->r_info);
5590       switch (r_type)
5591         {
5592         case R_PPC64_TLSGD:
5593         case R_PPC64_TLSLD:
5594           /* These special tls relocs tie a call to __tls_get_addr with
5595              its parameter symbol.  */
5596           if (h != NULL)
5597             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5598           else
5599             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5600                                         rel->r_addend,
5601                                         NON_GOT | TLS_TLS | TLS_MARK))
5602               return FALSE;
5603           sec->has_tls_reloc = 1;
5604           break;
5605
5606         case R_PPC64_GOT_TLSLD16:
5607         case R_PPC64_GOT_TLSLD16_LO:
5608         case R_PPC64_GOT_TLSLD16_HI:
5609         case R_PPC64_GOT_TLSLD16_HA:
5610           tls_type = TLS_TLS | TLS_LD;
5611           goto dogottls;
5612
5613         case R_PPC64_GOT_TLSGD16:
5614         case R_PPC64_GOT_TLSGD16_LO:
5615         case R_PPC64_GOT_TLSGD16_HI:
5616         case R_PPC64_GOT_TLSGD16_HA:
5617           tls_type = TLS_TLS | TLS_GD;
5618           goto dogottls;
5619
5620         case R_PPC64_GOT_TPREL16_DS:
5621         case R_PPC64_GOT_TPREL16_LO_DS:
5622         case R_PPC64_GOT_TPREL16_HI:
5623         case R_PPC64_GOT_TPREL16_HA:
5624           if (bfd_link_dll (info))
5625             info->flags |= DF_STATIC_TLS;
5626           tls_type = TLS_TLS | TLS_TPREL;
5627           goto dogottls;
5628
5629         case R_PPC64_GOT_DTPREL16_DS:
5630         case R_PPC64_GOT_DTPREL16_LO_DS:
5631         case R_PPC64_GOT_DTPREL16_HI:
5632         case R_PPC64_GOT_DTPREL16_HA:
5633           tls_type = TLS_TLS | TLS_DTPREL;
5634         dogottls:
5635           sec->has_tls_reloc = 1;
5636           /* Fall through */
5637
5638         case R_PPC64_GOT16:
5639         case R_PPC64_GOT16_DS:
5640         case R_PPC64_GOT16_HA:
5641         case R_PPC64_GOT16_HI:
5642         case R_PPC64_GOT16_LO:
5643         case R_PPC64_GOT16_LO_DS:
5644           /* This symbol requires a global offset table entry.  */
5645           sec->has_toc_reloc = 1;
5646           if (r_type == R_PPC64_GOT_TLSLD16
5647               || r_type == R_PPC64_GOT_TLSGD16
5648               || r_type == R_PPC64_GOT_TPREL16_DS
5649               || r_type == R_PPC64_GOT_DTPREL16_DS
5650               || r_type == R_PPC64_GOT16
5651               || r_type == R_PPC64_GOT16_DS)
5652             {
5653               htab->do_multi_toc = 1;
5654               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5655             }
5656
5657           if (ppc64_elf_tdata (abfd)->got == NULL
5658               && !create_got_section (abfd, info))
5659             return FALSE;
5660
5661           if (h != NULL)
5662             {
5663               struct ppc_link_hash_entry *eh;
5664               struct got_entry *ent;
5665
5666               eh = (struct ppc_link_hash_entry *) h;
5667               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5668                 if (ent->addend == rel->r_addend
5669                     && ent->owner == abfd
5670                     && ent->tls_type == tls_type)
5671                   break;
5672               if (ent == NULL)
5673                 {
5674                   bfd_size_type amt = sizeof (*ent);
5675                   ent = bfd_alloc (abfd, amt);
5676                   if (ent == NULL)
5677                     return FALSE;
5678                   ent->next = eh->elf.got.glist;
5679                   ent->addend = rel->r_addend;
5680                   ent->owner = abfd;
5681                   ent->tls_type = tls_type;
5682                   ent->is_indirect = FALSE;
5683                   ent->got.refcount = 0;
5684                   eh->elf.got.glist = ent;
5685                 }
5686               ent->got.refcount += 1;
5687               eh->tls_mask |= tls_type;
5688             }
5689           else
5690             /* This is a global offset table entry for a local symbol.  */
5691             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5692                                         rel->r_addend, tls_type))
5693               return FALSE;
5694
5695           /* We may also need a plt entry if the symbol turns out to be
5696              an ifunc.  */
5697           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5698             {
5699               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5700                 return FALSE;
5701             }
5702           break;
5703
5704         case R_PPC64_PLT16_HA:
5705         case R_PPC64_PLT16_HI:
5706         case R_PPC64_PLT16_LO:
5707         case R_PPC64_PLT16_LO_DS:
5708         case R_PPC64_PLT32:
5709         case R_PPC64_PLT64:
5710           /* This symbol requires a procedure linkage table entry.  */
5711           plt_list = ifunc;
5712           if (h != NULL)
5713             {
5714               h->needs_plt = 1;
5715               if (h->root.root.string[0] == '.'
5716                   && h->root.root.string[1] != '\0')
5717                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5718               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5719               plt_list = &h->plt.plist;
5720             }
5721           if (plt_list == NULL)
5722             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5723                                               rel->r_addend,
5724                                               NON_GOT | PLT_KEEP);
5725           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5726             return FALSE;
5727           break;
5728
5729           /* The following relocations don't need to propagate the
5730              relocation if linking a shared object since they are
5731              section relative.  */
5732         case R_PPC64_SECTOFF:
5733         case R_PPC64_SECTOFF_LO:
5734         case R_PPC64_SECTOFF_HI:
5735         case R_PPC64_SECTOFF_HA:
5736         case R_PPC64_SECTOFF_DS:
5737         case R_PPC64_SECTOFF_LO_DS:
5738         case R_PPC64_DTPREL16:
5739         case R_PPC64_DTPREL16_LO:
5740         case R_PPC64_DTPREL16_HI:
5741         case R_PPC64_DTPREL16_HA:
5742         case R_PPC64_DTPREL16_DS:
5743         case R_PPC64_DTPREL16_LO_DS:
5744         case R_PPC64_DTPREL16_HIGH:
5745         case R_PPC64_DTPREL16_HIGHA:
5746         case R_PPC64_DTPREL16_HIGHER:
5747         case R_PPC64_DTPREL16_HIGHERA:
5748         case R_PPC64_DTPREL16_HIGHEST:
5749         case R_PPC64_DTPREL16_HIGHESTA:
5750           break;
5751
5752           /* Nor do these.  */
5753         case R_PPC64_REL16:
5754         case R_PPC64_REL16_LO:
5755         case R_PPC64_REL16_HI:
5756         case R_PPC64_REL16_HA:
5757         case R_PPC64_REL16DX_HA:
5758           break;
5759
5760           /* Not supported as a dynamic relocation.  */
5761         case R_PPC64_ADDR64_LOCAL:
5762           if (bfd_link_pic (info))
5763             {
5764               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5765                 ppc_howto_init ();
5766               /* xgettext:c-format */
5767               info->callbacks->einfo (_("%H: %s reloc unsupported "
5768                                         "in shared libraries and PIEs\n"),
5769                                       abfd, sec, rel->r_offset,
5770                                       ppc64_elf_howto_table[r_type]->name);
5771               bfd_set_error (bfd_error_bad_value);
5772               return FALSE;
5773             }
5774           break;
5775
5776         case R_PPC64_TOC16:
5777         case R_PPC64_TOC16_DS:
5778           htab->do_multi_toc = 1;
5779           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5780           /* Fall through.  */
5781         case R_PPC64_TOC16_LO:
5782         case R_PPC64_TOC16_HI:
5783         case R_PPC64_TOC16_HA:
5784         case R_PPC64_TOC16_LO_DS:
5785           sec->has_toc_reloc = 1;
5786           break;
5787
5788           /* Marker reloc.  */
5789         case R_PPC64_ENTRY:
5790           break;
5791
5792           /* This relocation describes the C++ object vtable hierarchy.
5793              Reconstruct it for later use during GC.  */
5794         case R_PPC64_GNU_VTINHERIT:
5795           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5796             return FALSE;
5797           break;
5798
5799           /* This relocation describes which C++ vtable entries are actually
5800              used.  Record for later use during GC.  */
5801         case R_PPC64_GNU_VTENTRY:
5802           BFD_ASSERT (h != NULL);
5803           if (h != NULL
5804               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5805             return FALSE;
5806           break;
5807
5808         case R_PPC64_REL14:
5809         case R_PPC64_REL14_BRTAKEN:
5810         case R_PPC64_REL14_BRNTAKEN:
5811           {
5812             asection *dest = NULL;
5813
5814             /* Heuristic: If jumping outside our section, chances are
5815                we are going to need a stub.  */
5816             if (h != NULL)
5817               {
5818                 /* If the sym is weak it may be overridden later, so
5819                    don't assume we know where a weak sym lives.  */
5820                 if (h->root.type == bfd_link_hash_defined)
5821                   dest = h->root.u.def.section;
5822               }
5823             else
5824               {
5825                 Elf_Internal_Sym *isym;
5826
5827                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5828                                               abfd, r_symndx);
5829                 if (isym == NULL)
5830                   return FALSE;
5831
5832                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5833               }
5834
5835             if (dest != sec)
5836               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5837           }
5838           goto rel24;
5839
5840         case R_PPC64_PLTCALL:
5841           ppc64_elf_section_data (sec)->has_pltcall = 1;
5842           /* Fall through.  */
5843
5844         case R_PPC64_REL24:
5845         rel24:
5846           plt_list = ifunc;
5847           if (h != NULL)
5848             {
5849               h->needs_plt = 1;
5850               if (h->root.root.string[0] == '.'
5851                   && h->root.root.string[1] != '\0')
5852                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5853
5854               if (h == tga || h == dottga)
5855                 {
5856                   sec->has_tls_reloc = 1;
5857                   if (rel != relocs
5858                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5859                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5860                     /* We have a new-style __tls_get_addr call with
5861                        a marker reloc.  */
5862                     ;
5863                   else
5864                     /* Mark this section as having an old-style call.  */
5865                     sec->has_tls_get_addr_call = 1;
5866                 }
5867               plt_list = &h->plt.plist;
5868             }
5869
5870           /* We may need a .plt entry if the function this reloc
5871              refers to is in a shared lib.  */
5872           if (plt_list
5873               && !update_plt_info (abfd, plt_list, rel->r_addend))
5874             return FALSE;
5875           break;
5876
5877         case R_PPC64_ADDR14:
5878         case R_PPC64_ADDR14_BRNTAKEN:
5879         case R_PPC64_ADDR14_BRTAKEN:
5880         case R_PPC64_ADDR24:
5881           goto dodyn;
5882
5883         case R_PPC64_TPREL64:
5884           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5885           if (bfd_link_dll (info))
5886             info->flags |= DF_STATIC_TLS;
5887           goto dotlstoc;
5888
5889         case R_PPC64_DTPMOD64:
5890           if (rel + 1 < rel_end
5891               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5892               && rel[1].r_offset == rel->r_offset + 8)
5893             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5894           else
5895             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5896           goto dotlstoc;
5897
5898         case R_PPC64_DTPREL64:
5899           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5900           if (rel != relocs
5901               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5902               && rel[-1].r_offset == rel->r_offset - 8)
5903             /* This is the second reloc of a dtpmod, dtprel pair.
5904                Don't mark with TLS_DTPREL.  */
5905             goto dodyn;
5906
5907         dotlstoc:
5908           sec->has_tls_reloc = 1;
5909           if (h != NULL)
5910             {
5911               struct ppc_link_hash_entry *eh;
5912               eh = (struct ppc_link_hash_entry *) h;
5913               eh->tls_mask |= tls_type;
5914             }
5915           else
5916             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5917                                         rel->r_addend, tls_type))
5918               return FALSE;
5919
5920           ppc64_sec = ppc64_elf_section_data (sec);
5921           if (ppc64_sec->sec_type != sec_toc)
5922             {
5923               bfd_size_type amt;
5924
5925               /* One extra to simplify get_tls_mask.  */
5926               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5927               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5928               if (ppc64_sec->u.toc.symndx == NULL)
5929                 return FALSE;
5930               amt = sec->size * sizeof (bfd_vma) / 8;
5931               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5932               if (ppc64_sec->u.toc.add == NULL)
5933                 return FALSE;
5934               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5935               ppc64_sec->sec_type = sec_toc;
5936             }
5937           BFD_ASSERT (rel->r_offset % 8 == 0);
5938           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5939           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5940
5941           /* Mark the second slot of a GD or LD entry.
5942              -1 to indicate GD and -2 to indicate LD.  */
5943           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5944             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5945           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5946             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5947           goto dodyn;
5948
5949         case R_PPC64_TPREL16:
5950         case R_PPC64_TPREL16_LO:
5951         case R_PPC64_TPREL16_HI:
5952         case R_PPC64_TPREL16_HA:
5953         case R_PPC64_TPREL16_DS:
5954         case R_PPC64_TPREL16_LO_DS:
5955         case R_PPC64_TPREL16_HIGH:
5956         case R_PPC64_TPREL16_HIGHA:
5957         case R_PPC64_TPREL16_HIGHER:
5958         case R_PPC64_TPREL16_HIGHERA:
5959         case R_PPC64_TPREL16_HIGHEST:
5960         case R_PPC64_TPREL16_HIGHESTA:
5961           if (bfd_link_dll (info))
5962             info->flags |= DF_STATIC_TLS;
5963           goto dodyn;
5964
5965         case R_PPC64_ADDR64:
5966           if (is_opd
5967               && rel + 1 < rel_end
5968               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5969             {
5970               if (h != NULL)
5971                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5972             }
5973           /* Fall through.  */
5974
5975         case R_PPC64_ADDR16:
5976         case R_PPC64_ADDR16_DS:
5977         case R_PPC64_ADDR16_HA:
5978         case R_PPC64_ADDR16_HI:
5979         case R_PPC64_ADDR16_HIGH:
5980         case R_PPC64_ADDR16_HIGHA:
5981         case R_PPC64_ADDR16_HIGHER:
5982         case R_PPC64_ADDR16_HIGHERA:
5983         case R_PPC64_ADDR16_HIGHEST:
5984         case R_PPC64_ADDR16_HIGHESTA:
5985         case R_PPC64_ADDR16_LO:
5986         case R_PPC64_ADDR16_LO_DS:
5987           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5988               && rel->r_addend == 0)
5989             {
5990               /* We may need a .plt entry if this reloc refers to a
5991                  function in a shared lib.  */
5992               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5993                 return FALSE;
5994               h->pointer_equality_needed = 1;
5995             }
5996           /* Fall through.  */
5997
5998         case R_PPC64_REL30:
5999         case R_PPC64_REL32:
6000         case R_PPC64_REL64:
6001         case R_PPC64_ADDR32:
6002         case R_PPC64_UADDR16:
6003         case R_PPC64_UADDR32:
6004         case R_PPC64_UADDR64:
6005         case R_PPC64_TOC:
6006           if (h != NULL && !bfd_link_pic (info))
6007             /* We may need a copy reloc.  */
6008             h->non_got_ref = 1;
6009
6010           /* Don't propagate .opd relocs.  */
6011           if (NO_OPD_RELOCS && is_opd)
6012             break;
6013
6014           /* If we are creating a shared library, and this is a reloc
6015              against a global symbol, or a non PC relative reloc
6016              against a local symbol, then we need to copy the reloc
6017              into the shared library.  However, if we are linking with
6018              -Bsymbolic, we do not need to copy a reloc against a
6019              global symbol which is defined in an object we are
6020              including in the link (i.e., DEF_REGULAR is set).  At
6021              this point we have not seen all the input files, so it is
6022              possible that DEF_REGULAR is not set now but will be set
6023              later (it is never cleared).  In case of a weak definition,
6024              DEF_REGULAR may be cleared later by a strong definition in
6025              a shared library.  We account for that possibility below by
6026              storing information in the dyn_relocs field of the hash
6027              table entry.  A similar situation occurs when creating
6028              shared libraries and symbol visibility changes render the
6029              symbol local.
6030
6031              If on the other hand, we are creating an executable, we
6032              may need to keep relocations for symbols satisfied by a
6033              dynamic library if we manage to avoid copy relocs for the
6034              symbol.  */
6035         dodyn:
6036           if ((bfd_link_pic (info)
6037                && (must_be_dyn_reloc (info, r_type)
6038                    || (h != NULL
6039                        && (!SYMBOLIC_BIND (info, h)
6040                            || h->root.type == bfd_link_hash_defweak
6041                            || !h->def_regular))))
6042               || (ELIMINATE_COPY_RELOCS
6043                   && !bfd_link_pic (info)
6044                   && h != NULL
6045                   && (h->root.type == bfd_link_hash_defweak
6046                       || !h->def_regular))
6047               || (!bfd_link_pic (info)
6048                   && ifunc != NULL))
6049             {
6050               /* We must copy these reloc types into the output file.
6051                  Create a reloc section in dynobj and make room for
6052                  this reloc.  */
6053               if (sreloc == NULL)
6054                 {
6055                   sreloc = _bfd_elf_make_dynamic_reloc_section
6056                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6057
6058                   if (sreloc == NULL)
6059                     return FALSE;
6060                 }
6061
6062               /* If this is a global symbol, we count the number of
6063                  relocations we need for this symbol.  */
6064               if (h != NULL)
6065                 {
6066                   struct elf_dyn_relocs *p;
6067                   struct elf_dyn_relocs **head;
6068
6069                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6070                   p = *head;
6071                   if (p == NULL || p->sec != sec)
6072                     {
6073                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6074                       if (p == NULL)
6075                         return FALSE;
6076                       p->next = *head;
6077                       *head = p;
6078                       p->sec = sec;
6079                       p->count = 0;
6080                       p->pc_count = 0;
6081                     }
6082                   p->count += 1;
6083                   if (!must_be_dyn_reloc (info, r_type))
6084                     p->pc_count += 1;
6085                 }
6086               else
6087                 {
6088                   /* Track dynamic relocs needed for local syms too.
6089                      We really need local syms available to do this
6090                      easily.  Oh well.  */
6091                   struct ppc_dyn_relocs *p;
6092                   struct ppc_dyn_relocs **head;
6093                   bfd_boolean is_ifunc;
6094                   asection *s;
6095                   void *vpp;
6096                   Elf_Internal_Sym *isym;
6097
6098                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6099                                                 abfd, r_symndx);
6100                   if (isym == NULL)
6101                     return FALSE;
6102
6103                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6104                   if (s == NULL)
6105                     s = sec;
6106
6107                   vpp = &elf_section_data (s)->local_dynrel;
6108                   head = (struct ppc_dyn_relocs **) vpp;
6109                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6110                   p = *head;
6111                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6112                     p = p->next;
6113                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6114                     {
6115                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6116                       if (p == NULL)
6117                         return FALSE;
6118                       p->next = *head;
6119                       *head = p;
6120                       p->sec = sec;
6121                       p->ifunc = is_ifunc;
6122                       p->count = 0;
6123                     }
6124                   p->count += 1;
6125                 }
6126             }
6127           break;
6128
6129         default:
6130           break;
6131         }
6132     }
6133
6134   return TRUE;
6135 }
6136
6137 /* Merge backend specific data from an object file to the output
6138    object file when linking.  */
6139
6140 static bfd_boolean
6141 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6142 {
6143   bfd *obfd = info->output_bfd;
6144   unsigned long iflags, oflags;
6145
6146   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6147     return TRUE;
6148
6149   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6150     return TRUE;
6151
6152   if (!_bfd_generic_verify_endian_match (ibfd, info))
6153     return FALSE;
6154
6155   iflags = elf_elfheader (ibfd)->e_flags;
6156   oflags = elf_elfheader (obfd)->e_flags;
6157
6158   if (iflags & ~EF_PPC64_ABI)
6159     {
6160       _bfd_error_handler
6161         /* xgettext:c-format */
6162         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6163       bfd_set_error (bfd_error_bad_value);
6164       return FALSE;
6165     }
6166   else if (iflags != oflags && iflags != 0)
6167     {
6168       _bfd_error_handler
6169         /* xgettext:c-format */
6170         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6171          ibfd, iflags, oflags);
6172       bfd_set_error (bfd_error_bad_value);
6173       return FALSE;
6174     }
6175
6176   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6177
6178   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6179   _bfd_elf_merge_object_attributes (ibfd, info);
6180
6181   return TRUE;
6182 }
6183
6184 static bfd_boolean
6185 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6186 {
6187   /* Print normal ELF private data.  */
6188   _bfd_elf_print_private_bfd_data (abfd, ptr);
6189
6190   if (elf_elfheader (abfd)->e_flags != 0)
6191     {
6192       FILE *file = ptr;
6193
6194       fprintf (file, _("private flags = 0x%lx:"),
6195                elf_elfheader (abfd)->e_flags);
6196
6197       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6198         fprintf (file, _(" [abiv%ld]"),
6199                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6200       fputc ('\n', file);
6201     }
6202
6203   return TRUE;
6204 }
6205
6206 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6207    of the code entry point, and its section, which must be in the same
6208    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6209
6210 static bfd_vma
6211 opd_entry_value (asection *opd_sec,
6212                  bfd_vma offset,
6213                  asection **code_sec,
6214                  bfd_vma *code_off,
6215                  bfd_boolean in_code_sec)
6216 {
6217   bfd *opd_bfd = opd_sec->owner;
6218   Elf_Internal_Rela *relocs;
6219   Elf_Internal_Rela *lo, *hi, *look;
6220   bfd_vma val;
6221
6222   /* No relocs implies we are linking a --just-symbols object, or looking
6223      at a final linked executable with addr2line or somesuch.  */
6224   if (opd_sec->reloc_count == 0)
6225     {
6226       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6227
6228       if (contents == NULL)
6229         {
6230           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6231             return (bfd_vma) -1;
6232           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6233         }
6234
6235       /* PR 17512: file: 64b9dfbb.  */
6236       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6237         return (bfd_vma) -1;
6238
6239       val = bfd_get_64 (opd_bfd, contents + offset);
6240       if (code_sec != NULL)
6241         {
6242           asection *sec, *likely = NULL;
6243
6244           if (in_code_sec)
6245             {
6246               sec = *code_sec;
6247               if (sec->vma <= val
6248                   && val < sec->vma + sec->size)
6249                 likely = sec;
6250               else
6251                 val = -1;
6252             }
6253           else
6254             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6255               if (sec->vma <= val
6256                   && (sec->flags & SEC_LOAD) != 0
6257                   && (sec->flags & SEC_ALLOC) != 0)
6258                 likely = sec;
6259           if (likely != NULL)
6260             {
6261               *code_sec = likely;
6262               if (code_off != NULL)
6263                 *code_off = val - likely->vma;
6264             }
6265         }
6266       return val;
6267     }
6268
6269   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6270
6271   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6272   if (relocs == NULL)
6273     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6274   /* PR 17512: file: df8e1fd6.  */
6275   if (relocs == NULL)
6276     return (bfd_vma) -1;
6277
6278   /* Go find the opd reloc at the sym address.  */
6279   lo = relocs;
6280   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6281   val = (bfd_vma) -1;
6282   while (lo < hi)
6283     {
6284       look = lo + (hi - lo) / 2;
6285       if (look->r_offset < offset)
6286         lo = look + 1;
6287       else if (look->r_offset > offset)
6288         hi = look;
6289       else
6290         {
6291           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6292
6293           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6294               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6295             {
6296               unsigned long symndx = ELF64_R_SYM (look->r_info);
6297               asection *sec = NULL;
6298
6299               if (symndx >= symtab_hdr->sh_info
6300                   && elf_sym_hashes (opd_bfd) != NULL)
6301                 {
6302                   struct elf_link_hash_entry **sym_hashes;
6303                   struct elf_link_hash_entry *rh;
6304
6305                   sym_hashes = elf_sym_hashes (opd_bfd);
6306                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6307                   if (rh != NULL)
6308                     {
6309                       rh = elf_follow_link (rh);
6310                       if (rh->root.type != bfd_link_hash_defined
6311                           && rh->root.type != bfd_link_hash_defweak)
6312                         break;
6313                       if (rh->root.u.def.section->owner == opd_bfd)
6314                         {
6315                           val = rh->root.u.def.value;
6316                           sec = rh->root.u.def.section;
6317                         }
6318                     }
6319                 }
6320
6321               if (sec == NULL)
6322                 {
6323                   Elf_Internal_Sym *sym;
6324
6325                   if (symndx < symtab_hdr->sh_info)
6326                     {
6327                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6328                       if (sym == NULL)
6329                         {
6330                           size_t symcnt = symtab_hdr->sh_info;
6331                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6332                                                       symcnt, 0,
6333                                                       NULL, NULL, NULL);
6334                           if (sym == NULL)
6335                             break;
6336                           symtab_hdr->contents = (bfd_byte *) sym;
6337                         }
6338                       sym += symndx;
6339                     }
6340                   else
6341                     {
6342                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6343                                                   1, symndx,
6344                                                   NULL, NULL, NULL);
6345                       if (sym == NULL)
6346                         break;
6347                     }
6348                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6349                   if (sec == NULL)
6350                     break;
6351                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6352                   val = sym->st_value;
6353                 }
6354
6355               val += look->r_addend;
6356               if (code_off != NULL)
6357                 *code_off = val;
6358               if (code_sec != NULL)
6359                 {
6360                   if (in_code_sec && *code_sec != sec)
6361                     return -1;
6362                   else
6363                     *code_sec = sec;
6364                 }
6365               if (sec->output_section != NULL)
6366                 val += sec->output_section->vma + sec->output_offset;
6367             }
6368           break;
6369         }
6370     }
6371
6372   return val;
6373 }
6374
6375 /* If the ELF symbol SYM might be a function in SEC, return the
6376    function size and set *CODE_OFF to the function's entry point,
6377    otherwise return zero.  */
6378
6379 static bfd_size_type
6380 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6381                               bfd_vma *code_off)
6382 {
6383   bfd_size_type size;
6384
6385   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6386                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6387     return 0;
6388
6389   size = 0;
6390   if (!(sym->flags & BSF_SYNTHETIC))
6391     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6392
6393   if (strcmp (sym->section->name, ".opd") == 0)
6394     {
6395       struct _opd_sec_data *opd = get_opd_info (sym->section);
6396       bfd_vma symval = sym->value;
6397
6398       if (opd != NULL
6399           && opd->adjust != NULL
6400           && elf_section_data (sym->section)->relocs != NULL)
6401         {
6402           /* opd_entry_value will use cached relocs that have been
6403              adjusted, but with raw symbols.  That means both local
6404              and global symbols need adjusting.  */
6405           long adjust = opd->adjust[OPD_NDX (symval)];
6406           if (adjust == -1)
6407             return 0;
6408           symval += adjust;
6409         }
6410
6411       if (opd_entry_value (sym->section, symval,
6412                            &sec, code_off, TRUE) == (bfd_vma) -1)
6413         return 0;
6414       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6415          symbol.  This size has nothing to do with the code size of the
6416          function, which is what we're supposed to return, but the
6417          code size isn't available without looking up the dot-sym.
6418          However, doing that would be a waste of time particularly
6419          since elf_find_function will look at the dot-sym anyway.
6420          Now, elf_find_function will keep the largest size of any
6421          function sym found at the code address of interest, so return
6422          1 here to avoid it incorrectly caching a larger function size
6423          for a small function.  This does mean we return the wrong
6424          size for a new-ABI function of size 24, but all that does is
6425          disable caching for such functions.  */
6426       if (size == 24)
6427         size = 1;
6428     }
6429   else
6430     {
6431       if (sym->section != sec)
6432         return 0;
6433       *code_off = sym->value;
6434     }
6435   if (size == 0)
6436     size = 1;
6437   return size;
6438 }
6439
6440 /* Return true if symbol is a strong function defined in an ELFv2
6441    object with st_other localentry bits of zero, ie. its local entry
6442    point coincides with its global entry point.  */
6443
6444 static bfd_boolean
6445 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6446 {
6447   return (h != NULL
6448           && h->type == STT_FUNC
6449           && h->root.type == bfd_link_hash_defined
6450           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6451           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6452           && is_ppc64_elf (h->root.u.def.section->owner)
6453           && abiversion (h->root.u.def.section->owner) >= 2);
6454 }
6455
6456 /* Return true if symbol is defined in a regular object file.  */
6457
6458 static bfd_boolean
6459 is_static_defined (struct elf_link_hash_entry *h)
6460 {
6461   return ((h->root.type == bfd_link_hash_defined
6462            || h->root.type == bfd_link_hash_defweak)
6463           && h->root.u.def.section != NULL
6464           && h->root.u.def.section->output_section != NULL);
6465 }
6466
6467 /* If FDH is a function descriptor symbol, return the associated code
6468    entry symbol if it is defined.  Return NULL otherwise.  */
6469
6470 static struct ppc_link_hash_entry *
6471 defined_code_entry (struct ppc_link_hash_entry *fdh)
6472 {
6473   if (fdh->is_func_descriptor)
6474     {
6475       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6476       if (fh->elf.root.type == bfd_link_hash_defined
6477           || fh->elf.root.type == bfd_link_hash_defweak)
6478         return fh;
6479     }
6480   return NULL;
6481 }
6482
6483 /* If FH is a function code entry symbol, return the associated
6484    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6485
6486 static struct ppc_link_hash_entry *
6487 defined_func_desc (struct ppc_link_hash_entry *fh)
6488 {
6489   if (fh->oh != NULL
6490       && fh->oh->is_func_descriptor)
6491     {
6492       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6493       if (fdh->elf.root.type == bfd_link_hash_defined
6494           || fdh->elf.root.type == bfd_link_hash_defweak)
6495         return fdh;
6496     }
6497   return NULL;
6498 }
6499
6500 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6501
6502 /* Garbage collect sections, after first dealing with dot-symbols.  */
6503
6504 static bfd_boolean
6505 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6506 {
6507   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6508
6509   if (htab != NULL && htab->need_func_desc_adj)
6510     {
6511       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6512       htab->need_func_desc_adj = 0;
6513     }
6514   return bfd_elf_gc_sections (abfd, info);
6515 }
6516
6517 /* Mark all our entry sym sections, both opd and code section.  */
6518
6519 static void
6520 ppc64_elf_gc_keep (struct bfd_link_info *info)
6521 {
6522   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6523   struct bfd_sym_chain *sym;
6524
6525   if (htab == NULL)
6526     return;
6527
6528   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6529     {
6530       struct ppc_link_hash_entry *eh, *fh;
6531       asection *sec;
6532
6533       eh = (struct ppc_link_hash_entry *)
6534         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6535       if (eh == NULL)
6536         continue;
6537       if (eh->elf.root.type != bfd_link_hash_defined
6538           && eh->elf.root.type != bfd_link_hash_defweak)
6539         continue;
6540
6541       fh = defined_code_entry (eh);
6542       if (fh != NULL)
6543         {
6544           sec = fh->elf.root.u.def.section;
6545           sec->flags |= SEC_KEEP;
6546         }
6547       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6548                && opd_entry_value (eh->elf.root.u.def.section,
6549                                    eh->elf.root.u.def.value,
6550                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6551         sec->flags |= SEC_KEEP;
6552
6553       sec = eh->elf.root.u.def.section;
6554       sec->flags |= SEC_KEEP;
6555     }
6556 }
6557
6558 /* Mark sections containing dynamically referenced symbols.  When
6559    building shared libraries, we must assume that any visible symbol is
6560    referenced.  */
6561
6562 static bfd_boolean
6563 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6564 {
6565   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6566   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6567   struct ppc_link_hash_entry *fdh;
6568   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6569
6570   /* Dynamic linking info is on the func descriptor sym.  */
6571   fdh = defined_func_desc (eh);
6572   if (fdh != NULL)
6573     eh = fdh;
6574
6575   if ((eh->elf.root.type == bfd_link_hash_defined
6576        || eh->elf.root.type == bfd_link_hash_defweak)
6577       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6578           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6579               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6580               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6581               && (!bfd_link_executable (info)
6582                   || info->gc_keep_exported
6583                   || info->export_dynamic
6584                   || (eh->elf.dynamic
6585                       && d != NULL
6586                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6587               && (eh->elf.versioned >= versioned
6588                   || !bfd_hide_sym_by_version (info->version_info,
6589                                                eh->elf.root.root.string)))))
6590     {
6591       asection *code_sec;
6592       struct ppc_link_hash_entry *fh;
6593
6594       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6595
6596       /* Function descriptor syms cause the associated
6597          function code sym section to be marked.  */
6598       fh = defined_code_entry (eh);
6599       if (fh != NULL)
6600         {
6601           code_sec = fh->elf.root.u.def.section;
6602           code_sec->flags |= SEC_KEEP;
6603         }
6604       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6605                && opd_entry_value (eh->elf.root.u.def.section,
6606                                    eh->elf.root.u.def.value,
6607                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6608         code_sec->flags |= SEC_KEEP;
6609     }
6610
6611   return TRUE;
6612 }
6613
6614 /* Return the section that should be marked against GC for a given
6615    relocation.  */
6616
6617 static asection *
6618 ppc64_elf_gc_mark_hook (asection *sec,
6619                         struct bfd_link_info *info,
6620                         Elf_Internal_Rela *rel,
6621                         struct elf_link_hash_entry *h,
6622                         Elf_Internal_Sym *sym)
6623 {
6624   asection *rsec;
6625
6626   /* Syms return NULL if we're marking .opd, so we avoid marking all
6627      function sections, as all functions are referenced in .opd.  */
6628   rsec = NULL;
6629   if (get_opd_info (sec) != NULL)
6630     return rsec;
6631
6632   if (h != NULL)
6633     {
6634       enum elf_ppc64_reloc_type r_type;
6635       struct ppc_link_hash_entry *eh, *fh, *fdh;
6636
6637       r_type = ELF64_R_TYPE (rel->r_info);
6638       switch (r_type)
6639         {
6640         case R_PPC64_GNU_VTINHERIT:
6641         case R_PPC64_GNU_VTENTRY:
6642           break;
6643
6644         default:
6645           switch (h->root.type)
6646             {
6647             case bfd_link_hash_defined:
6648             case bfd_link_hash_defweak:
6649               eh = (struct ppc_link_hash_entry *) h;
6650               fdh = defined_func_desc (eh);
6651               if (fdh != NULL)
6652                 {
6653                   /* -mcall-aixdesc code references the dot-symbol on
6654                      a call reloc.  Mark the function descriptor too
6655                      against garbage collection.  */
6656                   fdh->elf.mark = 1;
6657                   if (fdh->elf.is_weakalias)
6658                     weakdef (&fdh->elf)->mark = 1;
6659                   eh = fdh;
6660                 }
6661
6662               /* Function descriptor syms cause the associated
6663                  function code sym section to be marked.  */
6664               fh = defined_code_entry (eh);
6665               if (fh != NULL)
6666                 {
6667                   /* They also mark their opd section.  */
6668                   eh->elf.root.u.def.section->gc_mark = 1;
6669
6670                   rsec = fh->elf.root.u.def.section;
6671                 }
6672               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6673                        && opd_entry_value (eh->elf.root.u.def.section,
6674                                            eh->elf.root.u.def.value,
6675                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6676                 eh->elf.root.u.def.section->gc_mark = 1;
6677               else
6678                 rsec = h->root.u.def.section;
6679               break;
6680
6681             case bfd_link_hash_common:
6682               rsec = h->root.u.c.p->section;
6683               break;
6684
6685             default:
6686               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6687             }
6688         }
6689     }
6690   else
6691     {
6692       struct _opd_sec_data *opd;
6693
6694       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6695       opd = get_opd_info (rsec);
6696       if (opd != NULL && opd->func_sec != NULL)
6697         {
6698           rsec->gc_mark = 1;
6699
6700           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6701         }
6702     }
6703
6704   return rsec;
6705 }
6706
6707 /* The maximum size of .sfpr.  */
6708 #define SFPR_MAX (218*4)
6709
6710 struct sfpr_def_parms
6711 {
6712   const char name[12];
6713   unsigned char lo, hi;
6714   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6715   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6716 };
6717
6718 /* Auto-generate _save*, _rest* functions in .sfpr.
6719    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6720    instead.  */
6721
6722 static bfd_boolean
6723 sfpr_define (struct bfd_link_info *info,
6724              const struct sfpr_def_parms *parm,
6725              asection *stub_sec)
6726 {
6727   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6728   unsigned int i;
6729   size_t len = strlen (parm->name);
6730   bfd_boolean writing = FALSE;
6731   char sym[16];
6732
6733   if (htab == NULL)
6734     return FALSE;
6735
6736   memcpy (sym, parm->name, len);
6737   sym[len + 2] = 0;
6738
6739   for (i = parm->lo; i <= parm->hi; i++)
6740     {
6741       struct ppc_link_hash_entry *h;
6742
6743       sym[len + 0] = i / 10 + '0';
6744       sym[len + 1] = i % 10 + '0';
6745       h = (struct ppc_link_hash_entry *)
6746         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6747       if (stub_sec != NULL)
6748         {
6749           if (h != NULL
6750               && h->elf.root.type == bfd_link_hash_defined
6751               && h->elf.root.u.def.section == htab->sfpr)
6752             {
6753               struct elf_link_hash_entry *s;
6754               char buf[32];
6755               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6756               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6757               if (s == NULL)
6758                 return FALSE;
6759               if (s->root.type == bfd_link_hash_new
6760                   || (s->root.type = bfd_link_hash_defined
6761                       && s->root.u.def.section == stub_sec))
6762                 {
6763                   s->root.type = bfd_link_hash_defined;
6764                   s->root.u.def.section = stub_sec;
6765                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6766                                          + h->elf.root.u.def.value);
6767                   s->ref_regular = 1;
6768                   s->def_regular = 1;
6769                   s->ref_regular_nonweak = 1;
6770                   s->forced_local = 1;
6771                   s->non_elf = 0;
6772                   s->root.linker_def = 1;
6773                 }
6774             }
6775           continue;
6776         }
6777       if (h != NULL)
6778         {
6779           h->save_res = 1;
6780           if (!h->elf.def_regular)
6781             {
6782               h->elf.root.type = bfd_link_hash_defined;
6783               h->elf.root.u.def.section = htab->sfpr;
6784               h->elf.root.u.def.value = htab->sfpr->size;
6785               h->elf.type = STT_FUNC;
6786               h->elf.def_regular = 1;
6787               h->elf.non_elf = 0;
6788               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6789               writing = TRUE;
6790               if (htab->sfpr->contents == NULL)
6791                 {
6792                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6793                   if (htab->sfpr->contents == NULL)
6794                     return FALSE;
6795                 }
6796             }
6797         }
6798       if (writing)
6799         {
6800           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6801           if (i != parm->hi)
6802             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6803           else
6804             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6805           htab->sfpr->size = p - htab->sfpr->contents;
6806         }
6807     }
6808
6809   return TRUE;
6810 }
6811
6812 static bfd_byte *
6813 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6814 {
6815   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6816   return p + 4;
6817 }
6818
6819 static bfd_byte *
6820 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6821 {
6822   p = savegpr0 (abfd, p, r);
6823   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6824   p = p + 4;
6825   bfd_put_32 (abfd, BLR, p);
6826   return p + 4;
6827 }
6828
6829 static bfd_byte *
6830 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6831 {
6832   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6833   return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6838 {
6839   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6840   p = p + 4;
6841   p = restgpr0 (abfd, p, r);
6842   bfd_put_32 (abfd, MTLR_R0, p);
6843   p = p + 4;
6844   if (r == 29)
6845     {
6846       p = restgpr0 (abfd, p, 30);
6847       p = restgpr0 (abfd, p, 31);
6848     }
6849   bfd_put_32 (abfd, BLR, p);
6850   return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6855 {
6856   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6857   return p + 4;
6858 }
6859
6860 static bfd_byte *
6861 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6862 {
6863   p = savegpr1 (abfd, p, r);
6864   bfd_put_32 (abfd, BLR, p);
6865   return p + 4;
6866 }
6867
6868 static bfd_byte *
6869 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6870 {
6871   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6872   return p + 4;
6873 }
6874
6875 static bfd_byte *
6876 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6877 {
6878   p = restgpr1 (abfd, p, r);
6879   bfd_put_32 (abfd, BLR, p);
6880   return p + 4;
6881 }
6882
6883 static bfd_byte *
6884 savefpr (bfd *abfd, bfd_byte *p, int r)
6885 {
6886   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6887   return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6892 {
6893   p = savefpr (abfd, p, r);
6894   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6895   p = p + 4;
6896   bfd_put_32 (abfd, BLR, p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 restfpr (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6904   return p + 4;
6905 }
6906
6907 static bfd_byte *
6908 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6909 {
6910   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6911   p = p + 4;
6912   p = restfpr (abfd, p, r);
6913   bfd_put_32 (abfd, MTLR_R0, p);
6914   p = p + 4;
6915   if (r == 29)
6916     {
6917       p = restfpr (abfd, p, 30);
6918       p = restfpr (abfd, p, 31);
6919     }
6920   bfd_put_32 (abfd, BLR, p);
6921   return p + 4;
6922 }
6923
6924 static bfd_byte *
6925 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6926 {
6927   p = savefpr (abfd, p, r);
6928   bfd_put_32 (abfd, BLR, p);
6929   return p + 4;
6930 }
6931
6932 static bfd_byte *
6933 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6934 {
6935   p = restfpr (abfd, p, r);
6936   bfd_put_32 (abfd, BLR, p);
6937   return p + 4;
6938 }
6939
6940 static bfd_byte *
6941 savevr (bfd *abfd, bfd_byte *p, int r)
6942 {
6943   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6944   p = p + 4;
6945   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6946   return p + 4;
6947 }
6948
6949 static bfd_byte *
6950 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6951 {
6952   p = savevr (abfd, p, r);
6953   bfd_put_32 (abfd, BLR, p);
6954   return p + 4;
6955 }
6956
6957 static bfd_byte *
6958 restvr (bfd *abfd, bfd_byte *p, int r)
6959 {
6960   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6961   p = p + 4;
6962   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6963   return p + 4;
6964 }
6965
6966 static bfd_byte *
6967 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6968 {
6969   p = restvr (abfd, p, r);
6970   bfd_put_32 (abfd, BLR, p);
6971   return p + 4;
6972 }
6973
6974 /* Called via elf_link_hash_traverse to transfer dynamic linking
6975    information on function code symbol entries to their corresponding
6976    function descriptor symbol entries.  */
6977
6978 static bfd_boolean
6979 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6980 {
6981   struct bfd_link_info *info;
6982   struct ppc_link_hash_table *htab;
6983   struct ppc_link_hash_entry *fh;
6984   struct ppc_link_hash_entry *fdh;
6985   bfd_boolean force_local;
6986
6987   fh = (struct ppc_link_hash_entry *) h;
6988   if (fh->elf.root.type == bfd_link_hash_indirect)
6989     return TRUE;
6990
6991   if (!fh->is_func)
6992     return TRUE;
6993
6994   if (fh->elf.root.root.string[0] != '.'
6995       || fh->elf.root.root.string[1] == '\0')
6996     return TRUE;
6997
6998   info = inf;
6999   htab = ppc_hash_table (info);
7000   if (htab == NULL)
7001     return FALSE;
7002
7003   /* Find the corresponding function descriptor symbol.  */
7004   fdh = lookup_fdh (fh, htab);
7005
7006   /* Resolve undefined references to dot-symbols as the value
7007      in the function descriptor, if we have one in a regular object.
7008      This is to satisfy cases like ".quad .foo".  Calls to functions
7009      in dynamic objects are handled elsewhere.  */
7010   if ((fh->elf.root.type == bfd_link_hash_undefined
7011        || fh->elf.root.type == bfd_link_hash_undefweak)
7012       && (fdh->elf.root.type == bfd_link_hash_defined
7013           || fdh->elf.root.type == bfd_link_hash_defweak)
7014       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7015       && opd_entry_value (fdh->elf.root.u.def.section,
7016                           fdh->elf.root.u.def.value,
7017                           &fh->elf.root.u.def.section,
7018                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7019     {
7020       fh->elf.root.type = fdh->elf.root.type;
7021       fh->elf.forced_local = 1;
7022       fh->elf.def_regular = fdh->elf.def_regular;
7023       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7024     }
7025
7026   if (!fh->elf.dynamic)
7027     {
7028       struct plt_entry *ent;
7029
7030       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7031         if (ent->plt.refcount > 0)
7032           break;
7033       if (ent == NULL)
7034         return TRUE;
7035     }
7036
7037   /* Create a descriptor as undefined if necessary.  */
7038   if (fdh == NULL
7039       && !bfd_link_executable (info)
7040       && (fh->elf.root.type == bfd_link_hash_undefined
7041           || fh->elf.root.type == bfd_link_hash_undefweak))
7042     {
7043       fdh = make_fdh (info, fh);
7044       if (fdh == NULL)
7045         return FALSE;
7046     }
7047
7048   /* We can't support overriding of symbols on a fake descriptor.  */
7049   if (fdh != NULL
7050       && fdh->fake
7051       && (fh->elf.root.type == bfd_link_hash_defined
7052           || fh->elf.root.type == bfd_link_hash_defweak))
7053     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7054
7055   /* Transfer dynamic linking information to the function descriptor.  */
7056   if (fdh != NULL)
7057     {
7058       fdh->elf.ref_regular |= fh->elf.ref_regular;
7059       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7060       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7061       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7062       fdh->elf.dynamic |= fh->elf.dynamic;
7063       fdh->elf.needs_plt |= (fh->elf.needs_plt
7064                              || fh->elf.type == STT_FUNC
7065                              || fh->elf.type == STT_GNU_IFUNC);
7066       move_plt_plist (fh, fdh);
7067
7068       if (!fdh->elf.forced_local
7069           && fh->elf.dynindx != -1)
7070         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7071           return FALSE;
7072     }
7073
7074   /* Now that the info is on the function descriptor, clear the
7075      function code sym info.  Any function code syms for which we
7076      don't have a definition in a regular file, we force local.
7077      This prevents a shared library from exporting syms that have
7078      been imported from another library.  Function code syms that
7079      are really in the library we must leave global to prevent the
7080      linker dragging in a definition from a static library.  */
7081   force_local = (!fh->elf.def_regular
7082                  || fdh == NULL
7083                  || !fdh->elf.def_regular
7084                  || fdh->elf.forced_local);
7085   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7086
7087   return TRUE;
7088 }
7089
7090 static const struct sfpr_def_parms save_res_funcs[] =
7091   {
7092     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7093     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7094     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7095     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7096     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7097     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7098     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7099     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7100     { "._savef", 14, 31, savefpr, savefpr1_tail },
7101     { "._restf", 14, 31, restfpr, restfpr1_tail },
7102     { "_savevr_", 20, 31, savevr, savevr_tail },
7103     { "_restvr_", 20, 31, restvr, restvr_tail }
7104   };
7105
7106 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7107    this hook to a) provide some gcc support functions, and b) transfer
7108    dynamic linking information gathered so far on function code symbol
7109    entries, to their corresponding function descriptor symbol entries.  */
7110
7111 static bfd_boolean
7112 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7113                             struct bfd_link_info *info)
7114 {
7115   struct ppc_link_hash_table *htab;
7116
7117   htab = ppc_hash_table (info);
7118   if (htab == NULL)
7119     return FALSE;
7120
7121   /* Provide any missing _save* and _rest* functions.  */
7122   if (htab->sfpr != NULL)
7123     {
7124       unsigned int i;
7125
7126       htab->sfpr->size = 0;
7127       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7128         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7129           return FALSE;
7130       if (htab->sfpr->size == 0)
7131         htab->sfpr->flags |= SEC_EXCLUDE;
7132     }
7133
7134   if (bfd_link_relocatable (info))
7135     return TRUE;
7136
7137   if (htab->elf.hgot != NULL)
7138     {
7139       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7140       /* Make .TOC. defined so as to prevent it being made dynamic.
7141          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7142       if (!htab->elf.hgot->def_regular
7143           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7144         {
7145           htab->elf.hgot->root.type = bfd_link_hash_defined;
7146           htab->elf.hgot->root.u.def.value = 0;
7147           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7148           htab->elf.hgot->def_regular = 1;
7149           htab->elf.hgot->root.linker_def = 1;
7150         }
7151       htab->elf.hgot->type = STT_OBJECT;
7152       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7153                                | STV_HIDDEN);
7154     }
7155
7156   if (htab->need_func_desc_adj)
7157     {
7158       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7159       htab->need_func_desc_adj = 0;
7160     }
7161
7162   return TRUE;
7163 }
7164
7165 /* Find dynamic relocs for H that apply to read-only sections.  */
7166
7167 static asection *
7168 readonly_dynrelocs (struct elf_link_hash_entry *h)
7169 {
7170   struct ppc_link_hash_entry *eh;
7171   struct elf_dyn_relocs *p;
7172
7173   eh = (struct ppc_link_hash_entry *) h;
7174   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7175     {
7176       asection *s = p->sec->output_section;
7177
7178       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7179         return p->sec;
7180     }
7181   return NULL;
7182 }
7183
7184 /* Return true if we have dynamic relocs against H or any of its weak
7185    aliases, that apply to read-only sections.  Cannot be used after
7186    size_dynamic_sections.  */
7187
7188 static bfd_boolean
7189 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7190 {
7191   struct ppc_link_hash_entry *eh;
7192
7193   eh = (struct ppc_link_hash_entry *) h;
7194   do
7195     {
7196       if (readonly_dynrelocs (&eh->elf))
7197         return TRUE;
7198       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7199     } while (eh != NULL && &eh->elf != h);
7200
7201   return FALSE;
7202 }
7203
7204 /* Return whether EH has pc-relative dynamic relocs.  */
7205
7206 static bfd_boolean
7207 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7208 {
7209   struct elf_dyn_relocs *p;
7210
7211   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7212     if (p->pc_count != 0)
7213       return TRUE;
7214   return FALSE;
7215 }
7216
7217 /* Return true if a global entry stub will be created for H.  Valid
7218    for ELFv2 before plt entries have been allocated.  */
7219
7220 static bfd_boolean
7221 global_entry_stub (struct elf_link_hash_entry *h)
7222 {
7223   struct plt_entry *pent;
7224
7225   if (!h->pointer_equality_needed
7226       || h->def_regular)
7227     return FALSE;
7228
7229   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7230     if (pent->plt.refcount > 0
7231         && pent->addend == 0)
7232       return TRUE;
7233
7234   return FALSE;
7235 }
7236
7237 /* Adjust a symbol defined by a dynamic object and referenced by a
7238    regular object.  The current definition is in some section of the
7239    dynamic object, but we're not including those sections.  We have to
7240    change the definition to something the rest of the link can
7241    understand.  */
7242
7243 static bfd_boolean
7244 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7245                                  struct elf_link_hash_entry *h)
7246 {
7247   struct ppc_link_hash_table *htab;
7248   asection *s, *srel;
7249
7250   htab = ppc_hash_table (info);
7251   if (htab == NULL)
7252     return FALSE;
7253
7254   /* Deal with function syms.  */
7255   if (h->type == STT_FUNC
7256       || h->type == STT_GNU_IFUNC
7257       || h->needs_plt)
7258     {
7259       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7260                            || SYMBOL_CALLS_LOCAL (info, h)
7261                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7262       /* Discard dyn_relocs when non-pic if we've decided that a
7263          function symbol is local and not an ifunc.  We keep dynamic
7264          relocs for ifuncs when local rather than always emitting a
7265          plt call stub for them and defining the symbol on the call
7266          stub.  We can't do that for ELFv1 anyway (a function symbol
7267          is defined on a descriptor, not code) and it can be faster at
7268          run-time due to not needing to bounce through a stub.  The
7269          dyn_relocs for ifuncs will be applied even in a static
7270          executable.  */
7271       if (!bfd_link_pic (info)
7272           && h->type != STT_GNU_IFUNC
7273           && local)
7274         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7275
7276       /* Clear procedure linkage table information for any symbol that
7277          won't need a .plt entry.  */
7278       struct plt_entry *ent;
7279       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7280         if (ent->plt.refcount > 0)
7281           break;
7282       if (ent == NULL
7283           || (h->type != STT_GNU_IFUNC
7284               && local
7285               && (htab->can_convert_all_inline_plt
7286                   || (((struct ppc_link_hash_entry *) h)->tls_mask
7287                       & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7288         {
7289           h->plt.plist = NULL;
7290           h->needs_plt = 0;
7291           h->pointer_equality_needed = 0;
7292         }
7293       else if (abiversion (info->output_bfd) >= 2)
7294         {
7295           /* Taking a function's address in a read/write section
7296              doesn't require us to define the function symbol in the
7297              executable on a global entry stub.  A dynamic reloc can
7298              be used instead.  The reason we prefer a few more dynamic
7299              relocs is that calling via a global entry stub costs a
7300              few more instructions, and pointer_equality_needed causes
7301              extra work in ld.so when resolving these symbols.  */
7302           if (global_entry_stub (h))
7303             {
7304               if (!readonly_dynrelocs (h))
7305                 {
7306                   h->pointer_equality_needed = 0;
7307                   /* If we haven't seen a branch reloc and the symbol
7308                      isn't an ifunc then we don't need a plt entry.  */
7309                   if (!h->needs_plt)
7310                     h->plt.plist = NULL;
7311                 }
7312               else if (!bfd_link_pic (info))
7313                 /* We are going to be defining the function symbol on the
7314                    plt stub, so no dyn_relocs needed when non-pic.  */
7315                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7316             }
7317
7318           /* ELFv2 function symbols can't have copy relocs.  */
7319           return TRUE;
7320         }
7321       else if (!h->needs_plt
7322                && !readonly_dynrelocs (h))
7323         {
7324           /* If we haven't seen a branch reloc and the symbol isn't an
7325              ifunc then we don't need a plt entry.  */
7326           h->plt.plist = NULL;
7327           h->pointer_equality_needed = 0;
7328           return TRUE;
7329         }
7330     }
7331   else
7332     h->plt.plist = NULL;
7333
7334   /* If this is a weak symbol, and there is a real definition, the
7335      processor independent code will have arranged for us to see the
7336      real definition first, and we can just use the same value.  */
7337   if (h->is_weakalias)
7338     {
7339       struct elf_link_hash_entry *def = weakdef (h);
7340       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7341       h->root.u.def.section = def->root.u.def.section;
7342       h->root.u.def.value = def->root.u.def.value;
7343       if (def->root.u.def.section == htab->elf.sdynbss
7344           || def->root.u.def.section == htab->elf.sdynrelro)
7345         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7346       return TRUE;
7347     }
7348
7349   /* If we are creating a shared library, we must presume that the
7350      only references to the symbol are via the global offset table.
7351      For such cases we need not do anything here; the relocations will
7352      be handled correctly by relocate_section.  */
7353   if (bfd_link_pic (info))
7354     return TRUE;
7355
7356   /* If there are no references to this symbol that do not use the
7357      GOT, we don't need to generate a copy reloc.  */
7358   if (!h->non_got_ref)
7359     return TRUE;
7360
7361   /* Don't generate a copy reloc for symbols defined in the executable.  */
7362   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7363
7364       /* If -z nocopyreloc was given, don't generate them either.  */
7365       || info->nocopyreloc
7366
7367       /* If we don't find any dynamic relocs in read-only sections, then
7368          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7369       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7370
7371       /* Protected variables do not work with .dynbss.  The copy in
7372          .dynbss won't be used by the shared library with the protected
7373          definition for the variable.  Text relocations are preferable
7374          to an incorrect program.  */
7375       || h->protected_def)
7376     return TRUE;
7377
7378   if (h->plt.plist != NULL)
7379     {
7380       /* We should never get here, but unfortunately there are versions
7381          of gcc out there that improperly (for this ABI) put initialized
7382          function pointers, vtable refs and suchlike in read-only
7383          sections.  Allow them to proceed, but warn that this might
7384          break at runtime.  */
7385       info->callbacks->einfo
7386         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7387            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7388          h->root.root.string);
7389     }
7390
7391   /* This is a reference to a symbol defined by a dynamic object which
7392      is not a function.  */
7393
7394   /* We must allocate the symbol in our .dynbss section, which will
7395      become part of the .bss section of the executable.  There will be
7396      an entry for this symbol in the .dynsym section.  The dynamic
7397      object will contain position independent code, so all references
7398      from the dynamic object to this symbol will go through the global
7399      offset table.  The dynamic linker will use the .dynsym entry to
7400      determine the address it must put in the global offset table, so
7401      both the dynamic object and the regular object will refer to the
7402      same memory location for the variable.  */
7403   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7404     {
7405       s = htab->elf.sdynrelro;
7406       srel = htab->elf.sreldynrelro;
7407     }
7408   else
7409     {
7410       s = htab->elf.sdynbss;
7411       srel = htab->elf.srelbss;
7412     }
7413   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7414     {
7415       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7416          linker to copy the initial value out of the dynamic object
7417          and into the runtime process image.  */
7418       srel->size += sizeof (Elf64_External_Rela);
7419       h->needs_copy = 1;
7420     }
7421
7422   /* We no longer want dyn_relocs.  */
7423   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7424   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7425 }
7426
7427 /* If given a function descriptor symbol, hide both the function code
7428    sym and the descriptor.  */
7429 static void
7430 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7431                        struct elf_link_hash_entry *h,
7432                        bfd_boolean force_local)
7433 {
7434   struct ppc_link_hash_entry *eh;
7435   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7436
7437   eh = (struct ppc_link_hash_entry *) h;
7438   if (eh->is_func_descriptor)
7439     {
7440       struct ppc_link_hash_entry *fh = eh->oh;
7441
7442       if (fh == NULL)
7443         {
7444           const char *p, *q;
7445           struct elf_link_hash_table *htab = elf_hash_table (info);
7446           char save;
7447
7448           /* We aren't supposed to use alloca in BFD because on
7449              systems which do not have alloca the version in libiberty
7450              calls xmalloc, which might cause the program to crash
7451              when it runs out of memory.  This function doesn't have a
7452              return status, so there's no way to gracefully return an
7453              error.  So cheat.  We know that string[-1] can be safely
7454              accessed;  It's either a string in an ELF string table,
7455              or allocated in an objalloc structure.  */
7456
7457           p = eh->elf.root.root.string - 1;
7458           save = *p;
7459           *(char *) p = '.';
7460           fh = (struct ppc_link_hash_entry *)
7461             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7462           *(char *) p = save;
7463
7464           /* Unfortunately, if it so happens that the string we were
7465              looking for was allocated immediately before this string,
7466              then we overwrote the string terminator.  That's the only
7467              reason the lookup should fail.  */
7468           if (fh == NULL)
7469             {
7470               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7471               while (q >= eh->elf.root.root.string && *q == *p)
7472                 --q, --p;
7473               if (q < eh->elf.root.root.string && *p == '.')
7474                 fh = (struct ppc_link_hash_entry *)
7475                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7476             }
7477           if (fh != NULL)
7478             {
7479               eh->oh = fh;
7480               fh->oh = eh;
7481             }
7482         }
7483       if (fh != NULL)
7484         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7485     }
7486 }
7487
7488 static bfd_boolean
7489 get_sym_h (struct elf_link_hash_entry **hp,
7490            Elf_Internal_Sym **symp,
7491            asection **symsecp,
7492            unsigned char **tls_maskp,
7493            Elf_Internal_Sym **locsymsp,
7494            unsigned long r_symndx,
7495            bfd *ibfd)
7496 {
7497   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7498
7499   if (r_symndx >= symtab_hdr->sh_info)
7500     {
7501       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7502       struct elf_link_hash_entry *h;
7503
7504       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7505       h = elf_follow_link (h);
7506
7507       if (hp != NULL)
7508         *hp = h;
7509
7510       if (symp != NULL)
7511         *symp = NULL;
7512
7513       if (symsecp != NULL)
7514         {
7515           asection *symsec = NULL;
7516           if (h->root.type == bfd_link_hash_defined
7517               || h->root.type == bfd_link_hash_defweak)
7518             symsec = h->root.u.def.section;
7519           *symsecp = symsec;
7520         }
7521
7522       if (tls_maskp != NULL)
7523         {
7524           struct ppc_link_hash_entry *eh;
7525
7526           eh = (struct ppc_link_hash_entry *) h;
7527           *tls_maskp = &eh->tls_mask;
7528         }
7529     }
7530   else
7531     {
7532       Elf_Internal_Sym *sym;
7533       Elf_Internal_Sym *locsyms = *locsymsp;
7534
7535       if (locsyms == NULL)
7536         {
7537           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7538           if (locsyms == NULL)
7539             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7540                                             symtab_hdr->sh_info,
7541                                             0, NULL, NULL, NULL);
7542           if (locsyms == NULL)
7543             return FALSE;
7544           *locsymsp = locsyms;
7545         }
7546       sym = locsyms + r_symndx;
7547
7548       if (hp != NULL)
7549         *hp = NULL;
7550
7551       if (symp != NULL)
7552         *symp = sym;
7553
7554       if (symsecp != NULL)
7555         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7556
7557       if (tls_maskp != NULL)
7558         {
7559           struct got_entry **lgot_ents;
7560           unsigned char *tls_mask;
7561
7562           tls_mask = NULL;
7563           lgot_ents = elf_local_got_ents (ibfd);
7564           if (lgot_ents != NULL)
7565             {
7566               struct plt_entry **local_plt = (struct plt_entry **)
7567                 (lgot_ents + symtab_hdr->sh_info);
7568               unsigned char *lgot_masks = (unsigned char *)
7569                 (local_plt + symtab_hdr->sh_info);
7570               tls_mask = &lgot_masks[r_symndx];
7571             }
7572           *tls_maskp = tls_mask;
7573         }
7574     }
7575   return TRUE;
7576 }
7577
7578 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7579    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7580    type suitable for optimization, and 1 otherwise.  */
7581
7582 static int
7583 get_tls_mask (unsigned char **tls_maskp,
7584               unsigned long *toc_symndx,
7585               bfd_vma *toc_addend,
7586               Elf_Internal_Sym **locsymsp,
7587               const Elf_Internal_Rela *rel,
7588               bfd *ibfd)
7589 {
7590   unsigned long r_symndx;
7591   int next_r;
7592   struct elf_link_hash_entry *h;
7593   Elf_Internal_Sym *sym;
7594   asection *sec;
7595   bfd_vma off;
7596
7597   r_symndx = ELF64_R_SYM (rel->r_info);
7598   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7599     return 0;
7600
7601   if ((*tls_maskp != NULL
7602        && (**tls_maskp & TLS_TLS) != 0
7603        && **tls_maskp != (TLS_TLS | TLS_MARK))
7604       || sec == NULL
7605       || ppc64_elf_section_data (sec) == NULL
7606       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7607     return 1;
7608
7609   /* Look inside a TOC section too.  */
7610   if (h != NULL)
7611     {
7612       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7613       off = h->root.u.def.value;
7614     }
7615   else
7616     off = sym->st_value;
7617   off += rel->r_addend;
7618   BFD_ASSERT (off % 8 == 0);
7619   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7620   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7621   if (toc_symndx != NULL)
7622     *toc_symndx = r_symndx;
7623   if (toc_addend != NULL)
7624     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7625   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7626     return 0;
7627   if ((h == NULL || is_static_defined (h))
7628       && (next_r == -1 || next_r == -2))
7629     return 1 - next_r;
7630   return 1;
7631 }
7632
7633 /* Find (or create) an entry in the tocsave hash table.  */
7634
7635 static struct tocsave_entry *
7636 tocsave_find (struct ppc_link_hash_table *htab,
7637               enum insert_option insert,
7638               Elf_Internal_Sym **local_syms,
7639               const Elf_Internal_Rela *irela,
7640               bfd *ibfd)
7641 {
7642   unsigned long r_indx;
7643   struct elf_link_hash_entry *h;
7644   Elf_Internal_Sym *sym;
7645   struct tocsave_entry ent, *p;
7646   hashval_t hash;
7647   struct tocsave_entry **slot;
7648
7649   r_indx = ELF64_R_SYM (irela->r_info);
7650   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7651     return NULL;
7652   if (ent.sec == NULL || ent.sec->output_section == NULL)
7653     {
7654       _bfd_error_handler
7655         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7656       return NULL;
7657     }
7658
7659   if (h != NULL)
7660     ent.offset = h->root.u.def.value;
7661   else
7662     ent.offset = sym->st_value;
7663   ent.offset += irela->r_addend;
7664
7665   hash = tocsave_htab_hash (&ent);
7666   slot = ((struct tocsave_entry **)
7667           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7668   if (slot == NULL)
7669     return NULL;
7670
7671   if (*slot == NULL)
7672     {
7673       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7674       if (p == NULL)
7675         return NULL;
7676       *p = ent;
7677       *slot = p;
7678     }
7679   return *slot;
7680 }
7681
7682 /* Adjust all global syms defined in opd sections.  In gcc generated
7683    code for the old ABI, these will already have been done.  */
7684
7685 static bfd_boolean
7686 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7687 {
7688   struct ppc_link_hash_entry *eh;
7689   asection *sym_sec;
7690   struct _opd_sec_data *opd;
7691
7692   if (h->root.type == bfd_link_hash_indirect)
7693     return TRUE;
7694
7695   if (h->root.type != bfd_link_hash_defined
7696       && h->root.type != bfd_link_hash_defweak)
7697     return TRUE;
7698
7699   eh = (struct ppc_link_hash_entry *) h;
7700   if (eh->adjust_done)
7701     return TRUE;
7702
7703   sym_sec = eh->elf.root.u.def.section;
7704   opd = get_opd_info (sym_sec);
7705   if (opd != NULL && opd->adjust != NULL)
7706     {
7707       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7708       if (adjust == -1)
7709         {
7710           /* This entry has been deleted.  */
7711           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7712           if (dsec == NULL)
7713             {
7714               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7715                 if (discarded_section (dsec))
7716                   {
7717                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7718                     break;
7719                   }
7720             }
7721           eh->elf.root.u.def.value = 0;
7722           eh->elf.root.u.def.section = dsec;
7723         }
7724       else
7725         eh->elf.root.u.def.value += adjust;
7726       eh->adjust_done = 1;
7727     }
7728   return TRUE;
7729 }
7730
7731 /* Handles decrementing dynamic reloc counts for the reloc specified by
7732    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7733    have already been determined.  */
7734
7735 static bfd_boolean
7736 dec_dynrel_count (bfd_vma r_info,
7737                   asection *sec,
7738                   struct bfd_link_info *info,
7739                   Elf_Internal_Sym **local_syms,
7740                   struct elf_link_hash_entry *h,
7741                   Elf_Internal_Sym *sym)
7742 {
7743   enum elf_ppc64_reloc_type r_type;
7744   asection *sym_sec = NULL;
7745
7746   /* Can this reloc be dynamic?  This switch, and later tests here
7747      should be kept in sync with the code in check_relocs.  */
7748   r_type = ELF64_R_TYPE (r_info);
7749   switch (r_type)
7750     {
7751     default:
7752       return TRUE;
7753
7754     case R_PPC64_TPREL16:
7755     case R_PPC64_TPREL16_LO:
7756     case R_PPC64_TPREL16_HI:
7757     case R_PPC64_TPREL16_HA:
7758     case R_PPC64_TPREL16_DS:
7759     case R_PPC64_TPREL16_LO_DS:
7760     case R_PPC64_TPREL16_HIGH:
7761     case R_PPC64_TPREL16_HIGHA:
7762     case R_PPC64_TPREL16_HIGHER:
7763     case R_PPC64_TPREL16_HIGHERA:
7764     case R_PPC64_TPREL16_HIGHEST:
7765     case R_PPC64_TPREL16_HIGHESTA:
7766     case R_PPC64_TPREL64:
7767     case R_PPC64_DTPMOD64:
7768     case R_PPC64_DTPREL64:
7769     case R_PPC64_ADDR64:
7770     case R_PPC64_REL30:
7771     case R_PPC64_REL32:
7772     case R_PPC64_REL64:
7773     case R_PPC64_ADDR14:
7774     case R_PPC64_ADDR14_BRNTAKEN:
7775     case R_PPC64_ADDR14_BRTAKEN:
7776     case R_PPC64_ADDR16:
7777     case R_PPC64_ADDR16_DS:
7778     case R_PPC64_ADDR16_HA:
7779     case R_PPC64_ADDR16_HI:
7780     case R_PPC64_ADDR16_HIGH:
7781     case R_PPC64_ADDR16_HIGHA:
7782     case R_PPC64_ADDR16_HIGHER:
7783     case R_PPC64_ADDR16_HIGHERA:
7784     case R_PPC64_ADDR16_HIGHEST:
7785     case R_PPC64_ADDR16_HIGHESTA:
7786     case R_PPC64_ADDR16_LO:
7787     case R_PPC64_ADDR16_LO_DS:
7788     case R_PPC64_ADDR24:
7789     case R_PPC64_ADDR32:
7790     case R_PPC64_UADDR16:
7791     case R_PPC64_UADDR32:
7792     case R_PPC64_UADDR64:
7793     case R_PPC64_TOC:
7794       break;
7795     }
7796
7797   if (local_syms != NULL)
7798     {
7799       unsigned long r_symndx;
7800       bfd *ibfd = sec->owner;
7801
7802       r_symndx = ELF64_R_SYM (r_info);
7803       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7804         return FALSE;
7805     }
7806
7807   if ((bfd_link_pic (info)
7808        && (must_be_dyn_reloc (info, r_type)
7809            || (h != NULL
7810                && (!SYMBOLIC_BIND (info, h)
7811                    || h->root.type == bfd_link_hash_defweak
7812                    || !h->def_regular))))
7813       || (ELIMINATE_COPY_RELOCS
7814           && !bfd_link_pic (info)
7815           && h != NULL
7816           && (h->root.type == bfd_link_hash_defweak
7817               || !h->def_regular)))
7818     ;
7819   else
7820     return TRUE;
7821
7822   if (h != NULL)
7823     {
7824       struct elf_dyn_relocs *p;
7825       struct elf_dyn_relocs **pp;
7826       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7827
7828       /* elf_gc_sweep may have already removed all dyn relocs associated
7829          with local syms for a given section.  Also, symbol flags are
7830          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7831          report a dynreloc miscount.  */
7832       if (*pp == NULL && info->gc_sections)
7833         return TRUE;
7834
7835       while ((p = *pp) != NULL)
7836         {
7837           if (p->sec == sec)
7838             {
7839               if (!must_be_dyn_reloc (info, r_type))
7840                 p->pc_count -= 1;
7841               p->count -= 1;
7842               if (p->count == 0)
7843                 *pp = p->next;
7844               return TRUE;
7845             }
7846           pp = &p->next;
7847         }
7848     }
7849   else
7850     {
7851       struct ppc_dyn_relocs *p;
7852       struct ppc_dyn_relocs **pp;
7853       void *vpp;
7854       bfd_boolean is_ifunc;
7855
7856       if (local_syms == NULL)
7857         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7858       if (sym_sec == NULL)
7859         sym_sec = sec;
7860
7861       vpp = &elf_section_data (sym_sec)->local_dynrel;
7862       pp = (struct ppc_dyn_relocs **) vpp;
7863
7864       if (*pp == NULL && info->gc_sections)
7865         return TRUE;
7866
7867       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7868       while ((p = *pp) != NULL)
7869         {
7870           if (p->sec == sec && p->ifunc == is_ifunc)
7871             {
7872               p->count -= 1;
7873               if (p->count == 0)
7874                 *pp = p->next;
7875               return TRUE;
7876             }
7877           pp = &p->next;
7878         }
7879     }
7880
7881   /* xgettext:c-format */
7882   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7883                       sec->owner, sec);
7884   bfd_set_error (bfd_error_bad_value);
7885   return FALSE;
7886 }
7887
7888 /* Remove unused Official Procedure Descriptor entries.  Currently we
7889    only remove those associated with functions in discarded link-once
7890    sections, or weakly defined functions that have been overridden.  It
7891    would be possible to remove many more entries for statically linked
7892    applications.  */
7893
7894 bfd_boolean
7895 ppc64_elf_edit_opd (struct bfd_link_info *info)
7896 {
7897   bfd *ibfd;
7898   bfd_boolean some_edited = FALSE;
7899   asection *need_pad = NULL;
7900   struct ppc_link_hash_table *htab;
7901
7902   htab = ppc_hash_table (info);
7903   if (htab == NULL)
7904     return FALSE;
7905
7906   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7907     {
7908       asection *sec;
7909       Elf_Internal_Rela *relstart, *rel, *relend;
7910       Elf_Internal_Shdr *symtab_hdr;
7911       Elf_Internal_Sym *local_syms;
7912       struct _opd_sec_data *opd;
7913       bfd_boolean need_edit, add_aux_fields, broken;
7914       bfd_size_type cnt_16b = 0;
7915
7916       if (!is_ppc64_elf (ibfd))
7917         continue;
7918
7919       sec = bfd_get_section_by_name (ibfd, ".opd");
7920       if (sec == NULL || sec->size == 0)
7921         continue;
7922
7923       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7924         continue;
7925
7926       if (sec->output_section == bfd_abs_section_ptr)
7927         continue;
7928
7929       /* Look through the section relocs.  */
7930       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7931         continue;
7932
7933       local_syms = NULL;
7934       symtab_hdr = &elf_symtab_hdr (ibfd);
7935
7936       /* Read the relocations.  */
7937       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7938                                             info->keep_memory);
7939       if (relstart == NULL)
7940         return FALSE;
7941
7942       /* First run through the relocs to check they are sane, and to
7943          determine whether we need to edit this opd section.  */
7944       need_edit = FALSE;
7945       broken = FALSE;
7946       need_pad = sec;
7947       relend = relstart + sec->reloc_count;
7948       for (rel = relstart; rel < relend; )
7949         {
7950           enum elf_ppc64_reloc_type r_type;
7951           unsigned long r_symndx;
7952           asection *sym_sec;
7953           struct elf_link_hash_entry *h;
7954           Elf_Internal_Sym *sym;
7955           bfd_vma offset;
7956
7957           /* .opd contains an array of 16 or 24 byte entries.  We're
7958              only interested in the reloc pointing to a function entry
7959              point.  */
7960           offset = rel->r_offset;
7961           if (rel + 1 == relend
7962               || rel[1].r_offset != offset + 8)
7963             {
7964               /* If someone messes with .opd alignment then after a
7965                  "ld -r" we might have padding in the middle of .opd.
7966                  Also, there's nothing to prevent someone putting
7967                  something silly in .opd with the assembler.  No .opd
7968                  optimization for them!  */
7969             broken_opd:
7970               _bfd_error_handler
7971                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7972               broken = TRUE;
7973               break;
7974             }
7975
7976           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7977               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7978             {
7979               _bfd_error_handler
7980                 /* xgettext:c-format */
7981                 (_("%pB: unexpected reloc type %u in .opd section"),
7982                  ibfd, r_type);
7983               broken = TRUE;
7984               break;
7985             }
7986
7987           r_symndx = ELF64_R_SYM (rel->r_info);
7988           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7989                           r_symndx, ibfd))
7990             goto error_ret;
7991
7992           if (sym_sec == NULL || sym_sec->owner == NULL)
7993             {
7994               const char *sym_name;
7995               if (h != NULL)
7996                 sym_name = h->root.root.string;
7997               else
7998                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7999                                              sym_sec);
8000
8001               _bfd_error_handler
8002                 /* xgettext:c-format */
8003                 (_("%pB: undefined sym `%s' in .opd section"),
8004                  ibfd, sym_name);
8005               broken = TRUE;
8006               break;
8007             }
8008
8009           /* opd entries are always for functions defined in the
8010              current input bfd.  If the symbol isn't defined in the
8011              input bfd, then we won't be using the function in this
8012              bfd;  It must be defined in a linkonce section in another
8013              bfd, or is weak.  It's also possible that we are
8014              discarding the function due to a linker script /DISCARD/,
8015              which we test for via the output_section.  */
8016           if (sym_sec->owner != ibfd
8017               || sym_sec->output_section == bfd_abs_section_ptr)
8018             need_edit = TRUE;
8019
8020           rel += 2;
8021           if (rel + 1 == relend
8022               || (rel + 2 < relend
8023                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8024             ++rel;
8025
8026           if (rel == relend)
8027             {
8028               if (sec->size == offset + 24)
8029                 {
8030                   need_pad = NULL;
8031                   break;
8032                 }
8033               if (sec->size == offset + 16)
8034                 {
8035                   cnt_16b++;
8036                   break;
8037                 }
8038               goto broken_opd;
8039             }
8040           else if (rel + 1 < relend
8041                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8042                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8043             {
8044               if (rel[0].r_offset == offset + 16)
8045                 cnt_16b++;
8046               else if (rel[0].r_offset != offset + 24)
8047                 goto broken_opd;
8048             }
8049           else
8050             goto broken_opd;
8051         }
8052
8053       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8054
8055       if (!broken && (need_edit || add_aux_fields))
8056         {
8057           Elf_Internal_Rela *write_rel;
8058           Elf_Internal_Shdr *rel_hdr;
8059           bfd_byte *rptr, *wptr;
8060           bfd_byte *new_contents;
8061           bfd_size_type amt;
8062
8063           new_contents = NULL;
8064           amt = OPD_NDX (sec->size) * sizeof (long);
8065           opd = &ppc64_elf_section_data (sec)->u.opd;
8066           opd->adjust = bfd_zalloc (sec->owner, amt);
8067           if (opd->adjust == NULL)
8068             return FALSE;
8069
8070           /* This seems a waste of time as input .opd sections are all
8071              zeros as generated by gcc, but I suppose there's no reason
8072              this will always be so.  We might start putting something in
8073              the third word of .opd entries.  */
8074           if ((sec->flags & SEC_IN_MEMORY) == 0)
8075             {
8076               bfd_byte *loc;
8077               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8078                 {
8079                   if (loc != NULL)
8080                     free (loc);
8081                 error_ret:
8082                   if (local_syms != NULL
8083                       && symtab_hdr->contents != (unsigned char *) local_syms)
8084                     free (local_syms);
8085                   if (elf_section_data (sec)->relocs != relstart)
8086                     free (relstart);
8087                   return FALSE;
8088                 }
8089               sec->contents = loc;
8090               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8091             }
8092
8093           elf_section_data (sec)->relocs = relstart;
8094
8095           new_contents = sec->contents;
8096           if (add_aux_fields)
8097             {
8098               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8099               if (new_contents == NULL)
8100                 return FALSE;
8101               need_pad = NULL;
8102             }
8103           wptr = new_contents;
8104           rptr = sec->contents;
8105           write_rel = relstart;
8106           for (rel = relstart; rel < relend; )
8107             {
8108               unsigned long r_symndx;
8109               asection *sym_sec;
8110               struct elf_link_hash_entry *h;
8111               struct ppc_link_hash_entry *fdh = NULL;
8112               Elf_Internal_Sym *sym;
8113               long opd_ent_size;
8114               Elf_Internal_Rela *next_rel;
8115               bfd_boolean skip;
8116
8117               r_symndx = ELF64_R_SYM (rel->r_info);
8118               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8119                               r_symndx, ibfd))
8120                 goto error_ret;
8121
8122               next_rel = rel + 2;
8123               if (next_rel + 1 == relend
8124                   || (next_rel + 2 < relend
8125                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8126                 ++next_rel;
8127
8128               /* See if the .opd entry is full 24 byte or
8129                  16 byte (with fd_aux entry overlapped with next
8130                  fd_func).  */
8131               opd_ent_size = 24;
8132               if (next_rel == relend)
8133                 {
8134                   if (sec->size == rel->r_offset + 16)
8135                     opd_ent_size = 16;
8136                 }
8137               else if (next_rel->r_offset == rel->r_offset + 16)
8138                 opd_ent_size = 16;
8139
8140               if (h != NULL
8141                   && h->root.root.string[0] == '.')
8142                 {
8143                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8144                   if (fdh != NULL)
8145                     {
8146                       fdh = ppc_follow_link (fdh);
8147                       if (fdh->elf.root.type != bfd_link_hash_defined
8148                           && fdh->elf.root.type != bfd_link_hash_defweak)
8149                         fdh = NULL;
8150                     }
8151                 }
8152
8153               skip = (sym_sec->owner != ibfd
8154                       || sym_sec->output_section == bfd_abs_section_ptr);
8155               if (skip)
8156                 {
8157                   if (fdh != NULL && sym_sec->owner == ibfd)
8158                     {
8159                       /* Arrange for the function descriptor sym
8160                          to be dropped.  */
8161                       fdh->elf.root.u.def.value = 0;
8162                       fdh->elf.root.u.def.section = sym_sec;
8163                     }
8164                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8165
8166                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8167                     rel = next_rel;
8168                   else
8169                     while (1)
8170                       {
8171                         if (!dec_dynrel_count (rel->r_info, sec, info,
8172                                                NULL, h, sym))
8173                           goto error_ret;
8174
8175                         if (++rel == next_rel)
8176                           break;
8177
8178                         r_symndx = ELF64_R_SYM (rel->r_info);
8179                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8180                                         r_symndx, ibfd))
8181                           goto error_ret;
8182                       }
8183                 }
8184               else
8185                 {
8186                   /* We'll be keeping this opd entry.  */
8187                   long adjust;
8188
8189                   if (fdh != NULL)
8190                     {
8191                       /* Redefine the function descriptor symbol to
8192                          this location in the opd section.  It is
8193                          necessary to update the value here rather
8194                          than using an array of adjustments as we do
8195                          for local symbols, because various places
8196                          in the generic ELF code use the value
8197                          stored in u.def.value.  */
8198                       fdh->elf.root.u.def.value = wptr - new_contents;
8199                       fdh->adjust_done = 1;
8200                     }
8201
8202                   /* Local syms are a bit tricky.  We could
8203                      tweak them as they can be cached, but
8204                      we'd need to look through the local syms
8205                      for the function descriptor sym which we
8206                      don't have at the moment.  So keep an
8207                      array of adjustments.  */
8208                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8209                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8210
8211                   if (wptr != rptr)
8212                     memcpy (wptr, rptr, opd_ent_size);
8213                   wptr += opd_ent_size;
8214                   if (add_aux_fields && opd_ent_size == 16)
8215                     {
8216                       memset (wptr, '\0', 8);
8217                       wptr += 8;
8218                     }
8219
8220                   /* We need to adjust any reloc offsets to point to the
8221                      new opd entries.  */
8222                   for ( ; rel != next_rel; ++rel)
8223                     {
8224                       rel->r_offset += adjust;
8225                       if (write_rel != rel)
8226                         memcpy (write_rel, rel, sizeof (*rel));
8227                       ++write_rel;
8228                     }
8229                 }
8230
8231               rptr += opd_ent_size;
8232             }
8233
8234           sec->size = wptr - new_contents;
8235           sec->reloc_count = write_rel - relstart;
8236           if (add_aux_fields)
8237             {
8238               free (sec->contents);
8239               sec->contents = new_contents;
8240             }
8241
8242           /* Fudge the header size too, as this is used later in
8243              elf_bfd_final_link if we are emitting relocs.  */
8244           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8245           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8246           some_edited = TRUE;
8247         }
8248       else if (elf_section_data (sec)->relocs != relstart)
8249         free (relstart);
8250
8251       if (local_syms != NULL
8252           && symtab_hdr->contents != (unsigned char *) local_syms)
8253         {
8254           if (!info->keep_memory)
8255             free (local_syms);
8256           else
8257             symtab_hdr->contents = (unsigned char *) local_syms;
8258         }
8259     }
8260
8261   if (some_edited)
8262     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8263
8264   /* If we are doing a final link and the last .opd entry is just 16 byte
8265      long, add a 8 byte padding after it.  */
8266   if (need_pad != NULL && !bfd_link_relocatable (info))
8267     {
8268       bfd_byte *p;
8269
8270       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8271         {
8272           BFD_ASSERT (need_pad->size > 0);
8273
8274           p = bfd_malloc (need_pad->size + 8);
8275           if (p == NULL)
8276             return FALSE;
8277
8278           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8279                                           p, 0, need_pad->size))
8280             return FALSE;
8281
8282           need_pad->contents = p;
8283           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8284         }
8285       else
8286         {
8287           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8288           if (p == NULL)
8289             return FALSE;
8290
8291           need_pad->contents = p;
8292         }
8293
8294       memset (need_pad->contents + need_pad->size, 0, 8);
8295       need_pad->size += 8;
8296     }
8297
8298   return TRUE;
8299 }
8300
8301 /* Analyze inline PLT call relocations to see whether calls to locally
8302    defined functions can be converted to direct calls.  */
8303
8304 bfd_boolean
8305 ppc64_elf_inline_plt (struct bfd_link_info *info)
8306 {
8307   struct ppc_link_hash_table *htab;
8308   bfd *ibfd;
8309   asection *sec;
8310   bfd_vma low_vma, high_vma, limit;
8311
8312   htab = ppc_hash_table (info);
8313   if (htab == NULL)
8314     return FALSE;
8315
8316   /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
8317      reduced somewhat to cater for possible stubs that might be added
8318      between the call and its destination.  */
8319   if (htab->params->group_size < 0)
8320     {
8321       limit = -htab->params->group_size;
8322       if (limit == 1)
8323         limit = 0x1e00000;
8324     }
8325   else
8326     {
8327       limit = htab->params->group_size;
8328       if (limit == 1)
8329         limit = 0x1c00000;
8330     }
8331
8332   low_vma = -1;
8333   high_vma = 0;
8334   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8335     if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8336       {
8337         if (low_vma > sec->vma)
8338           low_vma = sec->vma;
8339         if (high_vma < sec->vma + sec->size)
8340           high_vma = sec->vma + sec->size;
8341       }
8342
8343   /* If a "bl" can reach anywhere in local code sections, then we can
8344      convert all inline PLT sequences to direct calls when the symbol
8345      is local.  */
8346   if (high_vma - low_vma < limit)
8347     {
8348       htab->can_convert_all_inline_plt = 1;
8349       return TRUE;
8350     }
8351
8352   /* Otherwise, go looking through relocs for cases where a direct
8353      call won't reach.  Mark the symbol on any such reloc to disable
8354      the optimization and keep the PLT entry as it seems likely that
8355      this will be better than creating trampolines.  Note that this
8356      will disable the optimization for all inline PLT calls to a
8357      particular symbol, not just those that won't reach.  The
8358      difficulty in doing a more precise optimization is that the
8359      linker needs to make a decision depending on whether a
8360      particular R_PPC64_PLTCALL insn can be turned into a direct
8361      call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8362      the sequence, and there is nothing that ties those relocs
8363      together except their symbol.  */
8364
8365   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8366     {
8367       Elf_Internal_Shdr *symtab_hdr;
8368       Elf_Internal_Sym *local_syms;
8369
8370       if (!is_ppc64_elf (ibfd))
8371         continue;
8372
8373       local_syms = NULL;
8374       symtab_hdr = &elf_symtab_hdr (ibfd);
8375
8376       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8377         if (ppc64_elf_section_data (sec)->has_pltcall
8378             && !bfd_is_abs_section (sec->output_section))
8379           {
8380             Elf_Internal_Rela *relstart, *rel, *relend;
8381
8382             /* Read the relocations.  */
8383             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8384                                                   info->keep_memory);
8385             if (relstart == NULL)
8386               return FALSE;
8387
8388             relend = relstart + sec->reloc_count;
8389             for (rel = relstart; rel < relend; )
8390               {
8391                 enum elf_ppc64_reloc_type r_type;
8392                 unsigned long r_symndx;
8393                 asection *sym_sec;
8394                 struct elf_link_hash_entry *h;
8395                 Elf_Internal_Sym *sym;
8396                 unsigned char *tls_maskp;
8397
8398                 r_type = ELF64_R_TYPE (rel->r_info);
8399                 if (r_type != R_PPC64_PLTCALL)
8400                   continue;
8401
8402                 r_symndx = ELF64_R_SYM (rel->r_info);
8403                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8404                                 r_symndx, ibfd))
8405                   {
8406                     if (elf_section_data (sec)->relocs != relstart)
8407                       free (relstart);
8408                     if (local_syms != NULL
8409                         && symtab_hdr->contents != (unsigned char *) local_syms)
8410                       free (local_syms);
8411                     return FALSE;
8412                   }
8413
8414                 if (sym_sec != NULL && sym_sec->output_section != NULL)
8415                   {
8416                     bfd_vma from, to;
8417                     if (h != NULL)
8418                       to = h->root.u.def.value;
8419                     else
8420                       to = sym->st_value;
8421                     to += (rel->r_addend
8422                            + sym_sec->output_offset
8423                            + sym_sec->output_section->vma);
8424                     from = (rel->r_offset
8425                             + sec->output_offset
8426                             + sec->output_section->vma);
8427                     if (to - from + limit < 2 * limit)
8428                       *tls_maskp &= ~PLT_KEEP;
8429                   }
8430               }
8431             if (elf_section_data (sec)->relocs != relstart)
8432               free (relstart);
8433           }
8434
8435       if (local_syms != NULL
8436           && symtab_hdr->contents != (unsigned char *) local_syms)
8437         {
8438           if (!info->keep_memory)
8439             free (local_syms);
8440           else
8441             symtab_hdr->contents = (unsigned char *) local_syms;
8442         }
8443     }
8444
8445   return TRUE;
8446 }
8447
8448 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8449
8450 asection *
8451 ppc64_elf_tls_setup (struct bfd_link_info *info)
8452 {
8453   struct ppc_link_hash_table *htab;
8454
8455   htab = ppc_hash_table (info);
8456   if (htab == NULL)
8457     return NULL;
8458
8459   if (abiversion (info->output_bfd) == 1)
8460     htab->opd_abi = 1;
8461
8462   if (htab->params->no_multi_toc)
8463     htab->do_multi_toc = 0;
8464   else if (!htab->do_multi_toc)
8465     htab->params->no_multi_toc = 1;
8466
8467   /* Default to --no-plt-localentry, as this option can cause problems
8468      with symbol interposition.  For example, glibc libpthread.so and
8469      libc.so duplicate many pthread symbols, with a fallback
8470      implementation in libc.so.  In some cases the fallback does more
8471      work than the pthread implementation.  __pthread_condattr_destroy
8472      is one such symbol: the libpthread.so implementation is
8473      localentry:0 while the libc.so implementation is localentry:8.
8474      An app that "cleverly" uses dlopen to only load necessary
8475      libraries at runtime may omit loading libpthread.so when not
8476      running multi-threaded, which then results in the libc.so
8477      fallback symbols being used and ld.so complaining.  Now there
8478      are workarounds in ld (see non_zero_localentry) to detect the
8479      pthread situation, but that may not be the only case where
8480      --plt-localentry can cause trouble.  */
8481   if (htab->params->plt_localentry0 < 0)
8482     htab->params->plt_localentry0 = 0;
8483   if (htab->params->plt_localentry0
8484       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8485                                FALSE, FALSE, FALSE) == NULL)
8486     _bfd_error_handler
8487       (_("warning: --plt-localentry is especially dangerous without "
8488          "ld.so support to detect ABI violations"));
8489
8490   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8491                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8492                                               FALSE, FALSE, TRUE));
8493   /* Move dynamic linking info to the function descriptor sym.  */
8494   if (htab->tls_get_addr != NULL)
8495     func_desc_adjust (&htab->tls_get_addr->elf, info);
8496   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8497                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8498                                                  FALSE, FALSE, TRUE));
8499   if (htab->params->tls_get_addr_opt)
8500     {
8501       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8502
8503       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8504                                   FALSE, FALSE, TRUE);
8505       if (opt != NULL)
8506         func_desc_adjust (opt, info);
8507       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8508                                      FALSE, FALSE, TRUE);
8509       if (opt_fd != NULL
8510           && (opt_fd->root.type == bfd_link_hash_defined
8511               || opt_fd->root.type == bfd_link_hash_defweak))
8512         {
8513           /* If glibc supports an optimized __tls_get_addr call stub,
8514              signalled by the presence of __tls_get_addr_opt, and we'll
8515              be calling __tls_get_addr via a plt call stub, then
8516              make __tls_get_addr point to __tls_get_addr_opt.  */
8517           tga_fd = &htab->tls_get_addr_fd->elf;
8518           if (htab->elf.dynamic_sections_created
8519               && tga_fd != NULL
8520               && (tga_fd->type == STT_FUNC
8521                   || tga_fd->needs_plt)
8522               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8523                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8524             {
8525               struct plt_entry *ent;
8526
8527               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8528                 if (ent->plt.refcount > 0)
8529                   break;
8530               if (ent != NULL)
8531                 {
8532                   tga_fd->root.type = bfd_link_hash_indirect;
8533                   tga_fd->root.u.i.link = &opt_fd->root;
8534                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8535                   opt_fd->mark = 1;
8536                   if (opt_fd->dynindx != -1)
8537                     {
8538                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8539                       opt_fd->dynindx = -1;
8540                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8541                                               opt_fd->dynstr_index);
8542                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8543                         return NULL;
8544                     }
8545                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8546                   tga = &htab->tls_get_addr->elf;
8547                   if (opt != NULL && tga != NULL)
8548                     {
8549                       tga->root.type = bfd_link_hash_indirect;
8550                       tga->root.u.i.link = &opt->root;
8551                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8552                       opt->mark = 1;
8553                       _bfd_elf_link_hash_hide_symbol (info, opt,
8554                                                       tga->forced_local);
8555                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8556                     }
8557                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8558                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8559                   if (htab->tls_get_addr != NULL)
8560                     {
8561                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8562                       htab->tls_get_addr->is_func = 1;
8563                     }
8564                 }
8565             }
8566         }
8567       else if (htab->params->tls_get_addr_opt < 0)
8568         htab->params->tls_get_addr_opt = 0;
8569     }
8570   return _bfd_elf_tls_setup (info->output_bfd, info);
8571 }
8572
8573 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8574    HASH1 or HASH2.  */
8575
8576 static bfd_boolean
8577 branch_reloc_hash_match (const bfd *ibfd,
8578                          const Elf_Internal_Rela *rel,
8579                          const struct ppc_link_hash_entry *hash1,
8580                          const struct ppc_link_hash_entry *hash2)
8581 {
8582   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8583   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8584   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8585
8586   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8587     {
8588       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8589       struct elf_link_hash_entry *h;
8590
8591       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8592       h = elf_follow_link (h);
8593       if (h == &hash1->elf || h == &hash2->elf)
8594         return TRUE;
8595     }
8596   return FALSE;
8597 }
8598
8599 /* Run through all the TLS relocs looking for optimization
8600    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8601    a preliminary section layout so that we know the TLS segment
8602    offsets.  We can't optimize earlier because some optimizations need
8603    to know the tp offset, and we need to optimize before allocating
8604    dynamic relocations.  */
8605
8606 bfd_boolean
8607 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8608 {
8609   bfd *ibfd;
8610   asection *sec;
8611   struct ppc_link_hash_table *htab;
8612   unsigned char *toc_ref;
8613   int pass;
8614
8615   if (!bfd_link_executable (info))
8616     return TRUE;
8617
8618   htab = ppc_hash_table (info);
8619   if (htab == NULL)
8620     return FALSE;
8621
8622   /* Make two passes over the relocs.  On the first pass, mark toc
8623      entries involved with tls relocs, and check that tls relocs
8624      involved in setting up a tls_get_addr call are indeed followed by
8625      such a call.  If they are not, we can't do any tls optimization.
8626      On the second pass twiddle tls_mask flags to notify
8627      relocate_section that optimization can be done, and adjust got
8628      and plt refcounts.  */
8629   toc_ref = NULL;
8630   for (pass = 0; pass < 2; ++pass)
8631     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8632       {
8633         Elf_Internal_Sym *locsyms = NULL;
8634         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8635
8636         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8637           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8638             {
8639               Elf_Internal_Rela *relstart, *rel, *relend;
8640               bfd_boolean found_tls_get_addr_arg = 0;
8641
8642               /* Read the relocations.  */
8643               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8644                                                     info->keep_memory);
8645               if (relstart == NULL)
8646                 {
8647                   free (toc_ref);
8648                   return FALSE;
8649                 }
8650
8651               relend = relstart + sec->reloc_count;
8652               for (rel = relstart; rel < relend; rel++)
8653                 {
8654                   enum elf_ppc64_reloc_type r_type;
8655                   unsigned long r_symndx;
8656                   struct elf_link_hash_entry *h;
8657                   Elf_Internal_Sym *sym;
8658                   asection *sym_sec;
8659                   unsigned char *tls_mask;
8660                   unsigned char tls_set, tls_clear, tls_type = 0;
8661                   bfd_vma value;
8662                   bfd_boolean ok_tprel, is_local;
8663                   long toc_ref_index = 0;
8664                   int expecting_tls_get_addr = 0;
8665                   bfd_boolean ret = FALSE;
8666
8667                   r_symndx = ELF64_R_SYM (rel->r_info);
8668                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8669                                   r_symndx, ibfd))
8670                     {
8671                     err_free_rel:
8672                       if (elf_section_data (sec)->relocs != relstart)
8673                         free (relstart);
8674                       if (toc_ref != NULL)
8675                         free (toc_ref);
8676                       if (locsyms != NULL
8677                           && (elf_symtab_hdr (ibfd).contents
8678                               != (unsigned char *) locsyms))
8679                         free (locsyms);
8680                       return ret;
8681                     }
8682
8683                   if (h != NULL)
8684                     {
8685                       if (h->root.type == bfd_link_hash_defined
8686                           || h->root.type == bfd_link_hash_defweak)
8687                         value = h->root.u.def.value;
8688                       else if (h->root.type == bfd_link_hash_undefweak)
8689                         value = 0;
8690                       else
8691                         {
8692                           found_tls_get_addr_arg = 0;
8693                           continue;
8694                         }
8695                     }
8696                   else
8697                     /* Symbols referenced by TLS relocs must be of type
8698                        STT_TLS.  So no need for .opd local sym adjust.  */
8699                     value = sym->st_value;
8700
8701                   ok_tprel = FALSE;
8702                   is_local = FALSE;
8703                   if (h == NULL
8704                       || !h->def_dynamic)
8705                     {
8706                       is_local = TRUE;
8707                       if (h != NULL
8708                           && h->root.type == bfd_link_hash_undefweak)
8709                         ok_tprel = TRUE;
8710                       else if (sym_sec != NULL
8711                                && sym_sec->output_section != NULL)
8712                         {
8713                           value += sym_sec->output_offset;
8714                           value += sym_sec->output_section->vma;
8715                           value -= htab->elf.tls_sec->vma;
8716                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8717                                       < (bfd_vma) 1 << 32);
8718                         }
8719                     }
8720
8721                   r_type = ELF64_R_TYPE (rel->r_info);
8722                   /* If this section has old-style __tls_get_addr calls
8723                      without marker relocs, then check that each
8724                      __tls_get_addr call reloc is preceded by a reloc
8725                      that conceivably belongs to the __tls_get_addr arg
8726                      setup insn.  If we don't find matching arg setup
8727                      relocs, don't do any tls optimization.  */
8728                   if (pass == 0
8729                       && sec->has_tls_get_addr_call
8730                       && h != NULL
8731                       && (h == &htab->tls_get_addr->elf
8732                           || h == &htab->tls_get_addr_fd->elf)
8733                       && !found_tls_get_addr_arg
8734                       && is_branch_reloc (r_type))
8735                     {
8736                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8737                                                 "TLS optimization disabled\n"),
8738                                               ibfd, sec, rel->r_offset);
8739                       ret = TRUE;
8740                       goto err_free_rel;
8741                     }
8742
8743                   found_tls_get_addr_arg = 0;
8744                   switch (r_type)
8745                     {
8746                     case R_PPC64_GOT_TLSLD16:
8747                     case R_PPC64_GOT_TLSLD16_LO:
8748                       expecting_tls_get_addr = 1;
8749                       found_tls_get_addr_arg = 1;
8750                       /* Fall through.  */
8751
8752                     case R_PPC64_GOT_TLSLD16_HI:
8753                     case R_PPC64_GOT_TLSLD16_HA:
8754                       /* These relocs should never be against a symbol
8755                          defined in a shared lib.  Leave them alone if
8756                          that turns out to be the case.  */
8757                       if (!is_local)
8758                         continue;
8759
8760                       /* LD -> LE */
8761                       tls_set = 0;
8762                       tls_clear = TLS_LD;
8763                       tls_type = TLS_TLS | TLS_LD;
8764                       break;
8765
8766                     case R_PPC64_GOT_TLSGD16:
8767                     case R_PPC64_GOT_TLSGD16_LO:
8768                       expecting_tls_get_addr = 1;
8769                       found_tls_get_addr_arg = 1;
8770                       /* Fall through. */
8771
8772                     case R_PPC64_GOT_TLSGD16_HI:
8773                     case R_PPC64_GOT_TLSGD16_HA:
8774                       if (ok_tprel)
8775                         /* GD -> LE */
8776                         tls_set = 0;
8777                       else
8778                         /* GD -> IE */
8779                         tls_set = TLS_TLS | TLS_TPRELGD;
8780                       tls_clear = TLS_GD;
8781                       tls_type = TLS_TLS | TLS_GD;
8782                       break;
8783
8784                     case R_PPC64_GOT_TPREL16_DS:
8785                     case R_PPC64_GOT_TPREL16_LO_DS:
8786                     case R_PPC64_GOT_TPREL16_HI:
8787                     case R_PPC64_GOT_TPREL16_HA:
8788                       if (ok_tprel)
8789                         {
8790                           /* IE -> LE */
8791                           tls_set = 0;
8792                           tls_clear = TLS_TPREL;
8793                           tls_type = TLS_TLS | TLS_TPREL;
8794                           break;
8795                         }
8796                       continue;
8797
8798                     case R_PPC64_TLSGD:
8799                     case R_PPC64_TLSLD:
8800                       if (rel + 1 < relend
8801                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8802                         {
8803                           if (pass != 0
8804                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8805                             {
8806                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8807                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8808                                   r_symndx, ibfd))
8809                                 goto err_free_rel;
8810                               if (h != NULL)
8811                                 {
8812                                   struct plt_entry *ent = NULL;
8813
8814                                   for (ent = h->plt.plist;
8815                                        ent != NULL;
8816                                        ent = ent->next)
8817                                     if (ent->addend == rel[1].r_addend)
8818                                       break;
8819
8820                                   if (ent != NULL
8821                                       && ent->plt.refcount > 0)
8822                                     ent->plt.refcount -= 1;
8823                                 }
8824                             }
8825                           continue;
8826                         }
8827                       found_tls_get_addr_arg = 1;
8828                       /* Fall through.  */
8829
8830                     case R_PPC64_TLS:
8831                     case R_PPC64_TOC16:
8832                     case R_PPC64_TOC16_LO:
8833                       if (sym_sec == NULL || sym_sec != toc)
8834                         continue;
8835
8836                       /* Mark this toc entry as referenced by a TLS
8837                          code sequence.  We can do that now in the
8838                          case of R_PPC64_TLS, and after checking for
8839                          tls_get_addr for the TOC16 relocs.  */
8840                       if (toc_ref == NULL)
8841                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8842                       if (toc_ref == NULL)
8843                         goto err_free_rel;
8844
8845                       if (h != NULL)
8846                         value = h->root.u.def.value;
8847                       else
8848                         value = sym->st_value;
8849                       value += rel->r_addend;
8850                       if (value % 8 != 0)
8851                         continue;
8852                       BFD_ASSERT (value < toc->size
8853                                   && toc->output_offset % 8 == 0);
8854                       toc_ref_index = (value + toc->output_offset) / 8;
8855                       if (r_type == R_PPC64_TLS
8856                           || r_type == R_PPC64_TLSGD
8857                           || r_type == R_PPC64_TLSLD)
8858                         {
8859                           toc_ref[toc_ref_index] = 1;
8860                           continue;
8861                         }
8862
8863                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8864                         continue;
8865
8866                       tls_set = 0;
8867                       tls_clear = 0;
8868                       expecting_tls_get_addr = 2;
8869                       break;
8870
8871                     case R_PPC64_TPREL64:
8872                       if (pass == 0
8873                           || sec != toc
8874                           || toc_ref == NULL
8875                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8876                         continue;
8877                       if (ok_tprel)
8878                         {
8879                           /* IE -> LE */
8880                           tls_set = TLS_EXPLICIT;
8881                           tls_clear = TLS_TPREL;
8882                           break;
8883                         }
8884                       continue;
8885
8886                     case R_PPC64_DTPMOD64:
8887                       if (pass == 0
8888                           || sec != toc
8889                           || toc_ref == NULL
8890                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8891                         continue;
8892                       if (rel + 1 < relend
8893                           && (rel[1].r_info
8894                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8895                           && rel[1].r_offset == rel->r_offset + 8)
8896                         {
8897                           if (ok_tprel)
8898                             /* GD -> LE */
8899                             tls_set = TLS_EXPLICIT | TLS_GD;
8900                           else
8901                             /* GD -> IE */
8902                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8903                           tls_clear = TLS_GD;
8904                         }
8905                       else
8906                         {
8907                           if (!is_local)
8908                             continue;
8909
8910                           /* LD -> LE */
8911                           tls_set = TLS_EXPLICIT;
8912                           tls_clear = TLS_LD;
8913                         }
8914                       break;
8915
8916                     default:
8917                       continue;
8918                     }
8919
8920                   if (pass == 0)
8921                     {
8922                       if (!expecting_tls_get_addr
8923                           || !sec->has_tls_get_addr_call)
8924                         continue;
8925
8926                       if (rel + 1 < relend
8927                           && branch_reloc_hash_match (ibfd, rel + 1,
8928                                                       htab->tls_get_addr,
8929                                                       htab->tls_get_addr_fd))
8930                         {
8931                           if (expecting_tls_get_addr == 2)
8932                             {
8933                               /* Check for toc tls entries.  */
8934                               unsigned char *toc_tls;
8935                               int retval;
8936
8937                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8938                                                      &locsyms,
8939                                                      rel, ibfd);
8940                               if (retval == 0)
8941                                 goto err_free_rel;
8942                               if (toc_tls != NULL)
8943                                 {
8944                                   if ((*toc_tls & TLS_TLS) != 0
8945                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8946                                     found_tls_get_addr_arg = 1;
8947                                   if (retval > 1)
8948                                     toc_ref[toc_ref_index] = 1;
8949                                 }
8950                             }
8951                           continue;
8952                         }
8953
8954                       /* Uh oh, we didn't find the expected call.  We
8955                          could just mark this symbol to exclude it
8956                          from tls optimization but it's safer to skip
8957                          the entire optimization.  */
8958                       /* xgettext:c-format */
8959                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8960                                                 "TLS optimization disabled\n"),
8961                                               ibfd, sec, rel->r_offset);
8962                       ret = TRUE;
8963                       goto err_free_rel;
8964                     }
8965
8966                   /* If we don't have old-style __tls_get_addr calls
8967                      without TLSGD/TLSLD marker relocs, and we haven't
8968                      found a new-style __tls_get_addr call with a
8969                      marker for this symbol, then we either have a
8970                      broken object file or an -mlongcall style
8971                      indirect call to __tls_get_addr without a marker.
8972                      Disable optimization in this case.  */
8973                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8974                       && (tls_set & TLS_EXPLICIT) == 0
8975                       && !sec->has_tls_get_addr_call
8976                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8977                           != (TLS_TLS | TLS_MARK)))
8978                     continue;
8979
8980                   if (expecting_tls_get_addr)
8981                     {
8982                       struct plt_entry *ent = NULL;
8983
8984                       if (htab->tls_get_addr != NULL)
8985                         for (ent = htab->tls_get_addr->elf.plt.plist;
8986                              ent != NULL;
8987                              ent = ent->next)
8988                           if (ent->addend == 0)
8989                             break;
8990
8991                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
8992                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8993                              ent != NULL;
8994                              ent = ent->next)
8995                           if (ent->addend == 0)
8996                             break;
8997
8998                       if (ent != NULL
8999                           && ent->plt.refcount > 0)
9000                         ent->plt.refcount -= 1;
9001                     }
9002
9003                   if (tls_clear == 0)
9004                     continue;
9005
9006                   if ((tls_set & TLS_EXPLICIT) == 0)
9007                     {
9008                       struct got_entry *ent;
9009
9010                       /* Adjust got entry for this reloc.  */
9011                       if (h != NULL)
9012                         ent = h->got.glist;
9013                       else
9014                         ent = elf_local_got_ents (ibfd)[r_symndx];
9015
9016                       for (; ent != NULL; ent = ent->next)
9017                         if (ent->addend == rel->r_addend
9018                             && ent->owner == ibfd
9019                             && ent->tls_type == tls_type)
9020                           break;
9021                       if (ent == NULL)
9022                         abort ();
9023
9024                       if (tls_set == 0)
9025                         {
9026                           /* We managed to get rid of a got entry.  */
9027                           if (ent->got.refcount > 0)
9028                             ent->got.refcount -= 1;
9029                         }
9030                     }
9031                   else
9032                     {
9033                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
9034                          we'll lose one or two dyn relocs.  */
9035                       if (!dec_dynrel_count (rel->r_info, sec, info,
9036                                              NULL, h, sym))
9037                         return FALSE;
9038
9039                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
9040                         {
9041                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9042                                                  NULL, h, sym))
9043                             return FALSE;
9044                         }
9045                     }
9046
9047                   *tls_mask |= tls_set;
9048                   *tls_mask &= ~tls_clear;
9049                 }
9050
9051               if (elf_section_data (sec)->relocs != relstart)
9052                 free (relstart);
9053             }
9054
9055         if (locsyms != NULL
9056             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9057           {
9058             if (!info->keep_memory)
9059               free (locsyms);
9060             else
9061               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9062           }
9063       }
9064
9065   if (toc_ref != NULL)
9066     free (toc_ref);
9067   htab->do_tls_opt = 1;
9068   return TRUE;
9069 }
9070
9071 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9072    the values of any global symbols in a toc section that has been
9073    edited.  Globals in toc sections should be a rarity, so this function
9074    sets a flag if any are found in toc sections other than the one just
9075    edited, so that further hash table traversals can be avoided.  */
9076
9077 struct adjust_toc_info
9078 {
9079   asection *toc;
9080   unsigned long *skip;
9081   bfd_boolean global_toc_syms;
9082 };
9083
9084 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9085
9086 static bfd_boolean
9087 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9088 {
9089   struct ppc_link_hash_entry *eh;
9090   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9091   unsigned long i;
9092
9093   if (h->root.type != bfd_link_hash_defined
9094       && h->root.type != bfd_link_hash_defweak)
9095     return TRUE;
9096
9097   eh = (struct ppc_link_hash_entry *) h;
9098   if (eh->adjust_done)
9099     return TRUE;
9100
9101   if (eh->elf.root.u.def.section == toc_inf->toc)
9102     {
9103       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9104         i = toc_inf->toc->rawsize >> 3;
9105       else
9106         i = eh->elf.root.u.def.value >> 3;
9107
9108       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9109         {
9110           _bfd_error_handler
9111             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9112           do
9113             ++i;
9114           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9115           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9116         }
9117
9118       eh->elf.root.u.def.value -= toc_inf->skip[i];
9119       eh->adjust_done = 1;
9120     }
9121   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9122     toc_inf->global_toc_syms = TRUE;
9123
9124   return TRUE;
9125 }
9126
9127 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9128    on a _LO variety toc/got reloc.  */
9129
9130 static bfd_boolean
9131 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9132 {
9133   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9134           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9135           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9136           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9137           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9138           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9139           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9140           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9141           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9142           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9143           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9144           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9145           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9146           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9147           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9148           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9149           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9150               /* Exclude lfqu by testing reloc.  If relocs are ever
9151                  defined for the reduced D field in psq_lu then those
9152                  will need testing too.  */
9153               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9154           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9155               && (insn & 1) == 0)
9156           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9157           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9158               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9159               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9160           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9161               && (insn & 1) == 0));
9162 }
9163
9164 /* Examine all relocs referencing .toc sections in order to remove
9165    unused .toc entries.  */
9166
9167 bfd_boolean
9168 ppc64_elf_edit_toc (struct bfd_link_info *info)
9169 {
9170   bfd *ibfd;
9171   struct adjust_toc_info toc_inf;
9172   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9173
9174   htab->do_toc_opt = 1;
9175   toc_inf.global_toc_syms = TRUE;
9176   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9177     {
9178       asection *toc, *sec;
9179       Elf_Internal_Shdr *symtab_hdr;
9180       Elf_Internal_Sym *local_syms;
9181       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9182       unsigned long *skip, *drop;
9183       unsigned char *used;
9184       unsigned char *keep, last, some_unused;
9185
9186       if (!is_ppc64_elf (ibfd))
9187         continue;
9188
9189       toc = bfd_get_section_by_name (ibfd, ".toc");
9190       if (toc == NULL
9191           || toc->size == 0
9192           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9193           || discarded_section (toc))
9194         continue;
9195
9196       toc_relocs = NULL;
9197       local_syms = NULL;
9198       symtab_hdr = &elf_symtab_hdr (ibfd);
9199
9200       /* Look at sections dropped from the final link.  */
9201       skip = NULL;
9202       relstart = NULL;
9203       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9204         {
9205           if (sec->reloc_count == 0
9206               || !discarded_section (sec)
9207               || get_opd_info (sec)
9208               || (sec->flags & SEC_ALLOC) == 0
9209               || (sec->flags & SEC_DEBUGGING) != 0)
9210             continue;
9211
9212           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9213           if (relstart == NULL)
9214             goto error_ret;
9215
9216           /* Run through the relocs to see which toc entries might be
9217              unused.  */
9218           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9219             {
9220               enum elf_ppc64_reloc_type r_type;
9221               unsigned long r_symndx;
9222               asection *sym_sec;
9223               struct elf_link_hash_entry *h;
9224               Elf_Internal_Sym *sym;
9225               bfd_vma val;
9226
9227               r_type = ELF64_R_TYPE (rel->r_info);
9228               switch (r_type)
9229                 {
9230                 default:
9231                   continue;
9232
9233                 case R_PPC64_TOC16:
9234                 case R_PPC64_TOC16_LO:
9235                 case R_PPC64_TOC16_HI:
9236                 case R_PPC64_TOC16_HA:
9237                 case R_PPC64_TOC16_DS:
9238                 case R_PPC64_TOC16_LO_DS:
9239                   break;
9240                 }
9241
9242               r_symndx = ELF64_R_SYM (rel->r_info);
9243               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9244                               r_symndx, ibfd))
9245                 goto error_ret;
9246
9247               if (sym_sec != toc)
9248                 continue;
9249
9250               if (h != NULL)
9251                 val = h->root.u.def.value;
9252               else
9253                 val = sym->st_value;
9254               val += rel->r_addend;
9255
9256               if (val >= toc->size)
9257                 continue;
9258
9259               /* Anything in the toc ought to be aligned to 8 bytes.
9260                  If not, don't mark as unused.  */
9261               if (val & 7)
9262                 continue;
9263
9264               if (skip == NULL)
9265                 {
9266                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9267                   if (skip == NULL)
9268                     goto error_ret;
9269                 }
9270
9271               skip[val >> 3] = ref_from_discarded;
9272             }
9273
9274           if (elf_section_data (sec)->relocs != relstart)
9275             free (relstart);
9276         }
9277
9278       /* For largetoc loads of address constants, we can convert
9279          .  addis rx,2,addr@got@ha
9280          .  ld ry,addr@got@l(rx)
9281          to
9282          .  addis rx,2,addr@toc@ha
9283          .  addi ry,rx,addr@toc@l
9284          when addr is within 2G of the toc pointer.  This then means
9285          that the word storing "addr" in the toc is no longer needed.  */
9286
9287       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9288           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9289           && toc->reloc_count != 0)
9290         {
9291           /* Read toc relocs.  */
9292           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9293                                                   info->keep_memory);
9294           if (toc_relocs == NULL)
9295             goto error_ret;
9296
9297           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9298             {
9299               enum elf_ppc64_reloc_type r_type;
9300               unsigned long r_symndx;
9301               asection *sym_sec;
9302               struct elf_link_hash_entry *h;
9303               Elf_Internal_Sym *sym;
9304               bfd_vma val, addr;
9305
9306               r_type = ELF64_R_TYPE (rel->r_info);
9307               if (r_type != R_PPC64_ADDR64)
9308                 continue;
9309
9310               r_symndx = ELF64_R_SYM (rel->r_info);
9311               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9312                               r_symndx, ibfd))
9313                 goto error_ret;
9314
9315               if (sym_sec == NULL
9316                   || sym_sec->output_section == NULL
9317                   || discarded_section (sym_sec))
9318                 continue;
9319
9320               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9321                 continue;
9322
9323               if (h != NULL)
9324                 {
9325                   if (h->type == STT_GNU_IFUNC)
9326                     continue;
9327                   val = h->root.u.def.value;
9328                 }
9329               else
9330                 {
9331                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9332                     continue;
9333                   val = sym->st_value;
9334                 }
9335               val += rel->r_addend;
9336               val += sym_sec->output_section->vma + sym_sec->output_offset;
9337
9338               /* We don't yet know the exact toc pointer value, but we
9339                  know it will be somewhere in the toc section.  Don't
9340                  optimize if the difference from any possible toc
9341                  pointer is outside [ff..f80008000, 7fff7fff].  */
9342               addr = toc->output_section->vma + TOC_BASE_OFF;
9343               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9344                 continue;
9345
9346               addr = toc->output_section->vma + toc->output_section->rawsize;
9347               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9348                 continue;
9349
9350               if (skip == NULL)
9351                 {
9352                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9353                   if (skip == NULL)
9354                     goto error_ret;
9355                 }
9356
9357               skip[rel->r_offset >> 3]
9358                 |= can_optimize | ((rel - toc_relocs) << 2);
9359             }
9360         }
9361
9362       if (skip == NULL)
9363         continue;
9364
9365       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9366       if (used == NULL)
9367         {
9368         error_ret:
9369           if (local_syms != NULL
9370               && symtab_hdr->contents != (unsigned char *) local_syms)
9371             free (local_syms);
9372           if (sec != NULL
9373               && relstart != NULL
9374               && elf_section_data (sec)->relocs != relstart)
9375             free (relstart);
9376           if (toc_relocs != NULL
9377               && elf_section_data (toc)->relocs != toc_relocs)
9378             free (toc_relocs);
9379           if (skip != NULL)
9380             free (skip);
9381           return FALSE;
9382         }
9383
9384       /* Now check all kept sections that might reference the toc.
9385          Check the toc itself last.  */
9386       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9387                   : ibfd->sections);
9388            sec != NULL;
9389            sec = (sec == toc ? NULL
9390                   : sec->next == NULL ? toc
9391                   : sec->next == toc && toc->next ? toc->next
9392                   : sec->next))
9393         {
9394           int repeat;
9395
9396           if (sec->reloc_count == 0
9397               || discarded_section (sec)
9398               || get_opd_info (sec)
9399               || (sec->flags & SEC_ALLOC) == 0
9400               || (sec->flags & SEC_DEBUGGING) != 0)
9401             continue;
9402
9403           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9404                                                 info->keep_memory);
9405           if (relstart == NULL)
9406             {
9407               free (used);
9408               goto error_ret;
9409             }
9410
9411           /* Mark toc entries referenced as used.  */
9412           do
9413             {
9414               repeat = 0;
9415               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9416                 {
9417                   enum elf_ppc64_reloc_type r_type;
9418                   unsigned long r_symndx;
9419                   asection *sym_sec;
9420                   struct elf_link_hash_entry *h;
9421                   Elf_Internal_Sym *sym;
9422                   bfd_vma val;
9423                   enum {no_check, check_lo, check_ha} insn_check;
9424
9425                   r_type = ELF64_R_TYPE (rel->r_info);
9426                   switch (r_type)
9427                     {
9428                     default:
9429                       insn_check = no_check;
9430                       break;
9431
9432                     case R_PPC64_GOT_TLSLD16_HA:
9433                     case R_PPC64_GOT_TLSGD16_HA:
9434                     case R_PPC64_GOT_TPREL16_HA:
9435                     case R_PPC64_GOT_DTPREL16_HA:
9436                     case R_PPC64_GOT16_HA:
9437                     case R_PPC64_TOC16_HA:
9438                       insn_check = check_ha;
9439                       break;
9440
9441                     case R_PPC64_GOT_TLSLD16_LO:
9442                     case R_PPC64_GOT_TLSGD16_LO:
9443                     case R_PPC64_GOT_TPREL16_LO_DS:
9444                     case R_PPC64_GOT_DTPREL16_LO_DS:
9445                     case R_PPC64_GOT16_LO:
9446                     case R_PPC64_GOT16_LO_DS:
9447                     case R_PPC64_TOC16_LO:
9448                     case R_PPC64_TOC16_LO_DS:
9449                       insn_check = check_lo;
9450                       break;
9451                     }
9452
9453                   if (insn_check != no_check)
9454                     {
9455                       bfd_vma off = rel->r_offset & ~3;
9456                       unsigned char buf[4];
9457                       unsigned int insn;
9458
9459                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9460                         {
9461                           free (used);
9462                           goto error_ret;
9463                         }
9464                       insn = bfd_get_32 (ibfd, buf);
9465                       if (insn_check == check_lo
9466                           ? !ok_lo_toc_insn (insn, r_type)
9467                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9468                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9469                         {
9470                           char str[12];
9471
9472                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9473                           sprintf (str, "%#08x", insn);
9474                           info->callbacks->einfo
9475                             /* xgettext:c-format */
9476                             (_("%H: toc optimization is not supported for"
9477                                " %s instruction\n"),
9478                              ibfd, sec, rel->r_offset & ~3, str);
9479                         }
9480                     }
9481
9482                   switch (r_type)
9483                     {
9484                     case R_PPC64_TOC16:
9485                     case R_PPC64_TOC16_LO:
9486                     case R_PPC64_TOC16_HI:
9487                     case R_PPC64_TOC16_HA:
9488                     case R_PPC64_TOC16_DS:
9489                     case R_PPC64_TOC16_LO_DS:
9490                       /* In case we're taking addresses of toc entries.  */
9491                     case R_PPC64_ADDR64:
9492                       break;
9493
9494                     default:
9495                       continue;
9496                     }
9497
9498                   r_symndx = ELF64_R_SYM (rel->r_info);
9499                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9500                                   r_symndx, ibfd))
9501                     {
9502                       free (used);
9503                       goto error_ret;
9504                     }
9505
9506                   if (sym_sec != toc)
9507                     continue;
9508
9509                   if (h != NULL)
9510                     val = h->root.u.def.value;
9511                   else
9512                     val = sym->st_value;
9513                   val += rel->r_addend;
9514
9515                   if (val >= toc->size)
9516                     continue;
9517
9518                   if ((skip[val >> 3] & can_optimize) != 0)
9519                     {
9520                       bfd_vma off;
9521                       unsigned char opc;
9522
9523                       switch (r_type)
9524                         {
9525                         case R_PPC64_TOC16_HA:
9526                           break;
9527
9528                         case R_PPC64_TOC16_LO_DS:
9529                           off = rel->r_offset;
9530                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9531                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9532                                                          off, 1))
9533                             {
9534                               free (used);
9535                               goto error_ret;
9536                             }
9537                           if ((opc & (0x3f << 2)) == (58u << 2))
9538                             break;
9539                           /* Fall through.  */
9540
9541                         default:
9542                           /* Wrong sort of reloc, or not a ld.  We may
9543                              as well clear ref_from_discarded too.  */
9544                           skip[val >> 3] = 0;
9545                         }
9546                     }
9547
9548                   if (sec != toc)
9549                     used[val >> 3] = 1;
9550                   /* For the toc section, we only mark as used if this
9551                      entry itself isn't unused.  */
9552                   else if ((used[rel->r_offset >> 3]
9553                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9554                            && !used[val >> 3])
9555                     {
9556                       /* Do all the relocs again, to catch reference
9557                          chains.  */
9558                       repeat = 1;
9559                       used[val >> 3] = 1;
9560                     }
9561                 }
9562             }
9563           while (repeat);
9564
9565           if (elf_section_data (sec)->relocs != relstart)
9566             free (relstart);
9567         }
9568
9569       /* Merge the used and skip arrays.  Assume that TOC
9570          doublewords not appearing as either used or unused belong
9571          to an entry more than one doubleword in size.  */
9572       for (drop = skip, keep = used, last = 0, some_unused = 0;
9573            drop < skip + (toc->size + 7) / 8;
9574            ++drop, ++keep)
9575         {
9576           if (*keep)
9577             {
9578               *drop &= ~ref_from_discarded;
9579               if ((*drop & can_optimize) != 0)
9580                 some_unused = 1;
9581               last = 0;
9582             }
9583           else if ((*drop & ref_from_discarded) != 0)
9584             {
9585               some_unused = 1;
9586               last = ref_from_discarded;
9587             }
9588           else
9589             *drop = last;
9590         }
9591
9592       free (used);
9593
9594       if (some_unused)
9595         {
9596           bfd_byte *contents, *src;
9597           unsigned long off;
9598           Elf_Internal_Sym *sym;
9599           bfd_boolean local_toc_syms = FALSE;
9600
9601           /* Shuffle the toc contents, and at the same time convert the
9602              skip array from booleans into offsets.  */
9603           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9604             goto error_ret;
9605
9606           elf_section_data (toc)->this_hdr.contents = contents;
9607
9608           for (src = contents, off = 0, drop = skip;
9609                src < contents + toc->size;
9610                src += 8, ++drop)
9611             {
9612               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9613                 off += 8;
9614               else if (off != 0)
9615                 {
9616                   *drop = off;
9617                   memcpy (src - off, src, 8);
9618                 }
9619             }
9620           *drop = off;
9621           toc->rawsize = toc->size;
9622           toc->size = src - contents - off;
9623
9624           /* Adjust addends for relocs against the toc section sym,
9625              and optimize any accesses we can.  */
9626           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9627             {
9628               if (sec->reloc_count == 0
9629                   || discarded_section (sec))
9630                 continue;
9631
9632               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9633                                                     info->keep_memory);
9634               if (relstart == NULL)
9635                 goto error_ret;
9636
9637               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9638                 {
9639                   enum elf_ppc64_reloc_type r_type;
9640                   unsigned long r_symndx;
9641                   asection *sym_sec;
9642                   struct elf_link_hash_entry *h;
9643                   bfd_vma val;
9644
9645                   r_type = ELF64_R_TYPE (rel->r_info);
9646                   switch (r_type)
9647                     {
9648                     default:
9649                       continue;
9650
9651                     case R_PPC64_TOC16:
9652                     case R_PPC64_TOC16_LO:
9653                     case R_PPC64_TOC16_HI:
9654                     case R_PPC64_TOC16_HA:
9655                     case R_PPC64_TOC16_DS:
9656                     case R_PPC64_TOC16_LO_DS:
9657                     case R_PPC64_ADDR64:
9658                       break;
9659                     }
9660
9661                   r_symndx = ELF64_R_SYM (rel->r_info);
9662                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9663                                   r_symndx, ibfd))
9664                     goto error_ret;
9665
9666                   if (sym_sec != toc)
9667                     continue;
9668
9669                   if (h != NULL)
9670                     val = h->root.u.def.value;
9671                   else
9672                     {
9673                       val = sym->st_value;
9674                       if (val != 0)
9675                         local_toc_syms = TRUE;
9676                     }
9677
9678                   val += rel->r_addend;
9679
9680                   if (val > toc->rawsize)
9681                     val = toc->rawsize;
9682                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9683                     continue;
9684                   else if ((skip[val >> 3] & can_optimize) != 0)
9685                     {
9686                       Elf_Internal_Rela *tocrel
9687                         = toc_relocs + (skip[val >> 3] >> 2);
9688                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9689
9690                       switch (r_type)
9691                         {
9692                         case R_PPC64_TOC16_HA:
9693                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9694                           break;
9695
9696                         case R_PPC64_TOC16_LO_DS:
9697                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9698                           break;
9699
9700                         default:
9701                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9702                             ppc_howto_init ();
9703                           info->callbacks->einfo
9704                             /* xgettext:c-format */
9705                             (_("%H: %s references "
9706                                "optimized away TOC entry\n"),
9707                              ibfd, sec, rel->r_offset,
9708                              ppc64_elf_howto_table[r_type]->name);
9709                           bfd_set_error (bfd_error_bad_value);
9710                           goto error_ret;
9711                         }
9712                       rel->r_addend = tocrel->r_addend;
9713                       elf_section_data (sec)->relocs = relstart;
9714                       continue;
9715                     }
9716
9717                   if (h != NULL || sym->st_value != 0)
9718                     continue;
9719
9720                   rel->r_addend -= skip[val >> 3];
9721                   elf_section_data (sec)->relocs = relstart;
9722                 }
9723
9724               if (elf_section_data (sec)->relocs != relstart)
9725                 free (relstart);
9726             }
9727
9728           /* We shouldn't have local or global symbols defined in the TOC,
9729              but handle them anyway.  */
9730           if (local_syms != NULL)
9731             for (sym = local_syms;
9732                  sym < local_syms + symtab_hdr->sh_info;
9733                  ++sym)
9734               if (sym->st_value != 0
9735                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9736                 {
9737                   unsigned long i;
9738
9739                   if (sym->st_value > toc->rawsize)
9740                     i = toc->rawsize >> 3;
9741                   else
9742                     i = sym->st_value >> 3;
9743
9744                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9745                     {
9746                       if (local_toc_syms)
9747                         _bfd_error_handler
9748                           (_("%s defined on removed toc entry"),
9749                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9750                       do
9751                         ++i;
9752                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9753                       sym->st_value = (bfd_vma) i << 3;
9754                     }
9755
9756                   sym->st_value -= skip[i];
9757                   symtab_hdr->contents = (unsigned char *) local_syms;
9758                 }
9759
9760           /* Adjust any global syms defined in this toc input section.  */
9761           if (toc_inf.global_toc_syms)
9762             {
9763               toc_inf.toc = toc;
9764               toc_inf.skip = skip;
9765               toc_inf.global_toc_syms = FALSE;
9766               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9767                                       &toc_inf);
9768             }
9769
9770           if (toc->reloc_count != 0)
9771             {
9772               Elf_Internal_Shdr *rel_hdr;
9773               Elf_Internal_Rela *wrel;
9774               bfd_size_type sz;
9775
9776               /* Remove unused toc relocs, and adjust those we keep.  */
9777               if (toc_relocs == NULL)
9778                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9779                                                         info->keep_memory);
9780               if (toc_relocs == NULL)
9781                 goto error_ret;
9782
9783               wrel = toc_relocs;
9784               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9785                 if ((skip[rel->r_offset >> 3]
9786                      & (ref_from_discarded | can_optimize)) == 0)
9787                   {
9788                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9789                     wrel->r_info = rel->r_info;
9790                     wrel->r_addend = rel->r_addend;
9791                     ++wrel;
9792                   }
9793                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9794                                             &local_syms, NULL, NULL))
9795                   goto error_ret;
9796
9797               elf_section_data (toc)->relocs = toc_relocs;
9798               toc->reloc_count = wrel - toc_relocs;
9799               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9800               sz = rel_hdr->sh_entsize;
9801               rel_hdr->sh_size = toc->reloc_count * sz;
9802             }
9803         }
9804       else if (toc_relocs != NULL
9805                && elf_section_data (toc)->relocs != toc_relocs)
9806         free (toc_relocs);
9807
9808       if (local_syms != NULL
9809           && symtab_hdr->contents != (unsigned char *) local_syms)
9810         {
9811           if (!info->keep_memory)
9812             free (local_syms);
9813           else
9814             symtab_hdr->contents = (unsigned char *) local_syms;
9815         }
9816       free (skip);
9817     }
9818
9819   return TRUE;
9820 }
9821
9822 /* Return true iff input section I references the TOC using
9823    instructions limited to +/-32k offsets.  */
9824
9825 bfd_boolean
9826 ppc64_elf_has_small_toc_reloc (asection *i)
9827 {
9828   return (is_ppc64_elf (i->owner)
9829           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9830 }
9831
9832 /* Allocate space for one GOT entry.  */
9833
9834 static void
9835 allocate_got (struct elf_link_hash_entry *h,
9836               struct bfd_link_info *info,
9837               struct got_entry *gent)
9838 {
9839   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9840   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9841   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9842                  ? 16 : 8);
9843   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9844                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9845   asection *got = ppc64_elf_tdata (gent->owner)->got;
9846
9847   gent->got.offset = got->size;
9848   got->size += entsize;
9849
9850   if (h->type == STT_GNU_IFUNC)
9851     {
9852       htab->elf.irelplt->size += rentsize;
9853       htab->got_reli_size += rentsize;
9854     }
9855   else if (((bfd_link_pic (info)
9856              && !((gent->tls_type & TLS_TPREL) != 0
9857                   && bfd_link_executable (info)
9858                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9859             || (htab->elf.dynamic_sections_created
9860                 && h->dynindx != -1
9861                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9862            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9863     {
9864       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9865       relgot->size += rentsize;
9866     }
9867 }
9868
9869 /* This function merges got entries in the same toc group.  */
9870
9871 static void
9872 merge_got_entries (struct got_entry **pent)
9873 {
9874   struct got_entry *ent, *ent2;
9875
9876   for (ent = *pent; ent != NULL; ent = ent->next)
9877     if (!ent->is_indirect)
9878       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9879         if (!ent2->is_indirect
9880             && ent2->addend == ent->addend
9881             && ent2->tls_type == ent->tls_type
9882             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9883           {
9884             ent2->is_indirect = TRUE;
9885             ent2->got.ent = ent;
9886           }
9887 }
9888
9889 /* If H is undefined, make it dynamic if that makes sense.  */
9890
9891 static bfd_boolean
9892 ensure_undef_dynamic (struct bfd_link_info *info,
9893                       struct elf_link_hash_entry *h)
9894 {
9895   struct elf_link_hash_table *htab = elf_hash_table (info);
9896
9897   if (htab->dynamic_sections_created
9898       && ((info->dynamic_undefined_weak != 0
9899            && h->root.type == bfd_link_hash_undefweak)
9900           || h->root.type == bfd_link_hash_undefined)
9901       && h->dynindx == -1
9902       && !h->forced_local
9903       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9904     return bfd_elf_link_record_dynamic_symbol (info, h);
9905   return TRUE;
9906 }
9907
9908 /* Allocate space in .plt, .got and associated reloc sections for
9909    dynamic relocs.  */
9910
9911 static bfd_boolean
9912 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9913 {
9914   struct bfd_link_info *info;
9915   struct ppc_link_hash_table *htab;
9916   asection *s;
9917   struct ppc_link_hash_entry *eh;
9918   struct got_entry **pgent, *gent;
9919
9920   if (h->root.type == bfd_link_hash_indirect)
9921     return TRUE;
9922
9923   info = (struct bfd_link_info *) inf;
9924   htab = ppc_hash_table (info);
9925   if (htab == NULL)
9926     return FALSE;
9927
9928   eh = (struct ppc_link_hash_entry *) h;
9929   /* Run through the TLS GD got entries first if we're changing them
9930      to TPREL.  */
9931   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9932     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9933       if (gent->got.refcount > 0
9934           && (gent->tls_type & TLS_GD) != 0)
9935         {
9936           /* This was a GD entry that has been converted to TPREL.  If
9937              there happens to be a TPREL entry we can use that one.  */
9938           struct got_entry *ent;
9939           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9940             if (ent->got.refcount > 0
9941                 && (ent->tls_type & TLS_TPREL) != 0
9942                 && ent->addend == gent->addend
9943                 && ent->owner == gent->owner)
9944               {
9945                 gent->got.refcount = 0;
9946                 break;
9947               }
9948
9949           /* If not, then we'll be using our own TPREL entry.  */
9950           if (gent->got.refcount != 0)
9951             gent->tls_type = TLS_TLS | TLS_TPREL;
9952         }
9953
9954   /* Remove any list entry that won't generate a word in the GOT before
9955      we call merge_got_entries.  Otherwise we risk merging to empty
9956      entries.  */
9957   pgent = &h->got.glist;
9958   while ((gent = *pgent) != NULL)
9959     if (gent->got.refcount > 0)
9960       {
9961         if ((gent->tls_type & TLS_LD) != 0
9962             && !h->def_dynamic)
9963           {
9964             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9965             *pgent = gent->next;
9966           }
9967         else
9968           pgent = &gent->next;
9969       }
9970     else
9971       *pgent = gent->next;
9972
9973   if (!htab->do_multi_toc)
9974     merge_got_entries (&h->got.glist);
9975
9976   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9977     if (!gent->is_indirect)
9978       {
9979         /* Make sure this symbol is output as a dynamic symbol.  */
9980         if (!ensure_undef_dynamic (info, h))
9981           return FALSE;
9982
9983         if (!is_ppc64_elf (gent->owner))
9984           abort ();
9985
9986         allocate_got (h, info, gent);
9987       }
9988
9989   /* If no dynamic sections we can't have dynamic relocs, except for
9990      IFUNCs which are handled even in static executables.  */
9991   if (!htab->elf.dynamic_sections_created
9992       && h->type != STT_GNU_IFUNC)
9993     eh->dyn_relocs = NULL;
9994
9995   /* Discard relocs on undefined symbols that must be local.  */
9996   else if (h->root.type == bfd_link_hash_undefined
9997            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9998     eh->dyn_relocs = NULL;
9999
10000   /* Also discard relocs on undefined weak syms with non-default
10001      visibility, or when dynamic_undefined_weak says so.  */
10002   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10003     eh->dyn_relocs = NULL;
10004
10005   if (eh->dyn_relocs != NULL)
10006     {
10007       struct elf_dyn_relocs *p, **pp;
10008
10009       /* In the shared -Bsymbolic case, discard space allocated for
10010          dynamic pc-relative relocs against symbols which turn out to
10011          be defined in regular objects.  For the normal shared case,
10012          discard space for relocs that have become local due to symbol
10013          visibility changes.  */
10014
10015       if (bfd_link_pic (info))
10016         {
10017           /* Relocs that use pc_count are those that appear on a call
10018              insn, or certain REL relocs (see must_be_dyn_reloc) that
10019              can be generated via assembly.  We want calls to
10020              protected symbols to resolve directly to the function
10021              rather than going via the plt.  If people want function
10022              pointer comparisons to work as expected then they should
10023              avoid writing weird assembly.  */
10024           if (SYMBOL_CALLS_LOCAL (info, h))
10025             {
10026               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10027                 {
10028                   p->count -= p->pc_count;
10029                   p->pc_count = 0;
10030                   if (p->count == 0)
10031                     *pp = p->next;
10032                   else
10033                     pp = &p->next;
10034                 }
10035             }
10036
10037           if (eh->dyn_relocs != NULL)
10038             {
10039               /* Make sure this symbol is output as a dynamic symbol.  */
10040               if (!ensure_undef_dynamic (info, h))
10041                 return FALSE;
10042             }
10043         }
10044       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10045         {
10046           /* For the non-pic case, discard space for relocs against
10047              symbols which turn out to need copy relocs or are not
10048              dynamic.  */
10049           if (h->dynamic_adjusted
10050               && !h->def_regular
10051               && !ELF_COMMON_DEF_P (h))
10052             {
10053               /* Make sure this symbol is output as a dynamic symbol.  */
10054               if (!ensure_undef_dynamic (info, h))
10055                 return FALSE;
10056
10057               if (h->dynindx == -1)
10058                 eh->dyn_relocs = NULL;
10059             }
10060           else
10061             eh->dyn_relocs = NULL;
10062         }
10063
10064       /* Finally, allocate space.  */
10065       for (p = eh->dyn_relocs; p != NULL; p = p->next)
10066         {
10067           asection *sreloc = elf_section_data (p->sec)->sreloc;
10068           if (eh->elf.type == STT_GNU_IFUNC)
10069             sreloc = htab->elf.irelplt;
10070           sreloc->size += p->count * sizeof (Elf64_External_Rela);
10071         }
10072     }
10073
10074   /* We might need a PLT entry when the symbol
10075      a) is dynamic, or
10076      b) is an ifunc, or
10077      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10078      d) has plt16 relocs and we are linking statically.  */
10079   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10080       || h->type == STT_GNU_IFUNC
10081       || (h->needs_plt && h->dynamic_adjusted)
10082       || (h->needs_plt
10083           && h->def_regular
10084           && !htab->elf.dynamic_sections_created
10085           && !htab->can_convert_all_inline_plt
10086           && (((struct ppc_link_hash_entry *) h)->tls_mask
10087               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10088     {
10089       struct plt_entry *pent;
10090       bfd_boolean doneone = FALSE;
10091       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10092         if (pent->plt.refcount > 0)
10093           {
10094             if (!htab->elf.dynamic_sections_created
10095                 || h->dynindx == -1)
10096               {
10097                 if (h->type == STT_GNU_IFUNC)
10098                   {
10099                     s = htab->elf.iplt;
10100                     pent->plt.offset = s->size;
10101                     s->size += PLT_ENTRY_SIZE (htab);
10102                     s = htab->elf.irelplt;
10103                   }
10104                 else
10105                   {
10106                     s = htab->pltlocal;
10107                     pent->plt.offset = s->size;
10108                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10109                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10110                   }
10111               }
10112             else
10113               {
10114                 /* If this is the first .plt entry, make room for the special
10115                    first entry.  */
10116                 s = htab->elf.splt;
10117                 if (s->size == 0)
10118                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10119
10120                 pent->plt.offset = s->size;
10121
10122                 /* Make room for this entry.  */
10123                 s->size += PLT_ENTRY_SIZE (htab);
10124
10125                 /* Make room for the .glink code.  */
10126                 s = htab->glink;
10127                 if (s->size == 0)
10128                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
10129                 if (htab->opd_abi)
10130                   {
10131                     /* We need bigger stubs past index 32767.  */
10132                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10133                       s->size += 4;
10134                     s->size += 2*4;
10135                   }
10136                 else
10137                   s->size += 4;
10138
10139                 /* We also need to make an entry in the .rela.plt section.  */
10140                 s = htab->elf.srelplt;
10141               }
10142             if (s != NULL)
10143               s->size += sizeof (Elf64_External_Rela);
10144             doneone = TRUE;
10145           }
10146         else
10147           pent->plt.offset = (bfd_vma) -1;
10148       if (!doneone)
10149         {
10150           h->plt.plist = NULL;
10151           h->needs_plt = 0;
10152         }
10153     }
10154   else
10155     {
10156       h->plt.plist = NULL;
10157       h->needs_plt = 0;
10158     }
10159
10160   return TRUE;
10161 }
10162
10163 #define PPC_LO(v) ((v) & 0xffff)
10164 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10165 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10166
10167 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10168    to set up space for global entry stubs.  These are put in glink,
10169    after the branch table.  */
10170
10171 static bfd_boolean
10172 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10173 {
10174   struct bfd_link_info *info;
10175   struct ppc_link_hash_table *htab;
10176   struct plt_entry *pent;
10177   asection *s, *plt;
10178
10179   if (h->root.type == bfd_link_hash_indirect)
10180     return TRUE;
10181
10182   if (!h->pointer_equality_needed)
10183     return TRUE;
10184
10185   if (h->def_regular)
10186     return TRUE;
10187
10188   info = inf;
10189   htab = ppc_hash_table (info);
10190   if (htab == NULL)
10191     return FALSE;
10192
10193   s = htab->global_entry;
10194   plt = htab->elf.splt;
10195   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10196     if (pent->plt.offset != (bfd_vma) -1
10197         && pent->addend == 0)
10198       {
10199         /* For ELFv2, if this symbol is not defined in a regular file
10200            and we are not generating a shared library or pie, then we
10201            need to define the symbol in the executable on a call stub.
10202            This is to avoid text relocations.  */
10203         bfd_vma off, stub_align, stub_off, stub_size;
10204         unsigned int align_power;
10205
10206         stub_size = 16;
10207         stub_off = s->size;
10208         if (htab->params->plt_stub_align >= 0)
10209           align_power = htab->params->plt_stub_align;
10210         else
10211           align_power = -htab->params->plt_stub_align;
10212         /* Setting section alignment is delayed until we know it is
10213            non-empty.  Otherwise the .text output section will be
10214            aligned at least to plt_stub_align even when no global
10215            entry stubs are needed.  */
10216         if (s->alignment_power < align_power)
10217           s->alignment_power = align_power;
10218         stub_align = (bfd_vma) 1 << align_power;
10219         if (htab->params->plt_stub_align >= 0
10220             || ((((stub_off + stub_size - 1) & -stub_align)
10221                  - (stub_off & -stub_align))
10222                 > ((stub_size - 1) & -stub_align)))
10223           stub_off = (stub_off + stub_align - 1) & -stub_align;
10224         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10225         off -= stub_off + s->output_offset + s->output_section->vma;
10226         /* Note that for --plt-stub-align negative we have a possible
10227            dependency between stub offset and size.  Break that
10228            dependency by assuming the max stub size when calculating
10229            the stub offset.  */
10230         if (PPC_HA (off) == 0)
10231           stub_size -= 4;
10232         h->root.type = bfd_link_hash_defined;
10233         h->root.u.def.section = s;
10234         h->root.u.def.value = stub_off;
10235         s->size = stub_off + stub_size;
10236         break;
10237       }
10238   return TRUE;
10239 }
10240
10241 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10242    read-only sections.  */
10243
10244 static bfd_boolean
10245 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10246 {
10247   asection *sec;
10248
10249   if (h->root.type == bfd_link_hash_indirect)
10250     return TRUE;
10251
10252   sec = readonly_dynrelocs (h);
10253   if (sec != NULL)
10254     {
10255       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10256
10257       info->flags |= DF_TEXTREL;
10258       info->callbacks->minfo
10259         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10260          sec->owner, h->root.root.string, sec);
10261
10262       /* Not an error, just cut short the traversal.  */
10263       return FALSE;
10264     }
10265   return TRUE;
10266 }
10267
10268 /* Set the sizes of the dynamic sections.  */
10269
10270 static bfd_boolean
10271 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10272                                  struct bfd_link_info *info)
10273 {
10274   struct ppc_link_hash_table *htab;
10275   bfd *dynobj;
10276   asection *s;
10277   bfd_boolean relocs;
10278   bfd *ibfd;
10279   struct got_entry *first_tlsld;
10280
10281   htab = ppc_hash_table (info);
10282   if (htab == NULL)
10283     return FALSE;
10284
10285   dynobj = htab->elf.dynobj;
10286   if (dynobj == NULL)
10287     abort ();
10288
10289   if (htab->elf.dynamic_sections_created)
10290     {
10291       /* Set the contents of the .interp section to the interpreter.  */
10292       if (bfd_link_executable (info) && !info->nointerp)
10293         {
10294           s = bfd_get_linker_section (dynobj, ".interp");
10295           if (s == NULL)
10296             abort ();
10297           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10298           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10299         }
10300     }
10301
10302   /* Set up .got offsets for local syms, and space for local dynamic
10303      relocs.  */
10304   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10305     {
10306       struct got_entry **lgot_ents;
10307       struct got_entry **end_lgot_ents;
10308       struct plt_entry **local_plt;
10309       struct plt_entry **end_local_plt;
10310       unsigned char *lgot_masks;
10311       bfd_size_type locsymcount;
10312       Elf_Internal_Shdr *symtab_hdr;
10313
10314       if (!is_ppc64_elf (ibfd))
10315         continue;
10316
10317       for (s = ibfd->sections; s != NULL; s = s->next)
10318         {
10319           struct ppc_dyn_relocs *p;
10320
10321           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10322             {
10323               if (!bfd_is_abs_section (p->sec)
10324                   && bfd_is_abs_section (p->sec->output_section))
10325                 {
10326                   /* Input section has been discarded, either because
10327                      it is a copy of a linkonce section or due to
10328                      linker script /DISCARD/, so we'll be discarding
10329                      the relocs too.  */
10330                 }
10331               else if (p->count != 0)
10332                 {
10333                   asection *srel = elf_section_data (p->sec)->sreloc;
10334                   if (p->ifunc)
10335                     srel = htab->elf.irelplt;
10336                   srel->size += p->count * sizeof (Elf64_External_Rela);
10337                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10338                     info->flags |= DF_TEXTREL;
10339                 }
10340             }
10341         }
10342
10343       lgot_ents = elf_local_got_ents (ibfd);
10344       if (!lgot_ents)
10345         continue;
10346
10347       symtab_hdr = &elf_symtab_hdr (ibfd);
10348       locsymcount = symtab_hdr->sh_info;
10349       end_lgot_ents = lgot_ents + locsymcount;
10350       local_plt = (struct plt_entry **) end_lgot_ents;
10351       end_local_plt = local_plt + locsymcount;
10352       lgot_masks = (unsigned char *) end_local_plt;
10353       s = ppc64_elf_tdata (ibfd)->got;
10354       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10355         {
10356           struct got_entry **pent, *ent;
10357
10358           pent = lgot_ents;
10359           while ((ent = *pent) != NULL)
10360             if (ent->got.refcount > 0)
10361               {
10362                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10363                   {
10364                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10365                     *pent = ent->next;
10366                   }
10367                 else
10368                   {
10369                     unsigned int ent_size = 8;
10370                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10371
10372                     ent->got.offset = s->size;
10373                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10374                       {
10375                         ent_size *= 2;
10376                         rel_size *= 2;
10377                       }
10378                     s->size += ent_size;
10379                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10380                       {
10381                         htab->elf.irelplt->size += rel_size;
10382                         htab->got_reli_size += rel_size;
10383                       }
10384                     else if (bfd_link_pic (info)
10385                              && !((ent->tls_type & TLS_TPREL) != 0
10386                                   && bfd_link_executable (info)))
10387                       {
10388                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10389                         srel->size += rel_size;
10390                       }
10391                     pent = &ent->next;
10392                   }
10393               }
10394             else
10395               *pent = ent->next;
10396         }
10397
10398       /* Allocate space for plt calls to local syms.  */
10399       lgot_masks = (unsigned char *) end_local_plt;
10400       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10401         {
10402           struct plt_entry *ent;
10403
10404           for (ent = *local_plt; ent != NULL; ent = ent->next)
10405             if (ent->plt.refcount > 0)
10406               {
10407                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10408                   {
10409                     s = htab->elf.iplt;
10410                     ent->plt.offset = s->size;
10411                     s->size += PLT_ENTRY_SIZE (htab);
10412                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10413                   }
10414                 else if (htab->can_convert_all_inline_plt
10415                          || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10416                   ent->plt.offset = (bfd_vma) -1;
10417                 else
10418                   {
10419                     s = htab->pltlocal;
10420                     ent->plt.offset = s->size;
10421                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10422                     if (bfd_link_pic (info))
10423                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10424                   }
10425               }
10426             else
10427               ent->plt.offset = (bfd_vma) -1;
10428         }
10429     }
10430
10431   /* Allocate global sym .plt and .got entries, and space for global
10432      sym dynamic relocs.  */
10433   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10434
10435   if (!htab->opd_abi && !bfd_link_pic (info))
10436     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10437
10438   first_tlsld = NULL;
10439   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10440     {
10441       struct got_entry *ent;
10442
10443       if (!is_ppc64_elf (ibfd))
10444         continue;
10445
10446       ent = ppc64_tlsld_got (ibfd);
10447       if (ent->got.refcount > 0)
10448         {
10449           if (!htab->do_multi_toc && first_tlsld != NULL)
10450             {
10451               ent->is_indirect = TRUE;
10452               ent->got.ent = first_tlsld;
10453             }
10454           else
10455             {
10456               if (first_tlsld == NULL)
10457                 first_tlsld = ent;
10458               s = ppc64_elf_tdata (ibfd)->got;
10459               ent->got.offset = s->size;
10460               ent->owner = ibfd;
10461               s->size += 16;
10462               if (bfd_link_pic (info))
10463                 {
10464                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10465                   srel->size += sizeof (Elf64_External_Rela);
10466                 }
10467             }
10468         }
10469       else
10470         ent->got.offset = (bfd_vma) -1;
10471     }
10472
10473   /* We now have determined the sizes of the various dynamic sections.
10474      Allocate memory for them.  */
10475   relocs = FALSE;
10476   for (s = dynobj->sections; s != NULL; s = s->next)
10477     {
10478       if ((s->flags & SEC_LINKER_CREATED) == 0)
10479         continue;
10480
10481       if (s == htab->brlt || s == htab->relbrlt)
10482         /* These haven't been allocated yet;  don't strip.  */
10483         continue;
10484       else if (s == htab->elf.sgot
10485                || s == htab->elf.splt
10486                || s == htab->elf.iplt
10487                || s == htab->pltlocal
10488                || s == htab->glink
10489                || s == htab->global_entry
10490                || s == htab->elf.sdynbss
10491                || s == htab->elf.sdynrelro)
10492         {
10493           /* Strip this section if we don't need it; see the
10494              comment below.  */
10495         }
10496       else if (s == htab->glink_eh_frame)
10497         {
10498           if (!bfd_is_abs_section (s->output_section))
10499             /* Not sized yet.  */
10500             continue;
10501         }
10502       else if (CONST_STRNEQ (s->name, ".rela"))
10503         {
10504           if (s->size != 0)
10505             {
10506               if (s != htab->elf.srelplt)
10507                 relocs = TRUE;
10508
10509               /* We use the reloc_count field as a counter if we need
10510                  to copy relocs into the output file.  */
10511               s->reloc_count = 0;
10512             }
10513         }
10514       else
10515         {
10516           /* It's not one of our sections, so don't allocate space.  */
10517           continue;
10518         }
10519
10520       if (s->size == 0)
10521         {
10522           /* If we don't need this section, strip it from the
10523              output file.  This is mostly to handle .rela.bss and
10524              .rela.plt.  We must create both sections in
10525              create_dynamic_sections, because they must be created
10526              before the linker maps input sections to output
10527              sections.  The linker does that before
10528              adjust_dynamic_symbol is called, and it is that
10529              function which decides whether anything needs to go
10530              into these sections.  */
10531           s->flags |= SEC_EXCLUDE;
10532           continue;
10533         }
10534
10535       if (bfd_is_abs_section (s->output_section))
10536         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10537                             s->name);
10538
10539       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10540         continue;
10541
10542       /* Allocate memory for the section contents.  We use bfd_zalloc
10543          here in case unused entries are not reclaimed before the
10544          section's contents are written out.  This should not happen,
10545          but this way if it does we get a R_PPC64_NONE reloc in .rela
10546          sections instead of garbage.
10547          We also rely on the section contents being zero when writing
10548          the GOT and .dynrelro.  */
10549       s->contents = bfd_zalloc (dynobj, s->size);
10550       if (s->contents == NULL)
10551         return FALSE;
10552     }
10553
10554   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10555     {
10556       if (!is_ppc64_elf (ibfd))
10557         continue;
10558
10559       s = ppc64_elf_tdata (ibfd)->got;
10560       if (s != NULL && s != htab->elf.sgot)
10561         {
10562           if (s->size == 0)
10563             s->flags |= SEC_EXCLUDE;
10564           else
10565             {
10566               s->contents = bfd_zalloc (ibfd, s->size);
10567               if (s->contents == NULL)
10568                 return FALSE;
10569             }
10570         }
10571       s = ppc64_elf_tdata (ibfd)->relgot;
10572       if (s != NULL)
10573         {
10574           if (s->size == 0)
10575             s->flags |= SEC_EXCLUDE;
10576           else
10577             {
10578               s->contents = bfd_zalloc (ibfd, s->size);
10579               if (s->contents == NULL)
10580                 return FALSE;
10581               relocs = TRUE;
10582               s->reloc_count = 0;
10583             }
10584         }
10585     }
10586
10587   if (htab->elf.dynamic_sections_created)
10588     {
10589       bfd_boolean tls_opt;
10590
10591       /* Add some entries to the .dynamic section.  We fill in the
10592          values later, in ppc64_elf_finish_dynamic_sections, but we
10593          must add the entries now so that we get the correct size for
10594          the .dynamic section.  The DT_DEBUG entry is filled in by the
10595          dynamic linker and used by the debugger.  */
10596 #define add_dynamic_entry(TAG, VAL) \
10597   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10598
10599       if (bfd_link_executable (info))
10600         {
10601           if (!add_dynamic_entry (DT_DEBUG, 0))
10602             return FALSE;
10603         }
10604
10605       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10606         {
10607           if (!add_dynamic_entry (DT_PLTGOT, 0)
10608               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10609               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10610               || !add_dynamic_entry (DT_JMPREL, 0)
10611               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10612             return FALSE;
10613         }
10614
10615       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10616         {
10617           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10618               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10619             return FALSE;
10620         }
10621
10622       tls_opt = (htab->params->tls_get_addr_opt
10623                  && htab->tls_get_addr_fd != NULL
10624                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10625       if (tls_opt || !htab->opd_abi)
10626         {
10627           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10628             return FALSE;
10629         }
10630
10631       if (relocs)
10632         {
10633           if (!add_dynamic_entry (DT_RELA, 0)
10634               || !add_dynamic_entry (DT_RELASZ, 0)
10635               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10636             return FALSE;
10637
10638           /* If any dynamic relocs apply to a read-only section,
10639              then we need a DT_TEXTREL entry.  */
10640           if ((info->flags & DF_TEXTREL) == 0)
10641             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10642
10643           if ((info->flags & DF_TEXTREL) != 0)
10644             {
10645               if (!add_dynamic_entry (DT_TEXTREL, 0))
10646                 return FALSE;
10647             }
10648         }
10649     }
10650 #undef add_dynamic_entry
10651
10652   return TRUE;
10653 }
10654
10655 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10656
10657 static bfd_boolean
10658 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10659 {
10660   if (h->plt.plist != NULL
10661       && !h->def_regular
10662       && !h->pointer_equality_needed)
10663     return FALSE;
10664
10665   return _bfd_elf_hash_symbol (h);
10666 }
10667
10668 /* Determine the type of stub needed, if any, for a call.  */
10669
10670 static inline enum ppc_stub_type
10671 ppc_type_of_stub (asection *input_sec,
10672                   const Elf_Internal_Rela *rel,
10673                   struct ppc_link_hash_entry **hash,
10674                   struct plt_entry **plt_ent,
10675                   bfd_vma destination,
10676                   unsigned long local_off)
10677 {
10678   struct ppc_link_hash_entry *h = *hash;
10679   bfd_vma location;
10680   bfd_vma branch_offset;
10681   bfd_vma max_branch_offset;
10682   enum elf_ppc64_reloc_type r_type;
10683
10684   if (h != NULL)
10685     {
10686       struct plt_entry *ent;
10687       struct ppc_link_hash_entry *fdh = h;
10688       if (h->oh != NULL
10689           && h->oh->is_func_descriptor)
10690         {
10691           fdh = ppc_follow_link (h->oh);
10692           *hash = fdh;
10693         }
10694
10695       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10696         if (ent->addend == rel->r_addend
10697             && ent->plt.offset != (bfd_vma) -1)
10698           {
10699             *plt_ent = ent;
10700             return ppc_stub_plt_call;
10701           }
10702
10703       /* Here, we know we don't have a plt entry.  If we don't have a
10704          either a defined function descriptor or a defined entry symbol
10705          in a regular object file, then it is pointless trying to make
10706          any other type of stub.  */
10707       if (!is_static_defined (&fdh->elf)
10708           && !is_static_defined (&h->elf))
10709         return ppc_stub_none;
10710     }
10711   else if (elf_local_got_ents (input_sec->owner) != NULL)
10712     {
10713       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10714       struct plt_entry **local_plt = (struct plt_entry **)
10715         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10716       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10717
10718       if (local_plt[r_symndx] != NULL)
10719         {
10720           struct plt_entry *ent;
10721
10722           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10723             if (ent->addend == rel->r_addend
10724                 && ent->plt.offset != (bfd_vma) -1)
10725               {
10726                 *plt_ent = ent;
10727                 return ppc_stub_plt_call;
10728               }
10729         }
10730     }
10731
10732   /* Determine where the call point is.  */
10733   location = (input_sec->output_offset
10734               + input_sec->output_section->vma
10735               + rel->r_offset);
10736
10737   branch_offset = destination - location;
10738   r_type = ELF64_R_TYPE (rel->r_info);
10739
10740   /* Determine if a long branch stub is needed.  */
10741   max_branch_offset = 1 << 25;
10742   if (r_type == R_PPC64_REL14
10743       || r_type == R_PPC64_REL14_BRTAKEN
10744       || r_type == R_PPC64_REL14_BRNTAKEN)
10745     max_branch_offset = 1 << 15;
10746
10747   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10748     /* We need a stub.  Figure out whether a long_branch or plt_branch
10749        is needed later.  */
10750     return ppc_stub_long_branch;
10751
10752   return ppc_stub_none;
10753 }
10754
10755 /* With power7 weakly ordered memory model, it is possible for ld.so
10756    to update a plt entry in one thread and have another thread see a
10757    stale zero toc entry.  To avoid this we need some sort of acquire
10758    barrier in the call stub.  One solution is to make the load of the
10759    toc word seem to appear to depend on the load of the function entry
10760    word.  Another solution is to test for r2 being zero, and branch to
10761    the appropriate glink entry if so.
10762
10763    .    fake dep barrier        compare
10764    .    ld 12,xxx(2)            ld 12,xxx(2)
10765    .    mtctr 12                mtctr 12
10766    .    xor 11,12,12            ld 2,xxx+8(2)
10767    .    add 2,2,11              cmpldi 2,0
10768    .    ld 2,xxx+8(2)           bnectr+
10769    .    bctr                    b <glink_entry>
10770
10771    The solution involving the compare turns out to be faster, so
10772    that's what we use unless the branch won't reach.  */
10773
10774 #define ALWAYS_USE_FAKE_DEP 0
10775 #define ALWAYS_EMIT_R2SAVE 0
10776
10777 static inline unsigned int
10778 plt_stub_size (struct ppc_link_hash_table *htab,
10779                struct ppc_stub_hash_entry *stub_entry,
10780                bfd_vma off)
10781 {
10782   unsigned size = 12;
10783
10784   if (ALWAYS_EMIT_R2SAVE
10785       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10786     size += 4;
10787   if (PPC_HA (off) != 0)
10788     size += 4;
10789   if (htab->opd_abi)
10790     {
10791       size += 4;
10792       if (htab->params->plt_static_chain)
10793         size += 4;
10794       if (htab->params->plt_thread_safe
10795           && htab->elf.dynamic_sections_created
10796           && stub_entry->h != NULL
10797           && stub_entry->h->elf.dynindx != -1)
10798         size += 8;
10799       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10800         size += 4;
10801     }
10802   if (stub_entry->h != NULL
10803       && (stub_entry->h == htab->tls_get_addr_fd
10804           || stub_entry->h == htab->tls_get_addr)
10805       && htab->params->tls_get_addr_opt)
10806     {
10807       size += 7 * 4;
10808       if (ALWAYS_EMIT_R2SAVE
10809           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10810         size += 6 * 4;
10811     }
10812   return size;
10813 }
10814
10815 /* Depending on the sign of plt_stub_align:
10816    If positive, return the padding to align to a 2**plt_stub_align
10817    boundary.
10818    If negative, if this stub would cross fewer 2**plt_stub_align
10819    boundaries if we align, then return the padding needed to do so.  */
10820
10821 static inline unsigned int
10822 plt_stub_pad (struct ppc_link_hash_table *htab,
10823               struct ppc_stub_hash_entry *stub_entry,
10824               bfd_vma plt_off)
10825 {
10826   int stub_align;
10827   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10828   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10829
10830   if (htab->params->plt_stub_align >= 0)
10831     {
10832       stub_align = 1 << htab->params->plt_stub_align;
10833       if ((stub_off & (stub_align - 1)) != 0)
10834         return stub_align - (stub_off & (stub_align - 1));
10835       return 0;
10836     }
10837
10838   stub_align = 1 << -htab->params->plt_stub_align;
10839   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10840       > ((stub_size - 1) & -stub_align))
10841     return stub_align - (stub_off & (stub_align - 1));
10842   return 0;
10843 }
10844
10845 /* Build a .plt call stub.  */
10846
10847 static inline bfd_byte *
10848 build_plt_stub (struct ppc_link_hash_table *htab,
10849                 struct ppc_stub_hash_entry *stub_entry,
10850                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10851 {
10852   bfd *obfd = htab->params->stub_bfd;
10853   bfd_boolean plt_load_toc = htab->opd_abi;
10854   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10855   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10856                                  && htab->elf.dynamic_sections_created
10857                                  && stub_entry->h != NULL
10858                                  && stub_entry->h->elf.dynindx != -1);
10859   bfd_boolean use_fake_dep = plt_thread_safe;
10860   bfd_vma cmp_branch_off = 0;
10861
10862   if (!ALWAYS_USE_FAKE_DEP
10863       && plt_load_toc
10864       && plt_thread_safe
10865       && !((stub_entry->h == htab->tls_get_addr_fd
10866             || stub_entry->h == htab->tls_get_addr)
10867            && htab->params->tls_get_addr_opt))
10868     {
10869       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10870       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10871                           / PLT_ENTRY_SIZE (htab));
10872       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10873       bfd_vma to, from;
10874
10875       if (pltindex > 32768)
10876         glinkoff += (pltindex - 32768) * 4;
10877       to = (glinkoff
10878             + htab->glink->output_offset
10879             + htab->glink->output_section->vma);
10880       from = (p - stub_entry->group->stub_sec->contents
10881               + 4 * (ALWAYS_EMIT_R2SAVE
10882                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10883               + 4 * (PPC_HA (offset) != 0)
10884               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10885                      != PPC_HA (offset))
10886               + 4 * (plt_static_chain != 0)
10887               + 20
10888               + stub_entry->group->stub_sec->output_offset
10889               + stub_entry->group->stub_sec->output_section->vma);
10890       cmp_branch_off = to - from;
10891       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10892     }
10893
10894   if (PPC_HA (offset) != 0)
10895     {
10896       if (r != NULL)
10897         {
10898           if (ALWAYS_EMIT_R2SAVE
10899               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10900             r[0].r_offset += 4;
10901           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10902           r[1].r_offset = r[0].r_offset + 4;
10903           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10904           r[1].r_addend = r[0].r_addend;
10905           if (plt_load_toc)
10906             {
10907               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10908                 {
10909                   r[2].r_offset = r[1].r_offset + 4;
10910                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10911                   r[2].r_addend = r[0].r_addend;
10912                 }
10913               else
10914                 {
10915                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10916                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10917                   r[2].r_addend = r[0].r_addend + 8;
10918                   if (plt_static_chain)
10919                     {
10920                       r[3].r_offset = r[2].r_offset + 4;
10921                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10922                       r[3].r_addend = r[0].r_addend + 16;
10923                     }
10924                 }
10925             }
10926         }
10927       if (ALWAYS_EMIT_R2SAVE
10928           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10929         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10930       if (plt_load_toc)
10931         {
10932           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10933           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10934         }
10935       else
10936         {
10937           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10938           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10939         }
10940       if (plt_load_toc
10941           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10942         {
10943           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10944           offset = 0;
10945         }
10946       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10947       if (plt_load_toc)
10948         {
10949           if (use_fake_dep)
10950             {
10951               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10952               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10953             }
10954           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10955           if (plt_static_chain)
10956             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10957         }
10958     }
10959   else
10960     {
10961       if (r != NULL)
10962         {
10963           if (ALWAYS_EMIT_R2SAVE
10964               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10965             r[0].r_offset += 4;
10966           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10967           if (plt_load_toc)
10968             {
10969               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10970                 {
10971                   r[1].r_offset = r[0].r_offset + 4;
10972                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10973                   r[1].r_addend = r[0].r_addend;
10974                 }
10975               else
10976                 {
10977                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10978                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10979                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10980                   if (plt_static_chain)
10981                     {
10982                       r[2].r_offset = r[1].r_offset + 4;
10983                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10984                       r[2].r_addend = r[0].r_addend + 8;
10985                     }
10986                 }
10987             }
10988         }
10989       if (ALWAYS_EMIT_R2SAVE
10990           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10991         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10992       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10993       if (plt_load_toc
10994           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10995         {
10996           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10997           offset = 0;
10998         }
10999       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11000       if (plt_load_toc)
11001         {
11002           if (use_fake_dep)
11003             {
11004               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
11005               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
11006             }
11007           if (plt_static_chain)
11008             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11009           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11010         }
11011     }
11012   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11013     {
11014       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11015       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11016       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11017     }
11018   else
11019     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11020   return p;
11021 }
11022
11023 /* Build a special .plt call stub for __tls_get_addr.  */
11024
11025 #define LD_R11_0R3      0xe9630000
11026 #define LD_R12_0R3      0xe9830000
11027 #define MR_R0_R3        0x7c601b78
11028 #define CMPDI_R11_0     0x2c2b0000
11029 #define ADD_R3_R12_R13  0x7c6c6a14
11030 #define BEQLR           0x4d820020
11031 #define MR_R3_R0        0x7c030378
11032 #define STD_R11_0R1     0xf9610000
11033 #define BCTRL           0x4e800421
11034 #define LD_R11_0R1      0xe9610000
11035 #define MTLR_R11        0x7d6803a6
11036
11037 static inline bfd_byte *
11038 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11039                          struct ppc_stub_hash_entry *stub_entry,
11040                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11041 {
11042   bfd *obfd = htab->params->stub_bfd;
11043
11044   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11045   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11046   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11047   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11048   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11049   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11050   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11051   if (r != NULL)
11052     r[0].r_offset += 7 * 4;
11053   if (!ALWAYS_EMIT_R2SAVE
11054       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
11055     return build_plt_stub (htab, stub_entry, p, offset, r);
11056
11057   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11058   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11059
11060   if (r != NULL)
11061     r[0].r_offset += 2 * 4;
11062   p = build_plt_stub (htab, stub_entry, p, offset, r);
11063   bfd_put_32 (obfd, BCTRL, p - 4);
11064
11065   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11066   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11067   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11068   bfd_put_32 (obfd, BLR, p),                    p += 4;
11069
11070   return p;
11071 }
11072
11073 static Elf_Internal_Rela *
11074 get_relocs (asection *sec, int count)
11075 {
11076   Elf_Internal_Rela *relocs;
11077   struct bfd_elf_section_data *elfsec_data;
11078
11079   elfsec_data = elf_section_data (sec);
11080   relocs = elfsec_data->relocs;
11081   if (relocs == NULL)
11082     {
11083       bfd_size_type relsize;
11084       relsize = sec->reloc_count * sizeof (*relocs);
11085       relocs = bfd_alloc (sec->owner, relsize);
11086       if (relocs == NULL)
11087         return NULL;
11088       elfsec_data->relocs = relocs;
11089       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11090                                           sizeof (Elf_Internal_Shdr));
11091       if (elfsec_data->rela.hdr == NULL)
11092         return NULL;
11093       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11094                                         * sizeof (Elf64_External_Rela));
11095       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11096       sec->reloc_count = 0;
11097     }
11098   relocs += sec->reloc_count;
11099   sec->reloc_count += count;
11100   return relocs;
11101 }
11102
11103 static bfd_vma
11104 get_r2off (struct bfd_link_info *info,
11105            struct ppc_stub_hash_entry *stub_entry)
11106 {
11107   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11108   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11109
11110   if (r2off == 0)
11111     {
11112       /* Support linking -R objects.  Get the toc pointer from the
11113          opd entry.  */
11114       char buf[8];
11115       if (!htab->opd_abi)
11116         return r2off;
11117       asection *opd = stub_entry->h->elf.root.u.def.section;
11118       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11119
11120       if (strcmp (opd->name, ".opd") != 0
11121           || opd->reloc_count != 0)
11122         {
11123           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11124                                   stub_entry->h->elf.root.root.string);
11125           bfd_set_error (bfd_error_bad_value);
11126           return (bfd_vma) -1;
11127         }
11128       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11129         return (bfd_vma) -1;
11130       r2off = bfd_get_64 (opd->owner, buf);
11131       r2off -= elf_gp (info->output_bfd);
11132     }
11133   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11134   return r2off;
11135 }
11136
11137 static bfd_boolean
11138 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11139 {
11140   struct ppc_stub_hash_entry *stub_entry;
11141   struct ppc_branch_hash_entry *br_entry;
11142   struct bfd_link_info *info;
11143   struct ppc_link_hash_table *htab;
11144   bfd_byte *loc;
11145   bfd_byte *p;
11146   bfd_vma dest, off;
11147   Elf_Internal_Rela *r;
11148   asection *plt;
11149
11150   /* Massage our args to the form they really have.  */
11151   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11152   info = in_arg;
11153
11154   htab = ppc_hash_table (info);
11155   if (htab == NULL)
11156     return FALSE;
11157
11158   /* Make a note of the offset within the stubs for this entry.  */
11159   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11160   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11161
11162   htab->stub_count[stub_entry->stub_type - 1] += 1;
11163   switch (stub_entry->stub_type)
11164     {
11165     case ppc_stub_long_branch:
11166     case ppc_stub_long_branch_r2off:
11167       /* Branches are relative.  This is where we are going to.  */
11168       dest = (stub_entry->target_value
11169               + stub_entry->target_section->output_offset
11170               + stub_entry->target_section->output_section->vma);
11171       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11172       off = dest;
11173
11174       /* And this is where we are coming from.  */
11175       off -= (stub_entry->stub_offset
11176               + stub_entry->group->stub_sec->output_offset
11177               + stub_entry->group->stub_sec->output_section->vma);
11178
11179       p = loc;
11180       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11181         {
11182           bfd_vma r2off = get_r2off (info, stub_entry);
11183
11184           if (r2off == (bfd_vma) -1)
11185             {
11186               htab->stub_error = TRUE;
11187               return FALSE;
11188             }
11189           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11190           p += 4;
11191           if (PPC_HA (r2off) != 0)
11192             {
11193               bfd_put_32 (htab->params->stub_bfd,
11194                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11195               p += 4;
11196             }
11197           if (PPC_LO (r2off) != 0)
11198             {
11199               bfd_put_32 (htab->params->stub_bfd,
11200                           ADDI_R2_R2 | PPC_LO (r2off), p);
11201               p += 4;
11202             }
11203           off -= p - loc;
11204         }
11205       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11206       p += 4;
11207
11208       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11209         {
11210           _bfd_error_handler
11211             (_("long branch stub `%s' offset overflow"),
11212              stub_entry->root.string);
11213           htab->stub_error = TRUE;
11214           return FALSE;
11215         }
11216
11217       if (info->emitrelocations)
11218         {
11219           r = get_relocs (stub_entry->group->stub_sec, 1);
11220           if (r == NULL)
11221             return FALSE;
11222           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11223           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11224           r->r_addend = dest;
11225           if (stub_entry->h != NULL)
11226             {
11227               struct elf_link_hash_entry **hashes;
11228               unsigned long symndx;
11229               struct ppc_link_hash_entry *h;
11230
11231               hashes = elf_sym_hashes (htab->params->stub_bfd);
11232               if (hashes == NULL)
11233                 {
11234                   bfd_size_type hsize;
11235
11236                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11237                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11238                   if (hashes == NULL)
11239                     return FALSE;
11240                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11241                   htab->stub_globals = 1;
11242                 }
11243               symndx = htab->stub_globals++;
11244               h = stub_entry->h;
11245               hashes[symndx] = &h->elf;
11246               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11247               if (h->oh != NULL && h->oh->is_func)
11248                 h = ppc_follow_link (h->oh);
11249               if (h->elf.root.u.def.section != stub_entry->target_section)
11250                 /* H is an opd symbol.  The addend must be zero.  */
11251                 r->r_addend = 0;
11252               else
11253                 {
11254                   off = (h->elf.root.u.def.value
11255                          + h->elf.root.u.def.section->output_offset
11256                          + h->elf.root.u.def.section->output_section->vma);
11257                   r->r_addend -= off;
11258                 }
11259             }
11260         }
11261       break;
11262
11263     case ppc_stub_plt_branch:
11264     case ppc_stub_plt_branch_r2off:
11265       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11266                                          stub_entry->root.string + 9,
11267                                          FALSE, FALSE);
11268       if (br_entry == NULL)
11269         {
11270           _bfd_error_handler (_("can't find branch stub `%s'"),
11271                               stub_entry->root.string);
11272           htab->stub_error = TRUE;
11273           return FALSE;
11274         }
11275
11276       dest = (stub_entry->target_value
11277               + stub_entry->target_section->output_offset
11278               + stub_entry->target_section->output_section->vma);
11279       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11280         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11281
11282       bfd_put_64 (htab->brlt->owner, dest,
11283                   htab->brlt->contents + br_entry->offset);
11284
11285       if (br_entry->iter == htab->stub_iteration)
11286         {
11287           br_entry->iter = 0;
11288
11289           if (htab->relbrlt != NULL)
11290             {
11291               /* Create a reloc for the branch lookup table entry.  */
11292               Elf_Internal_Rela rela;
11293               bfd_byte *rl;
11294
11295               rela.r_offset = (br_entry->offset
11296                                + htab->brlt->output_offset
11297                                + htab->brlt->output_section->vma);
11298               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11299               rela.r_addend = dest;
11300
11301               rl = htab->relbrlt->contents;
11302               rl += (htab->relbrlt->reloc_count++
11303                      * sizeof (Elf64_External_Rela));
11304               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11305             }
11306           else if (info->emitrelocations)
11307             {
11308               r = get_relocs (htab->brlt, 1);
11309               if (r == NULL)
11310                 return FALSE;
11311               /* brlt, being SEC_LINKER_CREATED does not go through the
11312                  normal reloc processing.  Symbols and offsets are not
11313                  translated from input file to output file form, so
11314                  set up the offset per the output file.  */
11315               r->r_offset = (br_entry->offset
11316                              + htab->brlt->output_offset
11317                              + htab->brlt->output_section->vma);
11318               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11319               r->r_addend = dest;
11320             }
11321         }
11322
11323       dest = (br_entry->offset
11324               + htab->brlt->output_offset
11325               + htab->brlt->output_section->vma);
11326
11327       off = (dest
11328              - elf_gp (info->output_bfd)
11329              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11330
11331       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11332         {
11333           info->callbacks->einfo
11334             (_("%P: linkage table error against `%pT'\n"),
11335              stub_entry->root.string);
11336           bfd_set_error (bfd_error_bad_value);
11337           htab->stub_error = TRUE;
11338           return FALSE;
11339         }
11340
11341       if (info->emitrelocations)
11342         {
11343           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11344           if (r == NULL)
11345             return FALSE;
11346           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11347           if (bfd_big_endian (info->output_bfd))
11348             r[0].r_offset += 2;
11349           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11350             r[0].r_offset += 4;
11351           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11352           r[0].r_addend = dest;
11353           if (PPC_HA (off) != 0)
11354             {
11355               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11356               r[1].r_offset = r[0].r_offset + 4;
11357               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11358               r[1].r_addend = r[0].r_addend;
11359             }
11360         }
11361
11362       p = loc;
11363       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11364         {
11365           if (PPC_HA (off) != 0)
11366             {
11367               bfd_put_32 (htab->params->stub_bfd,
11368                           ADDIS_R12_R2 | PPC_HA (off), p);
11369               p += 4;
11370               bfd_put_32 (htab->params->stub_bfd,
11371                           LD_R12_0R12 | PPC_LO (off), p);
11372             }
11373           else
11374             bfd_put_32 (htab->params->stub_bfd,
11375                         LD_R12_0R2 | PPC_LO (off), p);
11376         }
11377       else
11378         {
11379           bfd_vma r2off = get_r2off (info, stub_entry);
11380
11381           if (r2off == (bfd_vma) -1)
11382             {
11383               htab->stub_error = TRUE;
11384               return FALSE;
11385             }
11386
11387           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11388           p += 4;
11389           if (PPC_HA (off) != 0)
11390             {
11391               bfd_put_32 (htab->params->stub_bfd,
11392                           ADDIS_R12_R2 | PPC_HA (off), p);
11393               p += 4;
11394               bfd_put_32 (htab->params->stub_bfd,
11395                           LD_R12_0R12 | PPC_LO (off), p);
11396             }
11397           else
11398             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11399
11400           if (PPC_HA (r2off) != 0)
11401             {
11402               p += 4;
11403               bfd_put_32 (htab->params->stub_bfd,
11404                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11405             }
11406           if (PPC_LO (r2off) != 0)
11407             {
11408               p += 4;
11409               bfd_put_32 (htab->params->stub_bfd,
11410                           ADDI_R2_R2 | PPC_LO (r2off), p);
11411             }
11412         }
11413       p += 4;
11414       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11415       p += 4;
11416       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11417       p += 4;
11418       break;
11419
11420     case ppc_stub_plt_call:
11421     case ppc_stub_plt_call_r2save:
11422       if (stub_entry->h != NULL
11423           && stub_entry->h->is_func_descriptor
11424           && stub_entry->h->oh != NULL)
11425         {
11426           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11427
11428           /* If the old-ABI "dot-symbol" is undefined make it weak so
11429              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11430           if (fh->elf.root.type == bfd_link_hash_undefined
11431               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11432                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11433             fh->elf.root.type = bfd_link_hash_undefweak;
11434         }
11435
11436       /* Now build the stub.  */
11437       dest = stub_entry->plt_ent->plt.offset & ~1;
11438       if (dest >= (bfd_vma) -2)
11439         abort ();
11440
11441       plt = htab->elf.splt;
11442       if (!htab->elf.dynamic_sections_created
11443           || stub_entry->h == NULL
11444           || stub_entry->h->elf.dynindx == -1)
11445         {
11446           if (stub_entry->symtype == STT_GNU_IFUNC)
11447             plt = htab->elf.iplt;
11448           else
11449             plt = htab->pltlocal;
11450         }
11451
11452       dest += plt->output_offset + plt->output_section->vma;
11453
11454       off = (dest
11455              - elf_gp (info->output_bfd)
11456              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11457
11458       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11459         {
11460           info->callbacks->einfo
11461             /* xgettext:c-format */
11462             (_("%P: linkage table error against `%pT'\n"),
11463              stub_entry->h != NULL
11464              ? stub_entry->h->elf.root.root.string
11465              : "<local sym>");
11466           bfd_set_error (bfd_error_bad_value);
11467           htab->stub_error = TRUE;
11468           return FALSE;
11469         }
11470
11471       if (htab->params->plt_stub_align != 0)
11472         {
11473           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11474
11475           stub_entry->group->stub_sec->size += pad;
11476           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11477           loc += pad;
11478         }
11479
11480       r = NULL;
11481       if (info->emitrelocations)
11482         {
11483           r = get_relocs (stub_entry->group->stub_sec,
11484                           ((PPC_HA (off) != 0)
11485                            + (htab->opd_abi
11486                               ? 2 + (htab->params->plt_static_chain
11487                                      && PPC_HA (off + 16) == PPC_HA (off))
11488                               : 1)));
11489           if (r == NULL)
11490             return FALSE;
11491           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11492           if (bfd_big_endian (info->output_bfd))
11493             r[0].r_offset += 2;
11494           r[0].r_addend = dest;
11495         }
11496       if (stub_entry->h != NULL
11497           && (stub_entry->h == htab->tls_get_addr_fd
11498               || stub_entry->h == htab->tls_get_addr)
11499           && htab->params->tls_get_addr_opt)
11500         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11501       else
11502         p = build_plt_stub (htab, stub_entry, loc, off, r);
11503       break;
11504
11505     case ppc_stub_save_res:
11506       return TRUE;
11507
11508     default:
11509       BFD_FAIL ();
11510       return FALSE;
11511     }
11512
11513   stub_entry->group->stub_sec->size += p - loc;
11514
11515   if (htab->params->emit_stub_syms)
11516     {
11517       struct elf_link_hash_entry *h;
11518       size_t len1, len2;
11519       char *name;
11520       const char *const stub_str[] = { "long_branch",
11521                                        "long_branch_r2off",
11522                                        "plt_branch",
11523                                        "plt_branch_r2off",
11524                                        "plt_call",
11525                                        "plt_call" };
11526
11527       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11528       len2 = strlen (stub_entry->root.string);
11529       name = bfd_malloc (len1 + len2 + 2);
11530       if (name == NULL)
11531         return FALSE;
11532       memcpy (name, stub_entry->root.string, 9);
11533       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11534       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11535       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11536       if (h == NULL)
11537         return FALSE;
11538       if (h->root.type == bfd_link_hash_new)
11539         {
11540           h->root.type = bfd_link_hash_defined;
11541           h->root.u.def.section = stub_entry->group->stub_sec;
11542           h->root.u.def.value = stub_entry->stub_offset;
11543           h->ref_regular = 1;
11544           h->def_regular = 1;
11545           h->ref_regular_nonweak = 1;
11546           h->forced_local = 1;
11547           h->non_elf = 0;
11548           h->root.linker_def = 1;
11549         }
11550     }
11551
11552   return TRUE;
11553 }
11554
11555 /* As above, but don't actually build the stub.  Just bump offset so
11556    we know stub section sizes, and select plt_branch stubs where
11557    long_branch stubs won't do.  */
11558
11559 static bfd_boolean
11560 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11561 {
11562   struct ppc_stub_hash_entry *stub_entry;
11563   struct bfd_link_info *info;
11564   struct ppc_link_hash_table *htab;
11565   bfd_vma off;
11566   int size;
11567
11568   /* Massage our args to the form they really have.  */
11569   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11570   info = in_arg;
11571
11572   htab = ppc_hash_table (info);
11573   if (htab == NULL)
11574     return FALSE;
11575
11576   if (stub_entry->h != NULL
11577       && stub_entry->h->save_res
11578       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11579       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11580     {
11581       /* Don't make stubs to out-of-line register save/restore
11582          functions.  Instead, emit copies of the functions.  */
11583       stub_entry->group->needs_save_res = 1;
11584       stub_entry->stub_type = ppc_stub_save_res;
11585       return TRUE;
11586     }
11587
11588   if (stub_entry->stub_type == ppc_stub_plt_call
11589       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11590     {
11591       asection *plt;
11592       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11593       if (off >= (bfd_vma) -2)
11594         abort ();
11595       plt = htab->elf.splt;
11596       if (!htab->elf.dynamic_sections_created
11597           || stub_entry->h == NULL
11598           || stub_entry->h->elf.dynindx == -1)
11599         {
11600           if (stub_entry->symtype == STT_GNU_IFUNC)
11601             plt = htab->elf.iplt;
11602           else
11603             plt = htab->pltlocal;
11604         }
11605       off += (plt->output_offset
11606               + plt->output_section->vma
11607               - elf_gp (info->output_bfd)
11608               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11609
11610       size = plt_stub_size (htab, stub_entry, off);
11611       if (stub_entry->h != NULL
11612           && (stub_entry->h == htab->tls_get_addr_fd
11613               || stub_entry->h == htab->tls_get_addr)
11614           && htab->params->tls_get_addr_opt
11615           && (ALWAYS_EMIT_R2SAVE
11616               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11617         stub_entry->group->tls_get_addr_opt_bctrl
11618           = stub_entry->group->stub_sec->size + size - 5 * 4;
11619
11620       if (htab->params->plt_stub_align)
11621         size += plt_stub_pad (htab, stub_entry, off);
11622       if (info->emitrelocations)
11623         {
11624           stub_entry->group->stub_sec->reloc_count
11625             += ((PPC_HA (off) != 0)
11626                 + (htab->opd_abi
11627                    ? 2 + (htab->params->plt_static_chain
11628                           && PPC_HA (off + 16) == PPC_HA (off))
11629                    : 1));
11630           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11631         }
11632     }
11633   else
11634     {
11635       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11636          variants.  */
11637       bfd_vma r2off = 0;
11638       bfd_vma local_off = 0;
11639
11640       off = (stub_entry->target_value
11641              + stub_entry->target_section->output_offset
11642              + stub_entry->target_section->output_section->vma);
11643       off -= (stub_entry->group->stub_sec->size
11644               + stub_entry->group->stub_sec->output_offset
11645               + stub_entry->group->stub_sec->output_section->vma);
11646
11647       /* Reset the stub type from the plt variant in case we now
11648          can reach with a shorter stub.  */
11649       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11650         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11651
11652       size = 4;
11653       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11654         {
11655           r2off = get_r2off (info, stub_entry);
11656           if (r2off == (bfd_vma) -1)
11657             {
11658               htab->stub_error = TRUE;
11659               return FALSE;
11660             }
11661           size = 8;
11662           if (PPC_HA (r2off) != 0)
11663             size += 4;
11664           if (PPC_LO (r2off) != 0)
11665             size += 4;
11666           off -= size - 4;
11667         }
11668
11669       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11670
11671       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11672          Do the same for -R objects without function descriptors.  */
11673       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11674           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11675               && r2off == 0
11676               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11677         {
11678           struct ppc_branch_hash_entry *br_entry;
11679
11680           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11681                                              stub_entry->root.string + 9,
11682                                              TRUE, FALSE);
11683           if (br_entry == NULL)
11684             {
11685               _bfd_error_handler (_("can't build branch stub `%s'"),
11686                                   stub_entry->root.string);
11687               htab->stub_error = TRUE;
11688               return FALSE;
11689             }
11690
11691           if (br_entry->iter != htab->stub_iteration)
11692             {
11693               br_entry->iter = htab->stub_iteration;
11694               br_entry->offset = htab->brlt->size;
11695               htab->brlt->size += 8;
11696
11697               if (htab->relbrlt != NULL)
11698                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11699               else if (info->emitrelocations)
11700                 {
11701                   htab->brlt->reloc_count += 1;
11702                   htab->brlt->flags |= SEC_RELOC;
11703                 }
11704             }
11705
11706           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11707           off = (br_entry->offset
11708                  + htab->brlt->output_offset
11709                  + htab->brlt->output_section->vma
11710                  - elf_gp (info->output_bfd)
11711                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11712
11713           if (info->emitrelocations)
11714             {
11715               stub_entry->group->stub_sec->reloc_count
11716                 += 1 + (PPC_HA (off) != 0);
11717               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11718             }
11719
11720           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11721             {
11722               size = 12;
11723               if (PPC_HA (off) != 0)
11724                 size = 16;
11725             }
11726           else
11727             {
11728               size = 16;
11729               if (PPC_HA (off) != 0)
11730                 size += 4;
11731
11732               if (PPC_HA (r2off) != 0)
11733                 size += 4;
11734               if (PPC_LO (r2off) != 0)
11735                 size += 4;
11736             }
11737         }
11738       else if (info->emitrelocations)
11739         {
11740           stub_entry->group->stub_sec->reloc_count += 1;
11741           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11742         }
11743     }
11744
11745   stub_entry->group->stub_sec->size += size;
11746   return TRUE;
11747 }
11748
11749 /* Set up various things so that we can make a list of input sections
11750    for each output section included in the link.  Returns -1 on error,
11751    0 when no stubs will be needed, and 1 on success.  */
11752
11753 int
11754 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11755 {
11756   unsigned int id;
11757   bfd_size_type amt;
11758   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11759
11760   if (htab == NULL)
11761     return -1;
11762
11763   htab->sec_info_arr_size = _bfd_section_id;
11764   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11765   htab->sec_info = bfd_zmalloc (amt);
11766   if (htab->sec_info == NULL)
11767     return -1;
11768
11769   /* Set toc_off for com, und, abs and ind sections.  */
11770   for (id = 0; id < 3; id++)
11771     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11772
11773   return 1;
11774 }
11775
11776 /* Set up for first pass at multitoc partitioning.  */
11777
11778 void
11779 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11780 {
11781   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11782
11783   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11784   htab->toc_bfd = NULL;
11785   htab->toc_first_sec = NULL;
11786 }
11787
11788 /* The linker repeatedly calls this function for each TOC input section
11789    and linker generated GOT section.  Group input bfds such that the toc
11790    within a group is less than 64k in size.  */
11791
11792 bfd_boolean
11793 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11794 {
11795   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11796   bfd_vma addr, off, limit;
11797
11798   if (htab == NULL)
11799     return FALSE;
11800
11801   if (!htab->second_toc_pass)
11802     {
11803       /* Keep track of the first .toc or .got section for this input bfd.  */
11804       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11805
11806       if (new_bfd)
11807         {
11808           htab->toc_bfd = isec->owner;
11809           htab->toc_first_sec = isec;
11810         }
11811
11812       addr = isec->output_offset + isec->output_section->vma;
11813       off = addr - htab->toc_curr;
11814       limit = 0x80008000;
11815       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11816         limit = 0x10000;
11817       if (off + isec->size > limit)
11818         {
11819           addr = (htab->toc_first_sec->output_offset
11820                   + htab->toc_first_sec->output_section->vma);
11821           htab->toc_curr = addr;
11822           htab->toc_curr &= -TOC_BASE_ALIGN;
11823         }
11824
11825       /* toc_curr is the base address of this toc group.  Set elf_gp
11826          for the input section to be the offset relative to the
11827          output toc base plus 0x8000.  Making the input elf_gp an
11828          offset allows us to move the toc as a whole without
11829          recalculating input elf_gp.  */
11830       off = htab->toc_curr - elf_gp (info->output_bfd);
11831       off += TOC_BASE_OFF;
11832
11833       /* Die if someone uses a linker script that doesn't keep input
11834          file .toc and .got together.  */
11835       if (new_bfd
11836           && elf_gp (isec->owner) != 0
11837           && elf_gp (isec->owner) != off)
11838         return FALSE;
11839
11840       elf_gp (isec->owner) = off;
11841       return TRUE;
11842     }
11843
11844   /* During the second pass toc_first_sec points to the start of
11845      a toc group, and toc_curr is used to track the old elf_gp.
11846      We use toc_bfd to ensure we only look at each bfd once.  */
11847   if (htab->toc_bfd == isec->owner)
11848     return TRUE;
11849   htab->toc_bfd = isec->owner;
11850
11851   if (htab->toc_first_sec == NULL
11852       || htab->toc_curr != elf_gp (isec->owner))
11853     {
11854       htab->toc_curr = elf_gp (isec->owner);
11855       htab->toc_first_sec = isec;
11856     }
11857   addr = (htab->toc_first_sec->output_offset
11858           + htab->toc_first_sec->output_section->vma);
11859   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11860   elf_gp (isec->owner) = off;
11861
11862   return TRUE;
11863 }
11864
11865 /* Called via elf_link_hash_traverse to merge GOT entries for global
11866    symbol H.  */
11867
11868 static bfd_boolean
11869 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11870 {
11871   if (h->root.type == bfd_link_hash_indirect)
11872     return TRUE;
11873
11874   merge_got_entries (&h->got.glist);
11875
11876   return TRUE;
11877 }
11878
11879 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11880    symbol H.  */
11881
11882 static bfd_boolean
11883 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11884 {
11885   struct got_entry *gent;
11886
11887   if (h->root.type == bfd_link_hash_indirect)
11888     return TRUE;
11889
11890   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11891     if (!gent->is_indirect)
11892       allocate_got (h, (struct bfd_link_info *) inf, gent);
11893   return TRUE;
11894 }
11895
11896 /* Called on the first multitoc pass after the last call to
11897    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11898    entries.  */
11899
11900 bfd_boolean
11901 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11902 {
11903   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11904   struct bfd *ibfd, *ibfd2;
11905   bfd_boolean done_something;
11906
11907   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11908
11909   if (!htab->do_multi_toc)
11910     return FALSE;
11911
11912   /* Merge global sym got entries within a toc group.  */
11913   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11914
11915   /* And tlsld_got.  */
11916   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11917     {
11918       struct got_entry *ent, *ent2;
11919
11920       if (!is_ppc64_elf (ibfd))
11921         continue;
11922
11923       ent = ppc64_tlsld_got (ibfd);
11924       if (!ent->is_indirect
11925           && ent->got.offset != (bfd_vma) -1)
11926         {
11927           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11928             {
11929               if (!is_ppc64_elf (ibfd2))
11930                 continue;
11931
11932               ent2 = ppc64_tlsld_got (ibfd2);
11933               if (!ent2->is_indirect
11934                   && ent2->got.offset != (bfd_vma) -1
11935                   && elf_gp (ibfd2) == elf_gp (ibfd))
11936                 {
11937                   ent2->is_indirect = TRUE;
11938                   ent2->got.ent = ent;
11939                 }
11940             }
11941         }
11942     }
11943
11944   /* Zap sizes of got sections.  */
11945   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11946   htab->elf.irelplt->size -= htab->got_reli_size;
11947   htab->got_reli_size = 0;
11948
11949   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11950     {
11951       asection *got, *relgot;
11952
11953       if (!is_ppc64_elf (ibfd))
11954         continue;
11955
11956       got = ppc64_elf_tdata (ibfd)->got;
11957       if (got != NULL)
11958         {
11959           got->rawsize = got->size;
11960           got->size = 0;
11961           relgot = ppc64_elf_tdata (ibfd)->relgot;
11962           relgot->rawsize = relgot->size;
11963           relgot->size = 0;
11964         }
11965     }
11966
11967   /* Now reallocate the got, local syms first.  We don't need to
11968      allocate section contents again since we never increase size.  */
11969   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11970     {
11971       struct got_entry **lgot_ents;
11972       struct got_entry **end_lgot_ents;
11973       struct plt_entry **local_plt;
11974       struct plt_entry **end_local_plt;
11975       unsigned char *lgot_masks;
11976       bfd_size_type locsymcount;
11977       Elf_Internal_Shdr *symtab_hdr;
11978       asection *s;
11979
11980       if (!is_ppc64_elf (ibfd))
11981         continue;
11982
11983       lgot_ents = elf_local_got_ents (ibfd);
11984       if (!lgot_ents)
11985         continue;
11986
11987       symtab_hdr = &elf_symtab_hdr (ibfd);
11988       locsymcount = symtab_hdr->sh_info;
11989       end_lgot_ents = lgot_ents + locsymcount;
11990       local_plt = (struct plt_entry **) end_lgot_ents;
11991       end_local_plt = local_plt + locsymcount;
11992       lgot_masks = (unsigned char *) end_local_plt;
11993       s = ppc64_elf_tdata (ibfd)->got;
11994       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11995         {
11996           struct got_entry *ent;
11997
11998           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11999             {
12000               unsigned int ent_size = 8;
12001               unsigned int rel_size = sizeof (Elf64_External_Rela);
12002
12003               ent->got.offset = s->size;
12004               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12005                 {
12006                   ent_size *= 2;
12007                   rel_size *= 2;
12008                 }
12009               s->size += ent_size;
12010               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12011                 {
12012                   htab->elf.irelplt->size += rel_size;
12013                   htab->got_reli_size += rel_size;
12014                 }
12015               else if (bfd_link_pic (info)
12016                        && !((ent->tls_type & TLS_TPREL) != 0
12017                             && bfd_link_executable (info)))
12018                 {
12019                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12020                   srel->size += rel_size;
12021                 }
12022             }
12023         }
12024     }
12025
12026   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12027
12028   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12029     {
12030       struct got_entry *ent;
12031
12032       if (!is_ppc64_elf (ibfd))
12033         continue;
12034
12035       ent = ppc64_tlsld_got (ibfd);
12036       if (!ent->is_indirect
12037           && ent->got.offset != (bfd_vma) -1)
12038         {
12039           asection *s = ppc64_elf_tdata (ibfd)->got;
12040           ent->got.offset = s->size;
12041           s->size += 16;
12042           if (bfd_link_pic (info))
12043             {
12044               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12045               srel->size += sizeof (Elf64_External_Rela);
12046             }
12047         }
12048     }
12049
12050   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12051   if (!done_something)
12052     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12053       {
12054         asection *got;
12055
12056         if (!is_ppc64_elf (ibfd))
12057           continue;
12058
12059         got = ppc64_elf_tdata (ibfd)->got;
12060         if (got != NULL)
12061           {
12062             done_something = got->rawsize != got->size;
12063             if (done_something)
12064               break;
12065           }
12066       }
12067
12068   if (done_something)
12069     (*htab->params->layout_sections_again) ();
12070
12071   /* Set up for second pass over toc sections to recalculate elf_gp
12072      on input sections.  */
12073   htab->toc_bfd = NULL;
12074   htab->toc_first_sec = NULL;
12075   htab->second_toc_pass = TRUE;
12076   return done_something;
12077 }
12078
12079 /* Called after second pass of multitoc partitioning.  */
12080
12081 void
12082 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12083 {
12084   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12085
12086   /* After the second pass, toc_curr tracks the TOC offset used
12087      for code sections below in ppc64_elf_next_input_section.  */
12088   htab->toc_curr = TOC_BASE_OFF;
12089 }
12090
12091 /* No toc references were found in ISEC.  If the code in ISEC makes no
12092    calls, then there's no need to use toc adjusting stubs when branching
12093    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12094    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12095    needed, and 2 if a cyclical call-graph was found but no other reason
12096    for a stub was detected.  If called from the top level, a return of
12097    2 means the same as a return of 0.  */
12098
12099 static int
12100 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12101 {
12102   int ret;
12103
12104   /* Mark this section as checked.  */
12105   isec->call_check_done = 1;
12106
12107   /* We know none of our code bearing sections will need toc stubs.  */
12108   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12109     return 0;
12110
12111   if (isec->size == 0)
12112     return 0;
12113
12114   if (isec->output_section == NULL)
12115     return 0;
12116
12117   ret = 0;
12118   if (isec->reloc_count != 0)
12119     {
12120       Elf_Internal_Rela *relstart, *rel;
12121       Elf_Internal_Sym *local_syms;
12122       struct ppc_link_hash_table *htab;
12123
12124       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12125                                             info->keep_memory);
12126       if (relstart == NULL)
12127         return -1;
12128
12129       /* Look for branches to outside of this section.  */
12130       local_syms = NULL;
12131       htab = ppc_hash_table (info);
12132       if (htab == NULL)
12133         return -1;
12134
12135       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12136         {
12137           enum elf_ppc64_reloc_type r_type;
12138           unsigned long r_symndx;
12139           struct elf_link_hash_entry *h;
12140           struct ppc_link_hash_entry *eh;
12141           Elf_Internal_Sym *sym;
12142           asection *sym_sec;
12143           struct _opd_sec_data *opd;
12144           bfd_vma sym_value;
12145           bfd_vma dest;
12146
12147           r_type = ELF64_R_TYPE (rel->r_info);
12148           if (r_type != R_PPC64_REL24
12149               && r_type != R_PPC64_REL14
12150               && r_type != R_PPC64_REL14_BRTAKEN
12151               && r_type != R_PPC64_REL14_BRNTAKEN
12152               && r_type != R_PPC64_PLTCALL)
12153             continue;
12154
12155           r_symndx = ELF64_R_SYM (rel->r_info);
12156           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12157                           isec->owner))
12158             {
12159               ret = -1;
12160               break;
12161             }
12162
12163           /* Calls to dynamic lib functions go through a plt call stub
12164              that uses r2.  */
12165           eh = (struct ppc_link_hash_entry *) h;
12166           if (eh != NULL
12167               && (eh->elf.plt.plist != NULL
12168                   || (eh->oh != NULL
12169                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12170             {
12171               ret = 1;
12172               break;
12173             }
12174
12175           if (sym_sec == NULL)
12176             /* Ignore other undefined symbols.  */
12177             continue;
12178
12179           /* Assume branches to other sections not included in the
12180              link need stubs too, to cover -R and absolute syms.  */
12181           if (sym_sec->output_section == NULL)
12182             {
12183               ret = 1;
12184               break;
12185             }
12186
12187           if (h == NULL)
12188             sym_value = sym->st_value;
12189           else
12190             {
12191               if (h->root.type != bfd_link_hash_defined
12192                   && h->root.type != bfd_link_hash_defweak)
12193                 abort ();
12194               sym_value = h->root.u.def.value;
12195             }
12196           sym_value += rel->r_addend;
12197
12198           /* If this branch reloc uses an opd sym, find the code section.  */
12199           opd = get_opd_info (sym_sec);
12200           if (opd != NULL)
12201             {
12202               if (h == NULL && opd->adjust != NULL)
12203                 {
12204                   long adjust;
12205
12206                   adjust = opd->adjust[OPD_NDX (sym_value)];
12207                   if (adjust == -1)
12208                     /* Assume deleted functions won't ever be called.  */
12209                     continue;
12210                   sym_value += adjust;
12211                 }
12212
12213               dest = opd_entry_value (sym_sec, sym_value,
12214                                       &sym_sec, NULL, FALSE);
12215               if (dest == (bfd_vma) -1)
12216                 continue;
12217             }
12218           else
12219             dest = (sym_value
12220                     + sym_sec->output_offset
12221                     + sym_sec->output_section->vma);
12222
12223           /* Ignore branch to self.  */
12224           if (sym_sec == isec)
12225             continue;
12226
12227           /* If the called function uses the toc, we need a stub.  */
12228           if (sym_sec->has_toc_reloc
12229               || sym_sec->makes_toc_func_call)
12230             {
12231               ret = 1;
12232               break;
12233             }
12234
12235           /* Assume any branch that needs a long branch stub might in fact
12236              need a plt_branch stub.  A plt_branch stub uses r2.  */
12237           else if (dest - (isec->output_offset
12238                            + isec->output_section->vma
12239                            + rel->r_offset) + (1 << 25)
12240                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12241                                                              ? h->other
12242                                                              : sym->st_other))
12243             {
12244               ret = 1;
12245               break;
12246             }
12247
12248           /* If calling back to a section in the process of being
12249              tested, we can't say for sure that no toc adjusting stubs
12250              are needed, so don't return zero.  */
12251           else if (sym_sec->call_check_in_progress)
12252             ret = 2;
12253
12254           /* Branches to another section that itself doesn't have any TOC
12255              references are OK.  Recursively call ourselves to check.  */
12256           else if (!sym_sec->call_check_done)
12257             {
12258               int recur;
12259
12260               /* Mark current section as indeterminate, so that other
12261                  sections that call back to current won't be marked as
12262                  known.  */
12263               isec->call_check_in_progress = 1;
12264               recur = toc_adjusting_stub_needed (info, sym_sec);
12265               isec->call_check_in_progress = 0;
12266
12267               if (recur != 0)
12268                 {
12269                   ret = recur;
12270                   if (recur != 2)
12271                     break;
12272                 }
12273             }
12274         }
12275
12276       if (local_syms != NULL
12277           && (elf_symtab_hdr (isec->owner).contents
12278               != (unsigned char *) local_syms))
12279         free (local_syms);
12280       if (elf_section_data (isec)->relocs != relstart)
12281         free (relstart);
12282     }
12283
12284   if ((ret & 1) == 0
12285       && isec->map_head.s != NULL
12286       && (strcmp (isec->output_section->name, ".init") == 0
12287           || strcmp (isec->output_section->name, ".fini") == 0))
12288     {
12289       if (isec->map_head.s->has_toc_reloc
12290           || isec->map_head.s->makes_toc_func_call)
12291         ret = 1;
12292       else if (!isec->map_head.s->call_check_done)
12293         {
12294           int recur;
12295           isec->call_check_in_progress = 1;
12296           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12297           isec->call_check_in_progress = 0;
12298           if (recur != 0)
12299             ret = recur;
12300         }
12301     }
12302
12303   if (ret == 1)
12304     isec->makes_toc_func_call = 1;
12305
12306   return ret;
12307 }
12308
12309 /* The linker repeatedly calls this function for each input section,
12310    in the order that input sections are linked into output sections.
12311    Build lists of input sections to determine groupings between which
12312    we may insert linker stubs.  */
12313
12314 bfd_boolean
12315 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12316 {
12317   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12318
12319   if (htab == NULL)
12320     return FALSE;
12321
12322   if ((isec->output_section->flags & SEC_CODE) != 0
12323       && isec->output_section->id < htab->sec_info_arr_size)
12324     {
12325       /* This happens to make the list in reverse order,
12326          which is what we want.  */
12327       htab->sec_info[isec->id].u.list
12328         = htab->sec_info[isec->output_section->id].u.list;
12329       htab->sec_info[isec->output_section->id].u.list = isec;
12330     }
12331
12332   if (htab->multi_toc_needed)
12333     {
12334       /* Analyse sections that aren't already flagged as needing a
12335          valid toc pointer.  Exclude .fixup for the linux kernel.
12336          .fixup contains branches, but only back to the function that
12337          hit an exception.  */
12338       if (!(isec->has_toc_reloc
12339             || (isec->flags & SEC_CODE) == 0
12340             || strcmp (isec->name, ".fixup") == 0
12341             || isec->call_check_done))
12342         {
12343           if (toc_adjusting_stub_needed (info, isec) < 0)
12344             return FALSE;
12345         }
12346       /* Make all sections use the TOC assigned for this object file.
12347          This will be wrong for pasted sections;  We fix that in
12348          check_pasted_section().  */
12349       if (elf_gp (isec->owner) != 0)
12350         htab->toc_curr = elf_gp (isec->owner);
12351     }
12352
12353   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12354   return TRUE;
12355 }
12356
12357 /* Check that all .init and .fini sections use the same toc, if they
12358    have toc relocs.  */
12359
12360 static bfd_boolean
12361 check_pasted_section (struct bfd_link_info *info, const char *name)
12362 {
12363   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12364
12365   if (o != NULL)
12366     {
12367       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12368       bfd_vma toc_off = 0;
12369       asection *i;
12370
12371       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12372         if (i->has_toc_reloc)
12373           {
12374             if (toc_off == 0)
12375               toc_off = htab->sec_info[i->id].toc_off;
12376             else if (toc_off != htab->sec_info[i->id].toc_off)
12377               return FALSE;
12378           }
12379
12380       if (toc_off == 0)
12381         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12382           if (i->makes_toc_func_call)
12383             {
12384               toc_off = htab->sec_info[i->id].toc_off;
12385               break;
12386             }
12387
12388       /* Make sure the whole pasted function uses the same toc offset.  */
12389       if (toc_off != 0)
12390         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12391           htab->sec_info[i->id].toc_off = toc_off;
12392     }
12393   return TRUE;
12394 }
12395
12396 bfd_boolean
12397 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12398 {
12399   return (check_pasted_section (info, ".init")
12400           & check_pasted_section (info, ".fini"));
12401 }
12402
12403 /* See whether we can group stub sections together.  Grouping stub
12404    sections may result in fewer stubs.  More importantly, we need to
12405    put all .init* and .fini* stubs at the beginning of the .init or
12406    .fini output sections respectively, because glibc splits the
12407    _init and _fini functions into multiple parts.  Putting a stub in
12408    the middle of a function is not a good idea.  */
12409
12410 static bfd_boolean
12411 group_sections (struct bfd_link_info *info,
12412                 bfd_size_type stub_group_size,
12413                 bfd_boolean stubs_always_before_branch)
12414 {
12415   struct ppc_link_hash_table *htab;
12416   asection *osec;
12417   bfd_boolean suppress_size_errors;
12418
12419   htab = ppc_hash_table (info);
12420   if (htab == NULL)
12421     return FALSE;
12422
12423   suppress_size_errors = FALSE;
12424   if (stub_group_size == 1)
12425     {
12426       /* Default values.  */
12427       if (stubs_always_before_branch)
12428         stub_group_size = 0x1e00000;
12429       else
12430         stub_group_size = 0x1c00000;
12431       suppress_size_errors = TRUE;
12432     }
12433
12434   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12435     {
12436       asection *tail;
12437
12438       if (osec->id >= htab->sec_info_arr_size)
12439         continue;
12440
12441       tail = htab->sec_info[osec->id].u.list;
12442       while (tail != NULL)
12443         {
12444           asection *curr;
12445           asection *prev;
12446           bfd_size_type total;
12447           bfd_boolean big_sec;
12448           bfd_vma curr_toc;
12449           struct map_stub *group;
12450           bfd_size_type group_size;
12451
12452           curr = tail;
12453           total = tail->size;
12454           group_size = (ppc64_elf_section_data (tail) != NULL
12455                         && ppc64_elf_section_data (tail)->has_14bit_branch
12456                         ? stub_group_size >> 10 : stub_group_size);
12457
12458           big_sec = total > group_size;
12459           if (big_sec && !suppress_size_errors)
12460             /* xgettext:c-format */
12461             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12462                                 tail->owner, tail);
12463           curr_toc = htab->sec_info[tail->id].toc_off;
12464
12465           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12466                  && ((total += curr->output_offset - prev->output_offset)
12467                      < (ppc64_elf_section_data (prev) != NULL
12468                         && ppc64_elf_section_data (prev)->has_14bit_branch
12469                         ? (group_size = stub_group_size >> 10) : group_size))
12470                  && htab->sec_info[prev->id].toc_off == curr_toc)
12471             curr = prev;
12472
12473           /* OK, the size from the start of CURR to the end is less
12474              than group_size and thus can be handled by one stub
12475              section.  (or the tail section is itself larger than
12476              group_size, in which case we may be toast.)  We should
12477              really be keeping track of the total size of stubs added
12478              here, as stubs contribute to the final output section
12479              size.  That's a little tricky, and this way will only
12480              break if stubs added make the total size more than 2^25,
12481              ie. for the default stub_group_size, if stubs total more
12482              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12483           group = bfd_alloc (curr->owner, sizeof (*group));
12484           if (group == NULL)
12485             return FALSE;
12486           group->link_sec = curr;
12487           group->stub_sec = NULL;
12488           group->needs_save_res = 0;
12489           group->tls_get_addr_opt_bctrl = -1u;
12490           group->next = htab->group;
12491           htab->group = group;
12492           do
12493             {
12494               prev = htab->sec_info[tail->id].u.list;
12495               /* Set up this stub group.  */
12496               htab->sec_info[tail->id].u.group = group;
12497             }
12498           while (tail != curr && (tail = prev) != NULL);
12499
12500           /* But wait, there's more!  Input sections up to group_size
12501              bytes before the stub section can be handled by it too.
12502              Don't do this if we have a really large section after the
12503              stubs, as adding more stubs increases the chance that
12504              branches may not reach into the stub section.  */
12505           if (!stubs_always_before_branch && !big_sec)
12506             {
12507               total = 0;
12508               while (prev != NULL
12509                      && ((total += tail->output_offset - prev->output_offset)
12510                          < (ppc64_elf_section_data (prev) != NULL
12511                             && ppc64_elf_section_data (prev)->has_14bit_branch
12512                             ? (group_size = stub_group_size >> 10) : group_size))
12513                      && htab->sec_info[prev->id].toc_off == curr_toc)
12514                 {
12515                   tail = prev;
12516                   prev = htab->sec_info[tail->id].u.list;
12517                   htab->sec_info[tail->id].u.group = group;
12518                 }
12519             }
12520           tail = prev;
12521         }
12522     }
12523   return TRUE;
12524 }
12525
12526 static const unsigned char glink_eh_frame_cie[] =
12527 {
12528   0, 0, 0, 16,                          /* length.  */
12529   0, 0, 0, 0,                           /* id.  */
12530   1,                                    /* CIE version.  */
12531   'z', 'R', 0,                          /* Augmentation string.  */
12532   4,                                    /* Code alignment.  */
12533   0x78,                                 /* Data alignment.  */
12534   65,                                   /* RA reg.  */
12535   1,                                    /* Augmentation size.  */
12536   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12537   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12538 };
12539
12540 static size_t
12541 stub_eh_frame_size (struct map_stub *group, size_t align)
12542 {
12543   size_t this_size = 17;
12544   if (group->tls_get_addr_opt_bctrl != -1u)
12545     {
12546       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12547       if (to_bctrl < 64)
12548         this_size += 1;
12549       else if (to_bctrl < 256)
12550         this_size += 2;
12551       else if (to_bctrl < 65536)
12552         this_size += 3;
12553       else
12554         this_size += 5;
12555       this_size += 6;
12556     }
12557   this_size = (this_size + align - 1) & -align;
12558   return this_size;
12559 }
12560
12561 /* Stripping output sections is normally done before dynamic section
12562    symbols have been allocated.  This function is called later, and
12563    handles cases like htab->brlt which is mapped to its own output
12564    section.  */
12565
12566 static void
12567 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12568 {
12569   if (isec->size == 0
12570       && isec->output_section->size == 0
12571       && !(isec->output_section->flags & SEC_KEEP)
12572       && !bfd_section_removed_from_list (info->output_bfd,
12573                                          isec->output_section)
12574       && elf_section_data (isec->output_section)->dynindx == 0)
12575     {
12576       isec->output_section->flags |= SEC_EXCLUDE;
12577       bfd_section_list_remove (info->output_bfd, isec->output_section);
12578       info->output_bfd->section_count--;
12579     }
12580 }
12581
12582 /* Determine and set the size of the stub section for a final link.
12583
12584    The basic idea here is to examine all the relocations looking for
12585    PC-relative calls to a target that is unreachable with a "bl"
12586    instruction.  */
12587
12588 bfd_boolean
12589 ppc64_elf_size_stubs (struct bfd_link_info *info)
12590 {
12591   bfd_size_type stub_group_size;
12592   bfd_boolean stubs_always_before_branch;
12593   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12594
12595   if (htab == NULL)
12596     return FALSE;
12597
12598   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12599     htab->params->plt_thread_safe = 1;
12600   if (!htab->opd_abi)
12601     htab->params->plt_thread_safe = 0;
12602   else if (htab->params->plt_thread_safe == -1)
12603     {
12604       static const char *const thread_starter[] =
12605         {
12606           "pthread_create",
12607           /* libstdc++ */
12608           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12609           /* librt */
12610           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12611           "mq_notify", "create_timer",
12612           /* libanl */
12613           "getaddrinfo_a",
12614           /* libgomp */
12615           "GOMP_parallel",
12616           "GOMP_parallel_start",
12617           "GOMP_parallel_loop_static",
12618           "GOMP_parallel_loop_static_start",
12619           "GOMP_parallel_loop_dynamic",
12620           "GOMP_parallel_loop_dynamic_start",
12621           "GOMP_parallel_loop_guided",
12622           "GOMP_parallel_loop_guided_start",
12623           "GOMP_parallel_loop_runtime",
12624           "GOMP_parallel_loop_runtime_start",
12625           "GOMP_parallel_sections",
12626           "GOMP_parallel_sections_start",
12627           /* libgo */
12628           "__go_go",
12629         };
12630       unsigned i;
12631
12632       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12633         {
12634           struct elf_link_hash_entry *h;
12635           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12636                                     FALSE, FALSE, TRUE);
12637           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12638           if (htab->params->plt_thread_safe)
12639             break;
12640         }
12641     }
12642   stubs_always_before_branch = htab->params->group_size < 0;
12643   if (htab->params->group_size < 0)
12644     stub_group_size = -htab->params->group_size;
12645   else
12646     stub_group_size = htab->params->group_size;
12647
12648   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12649     return FALSE;
12650
12651 #define STUB_SHRINK_ITER 20
12652   /* Loop until no stubs added.  After iteration 20 of this loop we may
12653      exit on a stub section shrinking.  This is to break out of a
12654      pathological case where adding stubs on one iteration decreases
12655      section gaps (perhaps due to alignment), which then requires
12656      fewer or smaller stubs on the next iteration.  */
12657
12658   while (1)
12659     {
12660       bfd *input_bfd;
12661       unsigned int bfd_indx;
12662       struct map_stub *group;
12663
12664       htab->stub_iteration += 1;
12665
12666       for (input_bfd = info->input_bfds, bfd_indx = 0;
12667            input_bfd != NULL;
12668            input_bfd = input_bfd->link.next, bfd_indx++)
12669         {
12670           Elf_Internal_Shdr *symtab_hdr;
12671           asection *section;
12672           Elf_Internal_Sym *local_syms = NULL;
12673
12674           if (!is_ppc64_elf (input_bfd))
12675             continue;
12676
12677           /* We'll need the symbol table in a second.  */
12678           symtab_hdr = &elf_symtab_hdr (input_bfd);
12679           if (symtab_hdr->sh_info == 0)
12680             continue;
12681
12682           /* Walk over each section attached to the input bfd.  */
12683           for (section = input_bfd->sections;
12684                section != NULL;
12685                section = section->next)
12686             {
12687               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12688
12689               /* If there aren't any relocs, then there's nothing more
12690                  to do.  */
12691               if ((section->flags & SEC_RELOC) == 0
12692                   || (section->flags & SEC_ALLOC) == 0
12693                   || (section->flags & SEC_LOAD) == 0
12694                   || (section->flags & SEC_CODE) == 0
12695                   || section->reloc_count == 0)
12696                 continue;
12697
12698               /* If this section is a link-once section that will be
12699                  discarded, then don't create any stubs.  */
12700               if (section->output_section == NULL
12701                   || section->output_section->owner != info->output_bfd)
12702                 continue;
12703
12704               /* Get the relocs.  */
12705               internal_relocs
12706                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12707                                              info->keep_memory);
12708               if (internal_relocs == NULL)
12709                 goto error_ret_free_local;
12710
12711               /* Now examine each relocation.  */
12712               irela = internal_relocs;
12713               irelaend = irela + section->reloc_count;
12714               for (; irela < irelaend; irela++)
12715                 {
12716                   enum elf_ppc64_reloc_type r_type;
12717                   unsigned int r_indx;
12718                   enum ppc_stub_type stub_type;
12719                   struct ppc_stub_hash_entry *stub_entry;
12720                   asection *sym_sec, *code_sec;
12721                   bfd_vma sym_value, code_value;
12722                   bfd_vma destination;
12723                   unsigned long local_off;
12724                   bfd_boolean ok_dest;
12725                   struct ppc_link_hash_entry *hash;
12726                   struct ppc_link_hash_entry *fdh;
12727                   struct elf_link_hash_entry *h;
12728                   Elf_Internal_Sym *sym;
12729                   char *stub_name;
12730                   const asection *id_sec;
12731                   struct _opd_sec_data *opd;
12732                   struct plt_entry *plt_ent;
12733
12734                   r_type = ELF64_R_TYPE (irela->r_info);
12735                   r_indx = ELF64_R_SYM (irela->r_info);
12736
12737                   if (r_type >= R_PPC64_max)
12738                     {
12739                       bfd_set_error (bfd_error_bad_value);
12740                       goto error_ret_free_internal;
12741                     }
12742
12743                   /* Only look for stubs on branch instructions.  */
12744                   if (r_type != R_PPC64_REL24
12745                       && r_type != R_PPC64_REL14
12746                       && r_type != R_PPC64_REL14_BRTAKEN
12747                       && r_type != R_PPC64_REL14_BRNTAKEN)
12748                     continue;
12749
12750                   /* Now determine the call target, its name, value,
12751                      section.  */
12752                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12753                                   r_indx, input_bfd))
12754                     goto error_ret_free_internal;
12755                   hash = (struct ppc_link_hash_entry *) h;
12756
12757                   ok_dest = FALSE;
12758                   fdh = NULL;
12759                   sym_value = 0;
12760                   if (hash == NULL)
12761                     {
12762                       sym_value = sym->st_value;
12763                       if (sym_sec != NULL
12764                           && sym_sec->output_section != NULL)
12765                         ok_dest = TRUE;
12766                     }
12767                   else if (hash->elf.root.type == bfd_link_hash_defined
12768                            || hash->elf.root.type == bfd_link_hash_defweak)
12769                     {
12770                       sym_value = hash->elf.root.u.def.value;
12771                       if (sym_sec->output_section != NULL)
12772                         ok_dest = TRUE;
12773                     }
12774                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12775                            || hash->elf.root.type == bfd_link_hash_undefined)
12776                     {
12777                       /* Recognise an old ABI func code entry sym, and
12778                          use the func descriptor sym instead if it is
12779                          defined.  */
12780                       if (hash->elf.root.root.string[0] == '.'
12781                           && hash->oh != NULL)
12782                         {
12783                           fdh = ppc_follow_link (hash->oh);
12784                           if (fdh->elf.root.type == bfd_link_hash_defined
12785                               || fdh->elf.root.type == bfd_link_hash_defweak)
12786                             {
12787                               sym_sec = fdh->elf.root.u.def.section;
12788                               sym_value = fdh->elf.root.u.def.value;
12789                               if (sym_sec->output_section != NULL)
12790                                 ok_dest = TRUE;
12791                             }
12792                           else
12793                             fdh = NULL;
12794                         }
12795                     }
12796                   else
12797                     {
12798                       bfd_set_error (bfd_error_bad_value);
12799                       goto error_ret_free_internal;
12800                     }
12801
12802                   destination = 0;
12803                   local_off = 0;
12804                   if (ok_dest)
12805                     {
12806                       sym_value += irela->r_addend;
12807                       destination = (sym_value
12808                                      + sym_sec->output_offset
12809                                      + sym_sec->output_section->vma);
12810                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12811                                                             ? hash->elf.other
12812                                                             : sym->st_other);
12813                     }
12814
12815                   code_sec = sym_sec;
12816                   code_value = sym_value;
12817                   opd = get_opd_info (sym_sec);
12818                   if (opd != NULL)
12819                     {
12820                       bfd_vma dest;
12821
12822                       if (hash == NULL && opd->adjust != NULL)
12823                         {
12824                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12825                           if (adjust == -1)
12826                             continue;
12827                           code_value += adjust;
12828                           sym_value += adjust;
12829                         }
12830                       dest = opd_entry_value (sym_sec, sym_value,
12831                                               &code_sec, &code_value, FALSE);
12832                       if (dest != (bfd_vma) -1)
12833                         {
12834                           destination = dest;
12835                           if (fdh != NULL)
12836                             {
12837                               /* Fixup old ABI sym to point at code
12838                                  entry.  */
12839                               hash->elf.root.type = bfd_link_hash_defweak;
12840                               hash->elf.root.u.def.section = code_sec;
12841                               hash->elf.root.u.def.value = code_value;
12842                             }
12843                         }
12844                     }
12845
12846                   /* Determine what (if any) linker stub is needed.  */
12847                   plt_ent = NULL;
12848                   stub_type = ppc_type_of_stub (section, irela, &hash,
12849                                                 &plt_ent, destination,
12850                                                 local_off);
12851
12852                   if (stub_type != ppc_stub_plt_call)
12853                     {
12854                       /* Check whether we need a TOC adjusting stub.
12855                          Since the linker pastes together pieces from
12856                          different object files when creating the
12857                          _init and _fini functions, it may be that a
12858                          call to what looks like a local sym is in
12859                          fact a call needing a TOC adjustment.  */
12860                       if (code_sec != NULL
12861                           && code_sec->output_section != NULL
12862                           && (htab->sec_info[code_sec->id].toc_off
12863                               != htab->sec_info[section->id].toc_off)
12864                           && (code_sec->has_toc_reloc
12865                               || code_sec->makes_toc_func_call))
12866                         stub_type = ppc_stub_long_branch_r2off;
12867                     }
12868
12869                   if (stub_type == ppc_stub_none)
12870                     continue;
12871
12872                   /* __tls_get_addr calls might be eliminated.  */
12873                   if (stub_type != ppc_stub_plt_call
12874                       && hash != NULL
12875                       && (hash == htab->tls_get_addr
12876                           || hash == htab->tls_get_addr_fd)
12877                       && section->has_tls_reloc
12878                       && irela != internal_relocs)
12879                     {
12880                       /* Get tls info.  */
12881                       unsigned char *tls_mask;
12882
12883                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12884                                          irela - 1, input_bfd))
12885                         goto error_ret_free_internal;
12886                       if ((*tls_mask & TLS_TLS) != 0)
12887                         continue;
12888                     }
12889
12890                   if (stub_type == ppc_stub_plt_call)
12891                     {
12892                       if (!htab->opd_abi
12893                           && htab->params->plt_localentry0 != 0
12894                           && is_elfv2_localentry0 (&hash->elf))
12895                         htab->has_plt_localentry0 = 1;
12896                       else if (irela + 1 < irelaend
12897                                && irela[1].r_offset == irela->r_offset + 4
12898                                && (ELF64_R_TYPE (irela[1].r_info)
12899                                    == R_PPC64_TOCSAVE))
12900                         {
12901                           if (!tocsave_find (htab, INSERT,
12902                                              &local_syms, irela + 1, input_bfd))
12903                             goto error_ret_free_internal;
12904                         }
12905                       else
12906                         stub_type = ppc_stub_plt_call_r2save;
12907                     }
12908
12909                   /* Support for grouping stub sections.  */
12910                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12911
12912                   /* Get the name of this stub.  */
12913                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12914                   if (!stub_name)
12915                     goto error_ret_free_internal;
12916
12917                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12918                                                      stub_name, FALSE, FALSE);
12919                   if (stub_entry != NULL)
12920                     {
12921                       /* The proper stub has already been created.  */
12922                       free (stub_name);
12923                       if (stub_type == ppc_stub_plt_call_r2save)
12924                         stub_entry->stub_type = stub_type;
12925                       continue;
12926                     }
12927
12928                   stub_entry = ppc_add_stub (stub_name, section, info);
12929                   if (stub_entry == NULL)
12930                     {
12931                       free (stub_name);
12932                     error_ret_free_internal:
12933                       if (elf_section_data (section)->relocs == NULL)
12934                         free (internal_relocs);
12935                     error_ret_free_local:
12936                       if (local_syms != NULL
12937                           && (symtab_hdr->contents
12938                               != (unsigned char *) local_syms))
12939                         free (local_syms);
12940                       return FALSE;
12941                     }
12942
12943                   stub_entry->stub_type = stub_type;
12944                   if (stub_type != ppc_stub_plt_call
12945                       && stub_type != ppc_stub_plt_call_r2save)
12946                     {
12947                       stub_entry->target_value = code_value;
12948                       stub_entry->target_section = code_sec;
12949                     }
12950                   else
12951                     {
12952                       stub_entry->target_value = sym_value;
12953                       stub_entry->target_section = sym_sec;
12954                     }
12955                   stub_entry->h = hash;
12956                   stub_entry->plt_ent = plt_ent;
12957                   stub_entry->symtype
12958                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12959                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12960
12961                   if (stub_entry->h != NULL)
12962                     htab->stub_globals += 1;
12963                 }
12964
12965               /* We're done with the internal relocs, free them.  */
12966               if (elf_section_data (section)->relocs != internal_relocs)
12967                 free (internal_relocs);
12968             }
12969
12970           if (local_syms != NULL
12971               && symtab_hdr->contents != (unsigned char *) local_syms)
12972             {
12973               if (!info->keep_memory)
12974                 free (local_syms);
12975               else
12976                 symtab_hdr->contents = (unsigned char *) local_syms;
12977             }
12978         }
12979
12980       /* We may have added some stubs.  Find out the new size of the
12981          stub sections.  */
12982       for (group = htab->group; group != NULL; group = group->next)
12983         if (group->stub_sec != NULL)
12984           {
12985             asection *stub_sec = group->stub_sec;
12986
12987             if (htab->stub_iteration <= STUB_SHRINK_ITER
12988                 || stub_sec->rawsize < stub_sec->size)
12989               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12990               stub_sec->rawsize = stub_sec->size;
12991             stub_sec->size = 0;
12992             stub_sec->reloc_count = 0;
12993             stub_sec->flags &= ~SEC_RELOC;
12994           }
12995
12996       if (htab->stub_iteration <= STUB_SHRINK_ITER
12997           || htab->brlt->rawsize < htab->brlt->size)
12998         htab->brlt->rawsize = htab->brlt->size;
12999       htab->brlt->size = 0;
13000       htab->brlt->reloc_count = 0;
13001       htab->brlt->flags &= ~SEC_RELOC;
13002       if (htab->relbrlt != NULL)
13003         htab->relbrlt->size = 0;
13004
13005       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13006
13007       for (group = htab->group; group != NULL; group = group->next)
13008         if (group->needs_save_res)
13009           group->stub_sec->size += htab->sfpr->size;
13010
13011       if (info->emitrelocations
13012           && htab->glink != NULL && htab->glink->size != 0)
13013         {
13014           htab->glink->reloc_count = 1;
13015           htab->glink->flags |= SEC_RELOC;
13016         }
13017
13018       if (htab->glink_eh_frame != NULL
13019           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13020           && htab->glink_eh_frame->output_section->size > 8)
13021         {
13022           size_t size = 0, align = 4;
13023
13024           for (group = htab->group; group != NULL; group = group->next)
13025             if (group->stub_sec != NULL)
13026               size += stub_eh_frame_size (group, align);
13027           if (htab->glink != NULL && htab->glink->size != 0)
13028             size += (24 + align - 1) & -align;
13029           if (size != 0)
13030             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13031           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13032           size = (size + align - 1) & -align;
13033           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13034           htab->glink_eh_frame->size = size;
13035         }
13036
13037       if (htab->params->plt_stub_align != 0)
13038         for (group = htab->group; group != NULL; group = group->next)
13039           if (group->stub_sec != NULL)
13040             {
13041               int align = abs (htab->params->plt_stub_align);
13042               group->stub_sec->size
13043                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13044             }
13045
13046       for (group = htab->group; group != NULL; group = group->next)
13047         if (group->stub_sec != NULL
13048             && group->stub_sec->rawsize != group->stub_sec->size
13049             && (htab->stub_iteration <= STUB_SHRINK_ITER
13050                 || group->stub_sec->rawsize < group->stub_sec->size))
13051           break;
13052
13053       if (group == NULL
13054           && (htab->brlt->rawsize == htab->brlt->size
13055               || (htab->stub_iteration > STUB_SHRINK_ITER
13056                   && htab->brlt->rawsize > htab->brlt->size))
13057           && (htab->glink_eh_frame == NULL
13058               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13059         break;
13060
13061       /* Ask the linker to do its stuff.  */
13062       (*htab->params->layout_sections_again) ();
13063     }
13064
13065   if (htab->glink_eh_frame != NULL
13066       && htab->glink_eh_frame->size != 0)
13067     {
13068       bfd_vma val;
13069       bfd_byte *p, *last_fde;
13070       size_t last_fde_len, size, align, pad;
13071       struct map_stub *group;
13072
13073       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13074       if (p == NULL)
13075         return FALSE;
13076       htab->glink_eh_frame->contents = p;
13077       last_fde = p;
13078       align = 4;
13079
13080       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13081       /* CIE length (rewrite in case little-endian).  */
13082       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13083       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13084       p += last_fde_len + 4;
13085
13086       for (group = htab->group; group != NULL; group = group->next)
13087         if (group->stub_sec != NULL)
13088           {
13089             last_fde = p;
13090             last_fde_len = stub_eh_frame_size (group, align) - 4;
13091             /* FDE length.  */
13092             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13093             p += 4;
13094             /* CIE pointer.  */
13095             val = p - htab->glink_eh_frame->contents;
13096             bfd_put_32 (htab->elf.dynobj, val, p);
13097             p += 4;
13098             /* Offset to stub section, written later.  */
13099             p += 4;
13100             /* stub section size.  */
13101             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13102             p += 4;
13103             /* Augmentation.  */
13104             p += 1;
13105             if (group->tls_get_addr_opt_bctrl != -1u)
13106               {
13107                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13108
13109                 /* This FDE needs more than just the default.
13110                    Describe __tls_get_addr_opt stub LR.  */
13111                 if (to_bctrl < 64)
13112                   *p++ = DW_CFA_advance_loc + to_bctrl;
13113                 else if (to_bctrl < 256)
13114                   {
13115                     *p++ = DW_CFA_advance_loc1;
13116                     *p++ = to_bctrl;
13117                   }
13118                 else if (to_bctrl < 65536)
13119                   {
13120                     *p++ = DW_CFA_advance_loc2;
13121                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13122                     p += 2;
13123                   }
13124                 else
13125                   {
13126                     *p++ = DW_CFA_advance_loc4;
13127                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13128                     p += 4;
13129                   }
13130                 *p++ = DW_CFA_offset_extended_sf;
13131                 *p++ = 65;
13132                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13133                 *p++ = DW_CFA_advance_loc + 4;
13134                 *p++ = DW_CFA_restore_extended;
13135                 *p++ = 65;
13136               }
13137             /* Pad.  */
13138             p = last_fde + last_fde_len + 4;
13139           }
13140       if (htab->glink != NULL && htab->glink->size != 0)
13141         {
13142           last_fde = p;
13143           last_fde_len = ((24 + align - 1) & -align) - 4;
13144           /* FDE length.  */
13145           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13146           p += 4;
13147           /* CIE pointer.  */
13148           val = p - htab->glink_eh_frame->contents;
13149           bfd_put_32 (htab->elf.dynobj, val, p);
13150           p += 4;
13151           /* Offset to .glink, written later.  */
13152           p += 4;
13153           /* .glink size.  */
13154           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13155           p += 4;
13156           /* Augmentation.  */
13157           p += 1;
13158
13159           *p++ = DW_CFA_advance_loc + 1;
13160           *p++ = DW_CFA_register;
13161           *p++ = 65;
13162           *p++ = htab->opd_abi ? 12 : 0;
13163           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13164           *p++ = DW_CFA_restore_extended;
13165           *p++ = 65;
13166           p += ((24 + align - 1) & -align) - 24;
13167         }
13168       /* Subsume any padding into the last FDE if user .eh_frame
13169          sections are aligned more than glink_eh_frame.  Otherwise any
13170          zero padding will be seen as a terminator.  */
13171       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13172       size = p - htab->glink_eh_frame->contents;
13173       pad = ((size + align - 1) & -align) - size;
13174       htab->glink_eh_frame->size = size + pad;
13175       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13176     }
13177
13178   maybe_strip_output (info, htab->brlt);
13179   if (htab->glink_eh_frame != NULL)
13180     maybe_strip_output (info, htab->glink_eh_frame);
13181
13182   return TRUE;
13183 }
13184
13185 /* Called after we have determined section placement.  If sections
13186    move, we'll be called again.  Provide a value for TOCstart.  */
13187
13188 bfd_vma
13189 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13190 {
13191   asection *s;
13192   bfd_vma TOCstart, adjust;
13193
13194   if (info != NULL)
13195     {
13196       struct elf_link_hash_entry *h;
13197       struct elf_link_hash_table *htab = elf_hash_table (info);
13198
13199       if (is_elf_hash_table (htab)
13200           && htab->hgot != NULL)
13201         h = htab->hgot;
13202       else
13203         {
13204           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13205           if (is_elf_hash_table (htab))
13206             htab->hgot = h;
13207         }
13208       if (h != NULL
13209           && h->root.type == bfd_link_hash_defined
13210           && !h->root.linker_def
13211           && (!is_elf_hash_table (htab)
13212               || h->def_regular))
13213         {
13214           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13215                       + h->root.u.def.section->output_offset
13216                       + h->root.u.def.section->output_section->vma);
13217           _bfd_set_gp_value (obfd, TOCstart);
13218           return TOCstart;
13219         }
13220     }
13221
13222   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13223      order.  The TOC starts where the first of these sections starts.  */
13224   s = bfd_get_section_by_name (obfd, ".got");
13225   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13226     s = bfd_get_section_by_name (obfd, ".toc");
13227   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13228     s = bfd_get_section_by_name (obfd, ".tocbss");
13229   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13230     s = bfd_get_section_by_name (obfd, ".plt");
13231   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13232     {
13233       /* This may happen for
13234          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13235          .toc directive
13236          o  bad linker script
13237          o --gc-sections and empty TOC sections
13238
13239          FIXME: Warn user?  */
13240
13241       /* Look for a likely section.  We probably won't even be
13242          using TOCstart.  */
13243       for (s = obfd->sections; s != NULL; s = s->next)
13244         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13245                          | SEC_EXCLUDE))
13246             == (SEC_ALLOC | SEC_SMALL_DATA))
13247           break;
13248       if (s == NULL)
13249         for (s = obfd->sections; s != NULL; s = s->next)
13250           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13251               == (SEC_ALLOC | SEC_SMALL_DATA))
13252             break;
13253       if (s == NULL)
13254         for (s = obfd->sections; s != NULL; s = s->next)
13255           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13256               == SEC_ALLOC)
13257             break;
13258       if (s == NULL)
13259         for (s = obfd->sections; s != NULL; s = s->next)
13260           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13261             break;
13262     }
13263
13264   TOCstart = 0;
13265   if (s != NULL)
13266     TOCstart = s->output_section->vma + s->output_offset;
13267
13268   /* Force alignment.  */
13269   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13270   TOCstart -= adjust;
13271   _bfd_set_gp_value (obfd, TOCstart);
13272
13273   if (info != NULL && s != NULL)
13274     {
13275       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13276
13277       if (htab != NULL)
13278         {
13279           if (htab->elf.hgot != NULL)
13280             {
13281               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13282               htab->elf.hgot->root.u.def.section = s;
13283             }
13284         }
13285       else
13286         {
13287           struct bfd_link_hash_entry *bh = NULL;
13288           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13289                                             s, TOC_BASE_OFF - adjust,
13290                                             NULL, FALSE, FALSE, &bh);
13291         }
13292     }
13293   return TOCstart;
13294 }
13295
13296 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13297    write out any global entry stubs, and PLT relocations.  */
13298
13299 static bfd_boolean
13300 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13301 {
13302   struct bfd_link_info *info;
13303   struct ppc_link_hash_table *htab;
13304   struct plt_entry *ent;
13305   asection *s;
13306
13307   if (h->root.type == bfd_link_hash_indirect)
13308     return TRUE;
13309
13310   info = inf;
13311   htab = ppc_hash_table (info);
13312   if (htab == NULL)
13313     return FALSE;
13314
13315   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13316     if (ent->plt.offset != (bfd_vma) -1)
13317       {
13318         /* This symbol has an entry in the procedure linkage
13319            table.  Set it up.  */
13320         Elf_Internal_Rela rela;
13321         asection *plt, *relplt;
13322         bfd_byte *loc;
13323
13324         if (!htab->elf.dynamic_sections_created
13325             || h->dynindx == -1)
13326           {
13327             if (!(h->def_regular
13328                   && (h->root.type == bfd_link_hash_defined
13329                       || h->root.type == bfd_link_hash_defweak)))
13330               continue;
13331             if (h->type == STT_GNU_IFUNC)
13332               {
13333                 plt = htab->elf.iplt;
13334                 relplt = htab->elf.irelplt;
13335                 htab->local_ifunc_resolver = 1;
13336                 if (htab->opd_abi)
13337                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13338                 else
13339                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13340               }
13341             else
13342               {
13343                 plt = htab->pltlocal;
13344                 if (bfd_link_pic (info))
13345                   {
13346                     relplt = htab->relpltlocal;
13347                     if (htab->opd_abi)
13348                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13349                     else
13350                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13351                   }
13352                 else
13353                   relplt = NULL;
13354               }
13355             rela.r_addend = (h->root.u.def.value
13356                              + h->root.u.def.section->output_offset
13357                              + h->root.u.def.section->output_section->vma
13358                              + ent->addend);
13359
13360             if (relplt == NULL)
13361               {
13362                 loc = plt->contents + ent->plt.offset;
13363                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13364                 if (htab->opd_abi)
13365                   {
13366                     bfd_vma toc = elf_gp (info->output_bfd);
13367                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13368                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13369                   }
13370               }
13371             else
13372               {
13373                 rela.r_offset = (plt->output_section->vma
13374                                  + plt->output_offset
13375                                  + ent->plt.offset);
13376                 loc = relplt->contents + (relplt->reloc_count++
13377                                           * sizeof (Elf64_External_Rela));
13378                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13379               }
13380           }
13381         else
13382           {
13383             rela.r_offset = (htab->elf.splt->output_section->vma
13384                              + htab->elf.splt->output_offset
13385                              + ent->plt.offset);
13386             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13387             rela.r_addend = ent->addend;
13388             loc = (htab->elf.srelplt->contents
13389                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13390                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13391             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13392               htab->maybe_local_ifunc_resolver = 1;
13393             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13394           }
13395       }
13396
13397   if (!h->pointer_equality_needed)
13398     return TRUE;
13399
13400   if (h->def_regular)
13401     return TRUE;
13402
13403   s = htab->global_entry;
13404   if (s == NULL || s->size == 0)
13405     return TRUE;
13406
13407   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13408     if (ent->plt.offset != (bfd_vma) -1
13409         && ent->addend == 0)
13410       {
13411         bfd_byte *p;
13412         asection *plt;
13413         bfd_vma off;
13414
13415         p = s->contents + h->root.u.def.value;
13416         plt = htab->elf.splt;
13417         if (!htab->elf.dynamic_sections_created
13418             || h->dynindx == -1)
13419           {
13420             if (h->type == STT_GNU_IFUNC)
13421               plt = htab->elf.iplt;
13422             else
13423               plt = htab->pltlocal;
13424           }
13425         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13426         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13427
13428         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13429           {
13430             info->callbacks->einfo
13431               (_("%P: linkage table error against `%pT'\n"),
13432                h->root.root.string);
13433             bfd_set_error (bfd_error_bad_value);
13434             htab->stub_error = TRUE;
13435           }
13436
13437         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13438         if (htab->params->emit_stub_syms)
13439           {
13440             size_t len = strlen (h->root.root.string);
13441             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13442
13443             if (name == NULL)
13444               return FALSE;
13445
13446             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13447             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13448             if (h == NULL)
13449               return FALSE;
13450             if (h->root.type == bfd_link_hash_new)
13451               {
13452                 h->root.type = bfd_link_hash_defined;
13453                 h->root.u.def.section = s;
13454                 h->root.u.def.value = p - s->contents;
13455                 h->ref_regular = 1;
13456                 h->def_regular = 1;
13457                 h->ref_regular_nonweak = 1;
13458                 h->forced_local = 1;
13459                 h->non_elf = 0;
13460                 h->root.linker_def = 1;
13461               }
13462           }
13463
13464         if (PPC_HA (off) != 0)
13465           {
13466             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13467             p += 4;
13468           }
13469         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13470         p += 4;
13471         bfd_put_32 (s->owner, MTCTR_R12, p);
13472         p += 4;
13473         bfd_put_32 (s->owner, BCTR, p);
13474         break;
13475       }
13476   return TRUE;
13477 }
13478
13479 /* Write PLT relocs for locals.  */
13480
13481 static bfd_boolean
13482 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13483 {
13484   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13485   bfd *ibfd;
13486
13487   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13488     {
13489       struct got_entry **lgot_ents, **end_lgot_ents;
13490       struct plt_entry **local_plt, **lplt, **end_local_plt;
13491       Elf_Internal_Shdr *symtab_hdr;
13492       bfd_size_type locsymcount;
13493       Elf_Internal_Sym *local_syms = NULL;
13494       struct plt_entry *ent;
13495
13496       if (!is_ppc64_elf (ibfd))
13497         continue;
13498
13499       lgot_ents = elf_local_got_ents (ibfd);
13500       if (!lgot_ents)
13501         continue;
13502
13503       symtab_hdr = &elf_symtab_hdr (ibfd);
13504       locsymcount = symtab_hdr->sh_info;
13505       end_lgot_ents = lgot_ents + locsymcount;
13506       local_plt = (struct plt_entry **) end_lgot_ents;
13507       end_local_plt = local_plt + locsymcount;
13508       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13509         for (ent = *lplt; ent != NULL; ent = ent->next)
13510           if (ent->plt.offset != (bfd_vma) -1)
13511             {
13512               Elf_Internal_Sym *sym;
13513               asection *sym_sec;
13514               asection *plt, *relplt;
13515               bfd_byte *loc;
13516               bfd_vma val;
13517
13518               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13519                               lplt - local_plt, ibfd))
13520                 {
13521                   if (local_syms != NULL
13522                       && symtab_hdr->contents != (unsigned char *) local_syms)
13523                     free (local_syms);
13524                   return FALSE;
13525                 }
13526
13527               val = sym->st_value + ent->addend;
13528               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13529               if (sym_sec != NULL && sym_sec->output_section != NULL)
13530                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13531
13532               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13533                 {
13534                   htab->local_ifunc_resolver = 1;
13535                   plt = htab->elf.iplt;
13536                   relplt = htab->elf.irelplt;
13537                 }
13538               else
13539                 {
13540                   plt = htab->pltlocal;
13541                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13542                 }
13543
13544               if (relplt == NULL)
13545                 {
13546                   loc = plt->contents + ent->plt.offset;
13547                   bfd_put_64 (info->output_bfd, val, loc);
13548                   if (htab->opd_abi)
13549                     {
13550                       bfd_vma toc = elf_gp (ibfd);
13551                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13552                     }
13553                 }
13554               else
13555                 {
13556                   Elf_Internal_Rela rela;
13557                   rela.r_offset = (ent->plt.offset
13558                                    + plt->output_offset
13559                                    + plt->output_section->vma);
13560                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13561                     {
13562                       if (htab->opd_abi)
13563                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13564                       else
13565                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13566                     }
13567                   else
13568                     {
13569                       if (htab->opd_abi)
13570                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13571                       else
13572                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13573                     }
13574                   rela.r_addend = val;
13575                   loc = relplt->contents + (relplt->reloc_count++
13576                                             * sizeof (Elf64_External_Rela));
13577                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13578                 }
13579             }
13580
13581       if (local_syms != NULL
13582           && symtab_hdr->contents != (unsigned char *) local_syms)
13583         {
13584           if (!info->keep_memory)
13585             free (local_syms);
13586           else
13587             symtab_hdr->contents = (unsigned char *) local_syms;
13588         }
13589     }
13590   return TRUE;
13591 }
13592
13593 /* Build all the stubs associated with the current output file.
13594    The stubs are kept in a hash table attached to the main linker
13595    hash table.  This function is called via gldelf64ppc_finish.  */
13596
13597 bfd_boolean
13598 ppc64_elf_build_stubs (struct bfd_link_info *info,
13599                        char **stats)
13600 {
13601   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13602   struct map_stub *group;
13603   asection *stub_sec;
13604   bfd_byte *p;
13605   int stub_sec_count = 0;
13606
13607   if (htab == NULL)
13608     return FALSE;
13609
13610   /* Allocate memory to hold the linker stubs.  */
13611   for (group = htab->group; group != NULL; group = group->next)
13612     if ((stub_sec = group->stub_sec) != NULL
13613         && stub_sec->size != 0)
13614       {
13615         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13616         if (stub_sec->contents == NULL)
13617           return FALSE;
13618         stub_sec->size = 0;
13619       }
13620
13621   if (htab->glink != NULL && htab->glink->size != 0)
13622     {
13623       unsigned int indx;
13624       bfd_vma plt0;
13625
13626       /* Build the .glink plt call stub.  */
13627       if (htab->params->emit_stub_syms)
13628         {
13629           struct elf_link_hash_entry *h;
13630           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13631                                     TRUE, FALSE, FALSE);
13632           if (h == NULL)
13633             return FALSE;
13634           if (h->root.type == bfd_link_hash_new)
13635             {
13636               h->root.type = bfd_link_hash_defined;
13637               h->root.u.def.section = htab->glink;
13638               h->root.u.def.value = 8;
13639               h->ref_regular = 1;
13640               h->def_regular = 1;
13641               h->ref_regular_nonweak = 1;
13642               h->forced_local = 1;
13643               h->non_elf = 0;
13644               h->root.linker_def = 1;
13645             }
13646         }
13647       plt0 = (htab->elf.splt->output_section->vma
13648               + htab->elf.splt->output_offset
13649               - 16);
13650       if (info->emitrelocations)
13651         {
13652           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13653           if (r == NULL)
13654             return FALSE;
13655           r->r_offset = (htab->glink->output_offset
13656                          + htab->glink->output_section->vma);
13657           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13658           r->r_addend = plt0;
13659         }
13660       p = htab->glink->contents;
13661       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13662       bfd_put_64 (htab->glink->owner, plt0, p);
13663       p += 8;
13664       if (htab->opd_abi)
13665         {
13666           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13667           p += 4;
13668           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13669           p += 4;
13670           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13671           p += 4;
13672           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13673           p += 4;
13674           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13675           p += 4;
13676           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13677           p += 4;
13678           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13679           p += 4;
13680           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13681           p += 4;
13682           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13683           p += 4;
13684           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13685           p += 4;
13686         }
13687       else
13688         {
13689           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13690           p += 4;
13691           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13692           p += 4;
13693           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13694           p += 4;
13695           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13696           p += 4;
13697           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13698           p += 4;
13699           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13700           p += 4;
13701           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13702           p += 4;
13703           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13704           p += 4;
13705           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13706           p += 4;
13707           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13708           p += 4;
13709           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13710           p += 4;
13711           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13712           p += 4;
13713           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13714           p += 4;
13715         }
13716       bfd_put_32 (htab->glink->owner, BCTR, p);
13717       p += 4;
13718       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13719
13720       /* Build the .glink lazy link call stubs.  */
13721       indx = 0;
13722       while (p < htab->glink->contents + htab->glink->size)
13723         {
13724           if (htab->opd_abi)
13725             {
13726               if (indx < 0x8000)
13727                 {
13728                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13729                   p += 4;
13730                 }
13731               else
13732                 {
13733                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13734                   p += 4;
13735                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13736                               p);
13737                   p += 4;
13738                 }
13739             }
13740           bfd_put_32 (htab->glink->owner,
13741                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13742           indx++;
13743           p += 4;
13744         }
13745     }
13746
13747   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13748   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13749
13750   if (!write_plt_relocs_for_local_syms (info))
13751     return FALSE;
13752
13753   if (htab->brlt != NULL && htab->brlt->size != 0)
13754     {
13755       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13756                                          htab->brlt->size);
13757       if (htab->brlt->contents == NULL)
13758         return FALSE;
13759     }
13760   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13761     {
13762       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13763                                             htab->relbrlt->size);
13764       if (htab->relbrlt->contents == NULL)
13765         return FALSE;
13766     }
13767
13768   /* Build the stubs as directed by the stub hash table.  */
13769   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13770
13771   for (group = htab->group; group != NULL; group = group->next)
13772     if (group->needs_save_res)
13773       group->stub_sec->size += htab->sfpr->size;
13774
13775   if (htab->relbrlt != NULL)
13776     htab->relbrlt->reloc_count = 0;
13777
13778   if (htab->params->plt_stub_align != 0)
13779     for (group = htab->group; group != NULL; group = group->next)
13780       if ((stub_sec = group->stub_sec) != NULL)
13781         {
13782           int align = abs (htab->params->plt_stub_align);
13783           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13784         }
13785
13786   for (group = htab->group; group != NULL; group = group->next)
13787     if (group->needs_save_res)
13788       {
13789         stub_sec = group->stub_sec;
13790         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13791                 htab->sfpr->contents, htab->sfpr->size);
13792         if (htab->params->emit_stub_syms)
13793           {
13794             unsigned int i;
13795
13796             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13797               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13798                 return FALSE;
13799           }
13800       }
13801
13802   for (group = htab->group; group != NULL; group = group->next)
13803     if ((stub_sec = group->stub_sec) != NULL)
13804       {
13805         stub_sec_count += 1;
13806         if (stub_sec->rawsize != stub_sec->size
13807             && (htab->stub_iteration <= STUB_SHRINK_ITER
13808                 || stub_sec->rawsize < stub_sec->size))
13809           break;
13810       }
13811
13812   if (group != NULL)
13813     {
13814       htab->stub_error = TRUE;
13815       _bfd_error_handler (_("stubs don't match calculated size"));
13816     }
13817
13818   if (htab->stub_error)
13819     return FALSE;
13820
13821   if (stats != NULL)
13822     {
13823       size_t len;
13824       *stats = bfd_malloc (500);
13825       if (*stats == NULL)
13826         return FALSE;
13827
13828       len = sprintf (*stats,
13829                      ngettext ("linker stubs in %u group\n",
13830                                "linker stubs in %u groups\n",
13831                                stub_sec_count),
13832                      stub_sec_count);
13833       sprintf (*stats + len, _("  branch       %lu\n"
13834                                "  toc adjust   %lu\n"
13835                                "  long branch  %lu\n"
13836                                "  long toc adj %lu\n"
13837                                "  plt call     %lu\n"
13838                                "  plt call toc %lu\n"
13839                                "  global entry %lu"),
13840                htab->stub_count[ppc_stub_long_branch - 1],
13841                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13842                htab->stub_count[ppc_stub_plt_branch - 1],
13843                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13844                htab->stub_count[ppc_stub_plt_call - 1],
13845                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13846                htab->stub_count[ppc_stub_global_entry - 1]);
13847     }
13848   return TRUE;
13849 }
13850
13851 /* What to do when ld finds relocations against symbols defined in
13852    discarded sections.  */
13853
13854 static unsigned int
13855 ppc64_elf_action_discarded (asection *sec)
13856 {
13857   if (strcmp (".opd", sec->name) == 0)
13858     return 0;
13859
13860   if (strcmp (".toc", sec->name) == 0)
13861     return 0;
13862
13863   if (strcmp (".toc1", sec->name) == 0)
13864     return 0;
13865
13866   return _bfd_elf_default_action_discarded (sec);
13867 }
13868
13869 /* The RELOCATE_SECTION function is called by the ELF backend linker
13870    to handle the relocations for a section.
13871
13872    The relocs are always passed as Rela structures; if the section
13873    actually uses Rel structures, the r_addend field will always be
13874    zero.
13875
13876    This function is responsible for adjust the section contents as
13877    necessary, and (if using Rela relocs and generating a
13878    relocatable output file) adjusting the reloc addend as
13879    necessary.
13880
13881    This function does not have to worry about setting the reloc
13882    address or the reloc symbol index.
13883
13884    LOCAL_SYMS is a pointer to the swapped in local symbols.
13885
13886    LOCAL_SECTIONS is an array giving the section in the input file
13887    corresponding to the st_shndx field of each local symbol.
13888
13889    The global hash table entry for the global symbols can be found
13890    via elf_sym_hashes (input_bfd).
13891
13892    When generating relocatable output, this function must handle
13893    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13894    going to be the section symbol corresponding to the output
13895    section, which means that the addend must be adjusted
13896    accordingly.  */
13897
13898 static bfd_boolean
13899 ppc64_elf_relocate_section (bfd *output_bfd,
13900                             struct bfd_link_info *info,
13901                             bfd *input_bfd,
13902                             asection *input_section,
13903                             bfd_byte *contents,
13904                             Elf_Internal_Rela *relocs,
13905                             Elf_Internal_Sym *local_syms,
13906                             asection **local_sections)
13907 {
13908   struct ppc_link_hash_table *htab;
13909   Elf_Internal_Shdr *symtab_hdr;
13910   struct elf_link_hash_entry **sym_hashes;
13911   Elf_Internal_Rela *rel;
13912   Elf_Internal_Rela *wrel;
13913   Elf_Internal_Rela *relend;
13914   Elf_Internal_Rela outrel;
13915   bfd_byte *loc;
13916   struct got_entry **local_got_ents;
13917   bfd_vma TOCstart;
13918   bfd_boolean ret = TRUE;
13919   bfd_boolean is_opd;
13920   /* Assume 'at' branch hints.  */
13921   bfd_boolean is_isa_v2 = TRUE;
13922   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13923
13924   /* Initialize howto table if needed.  */
13925   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13926     ppc_howto_init ();
13927
13928   htab = ppc_hash_table (info);
13929   if (htab == NULL)
13930     return FALSE;
13931
13932   /* Don't relocate stub sections.  */
13933   if (input_section->owner == htab->params->stub_bfd)
13934     return TRUE;
13935
13936   BFD_ASSERT (is_ppc64_elf (input_bfd));
13937
13938   local_got_ents = elf_local_got_ents (input_bfd);
13939   TOCstart = elf_gp (output_bfd);
13940   symtab_hdr = &elf_symtab_hdr (input_bfd);
13941   sym_hashes = elf_sym_hashes (input_bfd);
13942   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13943
13944   rel = wrel = relocs;
13945   relend = relocs + input_section->reloc_count;
13946   for (; rel < relend; wrel++, rel++)
13947     {
13948       enum elf_ppc64_reloc_type r_type;
13949       bfd_vma addend;
13950       bfd_reloc_status_type r;
13951       Elf_Internal_Sym *sym;
13952       asection *sec;
13953       struct elf_link_hash_entry *h_elf;
13954       struct ppc_link_hash_entry *h;
13955       struct ppc_link_hash_entry *fdh;
13956       const char *sym_name;
13957       unsigned long r_symndx, toc_symndx;
13958       bfd_vma toc_addend;
13959       unsigned char tls_mask, tls_gd, tls_type;
13960       unsigned char sym_type;
13961       bfd_vma relocation;
13962       bfd_boolean unresolved_reloc, save_unresolved_reloc;
13963       bfd_boolean warned;
13964       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13965       unsigned int insn;
13966       unsigned int mask;
13967       struct ppc_stub_hash_entry *stub_entry;
13968       bfd_vma max_br_offset;
13969       bfd_vma from;
13970       Elf_Internal_Rela orig_rel;
13971       reloc_howto_type *howto;
13972       struct reloc_howto_struct alt_howto;
13973
13974     again:
13975       orig_rel = *rel;
13976
13977       r_type = ELF64_R_TYPE (rel->r_info);
13978       r_symndx = ELF64_R_SYM (rel->r_info);
13979
13980       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13981          symbol of the previous ADDR64 reloc.  The symbol gives us the
13982          proper TOC base to use.  */
13983       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13984           && wrel != relocs
13985           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13986           && is_opd)
13987         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13988
13989       sym = NULL;
13990       sec = NULL;
13991       h_elf = NULL;
13992       sym_name = NULL;
13993       unresolved_reloc = FALSE;
13994       warned = FALSE;
13995
13996       if (r_symndx < symtab_hdr->sh_info)
13997         {
13998           /* It's a local symbol.  */
13999           struct _opd_sec_data *opd;
14000
14001           sym = local_syms + r_symndx;
14002           sec = local_sections[r_symndx];
14003           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14004           sym_type = ELF64_ST_TYPE (sym->st_info);
14005           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14006           opd = get_opd_info (sec);
14007           if (opd != NULL && opd->adjust != NULL)
14008             {
14009               long adjust = opd->adjust[OPD_NDX (sym->st_value
14010                                                  + rel->r_addend)];
14011               if (adjust == -1)
14012                 relocation = 0;
14013               else
14014                 {
14015                   /* If this is a relocation against the opd section sym
14016                      and we have edited .opd, adjust the reloc addend so
14017                      that ld -r and ld --emit-relocs output is correct.
14018                      If it is a reloc against some other .opd symbol,
14019                      then the symbol value will be adjusted later.  */
14020                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14021                     rel->r_addend += adjust;
14022                   else
14023                     relocation += adjust;
14024                 }
14025             }
14026         }
14027       else
14028         {
14029           bfd_boolean ignored;
14030
14031           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14032                                    r_symndx, symtab_hdr, sym_hashes,
14033                                    h_elf, sec, relocation,
14034                                    unresolved_reloc, warned, ignored);
14035           sym_name = h_elf->root.root.string;
14036           sym_type = h_elf->type;
14037           if (sec != NULL
14038               && sec->owner == output_bfd
14039               && strcmp (sec->name, ".opd") == 0)
14040             {
14041               /* This is a symbol defined in a linker script.  All
14042                  such are defined in output sections, even those
14043                  defined by simple assignment from a symbol defined in
14044                  an input section.  Transfer the symbol to an
14045                  appropriate input .opd section, so that a branch to
14046                  this symbol will be mapped to the location specified
14047                  by the opd entry.  */
14048               struct bfd_link_order *lo;
14049               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14050                 if (lo->type == bfd_indirect_link_order)
14051                   {
14052                     asection *isec = lo->u.indirect.section;
14053                     if (h_elf->root.u.def.value >= isec->output_offset
14054                         && h_elf->root.u.def.value < (isec->output_offset
14055                                                       + isec->size))
14056                       {
14057                         h_elf->root.u.def.value -= isec->output_offset;
14058                         h_elf->root.u.def.section = isec;
14059                         sec = isec;
14060                         break;
14061                       }
14062                   }
14063             }
14064         }
14065       h = (struct ppc_link_hash_entry *) h_elf;
14066
14067       if (sec != NULL && discarded_section (sec))
14068         {
14069           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14070                                input_bfd, input_section,
14071                                contents + rel->r_offset);
14072           wrel->r_offset = rel->r_offset;
14073           wrel->r_info = 0;
14074           wrel->r_addend = 0;
14075
14076           /* For ld -r, remove relocations in debug sections against
14077              symbols defined in discarded sections.  Not done for
14078              non-debug to preserve relocs in .eh_frame which the
14079              eh_frame editing code expects to be present.  */
14080           if (bfd_link_relocatable (info)
14081               && (input_section->flags & SEC_DEBUGGING))
14082             wrel--;
14083
14084           continue;
14085         }
14086
14087       if (bfd_link_relocatable (info))
14088         goto copy_reloc;
14089
14090       if (h != NULL && &h->elf == htab->elf.hgot)
14091         {
14092           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14093           sec = bfd_abs_section_ptr;
14094           unresolved_reloc = FALSE;
14095         }
14096
14097       /* TLS optimizations.  Replace instruction sequences and relocs
14098          based on information we collected in tls_optimize.  We edit
14099          RELOCS so that --emit-relocs will output something sensible
14100          for the final instruction stream.  */
14101       tls_mask = 0;
14102       tls_gd = 0;
14103       toc_symndx = 0;
14104       if (h != NULL)
14105         tls_mask = h->tls_mask;
14106       else if (local_got_ents != NULL)
14107         {
14108           struct plt_entry **local_plt = (struct plt_entry **)
14109             (local_got_ents + symtab_hdr->sh_info);
14110           unsigned char *lgot_masks = (unsigned char *)
14111             (local_plt + symtab_hdr->sh_info);
14112           tls_mask = lgot_masks[r_symndx];
14113         }
14114       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14115           && (r_type == R_PPC64_TLS
14116               || r_type == R_PPC64_TLSGD
14117               || r_type == R_PPC64_TLSLD))
14118         {
14119           /* Check for toc tls entries.  */
14120           unsigned char *toc_tls;
14121
14122           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14123                              &local_syms, rel, input_bfd))
14124             return FALSE;
14125
14126           if (toc_tls)
14127             tls_mask = *toc_tls;
14128         }
14129
14130       /* Check that tls relocs are used with tls syms, and non-tls
14131          relocs are used with non-tls syms.  */
14132       if (r_symndx != STN_UNDEF
14133           && r_type != R_PPC64_NONE
14134           && (h == NULL
14135               || h->elf.root.type == bfd_link_hash_defined
14136               || h->elf.root.type == bfd_link_hash_defweak)
14137           && (IS_PPC64_TLS_RELOC (r_type)
14138               != (sym_type == STT_TLS
14139                   || (sym_type == STT_SECTION
14140                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14141         {
14142           if ((tls_mask & TLS_TLS) != 0
14143               && (r_type == R_PPC64_TLS
14144                   || r_type == R_PPC64_TLSGD
14145                   || r_type == R_PPC64_TLSLD))
14146             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14147             ;
14148           else
14149             info->callbacks->einfo
14150               (!IS_PPC64_TLS_RELOC (r_type)
14151                /* xgettext:c-format */
14152                ? _("%H: %s used with TLS symbol `%pT'\n")
14153                /* xgettext:c-format */
14154                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14155                input_bfd, input_section, rel->r_offset,
14156                ppc64_elf_howto_table[r_type]->name,
14157                sym_name);
14158         }
14159
14160       /* Ensure reloc mapping code below stays sane.  */
14161       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14162           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14163           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14164           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14165           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14166           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14167           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14168           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14169           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14170           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14171         abort ();
14172
14173       switch (r_type)
14174         {
14175         default:
14176           break;
14177
14178         case R_PPC64_LO_DS_OPT:
14179           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14180           if ((insn & (0x3f << 26)) != 58u << 26)
14181             abort ();
14182           insn += (14u << 26) - (58u << 26);
14183           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14184           r_type = R_PPC64_TOC16_LO;
14185           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14186           break;
14187
14188         case R_PPC64_TOC16:
14189         case R_PPC64_TOC16_LO:
14190         case R_PPC64_TOC16_DS:
14191         case R_PPC64_TOC16_LO_DS:
14192           {
14193             /* Check for toc tls entries.  */
14194             unsigned char *toc_tls;
14195             int retval;
14196
14197             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14198                                    &local_syms, rel, input_bfd);
14199             if (retval == 0)
14200               return FALSE;
14201
14202             if (toc_tls)
14203               {
14204                 tls_mask = *toc_tls;
14205                 if (r_type == R_PPC64_TOC16_DS
14206                     || r_type == R_PPC64_TOC16_LO_DS)
14207                   {
14208                     if ((tls_mask & TLS_TLS) != 0
14209                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14210                       goto toctprel;
14211                   }
14212                 else
14213                   {
14214                     /* If we found a GD reloc pair, then we might be
14215                        doing a GD->IE transition.  */
14216                     if (retval == 2)
14217                       {
14218                         tls_gd = TLS_TPRELGD;
14219                         if ((tls_mask & TLS_TLS) != 0
14220                             && (tls_mask & TLS_GD) == 0)
14221                           goto tls_ldgd_opt;
14222                       }
14223                     else if (retval == 3)
14224                       {
14225                         if ((tls_mask & TLS_TLS) != 0
14226                             && (tls_mask & TLS_LD) == 0)
14227                           goto tls_ldgd_opt;
14228                       }
14229                   }
14230               }
14231           }
14232           break;
14233
14234         case R_PPC64_GOT_TPREL16_HI:
14235         case R_PPC64_GOT_TPREL16_HA:
14236           if ((tls_mask & TLS_TLS) != 0
14237               && (tls_mask & TLS_TPREL) == 0)
14238             {
14239               rel->r_offset -= d_offset;
14240               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14241               r_type = R_PPC64_NONE;
14242               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14243             }
14244           break;
14245
14246         case R_PPC64_GOT_TPREL16_DS:
14247         case R_PPC64_GOT_TPREL16_LO_DS:
14248           if ((tls_mask & TLS_TLS) != 0
14249               && (tls_mask & TLS_TPREL) == 0)
14250             {
14251             toctprel:
14252               insn = bfd_get_32 (input_bfd,
14253                                  contents + rel->r_offset - d_offset);
14254               insn &= 31 << 21;
14255               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14256               bfd_put_32 (input_bfd, insn,
14257                           contents + rel->r_offset - d_offset);
14258               r_type = R_PPC64_TPREL16_HA;
14259               if (toc_symndx != 0)
14260                 {
14261                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14262                   rel->r_addend = toc_addend;
14263                   /* We changed the symbol.  Start over in order to
14264                      get h, sym, sec etc. right.  */
14265                   goto again;
14266                 }
14267               else
14268                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14269             }
14270           break;
14271
14272         case R_PPC64_TLS:
14273           if ((tls_mask & TLS_TLS) != 0
14274               && (tls_mask & TLS_TPREL) == 0)
14275             {
14276               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14277               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14278               if (insn == 0)
14279                 abort ();
14280               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14281               /* Was PPC64_TLS which sits on insn boundary, now
14282                  PPC64_TPREL16_LO which is at low-order half-word.  */
14283               rel->r_offset += d_offset;
14284               r_type = R_PPC64_TPREL16_LO;
14285               if (toc_symndx != 0)
14286                 {
14287                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14288                   rel->r_addend = toc_addend;
14289                   /* We changed the symbol.  Start over in order to
14290                      get h, sym, sec etc. right.  */
14291                   goto again;
14292                 }
14293               else
14294                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14295             }
14296           break;
14297
14298         case R_PPC64_GOT_TLSGD16_HI:
14299         case R_PPC64_GOT_TLSGD16_HA:
14300           tls_gd = TLS_TPRELGD;
14301           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14302             goto tls_gdld_hi;
14303           break;
14304
14305         case R_PPC64_GOT_TLSLD16_HI:
14306         case R_PPC64_GOT_TLSLD16_HA:
14307           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14308             {
14309             tls_gdld_hi:
14310               if ((tls_mask & tls_gd) != 0)
14311                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14312                           + R_PPC64_GOT_TPREL16_DS);
14313               else
14314                 {
14315                   rel->r_offset -= d_offset;
14316                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14317                   r_type = R_PPC64_NONE;
14318                 }
14319               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14320             }
14321           break;
14322
14323         case R_PPC64_GOT_TLSGD16:
14324         case R_PPC64_GOT_TLSGD16_LO:
14325           tls_gd = TLS_TPRELGD;
14326           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14327             goto tls_ldgd_opt;
14328           break;
14329
14330         case R_PPC64_GOT_TLSLD16:
14331         case R_PPC64_GOT_TLSLD16_LO:
14332           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14333             {
14334               unsigned int insn1, insn2;
14335               bfd_vma offset;
14336
14337             tls_ldgd_opt:
14338               offset = (bfd_vma) -1;
14339               /* If not using the newer R_PPC64_TLSGD/LD to mark
14340                  __tls_get_addr calls, we must trust that the call
14341                  stays with its arg setup insns, ie. that the next
14342                  reloc is the __tls_get_addr call associated with
14343                  the current reloc.  Edit both insns.  */
14344               if (input_section->has_tls_get_addr_call
14345                   && rel + 1 < relend
14346                   && branch_reloc_hash_match (input_bfd, rel + 1,
14347                                               htab->tls_get_addr,
14348                                               htab->tls_get_addr_fd))
14349                 offset = rel[1].r_offset;
14350               /* We read the low GOT_TLS (or TOC16) insn because we
14351                  need to keep the destination reg.  It may be
14352                  something other than the usual r3, and moved to r3
14353                  before the call by intervening code.  */
14354               insn1 = bfd_get_32 (input_bfd,
14355                                   contents + rel->r_offset - d_offset);
14356               if ((tls_mask & tls_gd) != 0)
14357                 {
14358                   /* IE */
14359                   insn1 &= (0x1f << 21) | (0x1f << 16);
14360                   insn1 |= 58 << 26;    /* ld */
14361                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14362                   if (offset != (bfd_vma) -1)
14363                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14364                   if ((tls_mask & TLS_EXPLICIT) == 0)
14365                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14366                               + R_PPC64_GOT_TPREL16_DS);
14367                   else
14368                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14369                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14370                 }
14371               else
14372                 {
14373                   /* LE */
14374                   insn1 &= 0x1f << 21;
14375                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14376                   insn2 = 0x38630000;   /* addi 3,3,0 */
14377                   if (tls_gd == 0)
14378                     {
14379                       /* Was an LD reloc.  */
14380                       if (toc_symndx)
14381                         sec = local_sections[toc_symndx];
14382                       for (r_symndx = 0;
14383                            r_symndx < symtab_hdr->sh_info;
14384                            r_symndx++)
14385                         if (local_sections[r_symndx] == sec)
14386                           break;
14387                       if (r_symndx >= symtab_hdr->sh_info)
14388                         r_symndx = STN_UNDEF;
14389                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14390                       if (r_symndx != STN_UNDEF)
14391                         rel->r_addend -= (local_syms[r_symndx].st_value
14392                                           + sec->output_offset
14393                                           + sec->output_section->vma);
14394                     }
14395                   else if (toc_symndx != 0)
14396                     {
14397                       r_symndx = toc_symndx;
14398                       rel->r_addend = toc_addend;
14399                     }
14400                   r_type = R_PPC64_TPREL16_HA;
14401                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14402                   if (offset != (bfd_vma) -1)
14403                     {
14404                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14405                                                     R_PPC64_TPREL16_LO);
14406                       rel[1].r_offset = offset + d_offset;
14407                       rel[1].r_addend = rel->r_addend;
14408                     }
14409                 }
14410               bfd_put_32 (input_bfd, insn1,
14411                           contents + rel->r_offset - d_offset);
14412               if (offset != (bfd_vma) -1)
14413                 bfd_put_32 (input_bfd, insn2, contents + offset);
14414               if ((tls_mask & tls_gd) == 0
14415                   && (tls_gd == 0 || toc_symndx != 0))
14416                 {
14417                   /* We changed the symbol.  Start over in order
14418                      to get h, sym, sec etc. right.  */
14419                   goto again;
14420                 }
14421             }
14422           break;
14423
14424         case R_PPC64_TLSGD:
14425           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14426               && rel + 1 < relend)
14427             {
14428               unsigned int insn2;
14429               bfd_vma offset = rel->r_offset;
14430
14431               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14432                 {
14433                   bfd_put_32 (output_bfd, NOP, contents + offset);
14434                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14435                   break;
14436                 }
14437
14438               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14439                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14440
14441               if ((tls_mask & TLS_TPRELGD) != 0)
14442                 {
14443                   /* IE */
14444                   r_type = R_PPC64_NONE;
14445                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14446                 }
14447               else
14448                 {
14449                   /* LE */
14450                   if (toc_symndx != 0)
14451                     {
14452                       r_symndx = toc_symndx;
14453                       rel->r_addend = toc_addend;
14454                     }
14455                   r_type = R_PPC64_TPREL16_LO;
14456                   rel->r_offset = offset + d_offset;
14457                   insn2 = 0x38630000;   /* addi 3,3,0 */
14458                 }
14459               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14460               /* Zap the reloc on the _tls_get_addr call too.  */
14461               BFD_ASSERT (offset == rel[1].r_offset);
14462               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14463               bfd_put_32 (input_bfd, insn2, contents + offset);
14464               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14465                 goto again;
14466             }
14467           break;
14468
14469         case R_PPC64_TLSLD:
14470           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14471               && rel + 1 < relend)
14472             {
14473               unsigned int insn2;
14474               bfd_vma offset = rel->r_offset;
14475
14476               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14477                 {
14478                   bfd_put_32 (output_bfd, NOP, contents + offset);
14479                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14480                   break;
14481                 }
14482
14483               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14484                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14485
14486               if (toc_symndx)
14487                 sec = local_sections[toc_symndx];
14488               for (r_symndx = 0;
14489                    r_symndx < symtab_hdr->sh_info;
14490                    r_symndx++)
14491                 if (local_sections[r_symndx] == sec)
14492                   break;
14493               if (r_symndx >= symtab_hdr->sh_info)
14494                 r_symndx = STN_UNDEF;
14495               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14496               if (r_symndx != STN_UNDEF)
14497                 rel->r_addend -= (local_syms[r_symndx].st_value
14498                                   + sec->output_offset
14499                                   + sec->output_section->vma);
14500
14501               r_type = R_PPC64_TPREL16_LO;
14502               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14503               rel->r_offset = offset + d_offset;
14504               /* Zap the reloc on the _tls_get_addr call too.  */
14505               BFD_ASSERT (offset == rel[1].r_offset);
14506               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14507               insn2 = 0x38630000;       /* addi 3,3,0 */
14508               bfd_put_32 (input_bfd, insn2, contents + offset);
14509               goto again;
14510             }
14511           break;
14512
14513         case R_PPC64_DTPMOD64:
14514           if (rel + 1 < relend
14515               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14516               && rel[1].r_offset == rel->r_offset + 8)
14517             {
14518               if ((tls_mask & TLS_GD) == 0)
14519                 {
14520                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14521                   if ((tls_mask & TLS_TPRELGD) != 0)
14522                     r_type = R_PPC64_TPREL64;
14523                   else
14524                     {
14525                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14526                       r_type = R_PPC64_NONE;
14527                     }
14528                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14529                 }
14530             }
14531           else
14532             {
14533               if ((tls_mask & TLS_LD) == 0)
14534                 {
14535                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14536                   r_type = R_PPC64_NONE;
14537                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14538                 }
14539             }
14540           break;
14541
14542         case R_PPC64_TPREL64:
14543           if ((tls_mask & TLS_TPREL) == 0)
14544             {
14545               r_type = R_PPC64_NONE;
14546               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14547             }
14548           break;
14549
14550         case R_PPC64_ENTRY:
14551           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14552           if (!bfd_link_pic (info)
14553               && !info->traditional_format
14554               && relocation + 0x80008000 <= 0xffffffff)
14555             {
14556               unsigned int insn1, insn2;
14557
14558               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14559               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14560               if ((insn1 & ~0xfffc) == LD_R2_0R12
14561                   && insn2 == ADD_R2_R2_R12)
14562                 {
14563                   bfd_put_32 (input_bfd,
14564                               LIS_R2 + PPC_HA (relocation),
14565                               contents + rel->r_offset);
14566                   bfd_put_32 (input_bfd,
14567                               ADDI_R2_R2 + PPC_LO (relocation),
14568                               contents + rel->r_offset + 4);
14569                 }
14570             }
14571           else
14572             {
14573               relocation -= (rel->r_offset
14574                              + input_section->output_offset
14575                              + input_section->output_section->vma);
14576               if (relocation + 0x80008000 <= 0xffffffff)
14577                 {
14578                   unsigned int insn1, insn2;
14579
14580                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14581                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14582                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14583                       && insn2 == ADD_R2_R2_R12)
14584                     {
14585                       bfd_put_32 (input_bfd,
14586                                   ADDIS_R2_R12 + PPC_HA (relocation),
14587                                   contents + rel->r_offset);
14588                       bfd_put_32 (input_bfd,
14589                                   ADDI_R2_R2 + PPC_LO (relocation),
14590                                   contents + rel->r_offset + 4);
14591                     }
14592                 }
14593             }
14594           break;
14595
14596         case R_PPC64_REL16_HA:
14597           /* If we are generating a non-PIC executable, edit
14598              .  0:      addis 2,12,.TOC.-0b@ha
14599              .          addi 2,2,.TOC.-0b@l
14600              used by ELFv2 global entry points to set up r2, to
14601              .          lis 2,.TOC.@ha
14602              .          addi 2,2,.TOC.@l
14603              if .TOC. is in range.  */
14604           if (!bfd_link_pic (info)
14605               && !info->traditional_format
14606               && !htab->opd_abi
14607               && rel->r_addend == d_offset
14608               && h != NULL && &h->elf == htab->elf.hgot
14609               && rel + 1 < relend
14610               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14611               && rel[1].r_offset == rel->r_offset + 4
14612               && rel[1].r_addend == rel->r_addend + 4
14613               && relocation + 0x80008000 <= 0xffffffff)
14614             {
14615               unsigned int insn1, insn2;
14616               bfd_vma offset = rel->r_offset - d_offset;
14617               insn1 = bfd_get_32 (input_bfd, contents + offset);
14618               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14619               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14620                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14621                 {
14622                   r_type = R_PPC64_ADDR16_HA;
14623                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14624                   rel->r_addend -= d_offset;
14625                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14626                   rel[1].r_addend -= d_offset + 4;
14627                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14628                 }
14629             }
14630           break;
14631         }
14632
14633       /* Handle other relocations that tweak non-addend part of insn.  */
14634       insn = 0;
14635       max_br_offset = 1 << 25;
14636       addend = rel->r_addend;
14637       reloc_dest = DEST_NORMAL;
14638       switch (r_type)
14639         {
14640         default:
14641           break;
14642
14643         case R_PPC64_TOCSAVE:
14644           if (relocation + addend == (rel->r_offset
14645                                       + input_section->output_offset
14646                                       + input_section->output_section->vma)
14647               && tocsave_find (htab, NO_INSERT,
14648                                &local_syms, rel, input_bfd))
14649             {
14650               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14651               if (insn == NOP
14652                   || insn == CROR_151515 || insn == CROR_313131)
14653                 bfd_put_32 (input_bfd,
14654                             STD_R2_0R1 + STK_TOC (htab),
14655                             contents + rel->r_offset);
14656             }
14657           break;
14658
14659           /* Branch taken prediction relocations.  */
14660         case R_PPC64_ADDR14_BRTAKEN:
14661         case R_PPC64_REL14_BRTAKEN:
14662           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14663           /* Fall through.  */
14664
14665           /* Branch not taken prediction relocations.  */
14666         case R_PPC64_ADDR14_BRNTAKEN:
14667         case R_PPC64_REL14_BRNTAKEN:
14668           insn |= bfd_get_32 (input_bfd,
14669                               contents + rel->r_offset) & ~(0x01 << 21);
14670           /* Fall through.  */
14671
14672         case R_PPC64_REL14:
14673           max_br_offset = 1 << 15;
14674           /* Fall through.  */
14675
14676         case R_PPC64_REL24:
14677         case R_PPC64_PLTCALL:
14678           /* Calls to functions with a different TOC, such as calls to
14679              shared objects, need to alter the TOC pointer.  This is
14680              done using a linkage stub.  A REL24 branching to these
14681              linkage stubs needs to be followed by a nop, as the nop
14682              will be replaced with an instruction to restore the TOC
14683              base pointer.  */
14684           fdh = h;
14685           if (h != NULL
14686               && h->oh != NULL
14687               && h->oh->is_func_descriptor)
14688             fdh = ppc_follow_link (h->oh);
14689           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14690                                            htab);
14691           if (r_type == R_PPC64_PLTCALL
14692               && stub_entry != NULL
14693               && (stub_entry->stub_type == ppc_stub_plt_call
14694                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14695             stub_entry = NULL;
14696
14697           if (stub_entry != NULL
14698               && (stub_entry->stub_type == ppc_stub_plt_call
14699                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14700                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14701                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14702             {
14703               bfd_boolean can_plt_call = FALSE;
14704
14705               if (stub_entry->stub_type == ppc_stub_plt_call
14706                   && !htab->opd_abi
14707                   && htab->params->plt_localentry0 != 0
14708                   && is_elfv2_localentry0 (&h->elf))
14709                 {
14710                   /* The function doesn't use or change r2.  */
14711                   can_plt_call = TRUE;
14712                 }
14713
14714               /* All of these stubs may modify r2, so there must be a
14715                  branch and link followed by a nop.  The nop is
14716                  replaced by an insn to restore r2.  */
14717               else if (rel->r_offset + 8 <= input_section->size)
14718                 {
14719                   unsigned long br;
14720
14721                   br = bfd_get_32 (input_bfd,
14722                                    contents + rel->r_offset);
14723                   if ((br & 1) != 0)
14724                     {
14725                       unsigned long nop;
14726
14727                       nop = bfd_get_32 (input_bfd,
14728                                         contents + rel->r_offset + 4);
14729                       if (nop == LD_R2_0R1 + STK_TOC (htab))
14730                         can_plt_call = TRUE;
14731                       else if (nop == NOP
14732                                || nop == CROR_151515
14733                                || nop == CROR_313131)
14734                         {
14735                           if (h != NULL
14736                               && (h == htab->tls_get_addr_fd
14737                                   || h == htab->tls_get_addr)
14738                               && htab->params->tls_get_addr_opt)
14739                             {
14740                               /* Special stub used, leave nop alone.  */
14741                             }
14742                           else
14743                             bfd_put_32 (input_bfd,
14744                                         LD_R2_0R1 + STK_TOC (htab),
14745                                         contents + rel->r_offset + 4);
14746                           can_plt_call = TRUE;
14747                         }
14748                     }
14749                 }
14750
14751               if (!can_plt_call && h != NULL)
14752                 {
14753                   const char *name = h->elf.root.root.string;
14754
14755                   if (*name == '.')
14756                     ++name;
14757
14758                   if (strncmp (name, "__libc_start_main", 17) == 0
14759                       && (name[17] == 0 || name[17] == '@'))
14760                     {
14761                       /* Allow crt1 branch to go via a toc adjusting
14762                          stub.  Other calls that never return could do
14763                          the same, if we could detect such.  */
14764                       can_plt_call = TRUE;
14765                     }
14766                 }
14767
14768               if (!can_plt_call)
14769                 {
14770                   /* g++ as of 20130507 emits self-calls without a
14771                      following nop.  This is arguably wrong since we
14772                      have conflicting information.  On the one hand a
14773                      global symbol and on the other a local call
14774                      sequence, but don't error for this special case.
14775                      It isn't possible to cheaply verify we have
14776                      exactly such a call.  Allow all calls to the same
14777                      section.  */
14778                   asection *code_sec = sec;
14779
14780                   if (get_opd_info (sec) != NULL)
14781                     {
14782                       bfd_vma off = (relocation + addend
14783                                      - sec->output_section->vma
14784                                      - sec->output_offset);
14785
14786                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14787                     }
14788                   if (code_sec == input_section)
14789                     can_plt_call = TRUE;
14790                 }
14791
14792               if (!can_plt_call)
14793                 {
14794                   if (stub_entry->stub_type == ppc_stub_plt_call
14795                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14796                     info->callbacks->einfo
14797                       /* xgettext:c-format */
14798                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14799                          "recompile with -fPIC\n"),
14800                        input_bfd, input_section, rel->r_offset, sym_name);
14801                   else
14802                     info->callbacks->einfo
14803                       /* xgettext:c-format */
14804                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14805                          "(-mcmodel=small toc adjust stub)\n"),
14806                        input_bfd, input_section, rel->r_offset, sym_name);
14807
14808                   bfd_set_error (bfd_error_bad_value);
14809                   ret = FALSE;
14810                 }
14811
14812               if (can_plt_call
14813                   && (stub_entry->stub_type == ppc_stub_plt_call
14814                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14815                 unresolved_reloc = FALSE;
14816             }
14817
14818           if ((stub_entry == NULL
14819                || stub_entry->stub_type == ppc_stub_long_branch
14820                || stub_entry->stub_type == ppc_stub_plt_branch)
14821               && get_opd_info (sec) != NULL)
14822             {
14823               /* The branch destination is the value of the opd entry. */
14824               bfd_vma off = (relocation + addend
14825                              - sec->output_section->vma
14826                              - sec->output_offset);
14827               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14828               if (dest != (bfd_vma) -1)
14829                 {
14830                   relocation = dest;
14831                   addend = 0;
14832                   reloc_dest = DEST_OPD;
14833                 }
14834             }
14835
14836           /* If the branch is out of reach we ought to have a long
14837              branch stub.  */
14838           from = (rel->r_offset
14839                   + input_section->output_offset
14840                   + input_section->output_section->vma);
14841
14842           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14843                                                   ? fdh->elf.other
14844                                                   : sym->st_other);
14845
14846           if (stub_entry != NULL
14847               && (stub_entry->stub_type == ppc_stub_long_branch
14848                   || stub_entry->stub_type == ppc_stub_plt_branch)
14849               && (r_type == R_PPC64_ADDR14_BRTAKEN
14850                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14851                   || (relocation + addend - from + max_br_offset
14852                       < 2 * max_br_offset)))
14853             /* Don't use the stub if this branch is in range.  */
14854             stub_entry = NULL;
14855
14856           if (stub_entry != NULL)
14857             {
14858               /* Munge up the value and addend so that we call the stub
14859                  rather than the procedure directly.  */
14860               asection *stub_sec = stub_entry->group->stub_sec;
14861
14862               if (stub_entry->stub_type == ppc_stub_save_res)
14863                 relocation += (stub_sec->output_offset
14864                                + stub_sec->output_section->vma
14865                                + stub_sec->size - htab->sfpr->size
14866                                - htab->sfpr->output_offset
14867                                - htab->sfpr->output_section->vma);
14868               else
14869                 relocation = (stub_entry->stub_offset
14870                               + stub_sec->output_offset
14871                               + stub_sec->output_section->vma);
14872               addend = 0;
14873               reloc_dest = DEST_STUB;
14874
14875               if ((stub_entry->stub_type == ppc_stub_plt_call
14876                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14877                   && (ALWAYS_EMIT_R2SAVE
14878                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14879                   && rel + 1 < relend
14880                   && rel[1].r_offset == rel->r_offset + 4
14881                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14882                 relocation += 4;
14883             }
14884
14885           if (insn != 0)
14886             {
14887               if (is_isa_v2)
14888                 {
14889                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14890                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14891                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14892                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14893                     insn |= 0x02 << 21;
14894                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14895                     insn |= 0x08 << 21;
14896                   else
14897                     break;
14898                 }
14899               else
14900                 {
14901                   /* Invert 'y' bit if not the default.  */
14902                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14903                     insn ^= 0x01 << 21;
14904                 }
14905
14906               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14907             }
14908
14909           /* NOP out calls to undefined weak functions.
14910              We can thus call a weak function without first
14911              checking whether the function is defined.  */
14912           else if (h != NULL
14913                    && h->elf.root.type == bfd_link_hash_undefweak
14914                    && h->elf.dynindx == -1
14915                    && r_type == R_PPC64_REL24
14916                    && relocation == 0
14917                    && addend == 0)
14918             {
14919               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14920               goto copy_reloc;
14921             }
14922           break;
14923         }
14924
14925       /* Set `addend'.  */
14926       tls_type = 0;
14927       save_unresolved_reloc = unresolved_reloc;
14928       switch (r_type)
14929         {
14930         default:
14931           /* xgettext:c-format */
14932           _bfd_error_handler (_("%pB: %s unsupported"),
14933                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14934
14935           bfd_set_error (bfd_error_bad_value);
14936           ret = FALSE;
14937           goto copy_reloc;
14938
14939         case R_PPC64_NONE:
14940         case R_PPC64_TLS:
14941         case R_PPC64_TLSGD:
14942         case R_PPC64_TLSLD:
14943         case R_PPC64_TOCSAVE:
14944         case R_PPC64_GNU_VTINHERIT:
14945         case R_PPC64_GNU_VTENTRY:
14946         case R_PPC64_ENTRY:
14947           goto copy_reloc;
14948
14949           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14950              address in the GOT as relocation value instead of the
14951              symbol's value itself.  Also, create a GOT entry for the
14952              symbol and put the symbol value there.  */
14953         case R_PPC64_GOT_TLSGD16:
14954         case R_PPC64_GOT_TLSGD16_LO:
14955         case R_PPC64_GOT_TLSGD16_HI:
14956         case R_PPC64_GOT_TLSGD16_HA:
14957           tls_type = TLS_TLS | TLS_GD;
14958           goto dogot;
14959
14960         case R_PPC64_GOT_TLSLD16:
14961         case R_PPC64_GOT_TLSLD16_LO:
14962         case R_PPC64_GOT_TLSLD16_HI:
14963         case R_PPC64_GOT_TLSLD16_HA:
14964           tls_type = TLS_TLS | TLS_LD;
14965           goto dogot;
14966
14967         case R_PPC64_GOT_TPREL16_DS:
14968         case R_PPC64_GOT_TPREL16_LO_DS:
14969         case R_PPC64_GOT_TPREL16_HI:
14970         case R_PPC64_GOT_TPREL16_HA:
14971           tls_type = TLS_TLS | TLS_TPREL;
14972           goto dogot;
14973
14974         case R_PPC64_GOT_DTPREL16_DS:
14975         case R_PPC64_GOT_DTPREL16_LO_DS:
14976         case R_PPC64_GOT_DTPREL16_HI:
14977         case R_PPC64_GOT_DTPREL16_HA:
14978           tls_type = TLS_TLS | TLS_DTPREL;
14979           goto dogot;
14980
14981         case R_PPC64_GOT16:
14982         case R_PPC64_GOT16_LO:
14983         case R_PPC64_GOT16_HI:
14984         case R_PPC64_GOT16_HA:
14985         case R_PPC64_GOT16_DS:
14986         case R_PPC64_GOT16_LO_DS:
14987         dogot:
14988           {
14989             /* Relocation is to the entry for this symbol in the global
14990                offset table.  */
14991             asection *got;
14992             bfd_vma *offp;
14993             bfd_vma off;
14994             unsigned long indx = 0;
14995             struct got_entry *ent;
14996
14997             if (tls_type == (TLS_TLS | TLS_LD)
14998                 && (h == NULL
14999                     || !h->elf.def_dynamic))
15000               ent = ppc64_tlsld_got (input_bfd);
15001             else
15002               {
15003                 if (h != NULL)
15004                   {
15005                     if (!htab->elf.dynamic_sections_created
15006                         || h->elf.dynindx == -1
15007                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15008                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15009                       /* This is actually a static link, or it is a
15010                          -Bsymbolic link and the symbol is defined
15011                          locally, or the symbol was forced to be local
15012                          because of a version file.  */
15013                       ;
15014                     else
15015                       {
15016                         indx = h->elf.dynindx;
15017                         unresolved_reloc = FALSE;
15018                       }
15019                     ent = h->elf.got.glist;
15020                   }
15021                 else
15022                   {
15023                     if (local_got_ents == NULL)
15024                       abort ();
15025                     ent = local_got_ents[r_symndx];
15026                   }
15027
15028                 for (; ent != NULL; ent = ent->next)
15029                   if (ent->addend == orig_rel.r_addend
15030                       && ent->owner == input_bfd
15031                       && ent->tls_type == tls_type)
15032                     break;
15033               }
15034
15035             if (ent == NULL)
15036               abort ();
15037             if (ent->is_indirect)
15038               ent = ent->got.ent;
15039             offp = &ent->got.offset;
15040             got = ppc64_elf_tdata (ent->owner)->got;
15041             if (got == NULL)
15042               abort ();
15043
15044             /* The offset must always be a multiple of 8.  We use the
15045                least significant bit to record whether we have already
15046                processed this entry.  */
15047             off = *offp;
15048             if ((off & 1) != 0)
15049               off &= ~1;
15050             else
15051               {
15052                 /* Generate relocs for the dynamic linker, except in
15053                    the case of TLSLD where we'll use one entry per
15054                    module.  */
15055                 asection *relgot;
15056                 bfd_boolean ifunc;
15057
15058                 *offp = off | 1;
15059                 relgot = NULL;
15060                 ifunc = (h != NULL
15061                          ? h->elf.type == STT_GNU_IFUNC
15062                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15063                 if (ifunc)
15064                   {
15065                     relgot = htab->elf.irelplt;
15066                     if (indx == 0)
15067                       htab->local_ifunc_resolver = 1;
15068                     else if (is_static_defined (&h->elf))
15069                       htab->maybe_local_ifunc_resolver = 1;
15070                   }
15071                 else if (indx != 0
15072                          || (bfd_link_pic (info)
15073                              && (h == NULL
15074                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15075                                  || (tls_type == (TLS_TLS | TLS_LD)
15076                                      && !h->elf.def_dynamic))
15077                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15078                                   && bfd_link_executable (info)
15079                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15080                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15081                 if (relgot != NULL)
15082                   {
15083                     outrel.r_offset = (got->output_section->vma
15084                                        + got->output_offset
15085                                        + off);
15086                     outrel.r_addend = addend;
15087                     if (tls_type & (TLS_LD | TLS_GD))
15088                       {
15089                         outrel.r_addend = 0;
15090                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15091                         if (tls_type == (TLS_TLS | TLS_GD))
15092                           {
15093                             loc = relgot->contents;
15094                             loc += (relgot->reloc_count++
15095                                     * sizeof (Elf64_External_Rela));
15096                             bfd_elf64_swap_reloca_out (output_bfd,
15097                                                        &outrel, loc);
15098                             outrel.r_offset += 8;
15099                             outrel.r_addend = addend;
15100                             outrel.r_info
15101                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15102                           }
15103                       }
15104                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15105                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15106                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15107                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15108                     else if (indx != 0)
15109                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15110                     else
15111                       {
15112                         if (ifunc)
15113                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15114                         else
15115                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15116
15117                         /* Write the .got section contents for the sake
15118                            of prelink.  */
15119                         loc = got->contents + off;
15120                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15121                                     loc);
15122                       }
15123
15124                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15125                       {
15126                         outrel.r_addend += relocation;
15127                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15128                           {
15129                             if (htab->elf.tls_sec == NULL)
15130                               outrel.r_addend = 0;
15131                             else
15132                               outrel.r_addend -= htab->elf.tls_sec->vma;
15133                           }
15134                       }
15135                     loc = relgot->contents;
15136                     loc += (relgot->reloc_count++
15137                             * sizeof (Elf64_External_Rela));
15138                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15139                   }
15140
15141                 /* Init the .got section contents here if we're not
15142                    emitting a reloc.  */
15143                 else
15144                   {
15145                     relocation += addend;
15146                     if (tls_type != 0)
15147                       {
15148                         if (htab->elf.tls_sec == NULL)
15149                           relocation = 0;
15150                         else
15151                           {
15152                             if (tls_type & TLS_LD)
15153                               relocation = 0;
15154                             else
15155                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15156                             if (tls_type & TLS_TPREL)
15157                               relocation += DTP_OFFSET - TP_OFFSET;
15158                           }
15159
15160                         if (tls_type & (TLS_GD | TLS_LD))
15161                           {
15162                             bfd_put_64 (output_bfd, relocation,
15163                                         got->contents + off + 8);
15164                             relocation = 1;
15165                           }
15166                       }
15167                     bfd_put_64 (output_bfd, relocation,
15168                                 got->contents + off);
15169                   }
15170               }
15171
15172             if (off >= (bfd_vma) -2)
15173               abort ();
15174
15175             relocation = got->output_section->vma + got->output_offset + off;
15176             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15177           }
15178           break;
15179
15180         case R_PPC64_PLT16_HA:
15181         case R_PPC64_PLT16_HI:
15182         case R_PPC64_PLT16_LO:
15183         case R_PPC64_PLT16_LO_DS:
15184         case R_PPC64_PLT32:
15185         case R_PPC64_PLT64:
15186         case R_PPC64_PLTSEQ:
15187         case R_PPC64_PLTCALL:
15188           /* Relocation is to the entry for this symbol in the
15189              procedure linkage table.  */
15190           unresolved_reloc = TRUE;
15191           {
15192             struct plt_entry **plt_list = NULL;
15193             if (h != NULL)
15194               plt_list = &h->elf.plt.plist;
15195             else if (local_got_ents != NULL)
15196               {
15197                 struct plt_entry **local_plt = (struct plt_entry **)
15198                   (local_got_ents + symtab_hdr->sh_info);
15199                 plt_list = local_plt + r_symndx;
15200               }
15201             if (plt_list)
15202               {
15203                 struct plt_entry *ent;
15204
15205                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15206                   if (ent->plt.offset != (bfd_vma) -1
15207                       && ent->addend == orig_rel.r_addend)
15208                     {
15209                       asection *plt;
15210                       bfd_vma got;
15211
15212                       plt = htab->elf.splt;
15213                       if (!htab->elf.dynamic_sections_created
15214                           || h == NULL
15215                           || h->elf.dynindx == -1)
15216                         {
15217                           if (h != NULL
15218                               ? h->elf.type == STT_GNU_IFUNC
15219                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15220                             plt = htab->elf.iplt;
15221                           else
15222                             plt = htab->pltlocal;
15223                         }
15224                       relocation = (plt->output_section->vma
15225                                     + plt->output_offset
15226                                     + ent->plt.offset);
15227                       if (r_type == R_PPC64_PLT16_HA
15228                           || r_type ==R_PPC64_PLT16_HI
15229                           || r_type ==R_PPC64_PLT16_LO
15230                           || r_type ==R_PPC64_PLT16_LO_DS)
15231                         {
15232                           got = (elf_gp (output_bfd)
15233                                  + htab->sec_info[input_section->id].toc_off);
15234                           relocation -= got;
15235                         }
15236                       addend = 0;
15237                       unresolved_reloc = FALSE;
15238                       break;
15239                     }
15240               }
15241           }
15242           break;
15243
15244         case R_PPC64_TOC:
15245           /* Relocation value is TOC base.  */
15246           relocation = TOCstart;
15247           if (r_symndx == STN_UNDEF)
15248             relocation += htab->sec_info[input_section->id].toc_off;
15249           else if (unresolved_reloc)
15250             ;
15251           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15252             relocation += htab->sec_info[sec->id].toc_off;
15253           else
15254             unresolved_reloc = TRUE;
15255           goto dodyn;
15256
15257           /* TOC16 relocs.  We want the offset relative to the TOC base,
15258              which is the address of the start of the TOC plus 0x8000.
15259              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15260              in this order.  */
15261         case R_PPC64_TOC16:
15262         case R_PPC64_TOC16_LO:
15263         case R_PPC64_TOC16_HI:
15264         case R_PPC64_TOC16_DS:
15265         case R_PPC64_TOC16_LO_DS:
15266         case R_PPC64_TOC16_HA:
15267           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15268           break;
15269
15270           /* Relocate against the beginning of the section.  */
15271         case R_PPC64_SECTOFF:
15272         case R_PPC64_SECTOFF_LO:
15273         case R_PPC64_SECTOFF_HI:
15274         case R_PPC64_SECTOFF_DS:
15275         case R_PPC64_SECTOFF_LO_DS:
15276         case R_PPC64_SECTOFF_HA:
15277           if (sec != NULL)
15278             addend -= sec->output_section->vma;
15279           break;
15280
15281         case R_PPC64_REL16:
15282         case R_PPC64_REL16_LO:
15283         case R_PPC64_REL16_HI:
15284         case R_PPC64_REL16_HA:
15285         case R_PPC64_REL16DX_HA:
15286           break;
15287
15288         case R_PPC64_REL14:
15289         case R_PPC64_REL14_BRNTAKEN:
15290         case R_PPC64_REL14_BRTAKEN:
15291         case R_PPC64_REL24:
15292           break;
15293
15294         case R_PPC64_TPREL16:
15295         case R_PPC64_TPREL16_LO:
15296         case R_PPC64_TPREL16_HI:
15297         case R_PPC64_TPREL16_HA:
15298         case R_PPC64_TPREL16_DS:
15299         case R_PPC64_TPREL16_LO_DS:
15300         case R_PPC64_TPREL16_HIGH:
15301         case R_PPC64_TPREL16_HIGHA:
15302         case R_PPC64_TPREL16_HIGHER:
15303         case R_PPC64_TPREL16_HIGHERA:
15304         case R_PPC64_TPREL16_HIGHEST:
15305         case R_PPC64_TPREL16_HIGHESTA:
15306           if (h != NULL
15307               && h->elf.root.type == bfd_link_hash_undefweak
15308               && h->elf.dynindx == -1)
15309             {
15310               /* Make this relocation against an undefined weak symbol
15311                  resolve to zero.  This is really just a tweak, since
15312                  code using weak externs ought to check that they are
15313                  defined before using them.  */
15314               bfd_byte *p = contents + rel->r_offset - d_offset;
15315
15316               insn = bfd_get_32 (input_bfd, p);
15317               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15318               if (insn != 0)
15319                 bfd_put_32 (input_bfd, insn, p);
15320               break;
15321             }
15322           if (htab->elf.tls_sec != NULL)
15323             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15324           /* The TPREL16 relocs shouldn't really be used in shared
15325              libs or with non-local symbols as that will result in
15326              DT_TEXTREL being set, but support them anyway.  */
15327           goto dodyn;
15328
15329         case R_PPC64_DTPREL16:
15330         case R_PPC64_DTPREL16_LO:
15331         case R_PPC64_DTPREL16_HI:
15332         case R_PPC64_DTPREL16_HA:
15333         case R_PPC64_DTPREL16_DS:
15334         case R_PPC64_DTPREL16_LO_DS:
15335         case R_PPC64_DTPREL16_HIGH:
15336         case R_PPC64_DTPREL16_HIGHA:
15337         case R_PPC64_DTPREL16_HIGHER:
15338         case R_PPC64_DTPREL16_HIGHERA:
15339         case R_PPC64_DTPREL16_HIGHEST:
15340         case R_PPC64_DTPREL16_HIGHESTA:
15341           if (htab->elf.tls_sec != NULL)
15342             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15343           break;
15344
15345         case R_PPC64_ADDR64_LOCAL:
15346           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15347                                               ? h->elf.other
15348                                               : sym->st_other);
15349           break;
15350
15351         case R_PPC64_DTPMOD64:
15352           relocation = 1;
15353           addend = 0;
15354           goto dodyn;
15355
15356         case R_PPC64_TPREL64:
15357           if (htab->elf.tls_sec != NULL)
15358             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15359           goto dodyn;
15360
15361         case R_PPC64_DTPREL64:
15362           if (htab->elf.tls_sec != NULL)
15363             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15364           /* Fall through.  */
15365
15366           /* Relocations that may need to be propagated if this is a
15367              dynamic object.  */
15368         case R_PPC64_REL30:
15369         case R_PPC64_REL32:
15370         case R_PPC64_REL64:
15371         case R_PPC64_ADDR14:
15372         case R_PPC64_ADDR14_BRNTAKEN:
15373         case R_PPC64_ADDR14_BRTAKEN:
15374         case R_PPC64_ADDR16:
15375         case R_PPC64_ADDR16_DS:
15376         case R_PPC64_ADDR16_HA:
15377         case R_PPC64_ADDR16_HI:
15378         case R_PPC64_ADDR16_HIGH:
15379         case R_PPC64_ADDR16_HIGHA:
15380         case R_PPC64_ADDR16_HIGHER:
15381         case R_PPC64_ADDR16_HIGHERA:
15382         case R_PPC64_ADDR16_HIGHEST:
15383         case R_PPC64_ADDR16_HIGHESTA:
15384         case R_PPC64_ADDR16_LO:
15385         case R_PPC64_ADDR16_LO_DS:
15386         case R_PPC64_ADDR24:
15387         case R_PPC64_ADDR32:
15388         case R_PPC64_ADDR64:
15389         case R_PPC64_UADDR16:
15390         case R_PPC64_UADDR32:
15391         case R_PPC64_UADDR64:
15392         dodyn:
15393           if ((input_section->flags & SEC_ALLOC) == 0)
15394             break;
15395
15396           if (NO_OPD_RELOCS && is_opd)
15397             break;
15398
15399           if (bfd_link_pic (info)
15400               ? ((h == NULL
15401                   || h->dyn_relocs != NULL)
15402                  && ((h != NULL && pc_dynrelocs (h))
15403                      || must_be_dyn_reloc (info, r_type)))
15404               : (h != NULL
15405                  ? h->dyn_relocs != NULL
15406                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15407             {
15408               bfd_boolean skip, relocate;
15409               asection *sreloc;
15410               bfd_vma out_off;
15411               long indx = 0;
15412
15413               /* When generating a dynamic object, these relocations
15414                  are copied into the output file to be resolved at run
15415                  time.  */
15416
15417               skip = FALSE;
15418               relocate = FALSE;
15419
15420               out_off = _bfd_elf_section_offset (output_bfd, info,
15421                                                  input_section, rel->r_offset);
15422               if (out_off == (bfd_vma) -1)
15423                 skip = TRUE;
15424               else if (out_off == (bfd_vma) -2)
15425                 skip = TRUE, relocate = TRUE;
15426               out_off += (input_section->output_section->vma
15427                           + input_section->output_offset);
15428               outrel.r_offset = out_off;
15429               outrel.r_addend = rel->r_addend;
15430
15431               /* Optimize unaligned reloc use.  */
15432               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15433                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15434                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15435               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15436                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15437                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15438               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15439                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15440                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15441
15442               if (skip)
15443                 memset (&outrel, 0, sizeof outrel);
15444               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15445                        && !is_opd
15446                        && r_type != R_PPC64_TOC)
15447                 {
15448                   indx = h->elf.dynindx;
15449                   BFD_ASSERT (indx != -1);
15450                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15451                 }
15452               else
15453                 {
15454                   /* This symbol is local, or marked to become local,
15455                      or this is an opd section reloc which must point
15456                      at a local function.  */
15457                   outrel.r_addend += relocation;
15458                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15459                     {
15460                       if (is_opd && h != NULL)
15461                         {
15462                           /* Lie about opd entries.  This case occurs
15463                              when building shared libraries and we
15464                              reference a function in another shared
15465                              lib.  The same thing happens for a weak
15466                              definition in an application that's
15467                              overridden by a strong definition in a
15468                              shared lib.  (I believe this is a generic
15469                              bug in binutils handling of weak syms.)
15470                              In these cases we won't use the opd
15471                              entry in this lib.  */
15472                           unresolved_reloc = FALSE;
15473                         }
15474                       if (!is_opd
15475                           && r_type == R_PPC64_ADDR64
15476                           && (h != NULL
15477                               ? h->elf.type == STT_GNU_IFUNC
15478                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15479                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15480                       else
15481                         {
15482                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15483
15484                           /* We need to relocate .opd contents for ld.so.
15485                              Prelink also wants simple and consistent rules
15486                              for relocs.  This make all RELATIVE relocs have
15487                              *r_offset equal to r_addend.  */
15488                           relocate = TRUE;
15489                         }
15490                     }
15491                   else
15492                     {
15493                       if (h != NULL
15494                           ? h->elf.type == STT_GNU_IFUNC
15495                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15496                         {
15497                           info->callbacks->einfo
15498                             /* xgettext:c-format */
15499                             (_("%H: %s for indirect "
15500                                "function `%pT' unsupported\n"),
15501                              input_bfd, input_section, rel->r_offset,
15502                              ppc64_elf_howto_table[r_type]->name,
15503                              sym_name);
15504                           ret = FALSE;
15505                         }
15506                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15507                         ;
15508                       else if (sec == NULL || sec->owner == NULL)
15509                         {
15510                           bfd_set_error (bfd_error_bad_value);
15511                           return FALSE;
15512                         }
15513                       else
15514                         {
15515                           asection *osec;
15516
15517                           osec = sec->output_section;
15518                           indx = elf_section_data (osec)->dynindx;
15519
15520                           if (indx == 0)
15521                             {
15522                               if ((osec->flags & SEC_READONLY) == 0
15523                                   && htab->elf.data_index_section != NULL)
15524                                 osec = htab->elf.data_index_section;
15525                               else
15526                                 osec = htab->elf.text_index_section;
15527                               indx = elf_section_data (osec)->dynindx;
15528                             }
15529                           BFD_ASSERT (indx != 0);
15530
15531                           /* We are turning this relocation into one
15532                              against a section symbol, so subtract out
15533                              the output section's address but not the
15534                              offset of the input section in the output
15535                              section.  */
15536                           outrel.r_addend -= osec->vma;
15537                         }
15538
15539                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15540                     }
15541                 }
15542
15543               sreloc = elf_section_data (input_section)->sreloc;
15544               if (h != NULL
15545                   ? h->elf.type == STT_GNU_IFUNC
15546                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15547                 {
15548                   sreloc = htab->elf.irelplt;
15549                   if (indx == 0)
15550                     htab->local_ifunc_resolver = 1;
15551                   else if (is_static_defined (&h->elf))
15552                     htab->maybe_local_ifunc_resolver = 1;
15553                 }
15554               if (sreloc == NULL)
15555                 abort ();
15556
15557               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15558                   >= sreloc->size)
15559                 abort ();
15560               loc = sreloc->contents;
15561               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15562               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15563
15564               /* If this reloc is against an external symbol, it will
15565                  be computed at runtime, so there's no need to do
15566                  anything now.  However, for the sake of prelink ensure
15567                  that the section contents are a known value.  */
15568               if (! relocate)
15569                 {
15570                   unresolved_reloc = FALSE;
15571                   /* The value chosen here is quite arbitrary as ld.so
15572                      ignores section contents except for the special
15573                      case of .opd where the contents might be accessed
15574                      before relocation.  Choose zero, as that won't
15575                      cause reloc overflow.  */
15576                   relocation = 0;
15577                   addend = 0;
15578                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15579                      to improve backward compatibility with older
15580                      versions of ld.  */
15581                   if (r_type == R_PPC64_ADDR64)
15582                     addend = outrel.r_addend;
15583                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15584                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15585                     addend = outrel.r_offset;
15586                 }
15587             }
15588           break;
15589
15590         case R_PPC64_COPY:
15591         case R_PPC64_GLOB_DAT:
15592         case R_PPC64_JMP_SLOT:
15593         case R_PPC64_JMP_IREL:
15594         case R_PPC64_RELATIVE:
15595           /* We shouldn't ever see these dynamic relocs in relocatable
15596              files.  */
15597           /* Fall through.  */
15598
15599         case R_PPC64_PLTGOT16:
15600         case R_PPC64_PLTGOT16_DS:
15601         case R_PPC64_PLTGOT16_HA:
15602         case R_PPC64_PLTGOT16_HI:
15603         case R_PPC64_PLTGOT16_LO:
15604         case R_PPC64_PLTGOT16_LO_DS:
15605         case R_PPC64_PLTREL32:
15606         case R_PPC64_PLTREL64:
15607           /* These ones haven't been implemented yet.  */
15608
15609           info->callbacks->einfo
15610             /* xgettext:c-format */
15611             (_("%P: %pB: %s is not supported for `%pT'\n"),
15612              input_bfd,
15613              ppc64_elf_howto_table[r_type]->name, sym_name);
15614
15615           bfd_set_error (bfd_error_invalid_operation);
15616           ret = FALSE;
15617           goto copy_reloc;
15618         }
15619
15620       /* Multi-instruction sequences that access the TOC can be
15621          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15622          to             nop;           addi rb,r2,x;  */
15623       switch (r_type)
15624         {
15625         default:
15626           break;
15627
15628         case R_PPC64_GOT_TLSLD16_HI:
15629         case R_PPC64_GOT_TLSGD16_HI:
15630         case R_PPC64_GOT_TPREL16_HI:
15631         case R_PPC64_GOT_DTPREL16_HI:
15632         case R_PPC64_GOT16_HI:
15633         case R_PPC64_TOC16_HI:
15634           /* These relocs would only be useful if building up an
15635              offset to later add to r2, perhaps in an indexed
15636              addressing mode instruction.  Don't try to optimize.
15637              Unfortunately, the possibility of someone building up an
15638              offset like this or even with the HA relocs, means that
15639              we need to check the high insn when optimizing the low
15640              insn.  */
15641           break;
15642
15643         case R_PPC64_PLTCALL:
15644           if (unresolved_reloc)
15645             {
15646               /* No plt entry.  Make this into a direct call.  */
15647               bfd_byte *p = contents + rel->r_offset;
15648               insn = bfd_get_32 (input_bfd, p);
15649               insn &= 1;
15650               bfd_put_32 (input_bfd, B_DOT | insn, p);
15651               bfd_put_32 (input_bfd, NOP, p + 4);
15652               unresolved_reloc = save_unresolved_reloc;
15653               r_type = R_PPC64_REL24;
15654             }
15655           break;
15656
15657         case R_PPC64_PLTSEQ:
15658           if (unresolved_reloc)
15659             {
15660               unresolved_reloc = FALSE;
15661               goto nop_it;
15662             }
15663           break;
15664
15665         case R_PPC64_PLT16_HA:
15666           if (unresolved_reloc)
15667             {
15668               unresolved_reloc = FALSE;
15669               goto nop_it;
15670             }
15671           /* Fall through.  */
15672         case R_PPC64_GOT_TLSLD16_HA:
15673         case R_PPC64_GOT_TLSGD16_HA:
15674         case R_PPC64_GOT_TPREL16_HA:
15675         case R_PPC64_GOT_DTPREL16_HA:
15676         case R_PPC64_GOT16_HA:
15677         case R_PPC64_TOC16_HA:
15678           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15679               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15680             {
15681               bfd_byte *p;
15682             nop_it:
15683               p = contents + (rel->r_offset & ~3);
15684               bfd_put_32 (input_bfd, NOP, p);
15685               goto copy_reloc;
15686             }
15687           break;
15688
15689         case R_PPC64_PLT16_LO:
15690         case R_PPC64_PLT16_LO_DS:
15691           if (unresolved_reloc)
15692             {
15693               unresolved_reloc = FALSE;
15694               goto nop_it;
15695             }
15696           /* Fall through.  */
15697         case R_PPC64_GOT_TLSLD16_LO:
15698         case R_PPC64_GOT_TLSGD16_LO:
15699         case R_PPC64_GOT_TPREL16_LO_DS:
15700         case R_PPC64_GOT_DTPREL16_LO_DS:
15701         case R_PPC64_GOT16_LO:
15702         case R_PPC64_GOT16_LO_DS:
15703         case R_PPC64_TOC16_LO:
15704         case R_PPC64_TOC16_LO_DS:
15705           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15706               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15707             {
15708               bfd_byte *p = contents + (rel->r_offset & ~3);
15709               insn = bfd_get_32 (input_bfd, p);
15710               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15711                 {
15712                   /* Transform addic to addi when we change reg.  */
15713                   insn &= ~((0x3f << 26) | (0x1f << 16));
15714                   insn |= (14u << 26) | (2 << 16);
15715                 }
15716               else
15717                 {
15718                   insn &= ~(0x1f << 16);
15719                   insn |= 2 << 16;
15720                 }
15721               bfd_put_32 (input_bfd, insn, p);
15722             }
15723           break;
15724
15725         case R_PPC64_TPREL16_HA:
15726           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15727             {
15728               bfd_byte *p = contents + (rel->r_offset & ~3);
15729               insn = bfd_get_32 (input_bfd, p);
15730               if ((insn & ((0x3f << 26) | 0x1f << 16))
15731                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15732                 /* xgettext:c-format */
15733                 info->callbacks->minfo
15734                   (_("%H: warning: %s unexpected insn %#x.\n"),
15735                    input_bfd, input_section, rel->r_offset,
15736                    ppc64_elf_howto_table[r_type]->name, insn);
15737               else
15738                 {
15739                   bfd_put_32 (input_bfd, NOP, p);
15740                   goto copy_reloc;
15741                 }
15742             }
15743           break;
15744
15745         case R_PPC64_TPREL16_LO:
15746         case R_PPC64_TPREL16_LO_DS:
15747           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15748             {
15749               bfd_byte *p = contents + (rel->r_offset & ~3);
15750               insn = bfd_get_32 (input_bfd, p);
15751               insn &= ~(0x1f << 16);
15752               insn |= 13 << 16;
15753               bfd_put_32 (input_bfd, insn, p);
15754             }
15755           break;
15756         }
15757
15758       /* Do any further special processing.  */
15759       switch (r_type)
15760         {
15761         default:
15762           break;
15763
15764         case R_PPC64_REL16_HA:
15765         case R_PPC64_REL16DX_HA:
15766         case R_PPC64_ADDR16_HA:
15767         case R_PPC64_ADDR16_HIGHA:
15768         case R_PPC64_ADDR16_HIGHERA:
15769         case R_PPC64_ADDR16_HIGHESTA:
15770         case R_PPC64_TOC16_HA:
15771         case R_PPC64_SECTOFF_HA:
15772         case R_PPC64_TPREL16_HA:
15773         case R_PPC64_TPREL16_HIGHA:
15774         case R_PPC64_TPREL16_HIGHERA:
15775         case R_PPC64_TPREL16_HIGHESTA:
15776         case R_PPC64_DTPREL16_HA:
15777         case R_PPC64_DTPREL16_HIGHA:
15778         case R_PPC64_DTPREL16_HIGHERA:
15779         case R_PPC64_DTPREL16_HIGHESTA:
15780           /* It's just possible that this symbol is a weak symbol
15781              that's not actually defined anywhere. In that case,
15782              'sec' would be NULL, and we should leave the symbol
15783              alone (it will be set to zero elsewhere in the link).  */
15784           if (sec == NULL)
15785             break;
15786           /* Fall through.  */
15787
15788         case R_PPC64_GOT16_HA:
15789         case R_PPC64_PLTGOT16_HA:
15790         case R_PPC64_PLT16_HA:
15791         case R_PPC64_GOT_TLSGD16_HA:
15792         case R_PPC64_GOT_TLSLD16_HA:
15793         case R_PPC64_GOT_TPREL16_HA:
15794         case R_PPC64_GOT_DTPREL16_HA:
15795           /* Add 0x10000 if sign bit in 0:15 is set.
15796              Bits 0:15 are not used.  */
15797           addend += 0x8000;
15798           break;
15799
15800         case R_PPC64_ADDR16_DS:
15801         case R_PPC64_ADDR16_LO_DS:
15802         case R_PPC64_GOT16_DS:
15803         case R_PPC64_GOT16_LO_DS:
15804         case R_PPC64_PLT16_LO_DS:
15805         case R_PPC64_SECTOFF_DS:
15806         case R_PPC64_SECTOFF_LO_DS:
15807         case R_PPC64_TOC16_DS:
15808         case R_PPC64_TOC16_LO_DS:
15809         case R_PPC64_PLTGOT16_DS:
15810         case R_PPC64_PLTGOT16_LO_DS:
15811         case R_PPC64_GOT_TPREL16_DS:
15812         case R_PPC64_GOT_TPREL16_LO_DS:
15813         case R_PPC64_GOT_DTPREL16_DS:
15814         case R_PPC64_GOT_DTPREL16_LO_DS:
15815         case R_PPC64_TPREL16_DS:
15816         case R_PPC64_TPREL16_LO_DS:
15817         case R_PPC64_DTPREL16_DS:
15818         case R_PPC64_DTPREL16_LO_DS:
15819           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15820           mask = 3;
15821           /* If this reloc is against an lq, lxv, or stxv insn, then
15822              the value must be a multiple of 16.  This is somewhat of
15823              a hack, but the "correct" way to do this by defining _DQ
15824              forms of all the _DS relocs bloats all reloc switches in
15825              this file.  It doesn't make much sense to use these
15826              relocs in data, so testing the insn should be safe.  */
15827           if ((insn & (0x3f << 26)) == (56u << 26)
15828               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15829             mask = 15;
15830           relocation += addend;
15831           addend = insn & (mask ^ 3);
15832           if ((relocation & mask) != 0)
15833             {
15834               relocation ^= relocation & mask;
15835               info->callbacks->einfo
15836                 /* xgettext:c-format */
15837                 (_("%H: error: %s not a multiple of %u\n"),
15838                  input_bfd, input_section, rel->r_offset,
15839                  ppc64_elf_howto_table[r_type]->name,
15840                  mask + 1);
15841               bfd_set_error (bfd_error_bad_value);
15842               ret = FALSE;
15843               goto copy_reloc;
15844             }
15845           break;
15846         }
15847
15848       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15849          because such sections are not SEC_ALLOC and thus ld.so will
15850          not process them.  */
15851       howto = ppc64_elf_howto_table[(int) r_type];
15852       if (unresolved_reloc
15853           && !((input_section->flags & SEC_DEBUGGING) != 0
15854                && h->elf.def_dynamic)
15855           && _bfd_elf_section_offset (output_bfd, info, input_section,
15856                                       rel->r_offset) != (bfd_vma) -1)
15857         {
15858           info->callbacks->einfo
15859             /* xgettext:c-format */
15860             (_("%H: unresolvable %s against `%pT'\n"),
15861              input_bfd, input_section, rel->r_offset,
15862              howto->name,
15863              h->elf.root.root.string);
15864           ret = FALSE;
15865         }
15866
15867       /* 16-bit fields in insns mostly have signed values, but a
15868          few insns have 16-bit unsigned values.  Really, we should
15869          have different reloc types.  */
15870       if (howto->complain_on_overflow != complain_overflow_dont
15871           && howto->dst_mask == 0xffff
15872           && (input_section->flags & SEC_CODE) != 0)
15873         {
15874           enum complain_overflow complain = complain_overflow_signed;
15875
15876           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15877           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15878             complain = complain_overflow_bitfield;
15879           else if (howto->rightshift == 0
15880                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15881                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15882                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15883                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15884                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15885                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15886             complain = complain_overflow_unsigned;
15887           if (howto->complain_on_overflow != complain)
15888             {
15889               alt_howto = *howto;
15890               alt_howto.complain_on_overflow = complain;
15891               howto = &alt_howto;
15892             }
15893         }
15894
15895       if (r_type == R_PPC64_REL16DX_HA)
15896         {
15897           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15898           if (rel->r_offset + 4 > input_section->size)
15899             r = bfd_reloc_outofrange;
15900           else
15901             {
15902               relocation += addend;
15903               relocation -= (rel->r_offset
15904                              + input_section->output_offset
15905                              + input_section->output_section->vma);
15906               relocation = (bfd_signed_vma) relocation >> 16;
15907               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15908               insn &= ~0x1fffc1;
15909               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15910               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15911               r = bfd_reloc_ok;
15912               if (relocation + 0x8000 > 0xffff)
15913                 r = bfd_reloc_overflow;
15914             }
15915         }
15916       else
15917         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15918                                       rel->r_offset, relocation, addend);
15919
15920       if (r != bfd_reloc_ok)
15921         {
15922           char *more_info = NULL;
15923           const char *reloc_name = howto->name;
15924
15925           if (reloc_dest != DEST_NORMAL)
15926             {
15927               more_info = bfd_malloc (strlen (reloc_name) + 8);
15928               if (more_info != NULL)
15929                 {
15930                   strcpy (more_info, reloc_name);
15931                   strcat (more_info, (reloc_dest == DEST_OPD
15932                                       ? " (OPD)" : " (stub)"));
15933                   reloc_name = more_info;
15934                 }
15935             }
15936
15937           if (r == bfd_reloc_overflow)
15938             {
15939               /* On code like "if (foo) foo();" don't report overflow
15940                  on a branch to zero when foo is undefined.  */
15941               if (!warned
15942                   && (reloc_dest == DEST_STUB
15943                       || !(h != NULL
15944                            && (h->elf.root.type == bfd_link_hash_undefweak
15945                                || h->elf.root.type == bfd_link_hash_undefined)
15946                            && is_branch_reloc (r_type))))
15947                 info->callbacks->reloc_overflow (info, &h->elf.root,
15948                                                  sym_name, reloc_name,
15949                                                  orig_rel.r_addend,
15950                                                  input_bfd, input_section,
15951                                                  rel->r_offset);
15952             }
15953           else
15954             {
15955               info->callbacks->einfo
15956                 /* xgettext:c-format */
15957                 (_("%H: %s against `%pT': error %d\n"),
15958                  input_bfd, input_section, rel->r_offset,
15959                  reloc_name, sym_name, (int) r);
15960               ret = FALSE;
15961             }
15962           if (more_info != NULL)
15963             free (more_info);
15964         }
15965     copy_reloc:
15966       if (wrel != rel)
15967         *wrel = *rel;
15968     }
15969
15970   if (wrel != rel)
15971     {
15972       Elf_Internal_Shdr *rel_hdr;
15973       size_t deleted = rel - wrel;
15974
15975       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15976       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15977       if (rel_hdr->sh_size == 0)
15978         {
15979           /* It is too late to remove an empty reloc section.  Leave
15980              one NONE reloc.
15981              ??? What is wrong with an empty section???  */
15982           rel_hdr->sh_size = rel_hdr->sh_entsize;
15983           deleted -= 1;
15984         }
15985       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15986       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15987       input_section->reloc_count -= deleted;
15988     }
15989
15990   /* If we're emitting relocations, then shortly after this function
15991      returns, reloc offsets and addends for this section will be
15992      adjusted.  Worse, reloc symbol indices will be for the output
15993      file rather than the input.  Save a copy of the relocs for
15994      opd_entry_value.  */
15995   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15996     {
15997       bfd_size_type amt;
15998       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15999       rel = bfd_alloc (input_bfd, amt);
16000       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16001       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16002       if (rel == NULL)
16003         return FALSE;
16004       memcpy (rel, relocs, amt);
16005     }
16006   return ret;
16007 }
16008
16009 /* Adjust the value of any local symbols in opd sections.  */
16010
16011 static int
16012 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16013                               const char *name ATTRIBUTE_UNUSED,
16014                               Elf_Internal_Sym *elfsym,
16015                               asection *input_sec,
16016                               struct elf_link_hash_entry *h)
16017 {
16018   struct _opd_sec_data *opd;
16019   long adjust;
16020   bfd_vma value;
16021
16022   if (h != NULL)
16023     return 1;
16024
16025   opd = get_opd_info (input_sec);
16026   if (opd == NULL || opd->adjust == NULL)
16027     return 1;
16028
16029   value = elfsym->st_value - input_sec->output_offset;
16030   if (!bfd_link_relocatable (info))
16031     value -= input_sec->output_section->vma;
16032
16033   adjust = opd->adjust[OPD_NDX (value)];
16034   if (adjust == -1)
16035     return 2;
16036
16037   elfsym->st_value += adjust;
16038   return 1;
16039 }
16040
16041 /* Finish up dynamic symbol handling.  We set the contents of various
16042    dynamic sections here.  */
16043
16044 static bfd_boolean
16045 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16046                                  struct bfd_link_info *info,
16047                                  struct elf_link_hash_entry *h,
16048                                  Elf_Internal_Sym *sym)
16049 {
16050   struct ppc_link_hash_table *htab;
16051   struct plt_entry *ent;
16052
16053   htab = ppc_hash_table (info);
16054   if (htab == NULL)
16055     return FALSE;
16056
16057   if (!htab->opd_abi && !h->def_regular)
16058     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16059       if (ent->plt.offset != (bfd_vma) -1)
16060         {
16061           /* Mark the symbol as undefined, rather than as
16062              defined in glink.  Leave the value if there were
16063              any relocations where pointer equality matters
16064              (this is a clue for the dynamic linker, to make
16065              function pointer comparisons work between an
16066              application and shared library), otherwise set it
16067              to zero.  */
16068           sym->st_shndx = SHN_UNDEF;
16069           if (!h->pointer_equality_needed)
16070             sym->st_value = 0;
16071           else if (!h->ref_regular_nonweak)
16072             {
16073               /* This breaks function pointer comparisons, but
16074                  that is better than breaking tests for a NULL
16075                  function pointer.  */
16076               sym->st_value = 0;
16077             }
16078           break;
16079         }
16080
16081   if (h->needs_copy)
16082     {
16083       /* This symbol needs a copy reloc.  Set it up.  */
16084       Elf_Internal_Rela rela;
16085       asection *srel;
16086       bfd_byte *loc;
16087
16088       if (h->dynindx == -1
16089           || (h->root.type != bfd_link_hash_defined
16090               && h->root.type != bfd_link_hash_defweak)
16091           || htab->elf.srelbss == NULL
16092           || htab->elf.sreldynrelro == NULL)
16093         abort ();
16094
16095       rela.r_offset = (h->root.u.def.value
16096                        + h->root.u.def.section->output_section->vma
16097                        + h->root.u.def.section->output_offset);
16098       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16099       rela.r_addend = 0;
16100       if (h->root.u.def.section == htab->elf.sdynrelro)
16101         srel = htab->elf.sreldynrelro;
16102       else
16103         srel = htab->elf.srelbss;
16104       loc = srel->contents;
16105       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16106       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16107     }
16108
16109   return TRUE;
16110 }
16111
16112 /* Used to decide how to sort relocs in an optimal manner for the
16113    dynamic linker, before writing them out.  */
16114
16115 static enum elf_reloc_type_class
16116 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16117                             const asection *rel_sec,
16118                             const Elf_Internal_Rela *rela)
16119 {
16120   enum elf_ppc64_reloc_type r_type;
16121   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16122
16123   if (rel_sec == htab->elf.irelplt)
16124     return reloc_class_ifunc;
16125
16126   r_type = ELF64_R_TYPE (rela->r_info);
16127   switch (r_type)
16128     {
16129     case R_PPC64_RELATIVE:
16130       return reloc_class_relative;
16131     case R_PPC64_JMP_SLOT:
16132       return reloc_class_plt;
16133     case R_PPC64_COPY:
16134       return reloc_class_copy;
16135     default:
16136       return reloc_class_normal;
16137     }
16138 }
16139
16140 /* Finish up the dynamic sections.  */
16141
16142 static bfd_boolean
16143 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16144                                    struct bfd_link_info *info)
16145 {
16146   struct ppc_link_hash_table *htab;
16147   bfd *dynobj;
16148   asection *sdyn;
16149
16150   htab = ppc_hash_table (info);
16151   if (htab == NULL)
16152     return FALSE;
16153
16154   dynobj = htab->elf.dynobj;
16155   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16156
16157   if (htab->elf.dynamic_sections_created)
16158     {
16159       Elf64_External_Dyn *dyncon, *dynconend;
16160
16161       if (sdyn == NULL || htab->elf.sgot == NULL)
16162         abort ();
16163
16164       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16165       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16166       for (; dyncon < dynconend; dyncon++)
16167         {
16168           Elf_Internal_Dyn dyn;
16169           asection *s;
16170
16171           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16172
16173           switch (dyn.d_tag)
16174             {
16175             default:
16176               continue;
16177
16178             case DT_PPC64_GLINK:
16179               s = htab->glink;
16180               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16181               /* We stupidly defined DT_PPC64_GLINK to be the start
16182                  of glink rather than the first entry point, which is
16183                  what ld.so needs, and now have a bigger stub to
16184                  support automatic multiple TOCs.  */
16185               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16186               break;
16187
16188             case DT_PPC64_OPD:
16189               s = bfd_get_section_by_name (output_bfd, ".opd");
16190               if (s == NULL)
16191                 continue;
16192               dyn.d_un.d_ptr = s->vma;
16193               break;
16194
16195             case DT_PPC64_OPT:
16196               if (htab->do_multi_toc && htab->multi_toc_needed)
16197                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16198               if (htab->has_plt_localentry0)
16199                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16200               break;
16201
16202             case DT_PPC64_OPDSZ:
16203               s = bfd_get_section_by_name (output_bfd, ".opd");
16204               if (s == NULL)
16205                 continue;
16206               dyn.d_un.d_val = s->size;
16207               break;
16208
16209             case DT_PLTGOT:
16210               s = htab->elf.splt;
16211               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16212               break;
16213
16214             case DT_JMPREL:
16215               s = htab->elf.srelplt;
16216               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16217               break;
16218
16219             case DT_PLTRELSZ:
16220               dyn.d_un.d_val = htab->elf.srelplt->size;
16221               break;
16222
16223             case DT_TEXTREL:
16224               if (htab->local_ifunc_resolver)
16225                 info->callbacks->einfo
16226                   (_("%X%P: text relocations and GNU indirect "
16227                      "functions will result in a segfault at runtime\n"));
16228               else if (htab->maybe_local_ifunc_resolver)
16229                 info->callbacks->einfo
16230                   (_("%P: warning: text relocations and GNU indirect "
16231                      "functions may result in a segfault at runtime\n"));
16232               continue;
16233             }
16234
16235           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16236         }
16237     }
16238
16239   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16240       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16241     {
16242       /* Fill in the first entry in the global offset table.
16243          We use it to hold the link-time TOCbase.  */
16244       bfd_put_64 (output_bfd,
16245                   elf_gp (output_bfd) + TOC_BASE_OFF,
16246                   htab->elf.sgot->contents);
16247
16248       /* Set .got entry size.  */
16249       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16250     }
16251
16252   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16253       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16254     {
16255       /* Set .plt entry size.  */
16256       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16257         = PLT_ENTRY_SIZE (htab);
16258     }
16259
16260   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16261      brlt ourselves if emitrelocations.  */
16262   if (htab->brlt != NULL
16263       && htab->brlt->reloc_count != 0
16264       && !_bfd_elf_link_output_relocs (output_bfd,
16265                                        htab->brlt,
16266                                        elf_section_data (htab->brlt)->rela.hdr,
16267                                        elf_section_data (htab->brlt)->relocs,
16268                                        NULL))
16269     return FALSE;
16270
16271   if (htab->glink != NULL
16272       && htab->glink->reloc_count != 0
16273       && !_bfd_elf_link_output_relocs (output_bfd,
16274                                        htab->glink,
16275                                        elf_section_data (htab->glink)->rela.hdr,
16276                                        elf_section_data (htab->glink)->relocs,
16277                                        NULL))
16278     return FALSE;
16279
16280   if (htab->glink_eh_frame != NULL
16281       && htab->glink_eh_frame->size != 0)
16282     {
16283       bfd_vma val;
16284       bfd_byte *p;
16285       struct map_stub *group;
16286       size_t align = 4;
16287
16288       p = htab->glink_eh_frame->contents;
16289       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16290
16291       for (group = htab->group; group != NULL; group = group->next)
16292         if (group->stub_sec != NULL)
16293           {
16294             /* Offset to stub section.  */
16295             val = (group->stub_sec->output_section->vma
16296                    + group->stub_sec->output_offset);
16297             val -= (htab->glink_eh_frame->output_section->vma
16298                     + htab->glink_eh_frame->output_offset
16299                     + (p + 8 - htab->glink_eh_frame->contents));
16300             if (val + 0x80000000 > 0xffffffff)
16301               {
16302                 _bfd_error_handler
16303                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16304                    group->stub_sec->name);
16305                 return FALSE;
16306               }
16307             bfd_put_32 (dynobj, val, p + 8);
16308             p += stub_eh_frame_size (group, align);
16309           }
16310       if (htab->glink != NULL && htab->glink->size != 0)
16311         {
16312           /* Offset to .glink.  */
16313           val = (htab->glink->output_section->vma
16314                  + htab->glink->output_offset
16315                  + 8);
16316           val -= (htab->glink_eh_frame->output_section->vma
16317                   + htab->glink_eh_frame->output_offset
16318                   + (p + 8 - htab->glink_eh_frame->contents));
16319           if (val + 0x80000000 > 0xffffffff)
16320             {
16321               _bfd_error_handler
16322                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16323                  htab->glink->name);
16324               return FALSE;
16325             }
16326           bfd_put_32 (dynobj, val, p + 8);
16327           p += (24 + align - 1) & -align;
16328         }
16329
16330       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16331           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16332                                                htab->glink_eh_frame,
16333                                                htab->glink_eh_frame->contents))
16334         return FALSE;
16335     }
16336
16337   /* We need to handle writing out multiple GOT sections ourselves,
16338      since we didn't add them to DYNOBJ.  We know dynobj is the first
16339      bfd.  */
16340   while ((dynobj = dynobj->link.next) != NULL)
16341     {
16342       asection *s;
16343
16344       if (!is_ppc64_elf (dynobj))
16345         continue;
16346
16347       s = ppc64_elf_tdata (dynobj)->got;
16348       if (s != NULL
16349           && s->size != 0
16350           && s->output_section != bfd_abs_section_ptr
16351           && !bfd_set_section_contents (output_bfd, s->output_section,
16352                                         s->contents, s->output_offset,
16353                                         s->size))
16354         return FALSE;
16355       s = ppc64_elf_tdata (dynobj)->relgot;
16356       if (s != NULL
16357           && s->size != 0
16358           && s->output_section != bfd_abs_section_ptr
16359           && !bfd_set_section_contents (output_bfd, s->output_section,
16360                                         s->contents, s->output_offset,
16361                                         s->size))
16362         return FALSE;
16363     }
16364
16365   return TRUE;
16366 }
16367
16368 #include "elf64-target.h"
16369
16370 /* FreeBSD support */
16371
16372 #undef  TARGET_LITTLE_SYM
16373 #undef  TARGET_LITTLE_NAME
16374
16375 #undef  TARGET_BIG_SYM
16376 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16377 #undef  TARGET_BIG_NAME
16378 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16379
16380 #undef  ELF_OSABI
16381 #define ELF_OSABI       ELFOSABI_FREEBSD
16382
16383 #undef  elf64_bed
16384 #define elf64_bed       elf64_powerpc_fbsd_bed
16385
16386 #include "elf64-target.h"