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 <[email protected]>,
   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 ADDI_R12_R11    0x398b0000      /* addi %r12,%r11,off@l  */
 168 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 169 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 170 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 171
 172 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 173 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 174 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 175 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 176 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 177 #define BNECTR          0x4ca20420      /* bnectr+               */
 178 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 179
 180 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 181 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 182 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 183
 184 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 185 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 186 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 187
 188 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 189 #define LIS_R12         0x3d800000      /* lis %r12,xxx@ha        */
 190 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 191 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 192 #define ADDIS_R12_R11   0x3d8b0000      /* addis %r12,%r11,xxx@ha */
 193 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 194 #define ORIS_R12_R12_0  0x658c0000      /* oris  %r12,%r12,xxx@hi */
 195 #define ORI_R12_R12_0   0x618c0000      /* ori   %r12,%r12,xxx@l  */
 196 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 197 #define SLDI_R12_R12_32 0x799c07c6      /* sldi  %r12,%r12,32     */
 198 #define LDX_R12_R11_R12 0x7d8b602a      /* ldx   %r12,%r11,%r12   */
 199 #define ADD_R12_R11_R12 0x7d8b6214      /* add   %r12,%r11,%r12   */
 200
 201 /* __glink_PLTresolve stub instructions.  We enter with the index in R0.  */
 202 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 203   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 204                                         /* 0:                           */
 205                                         /*  .quad plt0-1f               */
 206                                         /* __glink:                     */
 207 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 208 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 209                                         /* 1:                           */
 210 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 211                                         /*  ld %2,(0b-1b)(%11)          */
 212 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 213 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 214                                         /*  ld %12,0(%11)               */
 215                                         /*  ld %2,8(%11)                */
 216                                         /*  mtctr %12                   */
 217                                         /*  ld %11,16(%11)              */
 218                                         /*  bctr                        */
 219 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 220 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 221 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 222 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 223 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 224
 225 /* Pad with this.  */
 226 #define NOP             0x60000000
 227
 228 /* Some other nops.  */
 229 #define CROR_151515     0x4def7b82
 230 #define CROR_313131     0x4ffffb82
 231
 232 /* .glink entries for the first 32k functions are two instructions.  */
 233 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 234 #define B_DOT           0x48000000      /* b     .              */
 235
 236 /* After that, we need two instructions to load the index, followed by
 237    a branch.  */
 238 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 239 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 240
 241 /* Instructions used by the save and restore reg functions.  */
 242 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 243 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 244 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 245 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 246 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 247 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 248 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 249 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 250 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 251 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 252 #define BLR             0x4e800020      /* blr                  */
 253
 254 /* Since .opd is an array of descriptors and each entry will end up
 255    with identical R_PPC64_RELATIVE relocs, there is really no need to
 256    propagate .opd relocs;  The dynamic linker should be taught to
 257    relocate .opd without reloc entries.  */
 258 #ifndef NO_OPD_RELOCS
 259 #define NO_OPD_RELOCS 0
 260 #endif
 261
 262 #ifndef ARRAY_SIZE
 263 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 264 #endif
 265
 266 static inline int
 267 abiversion (bfd *abfd)
 268 {
 269   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 270 }
 271
 272 static inline void
 273 set_abiversion (bfd *abfd, int ver)
 274 {
 275   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 276   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 277 }
 278 \f
 279 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 280
 281 /* Relocation HOWTO's.  */
 282 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 283
 284 static reloc_howto_type ppc64_elf_howto_raw[] =
 285 {
 286   /* This reloc does nothing.  */
 287   HOWTO (R_PPC64_NONE,          /* type */
 288          0,                     /* rightshift */
 289          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          0,                     /* bitsize */
 291          FALSE,                 /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_dont, /* complain_on_overflow */
 294          bfd_elf_generic_reloc, /* special_function */
 295          "R_PPC64_NONE",        /* name */
 296          FALSE,                 /* partial_inplace */
 297          0,                     /* src_mask */
 298          0,                     /* dst_mask */
 299          FALSE),                /* pcrel_offset */
 300
 301   /* A standard 32 bit relocation.  */
 302   HOWTO (R_PPC64_ADDR32,        /* type */
 303          0,                     /* rightshift */
 304          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 305          32,                    /* bitsize */
 306          FALSE,                 /* pc_relative */
 307          0,                     /* bitpos */
 308          complain_overflow_bitfield, /* complain_on_overflow */
 309          bfd_elf_generic_reloc, /* special_function */
 310          "R_PPC64_ADDR32",      /* name */
 311          FALSE,                 /* partial_inplace */
 312          0,                     /* src_mask */
 313          0xffffffff,            /* dst_mask */
 314          FALSE),                /* pcrel_offset */
 315
 316   /* An absolute 26 bit branch; the lower two bits must be zero.
 317      FIXME: we don't check that, we just clear them.  */
 318   HOWTO (R_PPC64_ADDR24,        /* type */
 319          0,                     /* rightshift */
 320          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 321          26,                    /* bitsize */
 322          FALSE,                 /* pc_relative */
 323          0,                     /* bitpos */
 324          complain_overflow_bitfield, /* complain_on_overflow */
 325          bfd_elf_generic_reloc, /* special_function */
 326          "R_PPC64_ADDR24",      /* name */
 327          FALSE,                 /* partial_inplace */
 328          0,                     /* src_mask */
 329          0x03fffffc,            /* dst_mask */
 330          FALSE),                /* pcrel_offset */
 331
 332   /* A standard 16 bit relocation.  */
 333   HOWTO (R_PPC64_ADDR16,        /* type */
 334          0,                     /* rightshift */
 335          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 336          16,                    /* bitsize */
 337          FALSE,                 /* pc_relative */
 338          0,                     /* bitpos */
 339          complain_overflow_bitfield, /* complain_on_overflow */
 340          bfd_elf_generic_reloc, /* special_function */
 341          "R_PPC64_ADDR16",      /* name */
 342          FALSE,                 /* partial_inplace */
 343          0,                     /* src_mask */
 344          0xffff,                /* dst_mask */
 345          FALSE),                /* pcrel_offset */
 346
 347   /* A 16 bit relocation without overflow.  */
 348   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 349          0,                     /* rightshift */
 350          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 351          16,                    /* bitsize */
 352          FALSE,                 /* pc_relative */
 353          0,                     /* bitpos */
 354          complain_overflow_dont,/* complain_on_overflow */
 355          bfd_elf_generic_reloc, /* special_function */
 356          "R_PPC64_ADDR16_LO",   /* name */
 357          FALSE,                 /* partial_inplace */
 358          0,                     /* src_mask */
 359          0xffff,                /* dst_mask */
 360          FALSE),                /* pcrel_offset */
 361
 362   /* Bits 16-31 of an address.  */
 363   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 364          16,                    /* rightshift */
 365          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 366          16,                    /* bitsize */
 367          FALSE,                 /* pc_relative */
 368          0,                     /* bitpos */
 369          complain_overflow_signed, /* complain_on_overflow */
 370          bfd_elf_generic_reloc, /* special_function */
 371          "R_PPC64_ADDR16_HI",   /* name */
 372          FALSE,                 /* partial_inplace */
 373          0,                     /* src_mask */
 374          0xffff,                /* dst_mask */
 375          FALSE),                /* pcrel_offset */
 376
 377   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 378      bits, treated as a signed number, is negative.  */
 379   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 380          16,                    /* rightshift */
 381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          16,                    /* bitsize */
 383          FALSE,                 /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_signed, /* complain_on_overflow */
 386          ppc64_elf_ha_reloc,    /* special_function */
 387          "R_PPC64_ADDR16_HA",   /* name */
 388          FALSE,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0xffff,                /* dst_mask */
 391          FALSE),                /* pcrel_offset */
 392
 393   /* An absolute 16 bit branch; the lower two bits must be zero.
 394      FIXME: we don't check that, we just clear them.  */
 395   HOWTO (R_PPC64_ADDR14,        /* type */
 396          0,                     /* rightshift */
 397          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 398          16,                    /* bitsize */
 399          FALSE,                 /* pc_relative */
 400          0,                     /* bitpos */
 401          complain_overflow_signed, /* complain_on_overflow */
 402          ppc64_elf_branch_reloc, /* special_function */
 403          "R_PPC64_ADDR14",      /* name */
 404          FALSE,                 /* partial_inplace */
 405          0,                     /* src_mask */
 406          0x0000fffc,            /* dst_mask */
 407          FALSE),                /* pcrel_offset */
 408
 409   /* An absolute 16 bit branch, for which bit 10 should be set to
 410      indicate that the branch is expected to be taken.  The lower two
 411      bits must be zero.  */
 412   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 413          0,                     /* rightshift */
 414          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 415          16,                    /* bitsize */
 416          FALSE,                 /* pc_relative */
 417          0,                     /* bitpos */
 418          complain_overflow_signed, /* complain_on_overflow */
 419          ppc64_elf_brtaken_reloc, /* special_function */
 420          "R_PPC64_ADDR14_BRTAKEN",/* name */
 421          FALSE,                 /* partial_inplace */
 422          0,                     /* src_mask */
 423          0x0000fffc,            /* dst_mask */
 424          FALSE),                /* pcrel_offset */
 425
 426   /* An absolute 16 bit branch, for which bit 10 should be set to
 427      indicate that the branch is not expected to be taken.  The lower
 428      two bits must be zero.  */
 429   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 430          0,                     /* rightshift */
 431          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 432          16,                    /* bitsize */
 433          FALSE,                 /* pc_relative */
 434          0,                     /* bitpos */
 435          complain_overflow_signed, /* complain_on_overflow */
 436          ppc64_elf_brtaken_reloc, /* special_function */
 437          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 438          FALSE,                 /* partial_inplace */
 439          0,                     /* src_mask */
 440          0x0000fffc,            /* dst_mask */
 441          FALSE),                /* pcrel_offset */
 442
 443   /* A relative 26 bit branch; the lower two bits must be zero.  */
 444   HOWTO (R_PPC64_REL24,         /* type */
 445          0,                     /* rightshift */
 446          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 447          26,                    /* bitsize */
 448          TRUE,                  /* pc_relative */
 449          0,                     /* bitpos */
 450          complain_overflow_signed, /* complain_on_overflow */
 451          ppc64_elf_branch_reloc, /* special_function */
 452          "R_PPC64_REL24",       /* name */
 453          FALSE,                 /* partial_inplace */
 454          0,                     /* src_mask */
 455          0x03fffffc,            /* dst_mask */
 456          TRUE),                 /* pcrel_offset */
 457
 458   /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer.  */
 459   HOWTO (R_PPC64_REL24_NOTOC,   /* type */
 460          0,                     /* rightshift */
 461          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 462          26,                    /* bitsize */
 463          TRUE,                  /* pc_relative */
 464          0,                     /* bitpos */
 465          complain_overflow_signed, /* complain_on_overflow */
 466          ppc64_elf_branch_reloc, /* special_function */
 467          "R_PPC64_REL24_NOTOC", /* name */
 468          FALSE,                 /* partial_inplace */
 469          0,                     /* src_mask */
 470          0x03fffffc,            /* dst_mask */
 471          TRUE),                 /* pcrel_offset */
 472
 473   /* A relative 16 bit branch; the lower two bits must be zero.  */
 474   HOWTO (R_PPC64_REL14,         /* type */
 475          0,                     /* rightshift */
 476          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 477          16,                    /* bitsize */
 478          TRUE,                  /* pc_relative */
 479          0,                     /* bitpos */
 480          complain_overflow_signed, /* complain_on_overflow */
 481          ppc64_elf_branch_reloc, /* special_function */
 482          "R_PPC64_REL14",       /* name */
 483          FALSE,                 /* partial_inplace */
 484          0,                     /* src_mask */
 485          0x0000fffc,            /* dst_mask */
 486          TRUE),                 /* pcrel_offset */
 487
 488   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 489      the branch is expected to be taken.  The lower two bits must be
 490      zero.  */
 491   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 492          0,                     /* rightshift */
 493          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          TRUE,                  /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_brtaken_reloc, /* special_function */
 499          "R_PPC64_REL14_BRTAKEN", /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0x0000fffc,            /* dst_mask */
 503          TRUE),                 /* pcrel_offset */
 504
 505   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 506      the branch is not expected to be taken.  The lower two bits must
 507      be zero.  */
 508   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 509          0,                     /* rightshift */
 510          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          16,                    /* bitsize */
 512          TRUE,                  /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_signed, /* complain_on_overflow */
 515          ppc64_elf_brtaken_reloc, /* special_function */
 516          "R_PPC64_REL14_BRNTAKEN",/* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0x0000fffc,            /* dst_mask */
 520          TRUE),                 /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 523      symbol.  */
 524   HOWTO (R_PPC64_GOT16,         /* type */
 525          0,                     /* rightshift */
 526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 527          16,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_signed, /* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc, /* special_function */
 532          "R_PPC64_GOT16",       /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          0xffff,                /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 539      the symbol.  */
 540   HOWTO (R_PPC64_GOT16_LO,      /* type */
 541          0,                     /* rightshift */
 542          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          16,                    /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_GOT16_LO",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0xffff,                /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 555      the symbol.  */
 556   HOWTO (R_PPC64_GOT16_HI,      /* type */
 557          16,                    /* rightshift */
 558          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 559          16,                    /* bitsize */
 560          FALSE,                 /* pc_relative */
 561          0,                     /* bitpos */
 562          complain_overflow_signed,/* complain_on_overflow */
 563          ppc64_elf_unhandled_reloc, /* special_function */
 564          "R_PPC64_GOT16_HI",    /* name */
 565          FALSE,                 /* partial_inplace */
 566          0,                     /* src_mask */
 567          0xffff,                /* dst_mask */
 568          FALSE),                /* pcrel_offset */
 569
 570   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 571      the symbol.  */
 572   HOWTO (R_PPC64_GOT16_HA,      /* type */
 573          16,                    /* rightshift */
 574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          16,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_signed,/* complain_on_overflow */
 579          ppc64_elf_unhandled_reloc, /* special_function */
 580          "R_PPC64_GOT16_HA",    /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffff,                /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* This is used only by the dynamic linker.  The symbol should exist
 587      both in the object being run and in some shared library.  The
 588      dynamic linker copies the data addressed by the symbol from the
 589      shared library into the object, because the object being
 590      run has to have the data at some particular address.  */
 591   HOWTO (R_PPC64_COPY,          /* type */
 592          0,                     /* rightshift */
 593          0,                     /* this one is variable size */
 594          0,                     /* bitsize */
 595          FALSE,                 /* pc_relative */
 596          0,                     /* bitpos */
 597          complain_overflow_dont, /* complain_on_overflow */
 598          ppc64_elf_unhandled_reloc, /* special_function */
 599          "R_PPC64_COPY",        /* name */
 600          FALSE,                 /* partial_inplace */
 601          0,                     /* src_mask */
 602          0,                     /* dst_mask */
 603          FALSE),                /* pcrel_offset */
 604
 605   /* Like R_PPC64_ADDR64, but used when setting global offset table
 606      entries.  */
 607   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          ppc64_elf_unhandled_reloc,  /* special_function */
 615          "R_PPC64_GLOB_DAT",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Created by the link editor.  Marks a procedure linkage table
 622      entry for a symbol.  */
 623   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 624          0,                     /* rightshift */
 625          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 626          0,                     /* bitsize */
 627          FALSE,                 /* pc_relative */
 628          0,                     /* bitpos */
 629          complain_overflow_dont, /* complain_on_overflow */
 630          ppc64_elf_unhandled_reloc, /* special_function */
 631          "R_PPC64_JMP_SLOT",    /* name */
 632          FALSE,                 /* partial_inplace */
 633          0,                     /* src_mask */
 634          0,                     /* dst_mask */
 635          FALSE),                /* pcrel_offset */
 636
 637   /* Used only by the dynamic linker.  When the object is run, this
 638      doubleword64 is set to the load address of the object, plus the
 639      addend.  */
 640   HOWTO (R_PPC64_RELATIVE,      /* type */
 641          0,                     /* rightshift */
 642          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 643          64,                    /* bitsize */
 644          FALSE,                 /* pc_relative */
 645          0,                     /* bitpos */
 646          complain_overflow_dont, /* complain_on_overflow */
 647          bfd_elf_generic_reloc, /* special_function */
 648          "R_PPC64_RELATIVE",    /* name */
 649          FALSE,                 /* partial_inplace */
 650          0,                     /* src_mask */
 651          ONES (64),             /* dst_mask */
 652          FALSE),                /* pcrel_offset */
 653
 654   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 655   HOWTO (R_PPC64_UADDR32,       /* type */
 656          0,                     /* rightshift */
 657          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 658          32,                    /* bitsize */
 659          FALSE,                 /* pc_relative */
 660          0,                     /* bitpos */
 661          complain_overflow_bitfield, /* complain_on_overflow */
 662          bfd_elf_generic_reloc, /* special_function */
 663          "R_PPC64_UADDR32",     /* name */
 664          FALSE,                 /* partial_inplace */
 665          0,                     /* src_mask */
 666          0xffffffff,            /* dst_mask */
 667          FALSE),                /* pcrel_offset */
 668
 669   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 670   HOWTO (R_PPC64_UADDR16,       /* type */
 671          0,                     /* rightshift */
 672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 673          16,                    /* bitsize */
 674          FALSE,                 /* pc_relative */
 675          0,                     /* bitpos */
 676          complain_overflow_bitfield, /* complain_on_overflow */
 677          bfd_elf_generic_reloc, /* special_function */
 678          "R_PPC64_UADDR16",     /* name */
 679          FALSE,                 /* partial_inplace */
 680          0,                     /* src_mask */
 681          0xffff,                /* dst_mask */
 682          FALSE),                /* pcrel_offset */
 683
 684   /* 32-bit PC relative.  */
 685   HOWTO (R_PPC64_REL32,         /* type */
 686          0,                     /* rightshift */
 687          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 688          32,                    /* bitsize */
 689          TRUE,                  /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_signed, /* complain_on_overflow */
 692          bfd_elf_generic_reloc, /* special_function */
 693          "R_PPC64_REL32",       /* name */
 694          FALSE,                 /* partial_inplace */
 695          0,                     /* src_mask */
 696          0xffffffff,            /* dst_mask */
 697          TRUE),                 /* pcrel_offset */
 698
 699   /* 32-bit relocation to the symbol's procedure linkage table.  */
 700   HOWTO (R_PPC64_PLT32,         /* type */
 701          0,                     /* rightshift */
 702          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          32,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_bitfield, /* complain_on_overflow */
 707          ppc64_elf_unhandled_reloc, /* special_function */
 708          "R_PPC64_PLT32",       /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffffffff,            /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 715      FIXME: R_PPC64_PLTREL32 not supported.  */
 716   HOWTO (R_PPC64_PLTREL32,      /* type */
 717          0,                     /* rightshift */
 718          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 719          32,                    /* bitsize */
 720          TRUE,                  /* pc_relative */
 721          0,                     /* bitpos */
 722          complain_overflow_signed, /* complain_on_overflow */
 723          ppc64_elf_unhandled_reloc, /* special_function */
 724          "R_PPC64_PLTREL32",    /* name */
 725          FALSE,                 /* partial_inplace */
 726          0,                     /* src_mask */
 727          0xffffffff,            /* dst_mask */
 728          TRUE),                 /* pcrel_offset */
 729
 730   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 731      the symbol.  */
 732   HOWTO (R_PPC64_PLT16_LO,      /* type */
 733          0,                     /* rightshift */
 734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 735          16,                    /* bitsize */
 736          FALSE,                 /* pc_relative */
 737          0,                     /* bitpos */
 738          complain_overflow_dont, /* complain_on_overflow */
 739          ppc64_elf_unhandled_reloc, /* special_function */
 740          "R_PPC64_PLT16_LO",    /* name */
 741          FALSE,                 /* partial_inplace */
 742          0,                     /* src_mask */
 743          0xffff,                /* dst_mask */
 744          FALSE),                /* pcrel_offset */
 745
 746   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 747      the symbol.  */
 748   HOWTO (R_PPC64_PLT16_HI,      /* type */
 749          16,                    /* rightshift */
 750          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 751          16,                    /* bitsize */
 752          FALSE,                 /* pc_relative */
 753          0,                     /* bitpos */
 754          complain_overflow_signed, /* complain_on_overflow */
 755          ppc64_elf_unhandled_reloc, /* special_function */
 756          "R_PPC64_PLT16_HI",    /* name */
 757          FALSE,                 /* partial_inplace */
 758          0,                     /* src_mask */
 759          0xffff,                /* dst_mask */
 760          FALSE),                /* pcrel_offset */
 761
 762   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 763      the symbol.  */
 764   HOWTO (R_PPC64_PLT16_HA,      /* type */
 765          16,                    /* rightshift */
 766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 767          16,                    /* bitsize */
 768          FALSE,                 /* pc_relative */
 769          0,                     /* bitpos */
 770          complain_overflow_signed, /* complain_on_overflow */
 771          ppc64_elf_unhandled_reloc, /* special_function */
 772          "R_PPC64_PLT16_HA",    /* name */
 773          FALSE,                 /* partial_inplace */
 774          0,                     /* src_mask */
 775          0xffff,                /* dst_mask */
 776          FALSE),                /* pcrel_offset */
 777
 778   /* 16-bit section relative relocation.  */
 779   HOWTO (R_PPC64_SECTOFF,       /* type */
 780          0,                     /* rightshift */
 781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 782          16,                    /* bitsize */
 783          FALSE,                 /* pc_relative */
 784          0,                     /* bitpos */
 785          complain_overflow_signed, /* complain_on_overflow */
 786          ppc64_elf_sectoff_reloc, /* special_function */
 787          "R_PPC64_SECTOFF",     /* name */
 788          FALSE,                 /* partial_inplace */
 789          0,                     /* src_mask */
 790          0xffff,                /* dst_mask */
 791          FALSE),                /* pcrel_offset */
 792
 793   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 794   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 795          0,                     /* rightshift */
 796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 797          16,                    /* bitsize */
 798          FALSE,                 /* pc_relative */
 799          0,                     /* bitpos */
 800          complain_overflow_dont, /* complain_on_overflow */
 801          ppc64_elf_sectoff_reloc, /* special_function */
 802          "R_PPC64_SECTOFF_LO",  /* name */
 803          FALSE,                 /* partial_inplace */
 804          0,                     /* src_mask */
 805          0xffff,                /* dst_mask */
 806          FALSE),                /* pcrel_offset */
 807
 808   /* 16-bit upper half section relative relocation.  */
 809   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 810          16,                    /* rightshift */
 811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 812          16,                    /* bitsize */
 813          FALSE,                 /* pc_relative */
 814          0,                     /* bitpos */
 815          complain_overflow_signed, /* complain_on_overflow */
 816          ppc64_elf_sectoff_reloc, /* special_function */
 817          "R_PPC64_SECTOFF_HI",  /* name */
 818          FALSE,                 /* partial_inplace */
 819          0,                     /* src_mask */
 820          0xffff,                /* dst_mask */
 821          FALSE),                /* pcrel_offset */
 822
 823   /* 16-bit upper half adjusted section relative relocation.  */
 824   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 825          16,                    /* rightshift */
 826          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 827          16,                    /* bitsize */
 828          FALSE,                 /* pc_relative */
 829          0,                     /* bitpos */
 830          complain_overflow_signed, /* complain_on_overflow */
 831          ppc64_elf_sectoff_ha_reloc, /* special_function */
 832          "R_PPC64_SECTOFF_HA",  /* name */
 833          FALSE,                 /* partial_inplace */
 834          0,                     /* src_mask */
 835          0xffff,                /* dst_mask */
 836          FALSE),                /* pcrel_offset */
 837
 838   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 839   HOWTO (R_PPC64_REL30,         /* type */
 840          2,                     /* rightshift */
 841          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 842          30,                    /* bitsize */
 843          TRUE,                  /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          bfd_elf_generic_reloc, /* special_function */
 847          "R_PPC64_REL30",       /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          0xfffffffc,            /* dst_mask */
 851          TRUE),                 /* pcrel_offset */
 852
 853   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 854
 855   /* A standard 64-bit relocation.  */
 856   HOWTO (R_PPC64_ADDR64,        /* type */
 857          0,                     /* rightshift */
 858          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 859          64,                    /* bitsize */
 860          FALSE,                 /* pc_relative */
 861          0,                     /* bitpos */
 862          complain_overflow_dont, /* complain_on_overflow */
 863          bfd_elf_generic_reloc, /* special_function */
 864          "R_PPC64_ADDR64",      /* name */
 865          FALSE,                 /* partial_inplace */
 866          0,                     /* src_mask */
 867          ONES (64),             /* dst_mask */
 868          FALSE),                /* pcrel_offset */
 869
 870   /* The bits 32-47 of an address.  */
 871   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 872          32,                    /* rightshift */
 873          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 874          16,                    /* bitsize */
 875          FALSE,                 /* pc_relative */
 876          0,                     /* bitpos */
 877          complain_overflow_dont, /* complain_on_overflow */
 878          bfd_elf_generic_reloc, /* special_function */
 879          "R_PPC64_ADDR16_HIGHER", /* name */
 880          FALSE,                 /* partial_inplace */
 881          0,                     /* src_mask */
 882          0xffff,                /* dst_mask */
 883          FALSE),                /* pcrel_offset */
 884
 885   /* The bits 32-47 of an address, plus 1 if the contents of the low
 886      16 bits, treated as a signed number, is negative.  */
 887   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 888          32,                    /* rightshift */
 889          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 890          16,                    /* bitsize */
 891          FALSE,                 /* pc_relative */
 892          0,                     /* bitpos */
 893          complain_overflow_dont, /* complain_on_overflow */
 894          ppc64_elf_ha_reloc,    /* special_function */
 895          "R_PPC64_ADDR16_HIGHERA", /* name */
 896          FALSE,                 /* partial_inplace */
 897          0,                     /* src_mask */
 898          0xffff,                /* dst_mask */
 899          FALSE),                /* pcrel_offset */
 900
 901   /* The bits 48-63 of an address.  */
 902   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 903          48,                    /* rightshift */
 904          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 905          16,                    /* bitsize */
 906          FALSE,                 /* pc_relative */
 907          0,                     /* bitpos */
 908          complain_overflow_dont, /* complain_on_overflow */
 909          bfd_elf_generic_reloc, /* special_function */
 910          "R_PPC64_ADDR16_HIGHEST", /* name */
 911          FALSE,                 /* partial_inplace */
 912          0,                     /* src_mask */
 913          0xffff,                /* dst_mask */
 914          FALSE),                /* pcrel_offset */
 915
 916   /* The bits 48-63 of an address, plus 1 if the contents of the low
 917      16 bits, treated as a signed number, is negative.  */
 918   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 919          48,                    /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          FALSE,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_dont, /* complain_on_overflow */
 925          ppc64_elf_ha_reloc,    /* special_function */
 926          "R_PPC64_ADDR16_HIGHESTA", /* name */
 927          FALSE,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          FALSE),                /* pcrel_offset */
 931
 932   /* Like ADDR64, but may be unaligned.  */
 933   HOWTO (R_PPC64_UADDR64,       /* type */
 934          0,                     /* rightshift */
 935          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 936          64,                    /* bitsize */
 937          FALSE,                 /* pc_relative */
 938          0,                     /* bitpos */
 939          complain_overflow_dont, /* complain_on_overflow */
 940          bfd_elf_generic_reloc, /* special_function */
 941          "R_PPC64_UADDR64",     /* name */
 942          FALSE,                 /* partial_inplace */
 943          0,                     /* src_mask */
 944          ONES (64),             /* dst_mask */
 945          FALSE),                /* pcrel_offset */
 946
 947   /* 64-bit relative relocation.  */
 948   HOWTO (R_PPC64_REL64,         /* type */
 949          0,                     /* rightshift */
 950          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 951          64,                    /* bitsize */
 952          TRUE,                  /* pc_relative */
 953          0,                     /* bitpos */
 954          complain_overflow_dont, /* complain_on_overflow */
 955          bfd_elf_generic_reloc, /* special_function */
 956          "R_PPC64_REL64",       /* name */
 957          FALSE,                 /* partial_inplace */
 958          0,                     /* src_mask */
 959          ONES (64),             /* dst_mask */
 960          TRUE),                 /* pcrel_offset */
 961
 962   /* 64-bit relocation to the symbol's procedure linkage table.  */
 963   HOWTO (R_PPC64_PLT64,         /* type */
 964          0,                     /* rightshift */
 965          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 966          64,                    /* bitsize */
 967          FALSE,                 /* pc_relative */
 968          0,                     /* bitpos */
 969          complain_overflow_dont, /* complain_on_overflow */
 970          ppc64_elf_unhandled_reloc, /* special_function */
 971          "R_PPC64_PLT64",       /* name */
 972          FALSE,                 /* partial_inplace */
 973          0,                     /* src_mask */
 974          ONES (64),             /* dst_mask */
 975          FALSE),                /* pcrel_offset */
 976
 977   /* 64-bit PC relative relocation to the symbol's procedure linkage
 978      table.  */
 979   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 980   HOWTO (R_PPC64_PLTREL64,      /* type */
 981          0,                     /* rightshift */
 982          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 983          64,                    /* bitsize */
 984          TRUE,                  /* pc_relative */
 985          0,                     /* bitpos */
 986          complain_overflow_dont, /* complain_on_overflow */
 987          ppc64_elf_unhandled_reloc, /* special_function */
 988          "R_PPC64_PLTREL64",    /* name */
 989          FALSE,                 /* partial_inplace */
 990          0,                     /* src_mask */
 991          ONES (64),             /* dst_mask */
 992          TRUE),                 /* pcrel_offset */
 993
 994   /* 16 bit TOC-relative relocation.  */
 995
 996   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 997   HOWTO (R_PPC64_TOC16,         /* type */
 998          0,                     /* rightshift */
 999          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1000          16,                    /* bitsize */
1001          FALSE,                 /* pc_relative */
1002          0,                     /* bitpos */
1003          complain_overflow_signed, /* complain_on_overflow */
1004          ppc64_elf_toc_reloc,   /* special_function */
1005          "R_PPC64_TOC16",       /* name */
1006          FALSE,                 /* partial_inplace */
1007          0,                     /* src_mask */
1008          0xffff,                /* dst_mask */
1009          FALSE),                /* pcrel_offset */
1010
1011   /* 16 bit TOC-relative relocation without overflow.  */
1012
1013   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
1014   HOWTO (R_PPC64_TOC16_LO,      /* type */
1015          0,                     /* rightshift */
1016          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1017          16,                    /* bitsize */
1018          FALSE,                 /* pc_relative */
1019          0,                     /* bitpos */
1020          complain_overflow_dont, /* complain_on_overflow */
1021          ppc64_elf_toc_reloc,   /* special_function */
1022          "R_PPC64_TOC16_LO",    /* name */
1023          FALSE,                 /* partial_inplace */
1024          0,                     /* src_mask */
1025          0xffff,                /* dst_mask */
1026          FALSE),                /* pcrel_offset */
1027
1028   /* 16 bit TOC-relative relocation, high 16 bits.  */
1029
1030   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1031   HOWTO (R_PPC64_TOC16_HI,      /* type */
1032          16,                    /* rightshift */
1033          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1034          16,                    /* bitsize */
1035          FALSE,                 /* pc_relative */
1036          0,                     /* bitpos */
1037          complain_overflow_signed, /* complain_on_overflow */
1038          ppc64_elf_toc_reloc,   /* special_function */
1039          "R_PPC64_TOC16_HI",    /* name */
1040          FALSE,                 /* partial_inplace */
1041          0,                     /* src_mask */
1042          0xffff,                /* dst_mask */
1043          FALSE),                /* pcrel_offset */
1044
1045   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1046      contents of the low 16 bits, treated as a signed number, is
1047      negative.  */
1048
1049   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1050   HOWTO (R_PPC64_TOC16_HA,      /* type */
1051          16,                    /* rightshift */
1052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1053          16,                    /* bitsize */
1054          FALSE,                 /* pc_relative */
1055          0,                     /* bitpos */
1056          complain_overflow_signed, /* complain_on_overflow */
1057          ppc64_elf_toc_ha_reloc, /* special_function */
1058          "R_PPC64_TOC16_HA",    /* name */
1059          FALSE,                 /* partial_inplace */
1060          0,                     /* src_mask */
1061          0xffff,                /* dst_mask */
1062          FALSE),                /* pcrel_offset */
1063
1064   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1065
1066   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1067   HOWTO (R_PPC64_TOC,           /* type */
1068          0,                     /* rightshift */
1069          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1070          64,                    /* bitsize */
1071          FALSE,                 /* pc_relative */
1072          0,                     /* bitpos */
1073          complain_overflow_dont, /* complain_on_overflow */
1074          ppc64_elf_toc64_reloc, /* special_function */
1075          "R_PPC64_TOC",         /* name */
1076          FALSE,                 /* partial_inplace */
1077          0,                     /* src_mask */
1078          ONES (64),             /* dst_mask */
1079          FALSE),                /* pcrel_offset */
1080
1081   /* Like R_PPC64_GOT16, but also informs the link editor that the
1082      value to relocate may (!) refer to a PLT entry which the link
1083      editor (a) may replace with the symbol value.  If the link editor
1084      is unable to fully resolve the symbol, it may (b) create a PLT
1085      entry and store the address to the new PLT entry in the GOT.
1086      This permits lazy resolution of function symbols at run time.
1087      The link editor may also skip all of this and just (c) emit a
1088      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1089   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1090     HOWTO (R_PPC64_PLTGOT16,    /* type */
1091          0,                     /* rightshift */
1092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1093          16,                    /* bitsize */
1094          FALSE,                 /* pc_relative */
1095          0,                     /* bitpos */
1096          complain_overflow_signed, /* complain_on_overflow */
1097          ppc64_elf_unhandled_reloc, /* special_function */
1098          "R_PPC64_PLTGOT16",    /* name */
1099          FALSE,                 /* partial_inplace */
1100          0,                     /* src_mask */
1101          0xffff,                /* dst_mask */
1102          FALSE),                /* pcrel_offset */
1103
1104   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1105   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1106   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1107          0,                     /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_dont, /* complain_on_overflow */
1113          ppc64_elf_unhandled_reloc, /* special_function */
1114          "R_PPC64_PLTGOT16_LO", /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xffff,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1121   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1122   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1123          16,                    /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          ppc64_elf_unhandled_reloc, /* special_function */
1130          "R_PPC64_PLTGOT16_HI", /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xffff,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1137      1 if the contents of the low 16 bits, treated as a signed number,
1138      is negative.  */
1139   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1140   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1141          16,                    /* rightshift */
1142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1143          16,                    /* bitsize */
1144          FALSE,                 /* pc_relative */
1145          0,                     /* bitpos */
1146          complain_overflow_signed, /* complain_on_overflow */
1147          ppc64_elf_unhandled_reloc, /* special_function */
1148          "R_PPC64_PLTGOT16_HA", /* name */
1149          FALSE,                 /* partial_inplace */
1150          0,                     /* src_mask */
1151          0xffff,                /* dst_mask */
1152          FALSE),                /* pcrel_offset */
1153
1154   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1155   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1156          0,                     /* rightshift */
1157          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1158          16,                    /* bitsize */
1159          FALSE,                 /* pc_relative */
1160          0,                     /* bitpos */
1161          complain_overflow_signed, /* complain_on_overflow */
1162          bfd_elf_generic_reloc, /* special_function */
1163          "R_PPC64_ADDR16_DS",   /* name */
1164          FALSE,                 /* partial_inplace */
1165          0,                     /* src_mask */
1166          0xfffc,                /* dst_mask */
1167          FALSE),                /* pcrel_offset */
1168
1169   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1170   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1171          0,                     /* rightshift */
1172          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1173          16,                    /* bitsize */
1174          FALSE,                 /* pc_relative */
1175          0,                     /* bitpos */
1176          complain_overflow_dont,/* complain_on_overflow */
1177          bfd_elf_generic_reloc, /* special_function */
1178          "R_PPC64_ADDR16_LO_DS",/* name */
1179          FALSE,                 /* partial_inplace */
1180          0,                     /* src_mask */
1181          0xfffc,                /* dst_mask */
1182          FALSE),                /* pcrel_offset */
1183
1184   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1185   HOWTO (R_PPC64_GOT16_DS,      /* type */
1186          0,                     /* rightshift */
1187          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1188          16,                    /* bitsize */
1189          FALSE,                 /* pc_relative */
1190          0,                     /* bitpos */
1191          complain_overflow_signed, /* complain_on_overflow */
1192          ppc64_elf_unhandled_reloc, /* special_function */
1193          "R_PPC64_GOT16_DS",    /* name */
1194          FALSE,                 /* partial_inplace */
1195          0,                     /* src_mask */
1196          0xfffc,                /* dst_mask */
1197          FALSE),                /* pcrel_offset */
1198
1199   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1200   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1201          0,                     /* rightshift */
1202          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1203          16,                    /* bitsize */
1204          FALSE,                 /* pc_relative */
1205          0,                     /* bitpos */
1206          complain_overflow_dont, /* complain_on_overflow */
1207          ppc64_elf_unhandled_reloc, /* special_function */
1208          "R_PPC64_GOT16_LO_DS", /* name */
1209          FALSE,                 /* partial_inplace */
1210          0,                     /* src_mask */
1211          0xfffc,                /* dst_mask */
1212          FALSE),                /* pcrel_offset */
1213
1214   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1215   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1216          0,                     /* rightshift */
1217          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1218          16,                    /* bitsize */
1219          FALSE,                 /* pc_relative */
1220          0,                     /* bitpos */
1221          complain_overflow_dont, /* complain_on_overflow */
1222          ppc64_elf_unhandled_reloc, /* special_function */
1223          "R_PPC64_PLT16_LO_DS", /* name */
1224          FALSE,                 /* partial_inplace */
1225          0,                     /* src_mask */
1226          0xfffc,                /* dst_mask */
1227          FALSE),                /* pcrel_offset */
1228
1229   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1230   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1231          0,                     /* rightshift */
1232          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1233          16,                    /* bitsize */
1234          FALSE,                 /* pc_relative */
1235          0,                     /* bitpos */
1236          complain_overflow_signed, /* complain_on_overflow */
1237          ppc64_elf_sectoff_reloc, /* special_function */
1238          "R_PPC64_SECTOFF_DS",  /* name */
1239          FALSE,                 /* partial_inplace */
1240          0,                     /* src_mask */
1241          0xfffc,                /* dst_mask */
1242          FALSE),                /* pcrel_offset */
1243
1244   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1245   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1246          0,                     /* rightshift */
1247          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1248          16,                    /* bitsize */
1249          FALSE,                 /* pc_relative */
1250          0,                     /* bitpos */
1251          complain_overflow_dont, /* complain_on_overflow */
1252          ppc64_elf_sectoff_reloc, /* special_function */
1253          "R_PPC64_SECTOFF_LO_DS",/* name */
1254          FALSE,                 /* partial_inplace */
1255          0,                     /* src_mask */
1256          0xfffc,                /* dst_mask */
1257          FALSE),                /* pcrel_offset */
1258
1259   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1260   HOWTO (R_PPC64_TOC16_DS,      /* type */
1261          0,                     /* rightshift */
1262          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1263          16,                    /* bitsize */
1264          FALSE,                 /* pc_relative */
1265          0,                     /* bitpos */
1266          complain_overflow_signed, /* complain_on_overflow */
1267          ppc64_elf_toc_reloc,   /* special_function */
1268          "R_PPC64_TOC16_DS",    /* name */
1269          FALSE,                 /* partial_inplace */
1270          0,                     /* src_mask */
1271          0xfffc,                /* dst_mask */
1272          FALSE),                /* pcrel_offset */
1273
1274   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1275   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1276          0,                     /* rightshift */
1277          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1278          16,                    /* bitsize */
1279          FALSE,                 /* pc_relative */
1280          0,                     /* bitpos */
1281          complain_overflow_dont, /* complain_on_overflow */
1282          ppc64_elf_toc_reloc,   /* special_function */
1283          "R_PPC64_TOC16_LO_DS", /* name */
1284          FALSE,                 /* partial_inplace */
1285          0,                     /* src_mask */
1286          0xfffc,                /* dst_mask */
1287          FALSE),                /* pcrel_offset */
1288
1289   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1290   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1291   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1292          0,                     /* rightshift */
1293          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1294          16,                    /* bitsize */
1295          FALSE,                 /* pc_relative */
1296          0,                     /* bitpos */
1297          complain_overflow_signed, /* complain_on_overflow */
1298          ppc64_elf_unhandled_reloc, /* special_function */
1299          "R_PPC64_PLTGOT16_DS", /* name */
1300          FALSE,                 /* partial_inplace */
1301          0,                     /* src_mask */
1302          0xfffc,                /* dst_mask */
1303          FALSE),                /* pcrel_offset */
1304
1305   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1306   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1307   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1308          0,                     /* rightshift */
1309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          16,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_dont, /* complain_on_overflow */
1314          ppc64_elf_unhandled_reloc, /* special_function */
1315          "R_PPC64_PLTGOT16_LO_DS",/* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0xfffc,                /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   /* Marker relocs for TLS.  */
1322   HOWTO (R_PPC64_TLS,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLS",         /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TLSGD,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TLSGD",       /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   HOWTO (R_PPC64_TLSLD,
1351          0,                     /* rightshift */
1352          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1353          32,                    /* bitsize */
1354          FALSE,                 /* pc_relative */
1355          0,                     /* bitpos */
1356          complain_overflow_dont, /* complain_on_overflow */
1357          bfd_elf_generic_reloc, /* special_function */
1358          "R_PPC64_TLSLD",       /* name */
1359          FALSE,                 /* partial_inplace */
1360          0,                     /* src_mask */
1361          0,                     /* dst_mask */
1362          FALSE),                /* pcrel_offset */
1363
1364   /* Marker reloc for optimizing r2 save in prologue rather than on
1365      each plt call stub.  */
1366   HOWTO (R_PPC64_TOCSAVE,
1367          0,                     /* rightshift */
1368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1369          32,                    /* bitsize */
1370          FALSE,                 /* pc_relative */
1371          0,                     /* bitpos */
1372          complain_overflow_dont, /* complain_on_overflow */
1373          bfd_elf_generic_reloc, /* special_function */
1374          "R_PPC64_TOCSAVE",     /* name */
1375          FALSE,                 /* partial_inplace */
1376          0,                     /* src_mask */
1377          0,                     /* dst_mask */
1378          FALSE),                /* pcrel_offset */
1379
1380   /* Marker relocs on inline plt call instructions.  */
1381   HOWTO (R_PPC64_PLTSEQ,
1382          0,                     /* rightshift */
1383          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1384          32,                    /* bitsize */
1385          FALSE,                 /* pc_relative */
1386          0,                     /* bitpos */
1387          complain_overflow_dont, /* complain_on_overflow */
1388          bfd_elf_generic_reloc, /* special_function */
1389          "R_PPC64_PLTSEQ",      /* name */
1390          FALSE,                 /* partial_inplace */
1391          0,                     /* src_mask */
1392          0,                     /* dst_mask */
1393          FALSE),                /* pcrel_offset */
1394
1395   HOWTO (R_PPC64_PLTCALL,
1396          0,                     /* rightshift */
1397          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1398          32,                    /* bitsize */
1399          FALSE,                 /* pc_relative */
1400          0,                     /* bitpos */
1401          complain_overflow_dont, /* complain_on_overflow */
1402          bfd_elf_generic_reloc, /* special_function */
1403          "R_PPC64_PLTCALL",     /* name */
1404          FALSE,                 /* partial_inplace */
1405          0,                     /* src_mask */
1406          0,                     /* dst_mask */
1407          FALSE),                /* pcrel_offset */
1408
1409   /* Computes the load module index of the load module that contains the
1410      definition of its TLS sym.  */
1411   HOWTO (R_PPC64_DTPMOD64,
1412          0,                     /* rightshift */
1413          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1414          64,                    /* bitsize */
1415          FALSE,                 /* pc_relative */
1416          0,                     /* bitpos */
1417          complain_overflow_dont, /* complain_on_overflow */
1418          ppc64_elf_unhandled_reloc, /* special_function */
1419          "R_PPC64_DTPMOD64",    /* name */
1420          FALSE,                 /* partial_inplace */
1421          0,                     /* src_mask */
1422          ONES (64),             /* dst_mask */
1423          FALSE),                /* pcrel_offset */
1424
1425   /* Computes a dtv-relative displacement, the difference between the value
1426      of sym+add and the base address of the thread-local storage block that
1427      contains the definition of sym, minus 0x8000.  */
1428   HOWTO (R_PPC64_DTPREL64,
1429          0,                     /* rightshift */
1430          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1431          64,                    /* bitsize */
1432          FALSE,                 /* pc_relative */
1433          0,                     /* bitpos */
1434          complain_overflow_dont, /* complain_on_overflow */
1435          ppc64_elf_unhandled_reloc, /* special_function */
1436          "R_PPC64_DTPREL64",    /* name */
1437          FALSE,                 /* partial_inplace */
1438          0,                     /* src_mask */
1439          ONES (64),             /* dst_mask */
1440          FALSE),                /* pcrel_offset */
1441
1442   /* A 16 bit dtprel reloc.  */
1443   HOWTO (R_PPC64_DTPREL16,
1444          0,                     /* rightshift */
1445          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1446          16,                    /* bitsize */
1447          FALSE,                 /* pc_relative */
1448          0,                     /* bitpos */
1449          complain_overflow_signed, /* complain_on_overflow */
1450          ppc64_elf_unhandled_reloc, /* special_function */
1451          "R_PPC64_DTPREL16",    /* name */
1452          FALSE,                 /* partial_inplace */
1453          0,                     /* src_mask */
1454          0xffff,                /* dst_mask */
1455          FALSE),                /* pcrel_offset */
1456
1457   /* Like DTPREL16, but no overflow.  */
1458   HOWTO (R_PPC64_DTPREL16_LO,
1459          0,                     /* rightshift */
1460          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1461          16,                    /* bitsize */
1462          FALSE,                 /* pc_relative */
1463          0,                     /* bitpos */
1464          complain_overflow_dont, /* complain_on_overflow */
1465          ppc64_elf_unhandled_reloc, /* special_function */
1466          "R_PPC64_DTPREL16_LO", /* name */
1467          FALSE,                 /* partial_inplace */
1468          0,                     /* src_mask */
1469          0xffff,                /* dst_mask */
1470          FALSE),                /* pcrel_offset */
1471
1472   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1473   HOWTO (R_PPC64_DTPREL16_HI,
1474          16,                    /* rightshift */
1475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1476          16,                    /* bitsize */
1477          FALSE,                 /* pc_relative */
1478          0,                     /* bitpos */
1479          complain_overflow_signed, /* complain_on_overflow */
1480          ppc64_elf_unhandled_reloc, /* special_function */
1481          "R_PPC64_DTPREL16_HI", /* name */
1482          FALSE,                 /* partial_inplace */
1483          0,                     /* src_mask */
1484          0xffff,                /* dst_mask */
1485          FALSE),                /* pcrel_offset */
1486
1487   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1488   HOWTO (R_PPC64_DTPREL16_HA,
1489          16,                    /* rightshift */
1490          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1491          16,                    /* bitsize */
1492          FALSE,                 /* pc_relative */
1493          0,                     /* bitpos */
1494          complain_overflow_signed, /* complain_on_overflow */
1495          ppc64_elf_unhandled_reloc, /* special_function */
1496          "R_PPC64_DTPREL16_HA", /* name */
1497          FALSE,                 /* partial_inplace */
1498          0,                     /* src_mask */
1499          0xffff,                /* dst_mask */
1500          FALSE),                /* pcrel_offset */
1501
1502   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1503   HOWTO (R_PPC64_DTPREL16_HIGHER,
1504          32,                    /* rightshift */
1505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1506          16,                    /* bitsize */
1507          FALSE,                 /* pc_relative */
1508          0,                     /* bitpos */
1509          complain_overflow_dont, /* complain_on_overflow */
1510          ppc64_elf_unhandled_reloc, /* special_function */
1511          "R_PPC64_DTPREL16_HIGHER", /* name */
1512          FALSE,                 /* partial_inplace */
1513          0,                     /* src_mask */
1514          0xffff,                /* dst_mask */
1515          FALSE),                /* pcrel_offset */
1516
1517   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1518   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1519          32,                    /* rightshift */
1520          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1521          16,                    /* bitsize */
1522          FALSE,                 /* pc_relative */
1523          0,                     /* bitpos */
1524          complain_overflow_dont, /* complain_on_overflow */
1525          ppc64_elf_unhandled_reloc, /* special_function */
1526          "R_PPC64_DTPREL16_HIGHERA", /* name */
1527          FALSE,                 /* partial_inplace */
1528          0,                     /* src_mask */
1529          0xffff,                /* dst_mask */
1530          FALSE),                /* pcrel_offset */
1531
1532   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1533   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1534          48,                    /* rightshift */
1535          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1536          16,                    /* bitsize */
1537          FALSE,                 /* pc_relative */
1538          0,                     /* bitpos */
1539          complain_overflow_dont, /* complain_on_overflow */
1540          ppc64_elf_unhandled_reloc, /* special_function */
1541          "R_PPC64_DTPREL16_HIGHEST", /* name */
1542          FALSE,                 /* partial_inplace */
1543          0,                     /* src_mask */
1544          0xffff,                /* dst_mask */
1545          FALSE),                /* pcrel_offset */
1546
1547   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1548   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1549          48,                    /* rightshift */
1550          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1551          16,                    /* bitsize */
1552          FALSE,                 /* pc_relative */
1553          0,                     /* bitpos */
1554          complain_overflow_dont, /* complain_on_overflow */
1555          ppc64_elf_unhandled_reloc, /* special_function */
1556          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1557          FALSE,                 /* partial_inplace */
1558          0,                     /* src_mask */
1559          0xffff,                /* dst_mask */
1560          FALSE),                /* pcrel_offset */
1561
1562   /* Like DTPREL16, but for insns with a DS field.  */
1563   HOWTO (R_PPC64_DTPREL16_DS,
1564          0,                     /* rightshift */
1565          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1566          16,                    /* bitsize */
1567          FALSE,                 /* pc_relative */
1568          0,                     /* bitpos */
1569          complain_overflow_signed, /* complain_on_overflow */
1570          ppc64_elf_unhandled_reloc, /* special_function */
1571          "R_PPC64_DTPREL16_DS", /* name */
1572          FALSE,                 /* partial_inplace */
1573          0,                     /* src_mask */
1574          0xfffc,                /* dst_mask */
1575          FALSE),                /* pcrel_offset */
1576
1577   /* Like DTPREL16_DS, but no overflow.  */
1578   HOWTO (R_PPC64_DTPREL16_LO_DS,
1579          0,                     /* rightshift */
1580          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1581          16,                    /* bitsize */
1582          FALSE,                 /* pc_relative */
1583          0,                     /* bitpos */
1584          complain_overflow_dont, /* complain_on_overflow */
1585          ppc64_elf_unhandled_reloc, /* special_function */
1586          "R_PPC64_DTPREL16_LO_DS", /* name */
1587          FALSE,                 /* partial_inplace */
1588          0,                     /* src_mask */
1589          0xfffc,                /* dst_mask */
1590          FALSE),                /* pcrel_offset */
1591
1592   /* Computes a tp-relative displacement, the difference between the value of
1593      sym+add and the value of the thread pointer (r13).  */
1594   HOWTO (R_PPC64_TPREL64,
1595          0,                     /* rightshift */
1596          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1597          64,                    /* bitsize */
1598          FALSE,                 /* pc_relative */
1599          0,                     /* bitpos */
1600          complain_overflow_dont, /* complain_on_overflow */
1601          ppc64_elf_unhandled_reloc, /* special_function */
1602          "R_PPC64_TPREL64",     /* name */
1603          FALSE,                 /* partial_inplace */
1604          0,                     /* src_mask */
1605          ONES (64),             /* dst_mask */
1606          FALSE),                /* pcrel_offset */
1607
1608   /* A 16 bit tprel reloc.  */
1609   HOWTO (R_PPC64_TPREL16,
1610          0,                     /* rightshift */
1611          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1612          16,                    /* bitsize */
1613          FALSE,                 /* pc_relative */
1614          0,                     /* bitpos */
1615          complain_overflow_signed, /* complain_on_overflow */
1616          ppc64_elf_unhandled_reloc, /* special_function */
1617          "R_PPC64_TPREL16",     /* name */
1618          FALSE,                 /* partial_inplace */
1619          0,                     /* src_mask */
1620          0xffff,                /* dst_mask */
1621          FALSE),                /* pcrel_offset */
1622
1623   /* Like TPREL16, but no overflow.  */
1624   HOWTO (R_PPC64_TPREL16_LO,
1625          0,                     /* rightshift */
1626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1627          16,                    /* bitsize */
1628          FALSE,                 /* pc_relative */
1629          0,                     /* bitpos */
1630          complain_overflow_dont, /* complain_on_overflow */
1631          ppc64_elf_unhandled_reloc, /* special_function */
1632          "R_PPC64_TPREL16_LO",  /* name */
1633          FALSE,                 /* partial_inplace */
1634          0,                     /* src_mask */
1635          0xffff,                /* dst_mask */
1636          FALSE),                /* pcrel_offset */
1637
1638   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1639   HOWTO (R_PPC64_TPREL16_HI,
1640          16,                    /* rightshift */
1641          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1642          16,                    /* bitsize */
1643          FALSE,                 /* pc_relative */
1644          0,                     /* bitpos */
1645          complain_overflow_signed, /* complain_on_overflow */
1646          ppc64_elf_unhandled_reloc, /* special_function */
1647          "R_PPC64_TPREL16_HI",  /* name */
1648          FALSE,                 /* partial_inplace */
1649          0,                     /* src_mask */
1650          0xffff,                /* dst_mask */
1651          FALSE),                /* pcrel_offset */
1652
1653   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1654   HOWTO (R_PPC64_TPREL16_HA,
1655          16,                    /* rightshift */
1656          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1657          16,                    /* bitsize */
1658          FALSE,                 /* pc_relative */
1659          0,                     /* bitpos */
1660          complain_overflow_signed, /* complain_on_overflow */
1661          ppc64_elf_unhandled_reloc, /* special_function */
1662          "R_PPC64_TPREL16_HA",  /* name */
1663          FALSE,                 /* partial_inplace */
1664          0,                     /* src_mask */
1665          0xffff,                /* dst_mask */
1666          FALSE),                /* pcrel_offset */
1667
1668   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1669   HOWTO (R_PPC64_TPREL16_HIGHER,
1670          32,                    /* rightshift */
1671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1672          16,                    /* bitsize */
1673          FALSE,                 /* pc_relative */
1674          0,                     /* bitpos */
1675          complain_overflow_dont, /* complain_on_overflow */
1676          ppc64_elf_unhandled_reloc, /* special_function */
1677          "R_PPC64_TPREL16_HIGHER",      /* name */
1678          FALSE,                 /* partial_inplace */
1679          0,                     /* src_mask */
1680          0xffff,                /* dst_mask */
1681          FALSE),                /* pcrel_offset */
1682
1683   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1684   HOWTO (R_PPC64_TPREL16_HIGHERA,
1685          32,                    /* rightshift */
1686          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1687          16,                    /* bitsize */
1688          FALSE,                 /* pc_relative */
1689          0,                     /* bitpos */
1690          complain_overflow_dont, /* complain_on_overflow */
1691          ppc64_elf_unhandled_reloc, /* special_function */
1692          "R_PPC64_TPREL16_HIGHERA", /* name */
1693          FALSE,                 /* partial_inplace */
1694          0,                     /* src_mask */
1695          0xffff,                /* dst_mask */
1696          FALSE),                /* pcrel_offset */
1697
1698   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1699   HOWTO (R_PPC64_TPREL16_HIGHEST,
1700          48,                    /* rightshift */
1701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1702          16,                    /* bitsize */
1703          FALSE,                 /* pc_relative */
1704          0,                     /* bitpos */
1705          complain_overflow_dont, /* complain_on_overflow */
1706          ppc64_elf_unhandled_reloc, /* special_function */
1707          "R_PPC64_TPREL16_HIGHEST", /* name */
1708          FALSE,                 /* partial_inplace */
1709          0,                     /* src_mask */
1710          0xffff,                /* dst_mask */
1711          FALSE),                /* pcrel_offset */
1712
1713   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1714   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1715          48,                    /* rightshift */
1716          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1717          16,                    /* bitsize */
1718          FALSE,                 /* pc_relative */
1719          0,                     /* bitpos */
1720          complain_overflow_dont, /* complain_on_overflow */
1721          ppc64_elf_unhandled_reloc, /* special_function */
1722          "R_PPC64_TPREL16_HIGHESTA", /* name */
1723          FALSE,                 /* partial_inplace */
1724          0,                     /* src_mask */
1725          0xffff,                /* dst_mask */
1726          FALSE),                /* pcrel_offset */
1727
1728   /* Like TPREL16, but for insns with a DS field.  */
1729   HOWTO (R_PPC64_TPREL16_DS,
1730          0,                     /* rightshift */
1731          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1732          16,                    /* bitsize */
1733          FALSE,                 /* pc_relative */
1734          0,                     /* bitpos */
1735          complain_overflow_signed, /* complain_on_overflow */
1736          ppc64_elf_unhandled_reloc, /* special_function */
1737          "R_PPC64_TPREL16_DS",  /* name */
1738          FALSE,                 /* partial_inplace */
1739          0,                     /* src_mask */
1740          0xfffc,                /* dst_mask */
1741          FALSE),                /* pcrel_offset */
1742
1743   /* Like TPREL16_DS, but no overflow.  */
1744   HOWTO (R_PPC64_TPREL16_LO_DS,
1745          0,                     /* rightshift */
1746          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1747          16,                    /* bitsize */
1748          FALSE,                 /* pc_relative */
1749          0,                     /* bitpos */
1750          complain_overflow_dont, /* complain_on_overflow */
1751          ppc64_elf_unhandled_reloc, /* special_function */
1752          "R_PPC64_TPREL16_LO_DS", /* name */
1753          FALSE,                 /* partial_inplace */
1754          0,                     /* src_mask */
1755          0xfffc,                /* dst_mask */
1756          FALSE),                /* pcrel_offset */
1757
1758   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1759      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1760      to the first entry relative to the TOC base (r2).  */
1761   HOWTO (R_PPC64_GOT_TLSGD16,
1762          0,                     /* rightshift */
1763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1764          16,                    /* bitsize */
1765          FALSE,                 /* pc_relative */
1766          0,                     /* bitpos */
1767          complain_overflow_signed, /* complain_on_overflow */
1768          ppc64_elf_unhandled_reloc, /* special_function */
1769          "R_PPC64_GOT_TLSGD16", /* name */
1770          FALSE,                 /* partial_inplace */
1771          0,                     /* src_mask */
1772          0xffff,                /* dst_mask */
1773          FALSE),                /* pcrel_offset */
1774
1775   /* Like GOT_TLSGD16, but no overflow.  */
1776   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1777          0,                     /* rightshift */
1778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1779          16,                    /* bitsize */
1780          FALSE,                 /* pc_relative */
1781          0,                     /* bitpos */
1782          complain_overflow_dont, /* complain_on_overflow */
1783          ppc64_elf_unhandled_reloc, /* special_function */
1784          "R_PPC64_GOT_TLSGD16_LO", /* name */
1785          FALSE,                 /* partial_inplace */
1786          0,                     /* src_mask */
1787          0xffff,                /* dst_mask */
1788          FALSE),                /* pcrel_offset */
1789
1790   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1791   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1792          16,                    /* rightshift */
1793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1794          16,                    /* bitsize */
1795          FALSE,                 /* pc_relative */
1796          0,                     /* bitpos */
1797          complain_overflow_signed, /* complain_on_overflow */
1798          ppc64_elf_unhandled_reloc, /* special_function */
1799          "R_PPC64_GOT_TLSGD16_HI", /* name */
1800          FALSE,                 /* partial_inplace */
1801          0,                     /* src_mask */
1802          0xffff,                /* dst_mask */
1803          FALSE),                /* pcrel_offset */
1804
1805   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1806   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1807          16,                    /* rightshift */
1808          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1809          16,                    /* bitsize */
1810          FALSE,                 /* pc_relative */
1811          0,                     /* bitpos */
1812          complain_overflow_signed, /* complain_on_overflow */
1813          ppc64_elf_unhandled_reloc, /* special_function */
1814          "R_PPC64_GOT_TLSGD16_HA", /* name */
1815          FALSE,                 /* partial_inplace */
1816          0,                     /* src_mask */
1817          0xffff,                /* dst_mask */
1818          FALSE),                /* pcrel_offset */
1819
1820   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1821      with values (sym+add)@dtpmod and zero, and computes the offset to the
1822      first entry relative to the TOC base (r2).  */
1823   HOWTO (R_PPC64_GOT_TLSLD16,
1824          0,                     /* rightshift */
1825          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1826          16,                    /* bitsize */
1827          FALSE,                 /* pc_relative */
1828          0,                     /* bitpos */
1829          complain_overflow_signed, /* complain_on_overflow */
1830          ppc64_elf_unhandled_reloc, /* special_function */
1831          "R_PPC64_GOT_TLSLD16", /* name */
1832          FALSE,                 /* partial_inplace */
1833          0,                     /* src_mask */
1834          0xffff,                /* dst_mask */
1835          FALSE),                /* pcrel_offset */
1836
1837   /* Like GOT_TLSLD16, but no overflow.  */
1838   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1839          0,                     /* rightshift */
1840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1841          16,                    /* bitsize */
1842          FALSE,                 /* pc_relative */
1843          0,                     /* bitpos */
1844          complain_overflow_dont, /* complain_on_overflow */
1845          ppc64_elf_unhandled_reloc, /* special_function */
1846          "R_PPC64_GOT_TLSLD16_LO", /* name */
1847          FALSE,                 /* partial_inplace */
1848          0,                     /* src_mask */
1849          0xffff,                /* dst_mask */
1850          FALSE),                /* pcrel_offset */
1851
1852   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1853   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1854          16,                    /* rightshift */
1855          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1856          16,                    /* bitsize */
1857          FALSE,                 /* pc_relative */
1858          0,                     /* bitpos */
1859          complain_overflow_signed, /* complain_on_overflow */
1860          ppc64_elf_unhandled_reloc, /* special_function */
1861          "R_PPC64_GOT_TLSLD16_HI", /* name */
1862          FALSE,                 /* partial_inplace */
1863          0,                     /* src_mask */
1864          0xffff,                /* dst_mask */
1865          FALSE),                /* pcrel_offset */
1866
1867   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1868   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1869          16,                    /* rightshift */
1870          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1871          16,                    /* bitsize */
1872          FALSE,                 /* pc_relative */
1873          0,                     /* bitpos */
1874          complain_overflow_signed, /* complain_on_overflow */
1875          ppc64_elf_unhandled_reloc, /* special_function */
1876          "R_PPC64_GOT_TLSLD16_HA", /* name */
1877          FALSE,                 /* partial_inplace */
1878          0,                     /* src_mask */
1879          0xffff,                /* dst_mask */
1880          FALSE),                /* pcrel_offset */
1881
1882   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1883      the offset to the entry relative to the TOC base (r2).  */
1884   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1885          0,                     /* rightshift */
1886          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1887          16,                    /* bitsize */
1888          FALSE,                 /* pc_relative */
1889          0,                     /* bitpos */
1890          complain_overflow_signed, /* complain_on_overflow */
1891          ppc64_elf_unhandled_reloc, /* special_function */
1892          "R_PPC64_GOT_DTPREL16_DS", /* name */
1893          FALSE,                 /* partial_inplace */
1894          0,                     /* src_mask */
1895          0xfffc,                /* dst_mask */
1896          FALSE),                /* pcrel_offset */
1897
1898   /* Like GOT_DTPREL16_DS, but no overflow.  */
1899   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1900          0,                     /* rightshift */
1901          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1902          16,                    /* bitsize */
1903          FALSE,                 /* pc_relative */
1904          0,                     /* bitpos */
1905          complain_overflow_dont, /* complain_on_overflow */
1906          ppc64_elf_unhandled_reloc, /* special_function */
1907          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1908          FALSE,                 /* partial_inplace */
1909          0,                     /* src_mask */
1910          0xfffc,                /* dst_mask */
1911          FALSE),                /* pcrel_offset */
1912
1913   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1914   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1915          16,                    /* rightshift */
1916          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1917          16,                    /* bitsize */
1918          FALSE,                 /* pc_relative */
1919          0,                     /* bitpos */
1920          complain_overflow_signed, /* complain_on_overflow */
1921          ppc64_elf_unhandled_reloc, /* special_function */
1922          "R_PPC64_GOT_DTPREL16_HI", /* name */
1923          FALSE,                 /* partial_inplace */
1924          0,                     /* src_mask */
1925          0xffff,                /* dst_mask */
1926          FALSE),                /* pcrel_offset */
1927
1928   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1929   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1930          16,                    /* rightshift */
1931          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1932          16,                    /* bitsize */
1933          FALSE,                 /* pc_relative */
1934          0,                     /* bitpos */
1935          complain_overflow_signed, /* complain_on_overflow */
1936          ppc64_elf_unhandled_reloc, /* special_function */
1937          "R_PPC64_GOT_DTPREL16_HA", /* name */
1938          FALSE,                 /* partial_inplace */
1939          0,                     /* src_mask */
1940          0xffff,                /* dst_mask */
1941          FALSE),                /* pcrel_offset */
1942
1943   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1944      offset to the entry relative to the TOC base (r2).  */
1945   HOWTO (R_PPC64_GOT_TPREL16_DS,
1946          0,                     /* rightshift */
1947          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1948          16,                    /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_signed, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_GOT_TPREL16_DS", /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0xfffc,                /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   /* Like GOT_TPREL16_DS, but no overflow.  */
1960   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1961          0,                     /* rightshift */
1962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1963          16,                    /* bitsize */
1964          FALSE,                 /* pc_relative */
1965          0,                     /* bitpos */
1966          complain_overflow_dont, /* complain_on_overflow */
1967          ppc64_elf_unhandled_reloc, /* special_function */
1968          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1969          FALSE,                 /* partial_inplace */
1970          0,                     /* src_mask */
1971          0xfffc,                /* dst_mask */
1972          FALSE),                /* pcrel_offset */
1973
1974   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1975   HOWTO (R_PPC64_GOT_TPREL16_HI,
1976          16,                    /* rightshift */
1977          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1978          16,                    /* bitsize */
1979          FALSE,                 /* pc_relative */
1980          0,                     /* bitpos */
1981          complain_overflow_signed, /* complain_on_overflow */
1982          ppc64_elf_unhandled_reloc, /* special_function */
1983          "R_PPC64_GOT_TPREL16_HI", /* name */
1984          FALSE,                 /* partial_inplace */
1985          0,                     /* src_mask */
1986          0xffff,                /* dst_mask */
1987          FALSE),                /* pcrel_offset */
1988
1989   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1990   HOWTO (R_PPC64_GOT_TPREL16_HA,
1991          16,                    /* rightshift */
1992          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1993          16,                    /* bitsize */
1994          FALSE,                 /* pc_relative */
1995          0,                     /* bitpos */
1996          complain_overflow_signed, /* complain_on_overflow */
1997          ppc64_elf_unhandled_reloc, /* special_function */
1998          "R_PPC64_GOT_TPREL16_HA", /* name */
1999          FALSE,                 /* partial_inplace */
2000          0,                     /* src_mask */
2001          0xffff,                /* dst_mask */
2002          FALSE),                /* pcrel_offset */
2003
2004   HOWTO (R_PPC64_JMP_IREL,      /* type */
2005          0,                     /* rightshift */
2006          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2007          0,                     /* bitsize */
2008          FALSE,                 /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_dont, /* complain_on_overflow */
2011          ppc64_elf_unhandled_reloc, /* special_function */
2012          "R_PPC64_JMP_IREL",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0,                     /* dst_mask */
2016          FALSE),                /* pcrel_offset */
2017
2018   HOWTO (R_PPC64_IRELATIVE,     /* type */
2019          0,                     /* rightshift */
2020          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2021          64,                    /* bitsize */
2022          FALSE,                 /* pc_relative */
2023          0,                     /* bitpos */
2024          complain_overflow_dont, /* complain_on_overflow */
2025          bfd_elf_generic_reloc, /* special_function */
2026          "R_PPC64_IRELATIVE",   /* name */
2027          FALSE,                 /* partial_inplace */
2028          0,                     /* src_mask */
2029          ONES (64),             /* dst_mask */
2030          FALSE),                /* pcrel_offset */
2031
2032   /* A 16 bit relative relocation.  */
2033   HOWTO (R_PPC64_REL16,         /* type */
2034          0,                     /* rightshift */
2035          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2036          16,                    /* bitsize */
2037          TRUE,                  /* pc_relative */
2038          0,                     /* bitpos */
2039          complain_overflow_signed, /* complain_on_overflow */
2040          bfd_elf_generic_reloc, /* special_function */
2041          "R_PPC64_REL16",       /* name */
2042          FALSE,                 /* partial_inplace */
2043          0,                     /* src_mask */
2044          0xffff,                /* dst_mask */
2045          TRUE),                 /* pcrel_offset */
2046
2047   /* A 16 bit relative relocation without overflow.  */
2048   HOWTO (R_PPC64_REL16_LO,      /* type */
2049          0,                     /* rightshift */
2050          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2051          16,                    /* bitsize */
2052          TRUE,                  /* pc_relative */
2053          0,                     /* bitpos */
2054          complain_overflow_dont,/* complain_on_overflow */
2055          bfd_elf_generic_reloc, /* special_function */
2056          "R_PPC64_REL16_LO",    /* name */
2057          FALSE,                 /* partial_inplace */
2058          0,                     /* src_mask */
2059          0xffff,                /* dst_mask */
2060          TRUE),                 /* pcrel_offset */
2061
2062   /* The high order 16 bits of a relative address.  */
2063   HOWTO (R_PPC64_REL16_HI,      /* type */
2064          16,                    /* rightshift */
2065          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2066          16,                    /* bitsize */
2067          TRUE,                  /* pc_relative */
2068          0,                     /* bitpos */
2069          complain_overflow_signed, /* complain_on_overflow */
2070          bfd_elf_generic_reloc, /* special_function */
2071          "R_PPC64_REL16_HI",    /* name */
2072          FALSE,                 /* partial_inplace */
2073          0,                     /* src_mask */
2074          0xffff,                /* dst_mask */
2075          TRUE),                 /* pcrel_offset */
2076
2077   /* The high order 16 bits of a relative address, plus 1 if the contents of
2078      the low 16 bits, treated as a signed number, is negative.  */
2079   HOWTO (R_PPC64_REL16_HA,      /* type */
2080          16,                    /* rightshift */
2081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2082          16,                    /* bitsize */
2083          TRUE,                  /* pc_relative */
2084          0,                     /* bitpos */
2085          complain_overflow_signed, /* complain_on_overflow */
2086          ppc64_elf_ha_reloc,    /* special_function */
2087          "R_PPC64_REL16_HA",    /* name */
2088          FALSE,                 /* partial_inplace */
2089          0,                     /* src_mask */
2090          0xffff,                /* dst_mask */
2091          TRUE),                 /* pcrel_offset */
2092
2093   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2094   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2095          16,                    /* rightshift */
2096          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2097          16,                    /* bitsize */
2098          TRUE,                  /* pc_relative */
2099          0,                     /* bitpos */
2100          complain_overflow_signed, /* complain_on_overflow */
2101          ppc64_elf_ha_reloc,    /* special_function */
2102          "R_PPC64_REL16DX_HA",  /* name */
2103          FALSE,                 /* partial_inplace */
2104          0,                     /* src_mask */
2105          0x1fffc1,              /* dst_mask */
2106          TRUE),                 /* pcrel_offset */
2107
2108   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2109   HOWTO (R_PPC64_16DX_HA,       /* type */
2110          16,                    /* rightshift */
2111          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2112          16,                    /* bitsize */
2113          FALSE,                 /* pc_relative */
2114          0,                     /* bitpos */
2115          complain_overflow_signed, /* complain_on_overflow */
2116          ppc64_elf_ha_reloc,    /* special_function */
2117          "R_PPC64_16DX_HA",     /* name */
2118          FALSE,                 /* partial_inplace */
2119          0,                     /* src_mask */
2120          0x1fffc1,              /* dst_mask */
2121          FALSE),                /* pcrel_offset */
2122
2123   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2124   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2125          16,                    /* rightshift */
2126          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2127          16,                    /* bitsize */
2128          FALSE,                 /* pc_relative */
2129          0,                     /* bitpos */
2130          complain_overflow_dont, /* complain_on_overflow */
2131          bfd_elf_generic_reloc, /* special_function */
2132          "R_PPC64_ADDR16_HIGH", /* name */
2133          FALSE,                 /* partial_inplace */
2134          0,                     /* src_mask */
2135          0xffff,                /* dst_mask */
2136          FALSE),                /* pcrel_offset */
2137
2138   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2139   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2140          16,                    /* rightshift */
2141          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2142          16,                    /* bitsize */
2143          FALSE,                 /* pc_relative */
2144          0,                     /* bitpos */
2145          complain_overflow_dont, /* complain_on_overflow */
2146          ppc64_elf_ha_reloc,    /* special_function */
2147          "R_PPC64_ADDR16_HIGHA",        /* name */
2148          FALSE,                 /* partial_inplace */
2149          0,                     /* src_mask */
2150          0xffff,                /* dst_mask */
2151          FALSE),                /* pcrel_offset */
2152
2153   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2154   HOWTO (R_PPC64_DTPREL16_HIGH,
2155          16,                    /* rightshift */
2156          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2157          16,                    /* bitsize */
2158          FALSE,                 /* pc_relative */
2159          0,                     /* bitpos */
2160          complain_overflow_dont, /* complain_on_overflow */
2161          ppc64_elf_unhandled_reloc, /* special_function */
2162          "R_PPC64_DTPREL16_HIGH", /* name */
2163          FALSE,                 /* partial_inplace */
2164          0,                     /* src_mask */
2165          0xffff,                /* dst_mask */
2166          FALSE),                /* pcrel_offset */
2167
2168   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2169   HOWTO (R_PPC64_DTPREL16_HIGHA,
2170          16,                    /* rightshift */
2171          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2172          16,                    /* bitsize */
2173          FALSE,                 /* pc_relative */
2174          0,                     /* bitpos */
2175          complain_overflow_dont, /* complain_on_overflow */
2176          ppc64_elf_unhandled_reloc, /* special_function */
2177          "R_PPC64_DTPREL16_HIGHA", /* name */
2178          FALSE,                 /* partial_inplace */
2179          0,                     /* src_mask */
2180          0xffff,                /* dst_mask */
2181          FALSE),                /* pcrel_offset */
2182
2183   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2184   HOWTO (R_PPC64_TPREL16_HIGH,
2185          16,                    /* rightshift */
2186          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2187          16,                    /* bitsize */
2188          FALSE,                 /* pc_relative */
2189          0,                     /* bitpos */
2190          complain_overflow_dont, /* complain_on_overflow */
2191          ppc64_elf_unhandled_reloc, /* special_function */
2192          "R_PPC64_TPREL16_HIGH",        /* name */
2193          FALSE,                 /* partial_inplace */
2194          0,                     /* src_mask */
2195          0xffff,                /* dst_mask */
2196          FALSE),                /* pcrel_offset */
2197
2198   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2199   HOWTO (R_PPC64_TPREL16_HIGHA,
2200          16,                    /* rightshift */
2201          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2202          16,                    /* bitsize */
2203          FALSE,                 /* pc_relative */
2204          0,                     /* bitpos */
2205          complain_overflow_dont, /* complain_on_overflow */
2206          ppc64_elf_unhandled_reloc, /* special_function */
2207          "R_PPC64_TPREL16_HIGHA",       /* name */
2208          FALSE,                 /* partial_inplace */
2209          0,                     /* src_mask */
2210          0xffff,                /* dst_mask */
2211          FALSE),                /* pcrel_offset */
2212
2213   /* Marker reloc on ELFv2 large-model function entry.  */
2214   HOWTO (R_PPC64_ENTRY,
2215          0,                     /* rightshift */
2216          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2217          32,                    /* bitsize */
2218          FALSE,                 /* pc_relative */
2219          0,                     /* bitpos */
2220          complain_overflow_dont, /* complain_on_overflow */
2221          bfd_elf_generic_reloc, /* special_function */
2222          "R_PPC64_ENTRY",       /* name */
2223          FALSE,                 /* partial_inplace */
2224          0,                     /* src_mask */
2225          0,                     /* dst_mask */
2226          FALSE),                /* pcrel_offset */
2227
2228   /* Like ADDR64, but use local entry point of function.  */
2229   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2230          0,                     /* rightshift */
2231          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2232          64,                    /* bitsize */
2233          FALSE,                 /* pc_relative */
2234          0,                     /* bitpos */
2235          complain_overflow_dont, /* complain_on_overflow */
2236          bfd_elf_generic_reloc, /* special_function */
2237          "R_PPC64_ADDR64_LOCAL", /* name */
2238          FALSE,                 /* partial_inplace */
2239          0,                     /* src_mask */
2240          ONES (64),             /* dst_mask */
2241          FALSE),                /* pcrel_offset */
2242
2243   /* GNU extension to record C++ vtable hierarchy.  */
2244   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2245          0,                     /* rightshift */
2246          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2247          0,                     /* bitsize */
2248          FALSE,                 /* pc_relative */
2249          0,                     /* bitpos */
2250          complain_overflow_dont, /* complain_on_overflow */
2251          NULL,                  /* special_function */
2252          "R_PPC64_GNU_VTINHERIT", /* name */
2253          FALSE,                 /* partial_inplace */
2254          0,                     /* src_mask */
2255          0,                     /* dst_mask */
2256          FALSE),                /* pcrel_offset */
2257
2258   /* GNU extension to record C++ vtable member usage.  */
2259   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2260          0,                     /* rightshift */
2261          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2262          0,                     /* bitsize */
2263          FALSE,                 /* pc_relative */
2264          0,                     /* bitpos */
2265          complain_overflow_dont, /* complain_on_overflow */
2266          NULL,                  /* special_function */
2267          "R_PPC64_GNU_VTENTRY", /* name */
2268          FALSE,                 /* partial_inplace */
2269          0,                     /* src_mask */
2270          0,                     /* dst_mask */
2271          FALSE),                /* pcrel_offset */
2272 };
2273
2274 \f
2275 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2276    be done.  */
2277
2278 static void
2279 ppc_howto_init (void)
2280 {
2281   unsigned int i, type;
2282
2283   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2284     {
2285       type = ppc64_elf_howto_raw[i].type;
2286       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2287       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2288     }
2289 }
2290
2291 static reloc_howto_type *
2292 ppc64_elf_reloc_type_lookup (bfd *abfd,
2293                              bfd_reloc_code_real_type code)
2294 {
2295   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2296
2297   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2298     /* Initialize howto table if needed.  */
2299     ppc_howto_init ();
2300
2301   switch (code)
2302     {
2303     default:
2304       /* xgettext:c-format */
2305       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2306       bfd_set_error (bfd_error_bad_value);
2307       return NULL;
2308
2309     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2310       break;
2311     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2312       break;
2313     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2314       break;
2315     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2316       break;
2317     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2318       break;
2319     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2320       break;
2321     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2322       break;
2323     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2324       break;
2325     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2326       break;
2327     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2328       break;
2329     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2330       break;
2331     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2332       break;
2333     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2334       break;
2335     case BFD_RELOC_PPC64_REL24_NOTOC:           r = R_PPC64_REL24_NOTOC;
2336       break;
2337     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2338       break;
2339     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2340       break;
2341     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2342       break;
2343     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2344       break;
2345     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2346       break;
2347     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2348       break;
2349     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2350       break;
2351     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2352       break;
2353     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2354       break;
2355     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2356       break;
2357     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2358       break;
2359     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2360       break;
2361     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2362       break;
2363     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2364       break;
2365     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2366       break;
2367     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2368       break;
2369     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2370       break;
2371     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2372       break;
2373     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2374       break;
2375     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2376       break;
2377     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2378       break;
2379     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2380       break;
2381     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2382       break;
2383     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2384       break;
2385     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2386       break;
2387     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2388       break;
2389     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2390       break;
2391     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2392       break;
2393     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2394       break;
2395     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2396       break;
2397     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2398       break;
2399     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2402       break;
2403     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2404       break;
2405     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2406       break;
2407     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2408       break;
2409     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2410       break;
2411     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2412       break;
2413     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2414       break;
2415     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2416       break;
2417     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2418       break;
2419     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2422       break;
2423     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2426       break;
2427     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2428       break;
2429     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2434       break;
2435     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2436       break;
2437     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2438       break;
2439     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2440       break;
2441     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2442       break;
2443     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2444       break;
2445     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2448       break;
2449     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2450       break;
2451     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2452       break;
2453     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2454       break;
2455     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2456       break;
2457     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2458       break;
2459     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2460       break;
2461     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2462       break;
2463     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2464       break;
2465     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2466       break;
2467     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2468       break;
2469     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2470       break;
2471     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2472       break;
2473     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2474       break;
2475     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2476       break;
2477     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2478       break;
2479     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2480       break;
2481     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2482       break;
2483     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2484       break;
2485     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2486       break;
2487     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2488       break;
2489     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2490       break;
2491     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2492       break;
2493     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2494       break;
2495     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2496       break;
2497     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2498       break;
2499     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2500       break;
2501     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2502       break;
2503     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2504       break;
2505     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2506       break;
2507     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2508       break;
2509     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2510       break;
2511     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2512       break;
2513     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2514       break;
2515     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2516       break;
2517     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2518       break;
2519     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2520       break;
2521     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2522       break;
2523     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2524       break;
2525     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2526       break;
2527     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2528       break;
2529     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2530       break;
2531     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2532       break;
2533     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2534       break;
2535     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2536       break;
2537     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2538       break;
2539     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2540       break;
2541     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2542       break;
2543     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2544       break;
2545     }
2546
2547   return ppc64_elf_howto_table[r];
2548 };
2549
2550 static reloc_howto_type *
2551 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2552                              const char *r_name)
2553 {
2554   unsigned int i;
2555
2556   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2557     if (ppc64_elf_howto_raw[i].name != NULL
2558         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2559       return &ppc64_elf_howto_raw[i];
2560
2561
2562   return NULL;
2563 }
2564
2565 /* Set the howto pointer for a PowerPC ELF reloc.  */
2566
2567 static bfd_boolean
2568 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2569                          Elf_Internal_Rela *dst)
2570 {
2571   unsigned int type;
2572
2573   /* Initialize howto table if needed.  */
2574   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2575     ppc_howto_init ();
2576
2577   type = ELF64_R_TYPE (dst->r_info);
2578   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2579     {
2580       /* xgettext:c-format */
2581       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2582                           abfd, type);
2583       bfd_set_error (bfd_error_bad_value);
2584       return FALSE;
2585     }
2586   cache_ptr->howto = ppc64_elf_howto_table[type];
2587   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2588     {
2589       /* xgettext:c-format */
2590       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2591                           abfd, type);
2592       bfd_set_error (bfd_error_bad_value);
2593       return FALSE;
2594     }
2595
2596   return TRUE;
2597 }
2598
2599 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603                     void *data, asection *input_section,
2604                     bfd *output_bfd, char **error_message)
2605 {
2606   enum elf_ppc64_reloc_type r_type;
2607   long insn;
2608   bfd_size_type octets;
2609   bfd_vma value;
2610
2611   /* If this is a relocatable link (output_bfd test tells us), just
2612      call the generic function.  Any adjustment will be done at final
2613      link time.  */
2614   if (output_bfd != NULL)
2615     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2616                                   input_section, output_bfd, error_message);
2617
2618   /* Adjust the addend for sign extension of the low 16 bits.
2619      We won't actually be using the low 16 bits, so trashing them
2620      doesn't matter.  */
2621   reloc_entry->addend += 0x8000;
2622   r_type = reloc_entry->howto->type;
2623   if (r_type != R_PPC64_REL16DX_HA)
2624     return bfd_reloc_continue;
2625
2626   value = 0;
2627   if (!bfd_is_com_section (symbol->section))
2628     value = symbol->value;
2629   value += (reloc_entry->addend
2630             + symbol->section->output_offset
2631             + symbol->section->output_section->vma);
2632   value -= (reloc_entry->address
2633             + input_section->output_offset
2634             + input_section->output_section->vma);
2635   value = (bfd_signed_vma) value >> 16;
2636
2637   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2638   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2639   insn &= ~0x1fffc1;
2640   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2641   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2642   if (value + 0x8000 > 0xffff)
2643     return bfd_reloc_overflow;
2644   return bfd_reloc_ok;
2645 }
2646
2647 static bfd_reloc_status_type
2648 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2649                         void *data, asection *input_section,
2650                         bfd *output_bfd, char **error_message)
2651 {
2652   if (output_bfd != NULL)
2653     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2654                                   input_section, output_bfd, error_message);
2655
2656   if (strcmp (symbol->section->name, ".opd") == 0
2657       && (symbol->section->owner->flags & DYNAMIC) == 0)
2658     {
2659       bfd_vma dest = opd_entry_value (symbol->section,
2660                                       symbol->value + reloc_entry->addend,
2661                                       NULL, NULL, FALSE);
2662       if (dest != (bfd_vma) -1)
2663         reloc_entry->addend = dest - (symbol->value
2664                                       + symbol->section->output_section->vma
2665                                       + symbol->section->output_offset);
2666     }
2667   else
2668     {
2669       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2670
2671       if (symbol->section->owner != abfd
2672           && symbol->section->owner != NULL
2673           && abiversion (symbol->section->owner) >= 2)
2674         {
2675           unsigned int i;
2676
2677           for (i = 0; i < symbol->section->owner->symcount; ++i)
2678             {
2679               asymbol *symdef = symbol->section->owner->outsymbols[i];
2680
2681               if (strcmp (symdef->name, symbol->name) == 0)
2682                 {
2683                   elfsym = (elf_symbol_type *) symdef;
2684                   break;
2685                 }
2686             }
2687         }
2688       reloc_entry->addend
2689         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2690     }
2691   return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696                          void *data, asection *input_section,
2697                          bfd *output_bfd, char **error_message)
2698 {
2699   long insn;
2700   enum elf_ppc64_reloc_type r_type;
2701   bfd_size_type octets;
2702   /* Assume 'at' branch hints.  */
2703   bfd_boolean is_isa_v2 = TRUE;
2704
2705   /* If this is a relocatable link (output_bfd test tells us), just
2706      call the generic function.  Any adjustment will be done at final
2707      link time.  */
2708   if (output_bfd != NULL)
2709     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2710                                   input_section, output_bfd, error_message);
2711
2712   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2713   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2714   insn &= ~(0x01 << 21);
2715   r_type = reloc_entry->howto->type;
2716   if (r_type == R_PPC64_ADDR14_BRTAKEN
2717       || r_type == R_PPC64_REL14_BRTAKEN)
2718     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2719
2720   if (is_isa_v2)
2721     {
2722       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2723          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2724          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2725       if ((insn & (0x14 << 21)) == (0x04 << 21))
2726         insn |= 0x02 << 21;
2727       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2728         insn |= 0x08 << 21;
2729       else
2730         goto out;
2731     }
2732   else
2733     {
2734       bfd_vma target = 0;
2735       bfd_vma from;
2736
2737       if (!bfd_is_com_section (symbol->section))
2738         target = symbol->value;
2739       target += symbol->section->output_section->vma;
2740       target += symbol->section->output_offset;
2741       target += reloc_entry->addend;
2742
2743       from = (reloc_entry->address
2744               + input_section->output_offset
2745               + input_section->output_section->vma);
2746
2747       /* Invert 'y' bit if not the default.  */
2748       if ((bfd_signed_vma) (target - from) < 0)
2749         insn ^= 0x01 << 21;
2750     }
2751   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2752  out:
2753   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2754                                  input_section, output_bfd, error_message);
2755 }
2756
2757 static bfd_reloc_status_type
2758 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2759                          void *data, asection *input_section,
2760                          bfd *output_bfd, char **error_message)
2761 {
2762   /* If this is a relocatable link (output_bfd test tells us), just
2763      call the generic function.  Any adjustment will be done at final
2764      link time.  */
2765   if (output_bfd != NULL)
2766     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2767                                   input_section, output_bfd, error_message);
2768
2769   /* Subtract the symbol section base address.  */
2770   reloc_entry->addend -= symbol->section->output_section->vma;
2771   return bfd_reloc_continue;
2772 }
2773
2774 static bfd_reloc_status_type
2775 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2776                             void *data, asection *input_section,
2777                             bfd *output_bfd, char **error_message)
2778 {
2779   /* If this is a relocatable link (output_bfd test tells us), just
2780      call the generic function.  Any adjustment will be done at final
2781      link time.  */
2782   if (output_bfd != NULL)
2783     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2784                                   input_section, output_bfd, error_message);
2785
2786   /* Subtract the symbol section base address.  */
2787   reloc_entry->addend -= symbol->section->output_section->vma;
2788
2789   /* Adjust the addend for sign extension of the low 16 bits.  */
2790   reloc_entry->addend += 0x8000;
2791   return bfd_reloc_continue;
2792 }
2793
2794 static bfd_reloc_status_type
2795 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2796                      void *data, asection *input_section,
2797                      bfd *output_bfd, char **error_message)
2798 {
2799   bfd_vma TOCstart;
2800
2801   /* If this is a relocatable link (output_bfd test tells us), just
2802      call the generic function.  Any adjustment will be done at final
2803      link time.  */
2804   if (output_bfd != NULL)
2805     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2806                                   input_section, output_bfd, error_message);
2807
2808   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2809   if (TOCstart == 0)
2810     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2811
2812   /* Subtract the TOC base address.  */
2813   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2814   return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc_ha_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
2824   /* If this is a relocatable link (output_bfd test tells us), just
2825      call the generic function.  Any adjustment will be done at final
2826      link time.  */
2827   if (output_bfd != NULL)
2828     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2829                                   input_section, output_bfd, error_message);
2830
2831   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2832   if (TOCstart == 0)
2833     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2834
2835   /* Subtract the TOC base address.  */
2836   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2837
2838   /* Adjust the addend for sign extension of the low 16 bits.  */
2839   reloc_entry->addend += 0x8000;
2840   return bfd_reloc_continue;
2841 }
2842
2843 static bfd_reloc_status_type
2844 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2845                        void *data, asection *input_section,
2846                        bfd *output_bfd, char **error_message)
2847 {
2848   bfd_vma TOCstart;
2849   bfd_size_type octets;
2850
2851   /* If this is a relocatable link (output_bfd test tells us), just
2852      call the generic function.  Any adjustment will be done at final
2853      link time.  */
2854   if (output_bfd != NULL)
2855     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2856                                   input_section, output_bfd, error_message);
2857
2858   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2859   if (TOCstart == 0)
2860     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2861
2862   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2863   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2864   return bfd_reloc_ok;
2865 }
2866
2867 static bfd_reloc_status_type
2868 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2869                            void *data, asection *input_section,
2870                            bfd *output_bfd, char **error_message)
2871 {
2872   /* If this is a relocatable link (output_bfd test tells us), just
2873      call the generic function.  Any adjustment will be done at final
2874      link time.  */
2875   if (output_bfd != NULL)
2876     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2877                                   input_section, output_bfd, error_message);
2878
2879   if (error_message != NULL)
2880     {
2881       static char buf[60];
2882       sprintf (buf, "generic linker can't handle %s",
2883                reloc_entry->howto->name);
2884       *error_message = buf;
2885     }
2886   return bfd_reloc_dangerous;
2887 }
2888
2889 /* Track GOT entries needed for a given symbol.  We might need more
2890    than one got entry per symbol.  */
2891 struct got_entry
2892 {
2893   struct got_entry *next;
2894
2895   /* The symbol addend that we'll be placing in the GOT.  */
2896   bfd_vma addend;
2897
2898   /* Unlike other ELF targets, we use separate GOT entries for the same
2899      symbol referenced from different input files.  This is to support
2900      automatic multiple TOC/GOT sections, where the TOC base can vary
2901      from one input file to another.  After partitioning into TOC groups
2902      we merge entries within the group.
2903
2904      Point to the BFD owning this GOT entry.  */
2905   bfd *owner;
2906
2907   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2908      TLS_TPREL or TLS_DTPREL for tls entries.  */
2909   unsigned char tls_type;
2910
2911   /* Non-zero if got.ent points to real entry.  */
2912   unsigned char is_indirect;
2913
2914   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2915   union
2916     {
2917       bfd_signed_vma refcount;
2918       bfd_vma offset;
2919       struct got_entry *ent;
2920     } got;
2921 };
2922
2923 /* The same for PLT.  */
2924 struct plt_entry
2925 {
2926   struct plt_entry *next;
2927
2928   bfd_vma addend;
2929
2930   union
2931     {
2932       bfd_signed_vma refcount;
2933       bfd_vma offset;
2934     } plt;
2935 };
2936
2937 struct ppc64_elf_obj_tdata
2938 {
2939   struct elf_obj_tdata elf;
2940
2941   /* Shortcuts to dynamic linker sections.  */
2942   asection *got;
2943   asection *relgot;
2944
2945   /* Used during garbage collection.  We attach global symbols defined
2946      on removed .opd entries to this section so that the sym is removed.  */
2947   asection *deleted_section;
2948
2949   /* TLS local dynamic got entry handling.  Support for multiple GOT
2950      sections means we potentially need one of these for each input bfd.  */
2951   struct got_entry tlsld_got;
2952
2953   union {
2954     /* A copy of relocs before they are modified for --emit-relocs.  */
2955     Elf_Internal_Rela *relocs;
2956
2957     /* Section contents.  */
2958     bfd_byte *contents;
2959   } opd;
2960
2961   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2962      the reloc to be in the range -32768 to 32767.  */
2963   unsigned int has_small_toc_reloc : 1;
2964
2965   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2966      instruction not one we handle.  */
2967   unsigned int unexpected_toc_insn : 1;
2968 };
2969
2970 #define ppc64_elf_tdata(bfd) \
2971   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2972
2973 #define ppc64_tlsld_got(bfd) \
2974   (&ppc64_elf_tdata (bfd)->tlsld_got)
2975
2976 #define is_ppc64_elf(bfd) \
2977   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2978    && elf_object_id (bfd) == PPC64_ELF_DATA)
2979
2980 /* Override the generic function because we store some extras.  */
2981
2982 static bfd_boolean
2983 ppc64_elf_mkobject (bfd *abfd)
2984 {
2985   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2986                                   PPC64_ELF_DATA);
2987 }
2988
2989 /* Fix bad default arch selected for a 64 bit input bfd when the
2990    default is 32 bit.  Also select arch based on apuinfo.  */
2991
2992 static bfd_boolean
2993 ppc64_elf_object_p (bfd *abfd)
2994 {
2995   if (!abfd->arch_info->the_default)
2996     return TRUE;
2997
2998   if (abfd->arch_info->bits_per_word == 32)
2999     {
3000       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
3001
3002       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
3003         {
3004           /* Relies on arch after 32 bit default being 64 bit default.  */
3005           abfd->arch_info = abfd->arch_info->next;
3006           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
3007         }
3008     }
3009   return _bfd_elf_ppc_set_arch (abfd);
3010 }
3011
3012 /* Support for core dump NOTE sections.  */
3013
3014 static bfd_boolean
3015 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3016 {
3017   size_t offset, size;
3018
3019   if (note->descsz != 504)
3020     return FALSE;
3021
3022   /* pr_cursig */
3023   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3024
3025   /* pr_pid */
3026   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3027
3028   /* pr_reg */
3029   offset = 112;
3030   size = 384;
3031
3032   /* Make a ".reg/999" section.  */
3033   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3034                                           size, note->descpos + offset);
3035 }
3036
3037 static bfd_boolean
3038 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3039 {
3040   if (note->descsz != 136)
3041     return FALSE;
3042
3043   elf_tdata (abfd)->core->pid
3044     = bfd_get_32 (abfd, note->descdata + 24);
3045   elf_tdata (abfd)->core->program
3046     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3047   elf_tdata (abfd)->core->command
3048     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3049
3050   return TRUE;
3051 }
3052
3053 static char *
3054 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3055                            ...)
3056 {
3057   switch (note_type)
3058     {
3059     default:
3060       return NULL;
3061
3062     case NT_PRPSINFO:
3063       {
3064         char data[136] ATTRIBUTE_NONSTRING;
3065         va_list ap;
3066
3067         va_start (ap, note_type);
3068         memset (data, 0, sizeof (data));
3069         strncpy (data + 40, va_arg (ap, const char *), 16);
3070 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3071         DIAGNOSTIC_PUSH;
3072         /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3073            -Wstringop-truncation:
3074            https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3075          */
3076         DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3077 #endif
3078         strncpy (data + 56, va_arg (ap, const char *), 80);
3079 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3080         DIAGNOSTIC_POP;
3081 #endif
3082         va_end (ap);
3083         return elfcore_write_note (abfd, buf, bufsiz,
3084                                    "CORE", note_type, data, sizeof (data));
3085       }
3086
3087     case NT_PRSTATUS:
3088       {
3089         char data[504];
3090         va_list ap;
3091         long pid;
3092         int cursig;
3093         const void *greg;
3094
3095         va_start (ap, note_type);
3096         memset (data, 0, 112);
3097         pid = va_arg (ap, long);
3098         bfd_put_32 (abfd, pid, data + 32);
3099         cursig = va_arg (ap, int);
3100         bfd_put_16 (abfd, cursig, data + 12);
3101         greg = va_arg (ap, const void *);
3102         memcpy (data + 112, greg, 384);
3103         memset (data + 496, 0, 8);
3104         va_end (ap);
3105         return elfcore_write_note (abfd, buf, bufsiz,
3106                                    "CORE", note_type, data, sizeof (data));
3107       }
3108     }
3109 }
3110
3111 /* Add extra PPC sections.  */
3112
3113 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3114 {
3115   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3116   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3117   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3118   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3119   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3120   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3121   { NULL,                     0,  0, 0,            0 }
3122 };
3123
3124 enum _ppc64_sec_type {
3125   sec_normal = 0,
3126   sec_opd = 1,
3127   sec_toc = 2
3128 };
3129
3130 struct _ppc64_elf_section_data
3131 {
3132   struct bfd_elf_section_data elf;
3133
3134   union
3135   {
3136     /* An array with one entry for each opd function descriptor,
3137        and some spares since opd entries may be either 16 or 24 bytes.  */
3138 #define OPD_NDX(OFF) ((OFF) >> 4)
3139     struct _opd_sec_data
3140     {
3141       /* Points to the function code section for local opd entries.  */
3142       asection **func_sec;
3143
3144       /* After editing .opd, adjust references to opd local syms.  */
3145       long *adjust;
3146     } opd;
3147
3148     /* An array for toc sections, indexed by offset/8.  */
3149     struct _toc_sec_data
3150     {
3151       /* Specifies the relocation symbol index used at a given toc offset.  */
3152       unsigned *symndx;
3153
3154       /* And the relocation addend.  */
3155       bfd_vma *add;
3156     } toc;
3157   } u;
3158
3159   enum _ppc64_sec_type sec_type:2;
3160
3161   /* Flag set when small branches are detected.  Used to
3162      select suitable defaults for the stub group size.  */
3163   unsigned int has_14bit_branch:1;
3164
3165   /* Flag set when PLTCALL relocs are detected.  */
3166   unsigned int has_pltcall:1;
3167 };
3168
3169 #define ppc64_elf_section_data(sec) \
3170   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3171
3172 static bfd_boolean
3173 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3174 {
3175   if (!sec->used_by_bfd)
3176     {
3177       struct _ppc64_elf_section_data *sdata;
3178       bfd_size_type amt = sizeof (*sdata);
3179
3180       sdata = bfd_zalloc (abfd, amt);
3181       if (sdata == NULL)
3182         return FALSE;
3183       sec->used_by_bfd = sdata;
3184     }
3185
3186   return _bfd_elf_new_section_hook (abfd, sec);
3187 }
3188
3189 static struct _opd_sec_data *
3190 get_opd_info (asection * sec)
3191 {
3192   if (sec != NULL
3193       && ppc64_elf_section_data (sec) != NULL
3194       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3195     return &ppc64_elf_section_data (sec)->u.opd;
3196   return NULL;
3197 }
3198 \f
3199 /* Parameters for the qsort hook.  */
3200 static bfd_boolean synthetic_relocatable;
3201 static asection *synthetic_opd;
3202
3203 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3204
3205 static int
3206 compare_symbols (const void *ap, const void *bp)
3207 {
3208   const asymbol *a = * (const asymbol **) ap;
3209   const asymbol *b = * (const asymbol **) bp;
3210
3211   /* Section symbols first.  */
3212   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3213     return -1;
3214   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3215     return 1;
3216
3217   /* then .opd symbols.  */
3218   if (synthetic_opd != NULL)
3219     {
3220       if (strcmp (a->section->name, ".opd") == 0
3221           && strcmp (b->section->name, ".opd") != 0)
3222         return -1;
3223       if (strcmp (a->section->name, ".opd") != 0
3224           && strcmp (b->section->name, ".opd") == 0)
3225         return 1;
3226     }
3227
3228   /* then other code symbols.  */
3229   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3230       == (SEC_CODE | SEC_ALLOC)
3231       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3232          != (SEC_CODE | SEC_ALLOC))
3233     return -1;
3234
3235   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3236       != (SEC_CODE | SEC_ALLOC)
3237       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3238          == (SEC_CODE | SEC_ALLOC))
3239     return 1;
3240
3241   if (synthetic_relocatable)
3242     {
3243       if (a->section->id < b->section->id)
3244         return -1;
3245
3246       if (a->section->id > b->section->id)
3247         return 1;
3248     }
3249
3250   if (a->value + a->section->vma < b->value + b->section->vma)
3251     return -1;
3252
3253   if (a->value + a->section->vma > b->value + b->section->vma)
3254     return 1;
3255
3256   /* For syms with the same value, prefer strong dynamic global function
3257      syms over other syms.  */
3258   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3259     return -1;
3260
3261   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3262     return 1;
3263
3264   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3265     return -1;
3266
3267   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3268     return 1;
3269
3270   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3271     return -1;
3272
3273   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3274     return 1;
3275
3276   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3277     return -1;
3278
3279   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3280     return 1;
3281
3282   return a > b;
3283 }
3284
3285 /* Search SYMS for a symbol of the given VALUE.  */
3286
3287 static asymbol *
3288 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3289 {
3290   long mid;
3291
3292   if (id == (unsigned) -1)
3293     {
3294       while (lo < hi)
3295         {
3296           mid = (lo + hi) >> 1;
3297           if (syms[mid]->value + syms[mid]->section->vma < value)
3298             lo = mid + 1;
3299           else if (syms[mid]->value + syms[mid]->section->vma > value)
3300             hi = mid;
3301           else
3302             return syms[mid];
3303         }
3304     }
3305   else
3306     {
3307       while (lo < hi)
3308         {
3309           mid = (lo + hi) >> 1;
3310           if (syms[mid]->section->id < id)
3311             lo = mid + 1;
3312           else if (syms[mid]->section->id > id)
3313             hi = mid;
3314           else if (syms[mid]->value < value)
3315             lo = mid + 1;
3316           else if (syms[mid]->value > value)
3317             hi = mid;
3318           else
3319             return syms[mid];
3320         }
3321     }
3322   return NULL;
3323 }
3324
3325 static bfd_boolean
3326 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3327 {
3328   bfd_vma vma = *(bfd_vma *) ptr;
3329   return ((section->flags & SEC_ALLOC) != 0
3330           && section->vma <= vma
3331           && vma < section->vma + section->size);
3332 }
3333
3334 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3335    entry syms.  Also generate @plt symbols for the glink branch table.
3336    Returns count of synthetic symbols in RET or -1 on error.  */
3337
3338 static long
3339 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3340                                 long static_count, asymbol **static_syms,
3341                                 long dyn_count, asymbol **dyn_syms,
3342                                 asymbol **ret)
3343 {
3344   asymbol *s;
3345   size_t i, j, count;
3346   char *names;
3347   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3348   asection *opd = NULL;
3349   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3350   asymbol **syms;
3351   int abi = abiversion (abfd);
3352
3353   *ret = NULL;
3354
3355   if (abi < 2)
3356     {
3357       opd = bfd_get_section_by_name (abfd, ".opd");
3358       if (opd == NULL && abi == 1)
3359         return 0;
3360     }
3361
3362   syms = NULL;
3363   codesecsym = 0;
3364   codesecsymend = 0;
3365   secsymend = 0;
3366   opdsymend = 0;
3367   symcount = 0;
3368   if (opd != NULL)
3369     {
3370       symcount = static_count;
3371       if (!relocatable)
3372         symcount += dyn_count;
3373       if (symcount == 0)
3374         return 0;
3375
3376       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3377       if (syms == NULL)
3378         return -1;
3379
3380       if (!relocatable && static_count != 0 && dyn_count != 0)
3381         {
3382           /* Use both symbol tables.  */
3383           memcpy (syms, static_syms, static_count * sizeof (*syms));
3384           memcpy (syms + static_count, dyn_syms,
3385                   (dyn_count + 1) * sizeof (*syms));
3386         }
3387       else if (!relocatable && static_count == 0)
3388         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3389       else
3390         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3391
3392       /* Trim uninteresting symbols.  Interesting symbols are section,
3393          function, and notype symbols.  */
3394       for (i = 0, j = 0; i < symcount; ++i)
3395         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3396                                | BSF_RELC | BSF_SRELC)) == 0)
3397           syms[j++] = syms[i];
3398       symcount = j;
3399
3400       synthetic_relocatable = relocatable;
3401       synthetic_opd = opd;
3402       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3403
3404       if (!relocatable && symcount > 1)
3405         {
3406           /* Trim duplicate syms, since we may have merged the normal
3407              and dynamic symbols.  Actually, we only care about syms
3408              that have different values, so trim any with the same
3409              value.  Don't consider ifunc and ifunc resolver symbols
3410              duplicates however, because GDB wants to know whether a
3411              text symbol is an ifunc resolver.  */
3412           for (i = 1, j = 1; i < symcount; ++i)
3413             {
3414               const asymbol *s0 = syms[i - 1];
3415               const asymbol *s1 = syms[i];
3416
3417               if ((s0->value + s0->section->vma
3418                    != s1->value + s1->section->vma)
3419                   || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3420                       != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3421                 syms[j++] = syms[i];
3422             }
3423           symcount = j;
3424         }
3425
3426       i = 0;
3427       /* Note that here and in compare_symbols we can't compare opd and
3428          sym->section directly.  With separate debug info files, the
3429          symbols will be extracted from the debug file while abfd passed
3430          to this function is the real binary.  */
3431       if (strcmp (syms[i]->section->name, ".opd") == 0)
3432         ++i;
3433       codesecsym = i;
3434
3435       for (; i < symcount; ++i)
3436         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3437                                          | SEC_THREAD_LOCAL))
3438              != (SEC_CODE | SEC_ALLOC))
3439             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3440           break;
3441       codesecsymend = i;
3442
3443       for (; i < symcount; ++i)
3444         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3445           break;
3446       secsymend = i;
3447
3448       for (; i < symcount; ++i)
3449         if (strcmp (syms[i]->section->name, ".opd") != 0)
3450           break;
3451       opdsymend = i;
3452
3453       for (; i < symcount; ++i)
3454         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3455             != (SEC_CODE | SEC_ALLOC))
3456           break;
3457       symcount = i;
3458     }
3459   count = 0;
3460
3461   if (relocatable)
3462     {
3463       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3464       arelent *r;
3465       size_t size;
3466       size_t relcount;
3467
3468       if (opdsymend == secsymend)
3469         goto done;
3470
3471       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3472       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3473       if (relcount == 0)
3474         goto done;
3475
3476       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3477         {
3478           count = -1;
3479           goto done;
3480         }
3481
3482       size = 0;
3483       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3484         {
3485           asymbol *sym;
3486
3487           while (r < opd->relocation + relcount
3488                  && r->address < syms[i]->value + opd->vma)
3489             ++r;
3490
3491           if (r == opd->relocation + relcount)
3492             break;
3493
3494           if (r->address != syms[i]->value + opd->vma)
3495             continue;
3496
3497           if (r->howto->type != R_PPC64_ADDR64)
3498             continue;
3499
3500           sym = *r->sym_ptr_ptr;
3501           if (!sym_exists_at (syms, opdsymend, symcount,
3502                               sym->section->id, sym->value + r->addend))
3503             {
3504               ++count;
3505               size += sizeof (asymbol);
3506               size += strlen (syms[i]->name) + 2;
3507             }
3508         }
3509
3510       if (size == 0)
3511         goto done;
3512       s = *ret = bfd_malloc (size);
3513       if (s == NULL)
3514         {
3515           count = -1;
3516           goto done;
3517         }
3518
3519       names = (char *) (s + count);
3520
3521       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3522         {
3523           asymbol *sym;
3524
3525           while (r < opd->relocation + relcount
3526                  && r->address < syms[i]->value + opd->vma)
3527             ++r;
3528
3529           if (r == opd->relocation + relcount)
3530             break;
3531
3532           if (r->address != syms[i]->value + opd->vma)
3533             continue;
3534
3535           if (r->howto->type != R_PPC64_ADDR64)
3536             continue;
3537
3538           sym = *r->sym_ptr_ptr;
3539           if (!sym_exists_at (syms, opdsymend, symcount,
3540                               sym->section->id, sym->value + r->addend))
3541             {
3542               size_t len;
3543
3544               *s = *syms[i];
3545               s->flags |= BSF_SYNTHETIC;
3546               s->section = sym->section;
3547               s->value = sym->value + r->addend;
3548               s->name = names;
3549               *names++ = '.';
3550               len = strlen (syms[i]->name);
3551               memcpy (names, syms[i]->name, len + 1);
3552               names += len + 1;
3553               /* Have udata.p point back to the original symbol this
3554                  synthetic symbol was derived from.  */
3555               s->udata.p = syms[i];
3556               s++;
3557             }
3558         }
3559     }
3560   else
3561     {
3562       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3563       bfd_byte *contents = NULL;
3564       size_t size;
3565       size_t plt_count = 0;
3566       bfd_vma glink_vma = 0, resolv_vma = 0;
3567       asection *dynamic, *glink = NULL, *relplt = NULL;
3568       arelent *p;
3569
3570       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3571         {
3572         free_contents_and_exit_err:
3573           count = -1;
3574         free_contents_and_exit:
3575           if (contents)
3576             free (contents);
3577           goto done;
3578         }
3579
3580       size = 0;
3581       for (i = secsymend; i < opdsymend; ++i)
3582         {
3583           bfd_vma ent;
3584
3585           /* Ignore bogus symbols.  */
3586           if (syms[i]->value > opd->size - 8)
3587             continue;
3588
3589           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3590           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3591             {
3592               ++count;
3593               size += sizeof (asymbol);
3594               size += strlen (syms[i]->name) + 2;
3595             }
3596         }
3597
3598       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3599       if (dyn_count != 0
3600           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3601         {
3602           bfd_byte *dynbuf, *extdyn, *extdynend;
3603           size_t extdynsize;
3604           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3605
3606           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3607             goto free_contents_and_exit_err;
3608
3609           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3610           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3611
3612           extdyn = dynbuf;
3613           extdynend = extdyn + dynamic->size;
3614           for (; extdyn < extdynend; extdyn += extdynsize)
3615             {
3616               Elf_Internal_Dyn dyn;
3617               (*swap_dyn_in) (abfd, extdyn, &dyn);
3618
3619               if (dyn.d_tag == DT_NULL)
3620                 break;
3621
3622               if (dyn.d_tag == DT_PPC64_GLINK)
3623                 {
3624                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3625                      See comment in ppc64_elf_finish_dynamic_sections. */
3626                   glink_vma = dyn.d_un.d_val + 8 * 4;
3627                   /* The .glink section usually does not survive the final
3628                      link; search for the section (usually .text) where the
3629                      glink stubs now reside.  */
3630                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3631                                                 &glink_vma);
3632                   break;
3633                 }
3634             }
3635
3636           free (dynbuf);
3637         }
3638
3639       if (glink != NULL)
3640         {
3641           /* Determine __glink trampoline by reading the relative branch
3642              from the first glink stub.  */
3643           bfd_byte buf[4];
3644           unsigned int off = 0;
3645
3646           while (bfd_get_section_contents (abfd, glink, buf,
3647                                            glink_vma + off - glink->vma, 4))
3648             {
3649               unsigned int insn = bfd_get_32 (abfd, buf);
3650               insn ^= B_DOT;
3651               if ((insn & ~0x3fffffc) == 0)
3652                 {
3653                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3654                   break;
3655                 }
3656               off += 4;
3657               if (off > 4)
3658                 break;
3659             }
3660
3661           if (resolv_vma)
3662             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3663
3664           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3665           if (relplt != NULL)
3666             {
3667               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3668               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3669                 goto free_contents_and_exit_err;
3670
3671               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3672               size += plt_count * sizeof (asymbol);
3673
3674               p = relplt->relocation;
3675               for (i = 0; i < plt_count; i++, p++)
3676                 {
3677                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3678                   if (p->addend != 0)
3679                     size += sizeof ("+0x") - 1 + 16;
3680                 }
3681             }
3682         }
3683
3684       if (size == 0)
3685         goto free_contents_and_exit;
3686       s = *ret = bfd_malloc (size);
3687       if (s == NULL)
3688         goto free_contents_and_exit_err;
3689
3690       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3691
3692       for (i = secsymend; i < opdsymend; ++i)
3693         {
3694           bfd_vma ent;
3695
3696           if (syms[i]->value > opd->size - 8)
3697             continue;
3698
3699           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3700           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3701             {
3702               size_t lo, hi;
3703               size_t len;
3704               asection *sec = abfd->sections;
3705
3706               *s = *syms[i];
3707               lo = codesecsym;
3708               hi = codesecsymend;
3709               while (lo < hi)
3710                 {
3711                   size_t mid = (lo + hi) >> 1;
3712                   if (syms[mid]->section->vma < ent)
3713                     lo = mid + 1;
3714                   else if (syms[mid]->section->vma > ent)
3715                     hi = mid;
3716                   else
3717                     {
3718                       sec = syms[mid]->section;
3719                       break;
3720                     }
3721                 }
3722
3723               if (lo >= hi && lo > codesecsym)
3724                 sec = syms[lo - 1]->section;
3725
3726               for (; sec != NULL; sec = sec->next)
3727                 {
3728                   if (sec->vma > ent)
3729                     break;
3730                   /* SEC_LOAD may not be set if SEC is from a separate debug
3731                      info file.  */
3732                   if ((sec->flags & SEC_ALLOC) == 0)
3733                     break;
3734                   if ((sec->flags & SEC_CODE) != 0)
3735                     s->section = sec;
3736                 }
3737               s->flags |= BSF_SYNTHETIC;
3738               s->value = ent - s->section->vma;
3739               s->name = names;
3740               *names++ = '.';
3741               len = strlen (syms[i]->name);
3742               memcpy (names, syms[i]->name, len + 1);
3743               names += len + 1;
3744               /* Have udata.p point back to the original symbol this
3745                  synthetic symbol was derived from.  */
3746               s->udata.p = syms[i];
3747               s++;
3748             }
3749         }
3750       free (contents);
3751
3752       if (glink != NULL && relplt != NULL)
3753         {
3754           if (resolv_vma)
3755             {
3756               /* Add a symbol for the main glink trampoline.  */
3757               memset (s, 0, sizeof *s);
3758               s->the_bfd = abfd;
3759               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3760               s->section = glink;
3761               s->value = resolv_vma - glink->vma;
3762               s->name = names;
3763               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3764               names += sizeof ("__glink_PLTresolve");
3765               s++;
3766               count++;
3767             }
3768
3769           /* FIXME: It would be very much nicer to put sym@plt on the
3770              stub rather than on the glink branch table entry.  The
3771              objdump disassembler would then use a sensible symbol
3772              name on plt calls.  The difficulty in doing so is
3773              a) finding the stubs, and,
3774              b) matching stubs against plt entries, and,
3775              c) there can be multiple stubs for a given plt entry.
3776
3777              Solving (a) could be done by code scanning, but older
3778              ppc64 binaries used different stubs to current code.
3779              (b) is the tricky one since you need to known the toc
3780              pointer for at least one function that uses a pic stub to
3781              be able to calculate the plt address referenced.
3782              (c) means gdb would need to set multiple breakpoints (or
3783              find the glink branch itself) when setting breakpoints
3784              for pending shared library loads.  */
3785           p = relplt->relocation;
3786           for (i = 0; i < plt_count; i++, p++)
3787             {
3788               size_t len;
3789
3790               *s = **p->sym_ptr_ptr;
3791               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3792                  we are defining a symbol, ensure one of them is set.  */
3793               if ((s->flags & BSF_LOCAL) == 0)
3794                 s->flags |= BSF_GLOBAL;
3795               s->flags |= BSF_SYNTHETIC;
3796               s->section = glink;
3797               s->value = glink_vma - glink->vma;
3798               s->name = names;
3799               s->udata.p = NULL;
3800               len = strlen ((*p->sym_ptr_ptr)->name);
3801               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3802               names += len;
3803               if (p->addend != 0)
3804                 {
3805                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3806                   names += sizeof ("+0x") - 1;
3807                   bfd_sprintf_vma (abfd, names, p->addend);
3808                   names += strlen (names);
3809                 }
3810               memcpy (names, "@plt", sizeof ("@plt"));
3811               names += sizeof ("@plt");
3812               s++;
3813               if (abi < 2)
3814                 {
3815                   glink_vma += 8;
3816                   if (i >= 0x8000)
3817                     glink_vma += 4;
3818                 }
3819               else
3820                 glink_vma += 4;
3821             }
3822           count += plt_count;
3823         }
3824     }
3825
3826  done:
3827   free (syms);
3828   return count;
3829 }
3830 \f
3831 /* The following functions are specific to the ELF linker, while
3832    functions above are used generally.  Those named ppc64_elf_* are
3833    called by the main ELF linker code.  They appear in this file more
3834    or less in the order in which they are called.  eg.
3835    ppc64_elf_check_relocs is called early in the link process,
3836    ppc64_elf_finish_dynamic_sections is one of the last functions
3837    called.
3838
3839    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3840    functions have both a function code symbol and a function descriptor
3841    symbol.  A call to foo in a relocatable object file looks like:
3842
3843    .            .text
3844    .    x:
3845    .            bl      .foo
3846    .            nop
3847
3848    The function definition in another object file might be:
3849
3850    .            .section .opd
3851    .    foo:    .quad   .foo
3852    .            .quad   .TOC.@tocbase
3853    .            .quad   0
3854    .
3855    .            .text
3856    .    .foo:   blr
3857
3858    When the linker resolves the call during a static link, the branch
3859    unsurprisingly just goes to .foo and the .opd information is unused.
3860    If the function definition is in a shared library, things are a little
3861    different:  The call goes via a plt call stub, the opd information gets
3862    copied to the plt, and the linker patches the nop.
3863
3864    .    x:
3865    .            bl      .foo_stub
3866    .            ld      2,40(1)
3867    .
3868    .
3869    .    .foo_stub:
3870    .            std     2,40(1)                 # in practice, the call stub
3871    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3872    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3873    .            ld      12,0(11)
3874    .            ld      2,8(11)
3875    .            mtctr   12
3876    .            ld      11,16(11)
3877    .            bctr
3878    .
3879    .            .section .plt
3880    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3881
3882    The "reloc ()" notation is supposed to indicate that the linker emits
3883    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3884    copying.
3885
3886    What are the difficulties here?  Well, firstly, the relocations
3887    examined by the linker in check_relocs are against the function code
3888    sym .foo, while the dynamic relocation in the plt is emitted against
3889    the function descriptor symbol, foo.  Somewhere along the line, we need
3890    to carefully copy dynamic link information from one symbol to the other.
3891    Secondly, the generic part of the elf linker will make .foo a dynamic
3892    symbol as is normal for most other backends.  We need foo dynamic
3893    instead, at least for an application final link.  However, when
3894    creating a shared library containing foo, we need to have both symbols
3895    dynamic so that references to .foo are satisfied during the early
3896    stages of linking.  Otherwise the linker might decide to pull in a
3897    definition from some other object, eg. a static library.
3898
3899    Update: As of August 2004, we support a new convention.  Function
3900    calls may use the function descriptor symbol, ie. "bl foo".  This
3901    behaves exactly as "bl .foo".  */
3902
3903 /* Of those relocs that might be copied as dynamic relocs, this
3904    function selects those that must be copied when linking a shared
3905    library or PIE, even when the symbol is local.  */
3906
3907 static int
3908 must_be_dyn_reloc (struct bfd_link_info *info,
3909                    enum elf_ppc64_reloc_type r_type)
3910 {
3911   switch (r_type)
3912     {
3913     default:
3914       /* Only relative relocs can be resolved when the object load
3915          address isn't fixed.  DTPREL64 is excluded because the
3916          dynamic linker needs to differentiate global dynamic from
3917          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3918       return 1;
3919
3920     case R_PPC64_REL32:
3921     case R_PPC64_REL64:
3922     case R_PPC64_REL30:
3923       return 0;
3924
3925     case R_PPC64_TPREL16:
3926     case R_PPC64_TPREL16_LO:
3927     case R_PPC64_TPREL16_HI:
3928     case R_PPC64_TPREL16_HA:
3929     case R_PPC64_TPREL16_DS:
3930     case R_PPC64_TPREL16_LO_DS:
3931     case R_PPC64_TPREL16_HIGH:
3932     case R_PPC64_TPREL16_HIGHA:
3933     case R_PPC64_TPREL16_HIGHER:
3934     case R_PPC64_TPREL16_HIGHERA:
3935     case R_PPC64_TPREL16_HIGHEST:
3936     case R_PPC64_TPREL16_HIGHESTA:
3937     case R_PPC64_TPREL64:
3938       /* These relocations are relative but in a shared library the
3939          linker doesn't know the thread pointer base.  */
3940       return bfd_link_dll (info);
3941     }
3942 }
3943
3944 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3945    copying dynamic variables from a shared lib into an app's dynbss
3946    section, and instead use a dynamic relocation to point into the
3947    shared lib.  With code that gcc generates, it's vital that this be
3948    enabled;  In the PowerPC64 ABI, the address of a function is actually
3949    the address of a function descriptor, which resides in the .opd
3950    section.  gcc uses the descriptor directly rather than going via the
3951    GOT as some other ABI's do, which means that initialized function
3952    pointers must reference the descriptor.  Thus, a function pointer
3953    initialized to the address of a function in a shared library will
3954    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3955    redefines the function descriptor symbol to point to the copy.  This
3956    presents a problem as a plt entry for that function is also
3957    initialized from the function descriptor symbol and the copy reloc
3958    may not be initialized first.  */
3959 #define ELIMINATE_COPY_RELOCS 1
3960
3961 /* Section name for stubs is the associated section name plus this
3962    string.  */
3963 #define STUB_SUFFIX ".stub"
3964
3965 /* Linker stubs.
3966    ppc_stub_long_branch:
3967    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3968    destination, but a 24 bit branch in a stub section will reach.
3969    .    b       dest
3970
3971    ppc_stub_plt_branch:
3972    Similar to the above, but a 24 bit branch in the stub section won't
3973    reach its destination.
3974    .    addis   %r11,%r2,xxx@toc@ha
3975    .    ld      %r12,xxx@toc@l(%r11)
3976    .    mtctr   %r12
3977    .    bctr
3978
3979    ppc_stub_plt_call:
3980    Used to call a function in a shared library.  If it so happens that
3981    the plt entry referenced crosses a 64k boundary, then an extra
3982    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3983    ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
3984    .    addis   %r11,%r2,xxx@toc@ha
3985    .    ld      %r12,xxx+0@toc@l(%r11)
3986    .    mtctr   %r12
3987    .    ld      %r2,xxx+8@toc@l(%r11)
3988    .    ld      %r11,xxx+16@toc@l(%r11)
3989    .    bctr
3990
3991    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3992    code to adjust the value and save r2 to support multiple toc sections.
3993    A ppc_stub_long_branch with an r2 offset looks like:
3994    .    std     %r2,40(%r1)
3995    .    addis   %r2,%r2,off@ha
3996    .    addi    %r2,%r2,off@l
3997    .    b       dest
3998
3999    A ppc_stub_plt_branch with an r2 offset looks like:
4000    .    std     %r2,40(%r1)
4001    .    addis   %r11,%r2,xxx@toc@ha
4002    .    ld      %r12,xxx@toc@l(%r11)
4003    .    addis   %r2,%r2,off@ha
4004    .    addi    %r2,%r2,off@l
4005    .    mtctr   %r12
4006    .    bctr
4007
4008    All of the above stubs are shown as their ELFv1 variants.  ELFv2
4009    variants exist too, simpler for plt calls since a new toc pointer
4010    and static chain are not loaded by the stub.  In addition, ELFv2
4011    has some more complex stubs to handle calls marked with NOTOC
4012    relocs from functions where r2 is not a valid toc pointer.  These
4013    come in two flavours, the ones shown below, and _both variants that
4014    start with "std %r2,24(%r1)" to save r2 in the unlikely event that
4015    one call is from a function where r2 is used as the toc pointer but
4016    needs a toc adjusting stub for small-model multi-toc, and another
4017    call is from a function where r2 is not valid.
4018    ppc_stub_long_branch_notoc:
4019    .    mflr    %r12
4020    .    bcl     20,31,1f
4021    .  1:
4022    .    mflr    %r11
4023    .    mtlr    %r12
4024    .    lis     %r12,xxx-1b@highest
4025    .    ori     %r12,xxx-1b@higher
4026    .    sldi    %r12,%r12,32
4027    .    oris    %r12,%r12,xxx-1b@hi
4028    .    ori     %r12,%r12,xxx-1b@l
4029    .    add     %r12,%r11,%r12
4030    .    b       dest
4031
4032    ppc_stub_plt_branch_notoc:
4033    .    mflr    %r12
4034    .    bcl     20,31,1f
4035    .  1:
4036    .    mflr    %r11
4037    .    mtlr    %r12
4038    .    lis     %r12,xxx-1b@highest
4039    .    ori     %r12,xxx-1b@higher
4040    .    sldi    %r12,%r12,32
4041    .    oris    %r12,%r12,xxx-1b@hi
4042    .    ori     %r12,%r12,xxx-1b@l
4043    .    add     %r12,%r11,%r12
4044    .    mtctr   %r12
4045    .    bctr
4046
4047    ppc_stub_plt_call_notoc:
4048    .    mflr    %r12
4049    .    bcl     20,31,1f
4050    .  1:
4051    .    mflr    %r11
4052    .    mtlr    %r12
4053    .    lis     %r12,xxx-1b@highest
4054    .    ori     %r12,xxx-1b@higher
4055    .    sldi    %r12,%r12,32
4056    .    oris    %r12,%r12,xxx-1b@hi
4057    .    ori     %r12,%r12,xxx-1b@l
4058    .    ldx     %r12,%r11,%r12
4059    .    mtctr   %r12
4060    .    bctr
4061
4062    In cases where the high instructions would add zero, they are
4063    omitted and following instructions modified in some cases.
4064
4065    For a given stub group (a set of sections all using the same toc
4066    pointer value) there will be just one stub type used for any
4067    particular function symbol.  For example, if printf is called from
4068    code with the tocsave optimization (ie. r2 saved in function
4069    prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
4070    and from other code without the tocsave optimization requiring a
4071    ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
4072    type will be created.  Calls with the tocsave optimization will
4073    enter this stub after the instruction saving r2.  A similar
4074    situation exists when calls are marked with R_PPC64_REL24_NOTOC
4075    relocations.  These require a ppc_stub_plt_call_notoc linkage stub
4076    to call an external function like printf.  If other calls to printf
4077    require a ppc_stub_plt_call linkage stub then a single
4078    ppc_stub_plt_call_notoc linkage stub will be used for both types of
4079    call.  If other calls to printf require a ppc_stub_plt_call_r2save
4080    linkage stub then a single ppc_stub_plt_call_both linkage stub will
4081    be created and calls not requiring r2 to be saved will enter the
4082    stub after the r2 save instruction.  There is an analogous
4083    hierarchy of long branch and plt branch stubs for local call
4084    linkage.  */
4085
4086 enum ppc_stub_type {
4087   ppc_stub_none,
4088   ppc_stub_long_branch,
4089   ppc_stub_long_branch_r2off,
4090   ppc_stub_long_branch_notoc,
4091   ppc_stub_long_branch_both, /* r2off and notoc variants both needed.  */
4092   ppc_stub_plt_branch,
4093   ppc_stub_plt_branch_r2off,
4094   ppc_stub_plt_branch_notoc,
4095   ppc_stub_plt_branch_both,
4096   ppc_stub_plt_call,
4097   ppc_stub_plt_call_r2save,
4098   ppc_stub_plt_call_notoc,
4099   ppc_stub_plt_call_both,
4100   ppc_stub_global_entry,
4101   ppc_stub_save_res
4102 };
4103
4104 /* Information on stub grouping.  */
4105 struct map_stub
4106 {
4107   /* The stub section.  */
4108   asection *stub_sec;
4109   /* This is the section to which stubs in the group will be attached.  */
4110   asection *link_sec;
4111   /* Next group.  */
4112   struct map_stub *next;
4113   /* Whether to emit a copy of register save/restore functions in this
4114      group.  */
4115   int needs_save_res;
4116   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
4117      or -1u if no such stub with bctrl exists.  */
4118   unsigned int tls_get_addr_opt_bctrl;
4119 };
4120
4121 struct ppc_stub_hash_entry {
4122
4123   /* Base hash table entry structure.  */
4124   struct bfd_hash_entry root;
4125
4126   enum ppc_stub_type stub_type;
4127
4128   /* Group information.  */
4129   struct map_stub *group;
4130
4131   /* Offset within stub_sec of the beginning of this stub.  */
4132   bfd_vma stub_offset;
4133
4134   /* Given the symbol's value and its section we can determine its final
4135      value when building the stubs (so the stub knows where to jump.  */
4136   bfd_vma target_value;
4137   asection *target_section;
4138
4139   /* The symbol table entry, if any, that this was derived from.  */
4140   struct ppc_link_hash_entry *h;
4141   struct plt_entry *plt_ent;
4142
4143   /* Symbol type.  */
4144   unsigned char symtype;
4145
4146   /* Symbol st_other.  */
4147   unsigned char other;
4148 };
4149
4150 struct ppc_branch_hash_entry {
4151
4152   /* Base hash table entry structure.  */
4153   struct bfd_hash_entry root;
4154
4155   /* Offset within branch lookup table.  */
4156   unsigned int offset;
4157
4158   /* Generation marker.  */
4159   unsigned int iter;
4160 };
4161
4162 /* Used to track dynamic relocations for local symbols.  */
4163 struct ppc_dyn_relocs
4164 {
4165   struct ppc_dyn_relocs *next;
4166
4167   /* The input section of the reloc.  */
4168   asection *sec;
4169
4170   /* Total number of relocs copied for the input section.  */
4171   unsigned int count : 31;
4172
4173   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4174   unsigned int ifunc : 1;
4175 };
4176
4177 struct ppc_link_hash_entry
4178 {
4179   struct elf_link_hash_entry elf;
4180
4181   union {
4182     /* A pointer to the most recently used stub hash entry against this
4183        symbol.  */
4184     struct ppc_stub_hash_entry *stub_cache;
4185
4186     /* A pointer to the next symbol starting with a '.'  */
4187     struct ppc_link_hash_entry *next_dot_sym;
4188   } u;
4189
4190   /* Track dynamic relocs copied for this symbol.  */
4191   struct elf_dyn_relocs *dyn_relocs;
4192
4193   /* Link between function code and descriptor symbols.  */
4194   struct ppc_link_hash_entry *oh;
4195
4196   /* Flag function code and descriptor symbols.  */
4197   unsigned int is_func:1;
4198   unsigned int is_func_descriptor:1;
4199   unsigned int fake:1;
4200
4201   /* Whether global opd/toc sym has been adjusted or not.
4202      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4203      should be set for all globals defined in any opd/toc section.  */
4204   unsigned int adjust_done:1;
4205
4206   /* Set if this is an out-of-line register save/restore function,
4207      with non-standard calling convention.  */
4208   unsigned int save_res:1;
4209
4210   /* Set if a duplicate symbol with non-zero localentry is detected,
4211      even when the duplicate symbol does not provide a definition.  */
4212   unsigned int non_zero_localentry:1;
4213
4214   /* Contexts in which symbol is used in the GOT (or TOC).
4215      Bits are or'd into the mask as the corresponding relocs are
4216      encountered during check_relocs, with TLS_TLS being set when any
4217      of the other TLS bits are set.  tls_optimize clears bits when
4218      optimizing to indicate the corresponding GOT entry type is not
4219      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4220      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4221      separate flag rather than setting TPREL just for convenience in
4222      distinguishing the two cases.
4223      These flags are also kept for local symbols.  */
4224 #define TLS_TLS          1      /* Any TLS reloc.  */
4225 #define TLS_GD           2      /* GD reloc. */
4226 #define TLS_LD           4      /* LD reloc. */
4227 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4228 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4229 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4230 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4231 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4232   unsigned char tls_mask;
4233
4234   /* The above field is also used to mark function symbols.  In which
4235      case TLS_TLS will be 0.  */
4236 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4237 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4238 #define NON_GOT        256      /* local symbol plt, not stored.  */
4239 };
4240
4241 /* ppc64 ELF linker hash table.  */
4242
4243 struct ppc_link_hash_table
4244 {
4245   struct elf_link_hash_table elf;
4246
4247   /* The stub hash table.  */
4248   struct bfd_hash_table stub_hash_table;
4249
4250   /* Another hash table for plt_branch stubs.  */
4251   struct bfd_hash_table branch_hash_table;
4252
4253   /* Hash table for function prologue tocsave.  */
4254   htab_t tocsave_htab;
4255
4256   /* Various options and other info passed from the linker.  */
4257   struct ppc64_elf_params *params;
4258
4259   /* The size of sec_info below.  */
4260   unsigned int sec_info_arr_size;
4261
4262   /* Per-section array of extra section info.  Done this way rather
4263      than as part of ppc64_elf_section_data so we have the info for
4264      non-ppc64 sections.  */
4265   struct
4266   {
4267     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4268     bfd_vma toc_off;
4269
4270     union
4271     {
4272       /* The section group that this section belongs to.  */
4273       struct map_stub *group;
4274       /* A temp section list pointer.  */
4275       asection *list;
4276     } u;
4277   } *sec_info;
4278
4279   /* Linked list of groups.  */
4280   struct map_stub *group;
4281
4282   /* Temp used when calculating TOC pointers.  */
4283   bfd_vma toc_curr;
4284   bfd *toc_bfd;
4285   asection *toc_first_sec;
4286
4287   /* Used when adding symbols.  */
4288   struct ppc_link_hash_entry *dot_syms;
4289
4290   /* Shortcuts to get to dynamic linker sections.  */
4291   asection *glink;
4292   asection *global_entry;
4293   asection *sfpr;
4294   asection *pltlocal;
4295   asection *relpltlocal;
4296   asection *brlt;
4297   asection *relbrlt;
4298   asection *glink_eh_frame;
4299
4300   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4301   struct ppc_link_hash_entry *tls_get_addr;
4302   struct ppc_link_hash_entry *tls_get_addr_fd;
4303
4304   /* The size of reliplt used by got entry relocs.  */
4305   bfd_size_type got_reli_size;
4306
4307   /* Statistics.  */
4308   unsigned long stub_count[ppc_stub_global_entry];
4309
4310   /* Number of stubs against global syms.  */
4311   unsigned long stub_globals;
4312
4313   /* Set if we're linking code with function descriptors.  */
4314   unsigned int opd_abi:1;
4315
4316   /* Support for multiple toc sections.  */
4317   unsigned int do_multi_toc:1;
4318   unsigned int multi_toc_needed:1;
4319   unsigned int second_toc_pass:1;
4320   unsigned int do_toc_opt:1;
4321
4322   /* Set if tls optimization is enabled.  */
4323   unsigned int do_tls_opt:1;
4324
4325   /* Set if inline plt calls should be converted to direct calls.  */
4326   unsigned int can_convert_all_inline_plt:1;
4327
4328   /* Set on error.  */
4329   unsigned int stub_error:1;
4330
4331   /* Whether func_desc_adjust needs to be run over symbols.  */
4332   unsigned int need_func_desc_adj:1;
4333
4334   /* Whether there exist local gnu indirect function resolvers,
4335      referenced by dynamic relocations.  */
4336   unsigned int local_ifunc_resolver:1;
4337   unsigned int maybe_local_ifunc_resolver:1;
4338
4339   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4340   unsigned int has_plt_localentry0:1;
4341
4342   /* Incremented every time we size stubs.  */
4343   unsigned int stub_iteration;
4344
4345   /* Small local sym cache.  */
4346   struct sym_cache sym_cache;
4347 };
4348
4349 /* Rename some of the generic section flags to better document how they
4350    are used here.  */
4351
4352 /* Nonzero if this section has TLS related relocations.  */
4353 #define has_tls_reloc sec_flg0
4354
4355 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4356 #define has_tls_get_addr_call sec_flg1
4357
4358 /* Nonzero if this section has any toc or got relocs.  */
4359 #define has_toc_reloc sec_flg2
4360
4361 /* Nonzero if this section has a call to another section that uses
4362    the toc or got.  */
4363 #define makes_toc_func_call sec_flg3
4364
4365 /* Recursion protection when determining above flag.  */
4366 #define call_check_in_progress sec_flg4
4367 #define call_check_done sec_flg5
4368
4369 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4370
4371 #define ppc_hash_table(p) \
4372   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4373   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4374
4375 #define ppc_stub_hash_lookup(table, string, create, copy) \
4376   ((struct ppc_stub_hash_entry *) \
4377    bfd_hash_lookup ((table), (string), (create), (copy)))
4378
4379 #define ppc_branch_hash_lookup(table, string, create, copy) \
4380   ((struct ppc_branch_hash_entry *) \
4381    bfd_hash_lookup ((table), (string), (create), (copy)))
4382
4383 /* Create an entry in the stub hash table.  */
4384
4385 static struct bfd_hash_entry *
4386 stub_hash_newfunc (struct bfd_hash_entry *entry,
4387                    struct bfd_hash_table *table,
4388                    const char *string)
4389 {
4390   /* Allocate the structure if it has not already been allocated by a
4391      subclass.  */
4392   if (entry == NULL)
4393     {
4394       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4395       if (entry == NULL)
4396         return entry;
4397     }
4398
4399   /* Call the allocation method of the superclass.  */
4400   entry = bfd_hash_newfunc (entry, table, string);
4401   if (entry != NULL)
4402     {
4403       struct ppc_stub_hash_entry *eh;
4404
4405       /* Initialize the local fields.  */
4406       eh = (struct ppc_stub_hash_entry *) entry;
4407       eh->stub_type = ppc_stub_none;
4408       eh->group = NULL;
4409       eh->stub_offset = 0;
4410       eh->target_value = 0;
4411       eh->target_section = NULL;
4412       eh->h = NULL;
4413       eh->plt_ent = NULL;
4414       eh->other = 0;
4415     }
4416
4417   return entry;
4418 }
4419
4420 /* Create an entry in the branch hash table.  */
4421
4422 static struct bfd_hash_entry *
4423 branch_hash_newfunc (struct bfd_hash_entry *entry,
4424                      struct bfd_hash_table *table,
4425                      const char *string)
4426 {
4427   /* Allocate the structure if it has not already been allocated by a
4428      subclass.  */
4429   if (entry == NULL)
4430     {
4431       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4432       if (entry == NULL)
4433         return entry;
4434     }
4435
4436   /* Call the allocation method of the superclass.  */
4437   entry = bfd_hash_newfunc (entry, table, string);
4438   if (entry != NULL)
4439     {
4440       struct ppc_branch_hash_entry *eh;
4441
4442       /* Initialize the local fields.  */
4443       eh = (struct ppc_branch_hash_entry *) entry;
4444       eh->offset = 0;
4445       eh->iter = 0;
4446     }
4447
4448   return entry;
4449 }
4450
4451 /* Create an entry in a ppc64 ELF linker hash table.  */
4452
4453 static struct bfd_hash_entry *
4454 link_hash_newfunc (struct bfd_hash_entry *entry,
4455                    struct bfd_hash_table *table,
4456                    const char *string)
4457 {
4458   /* Allocate the structure if it has not already been allocated by a
4459      subclass.  */
4460   if (entry == NULL)
4461     {
4462       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4463       if (entry == NULL)
4464         return entry;
4465     }
4466
4467   /* Call the allocation method of the superclass.  */
4468   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4469   if (entry != NULL)
4470     {
4471       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4472
4473       memset (&eh->u.stub_cache, 0,
4474               (sizeof (struct ppc_link_hash_entry)
4475                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4476
4477       /* When making function calls, old ABI code references function entry
4478          points (dot symbols), while new ABI code references the function
4479          descriptor symbol.  We need to make any combination of reference and
4480          definition work together, without breaking archive linking.
4481
4482          For a defined function "foo" and an undefined call to "bar":
4483          An old object defines "foo" and ".foo", references ".bar" (possibly
4484          "bar" too).
4485          A new object defines "foo" and references "bar".
4486
4487          A new object thus has no problem with its undefined symbols being
4488          satisfied by definitions in an old object.  On the other hand, the
4489          old object won't have ".bar" satisfied by a new object.
4490
4491          Keep a list of newly added dot-symbols.  */
4492
4493       if (string[0] == '.')
4494         {
4495           struct ppc_link_hash_table *htab;
4496
4497           htab = (struct ppc_link_hash_table *) table;
4498           eh->u.next_dot_sym = htab->dot_syms;
4499           htab->dot_syms = eh;
4500         }
4501     }
4502
4503   return entry;
4504 }
4505
4506 struct tocsave_entry {
4507   asection *sec;
4508   bfd_vma offset;
4509 };
4510
4511 static hashval_t
4512 tocsave_htab_hash (const void *p)
4513 {
4514   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4515   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4516 }
4517
4518 static int
4519 tocsave_htab_eq (const void *p1, const void *p2)
4520 {
4521   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4522   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4523   return e1->sec == e2->sec && e1->offset == e2->offset;
4524 }
4525
4526 /* Destroy a ppc64 ELF linker hash table.  */
4527
4528 static void
4529 ppc64_elf_link_hash_table_free (bfd *obfd)
4530 {
4531   struct ppc_link_hash_table *htab;
4532
4533   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4534   if (htab->tocsave_htab)
4535     htab_delete (htab->tocsave_htab);
4536   bfd_hash_table_free (&htab->branch_hash_table);
4537   bfd_hash_table_free (&htab->stub_hash_table);
4538   _bfd_elf_link_hash_table_free (obfd);
4539 }
4540
4541 /* Create a ppc64 ELF linker hash table.  */
4542
4543 static struct bfd_link_hash_table *
4544 ppc64_elf_link_hash_table_create (bfd *abfd)
4545 {
4546   struct ppc_link_hash_table *htab;
4547   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4548
4549   htab = bfd_zmalloc (amt);
4550   if (htab == NULL)
4551     return NULL;
4552
4553   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4554                                       sizeof (struct ppc_link_hash_entry),
4555                                       PPC64_ELF_DATA))
4556     {
4557       free (htab);
4558       return NULL;
4559     }
4560
4561   /* Init the stub hash table too.  */
4562   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4563                             sizeof (struct ppc_stub_hash_entry)))
4564     {
4565       _bfd_elf_link_hash_table_free (abfd);
4566       return NULL;
4567     }
4568
4569   /* And the branch hash table.  */
4570   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4571                             sizeof (struct ppc_branch_hash_entry)))
4572     {
4573       bfd_hash_table_free (&htab->stub_hash_table);
4574       _bfd_elf_link_hash_table_free (abfd);
4575       return NULL;
4576     }
4577
4578   htab->tocsave_htab = htab_try_create (1024,
4579                                         tocsave_htab_hash,
4580                                         tocsave_htab_eq,
4581                                         NULL);
4582   if (htab->tocsave_htab == NULL)
4583     {
4584       ppc64_elf_link_hash_table_free (abfd);
4585       return NULL;
4586     }
4587   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4588
4589   /* Initializing two fields of the union is just cosmetic.  We really
4590      only care about glist, but when compiled on a 32-bit host the
4591      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4592      debugger inspection of these fields look nicer.  */
4593   htab->elf.init_got_refcount.refcount = 0;
4594   htab->elf.init_got_refcount.glist = NULL;
4595   htab->elf.init_plt_refcount.refcount = 0;
4596   htab->elf.init_plt_refcount.glist = NULL;
4597   htab->elf.init_got_offset.offset = 0;
4598   htab->elf.init_got_offset.glist = NULL;
4599   htab->elf.init_plt_offset.offset = 0;
4600   htab->elf.init_plt_offset.glist = NULL;
4601
4602   return &htab->elf.root;
4603 }
4604
4605 /* Create sections for linker generated code.  */
4606
4607 static bfd_boolean
4608 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4609 {
4610   struct ppc_link_hash_table *htab;
4611   flagword flags;
4612
4613   htab = ppc_hash_table (info);
4614
4615   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4616            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4617   if (htab->params->save_restore_funcs)
4618     {
4619       /* Create .sfpr for code to save and restore fp regs.  */
4620       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4621                                                        flags);
4622       if (htab->sfpr == NULL
4623           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4624         return FALSE;
4625     }
4626
4627   if (bfd_link_relocatable (info))
4628     return TRUE;
4629
4630   /* Create .glink for lazy dynamic linking support.  */
4631   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4632                                                     flags);
4633   if (htab->glink == NULL
4634       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4635     return FALSE;
4636
4637   /* The part of .glink used by global entry stubs, separate so that
4638      it can be aligned appropriately without affecting htab->glink.  */
4639   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4640                                                            flags);
4641   if (htab->global_entry == NULL
4642       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4643     return FALSE;
4644
4645   if (!info->no_ld_generated_unwind_info)
4646     {
4647       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4648                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4649       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4650                                                                  ".eh_frame",
4651                                                                  flags);
4652       if (htab->glink_eh_frame == NULL
4653           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4654         return FALSE;
4655     }
4656
4657   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4658   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4659   if (htab->elf.iplt == NULL
4660       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4661     return FALSE;
4662
4663   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4664            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4665   htab->elf.irelplt
4666     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4667   if (htab->elf.irelplt == NULL
4668       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4669     return FALSE;
4670
4671   /* Create branch lookup table for plt_branch stubs.  */
4672   flags = (SEC_ALLOC | SEC_LOAD
4673            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4674   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4675                                                    flags);
4676   if (htab->brlt == NULL
4677       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4678     return FALSE;
4679
4680   /* Local plt entries, put in .branch_lt but a separate section for
4681      convenience.  */
4682   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4683                                                        flags);
4684   if (htab->pltlocal == NULL
4685       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4686     return FALSE;
4687
4688   if (!bfd_link_pic (info))
4689     return TRUE;
4690
4691   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4692            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4693   htab->relbrlt
4694     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4695   if (htab->relbrlt == NULL
4696       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4697     return FALSE;
4698
4699   htab->relpltlocal
4700     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4701   if (htab->relpltlocal == NULL
4702       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4703     return FALSE;
4704
4705   return TRUE;
4706 }
4707
4708 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4709
4710 bfd_boolean
4711 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4712                          struct ppc64_elf_params *params)
4713 {
4714   struct ppc_link_hash_table *htab;
4715
4716   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4717
4718 /* Always hook our dynamic sections into the first bfd, which is the
4719    linker created stub bfd.  This ensures that the GOT header is at
4720    the start of the output TOC section.  */
4721   htab = ppc_hash_table (info);
4722   htab->elf.dynobj = params->stub_bfd;
4723   htab->params = params;
4724
4725   return create_linkage_sections (htab->elf.dynobj, info);
4726 }
4727
4728 /* Build a name for an entry in the stub hash table.  */
4729
4730 static char *
4731 ppc_stub_name (const asection *input_section,
4732                const asection *sym_sec,
4733                const struct ppc_link_hash_entry *h,
4734                const Elf_Internal_Rela *rel)
4735 {
4736   char *stub_name;
4737   ssize_t len;
4738
4739   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4740      offsets from a sym as a branch target?  In fact, we could
4741      probably assume the addend is always zero.  */
4742   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4743
4744   if (h)
4745     {
4746       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4747       stub_name = bfd_malloc (len);
4748       if (stub_name == NULL)
4749         return stub_name;
4750
4751       len = sprintf (stub_name, "%08x.%s+%x",
4752                      input_section->id & 0xffffffff,
4753                      h->elf.root.root.string,
4754                      (int) rel->r_addend & 0xffffffff);
4755     }
4756   else
4757     {
4758       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4759       stub_name = bfd_malloc (len);
4760       if (stub_name == NULL)
4761         return stub_name;
4762
4763       len = sprintf (stub_name, "%08x.%x:%x+%x",
4764                      input_section->id & 0xffffffff,
4765                      sym_sec->id & 0xffffffff,
4766                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4767                      (int) rel->r_addend & 0xffffffff);
4768     }
4769   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4770     stub_name[len - 2] = 0;
4771   return stub_name;
4772 }
4773
4774 /* Look up an entry in the stub hash.  Stub entries are cached because
4775    creating the stub name takes a bit of time.  */
4776
4777 static struct ppc_stub_hash_entry *
4778 ppc_get_stub_entry (const asection *input_section,
4779                     const asection *sym_sec,
4780                     struct ppc_link_hash_entry *h,
4781                     const Elf_Internal_Rela *rel,
4782                     struct ppc_link_hash_table *htab)
4783 {
4784   struct ppc_stub_hash_entry *stub_entry;
4785   struct map_stub *group;
4786
4787   /* If this input section is part of a group of sections sharing one
4788      stub section, then use the id of the first section in the group.
4789      Stub names need to include a section id, as there may well be
4790      more than one stub used to reach say, printf, and we need to
4791      distinguish between them.  */
4792   group = htab->sec_info[input_section->id].u.group;
4793   if (group == NULL)
4794     return NULL;
4795
4796   if (h != NULL && h->u.stub_cache != NULL
4797       && h->u.stub_cache->h == h
4798       && h->u.stub_cache->group == group)
4799     {
4800       stub_entry = h->u.stub_cache;
4801     }
4802   else
4803     {
4804       char *stub_name;
4805
4806       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4807       if (stub_name == NULL)
4808         return NULL;
4809
4810       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4811                                          stub_name, FALSE, FALSE);
4812       if (h != NULL)
4813         h->u.stub_cache = stub_entry;
4814
4815       free (stub_name);
4816     }
4817
4818   return stub_entry;
4819 }
4820
4821 /* Add a new stub entry to the stub hash.  Not all fields of the new
4822    stub entry are initialised.  */
4823
4824 static struct ppc_stub_hash_entry *
4825 ppc_add_stub (const char *stub_name,
4826               asection *section,
4827               struct bfd_link_info *info)
4828 {
4829   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4830   struct map_stub *group;
4831   asection *link_sec;
4832   asection *stub_sec;
4833   struct ppc_stub_hash_entry *stub_entry;
4834
4835   group = htab->sec_info[section->id].u.group;
4836   link_sec = group->link_sec;
4837   stub_sec = group->stub_sec;
4838   if (stub_sec == NULL)
4839     {
4840       size_t namelen;
4841       bfd_size_type len;
4842       char *s_name;
4843
4844       namelen = strlen (link_sec->name);
4845       len = namelen + sizeof (STUB_SUFFIX);
4846       s_name = bfd_alloc (htab->params->stub_bfd, len);
4847       if (s_name == NULL)
4848         return NULL;
4849
4850       memcpy (s_name, link_sec->name, namelen);
4851       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4852       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4853       if (stub_sec == NULL)
4854         return NULL;
4855       group->stub_sec = stub_sec;
4856     }
4857
4858   /* Enter this entry into the linker stub hash table.  */
4859   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4860                                      TRUE, FALSE);
4861   if (stub_entry == NULL)
4862     {
4863       /* xgettext:c-format */
4864       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4865                           section->owner, stub_name);
4866       return NULL;
4867     }
4868
4869   stub_entry->group = group;
4870   stub_entry->stub_offset = 0;
4871   return stub_entry;
4872 }
4873
4874 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4875    not already done.  */
4876
4877 static bfd_boolean
4878 create_got_section (bfd *abfd, struct bfd_link_info *info)
4879 {
4880   asection *got, *relgot;
4881   flagword flags;
4882   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4883
4884   if (!is_ppc64_elf (abfd))
4885     return FALSE;
4886   if (htab == NULL)
4887     return FALSE;
4888
4889   if (!htab->elf.sgot
4890       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4891     return FALSE;
4892
4893   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4894            | SEC_LINKER_CREATED);
4895
4896   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4897   if (!got
4898       || !bfd_set_section_alignment (abfd, got, 3))
4899     return FALSE;
4900
4901   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4902                                                flags | SEC_READONLY);
4903   if (!relgot
4904       || ! bfd_set_section_alignment (abfd, relgot, 3))
4905     return FALSE;
4906
4907   ppc64_elf_tdata (abfd)->got = got;
4908   ppc64_elf_tdata (abfd)->relgot = relgot;
4909   return TRUE;
4910 }
4911
4912 /* Follow indirect and warning symbol links.  */
4913
4914 static inline struct bfd_link_hash_entry *
4915 follow_link (struct bfd_link_hash_entry *h)
4916 {
4917   while (h->type == bfd_link_hash_indirect
4918          || h->type == bfd_link_hash_warning)
4919     h = h->u.i.link;
4920   return h;
4921 }
4922
4923 static inline struct elf_link_hash_entry *
4924 elf_follow_link (struct elf_link_hash_entry *h)
4925 {
4926   return (struct elf_link_hash_entry *) follow_link (&h->root);
4927 }
4928
4929 static inline struct ppc_link_hash_entry *
4930 ppc_follow_link (struct ppc_link_hash_entry *h)
4931 {
4932   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4933 }
4934
4935 /* Merge PLT info on FROM with that on TO.  */
4936
4937 static void
4938 move_plt_plist (struct ppc_link_hash_entry *from,
4939                 struct ppc_link_hash_entry *to)
4940 {
4941   if (from->elf.plt.plist != NULL)
4942     {
4943       if (to->elf.plt.plist != NULL)
4944         {
4945           struct plt_entry **entp;
4946           struct plt_entry *ent;
4947
4948           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4949             {
4950               struct plt_entry *dent;
4951
4952               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4953                 if (dent->addend == ent->addend)
4954                   {
4955                     dent->plt.refcount += ent->plt.refcount;
4956                     *entp = ent->next;
4957                     break;
4958                   }
4959               if (dent == NULL)
4960                 entp = &ent->next;
4961             }
4962           *entp = to->elf.plt.plist;
4963         }
4964
4965       to->elf.plt.plist = from->elf.plt.plist;
4966       from->elf.plt.plist = NULL;
4967     }
4968 }
4969
4970 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4971
4972 static void
4973 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4974                                 struct elf_link_hash_entry *dir,
4975                                 struct elf_link_hash_entry *ind)
4976 {
4977   struct ppc_link_hash_entry *edir, *eind;
4978
4979   edir = (struct ppc_link_hash_entry *) dir;
4980   eind = (struct ppc_link_hash_entry *) ind;
4981
4982   edir->is_func |= eind->is_func;
4983   edir->is_func_descriptor |= eind->is_func_descriptor;
4984   edir->tls_mask |= eind->tls_mask;
4985   if (eind->oh != NULL)
4986     edir->oh = ppc_follow_link (eind->oh);
4987
4988   if (edir->elf.versioned != versioned_hidden)
4989     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4990   edir->elf.ref_regular |= eind->elf.ref_regular;
4991   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4992   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4993   edir->elf.needs_plt |= eind->elf.needs_plt;
4994   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4995
4996   /* If we were called to copy over info for a weak sym, don't copy
4997      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4998      in order to simplify readonly_dynrelocs and save a field in the
4999      symbol hash entry, but that means dyn_relocs can't be used in any
5000      tests about a specific symbol, or affect other symbol flags which
5001      are then tested.  */
5002   if (eind->elf.root.type != bfd_link_hash_indirect)
5003     return;
5004
5005   /* Copy over any dynamic relocs we may have on the indirect sym.  */
5006   if (eind->dyn_relocs != NULL)
5007     {
5008       if (edir->dyn_relocs != NULL)
5009         {
5010           struct elf_dyn_relocs **pp;
5011           struct elf_dyn_relocs *p;
5012
5013           /* Add reloc counts against the indirect sym to the direct sym
5014              list.  Merge any entries against the same section.  */
5015           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5016             {
5017               struct elf_dyn_relocs *q;
5018
5019               for (q = edir->dyn_relocs; q != NULL; q = q->next)
5020                 if (q->sec == p->sec)
5021                   {
5022                     q->pc_count += p->pc_count;
5023                     q->count += p->count;
5024                     *pp = p->next;
5025                     break;
5026                   }
5027               if (q == NULL)
5028                 pp = &p->next;
5029             }
5030           *pp = edir->dyn_relocs;
5031         }
5032
5033       edir->dyn_relocs = eind->dyn_relocs;
5034       eind->dyn_relocs = NULL;
5035     }
5036
5037   /* Copy over got entries that we may have already seen to the
5038      symbol which just became indirect.  */
5039   if (eind->elf.got.glist != NULL)
5040     {
5041       if (edir->elf.got.glist != NULL)
5042         {
5043           struct got_entry **entp;
5044           struct got_entry *ent;
5045
5046           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
5047             {
5048               struct got_entry *dent;
5049
5050               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
5051                 if (dent->addend == ent->addend
5052                     && dent->owner == ent->owner
5053                     && dent->tls_type == ent->tls_type)
5054                   {
5055                     dent->got.refcount += ent->got.refcount;
5056                     *entp = ent->next;
5057                     break;
5058                   }
5059               if (dent == NULL)
5060                 entp = &ent->next;
5061             }
5062           *entp = edir->elf.got.glist;
5063         }
5064
5065       edir->elf.got.glist = eind->elf.got.glist;
5066       eind->elf.got.glist = NULL;
5067     }
5068
5069   /* And plt entries.  */
5070   move_plt_plist (eind, edir);
5071
5072   if (eind->elf.dynindx != -1)
5073     {
5074       if (edir->elf.dynindx != -1)
5075         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5076                                 edir->elf.dynstr_index);
5077       edir->elf.dynindx = eind->elf.dynindx;
5078       edir->elf.dynstr_index = eind->elf.dynstr_index;
5079       eind->elf.dynindx = -1;
5080       eind->elf.dynstr_index = 0;
5081     }
5082 }
5083
5084 /* Find the function descriptor hash entry from the given function code
5085    hash entry FH.  Link the entries via their OH fields.  */
5086
5087 static struct ppc_link_hash_entry *
5088 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
5089 {
5090   struct ppc_link_hash_entry *fdh = fh->oh;
5091
5092   if (fdh == NULL)
5093     {
5094       const char *fd_name = fh->elf.root.root.string + 1;
5095
5096       fdh = (struct ppc_link_hash_entry *)
5097         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
5098       if (fdh == NULL)
5099         return fdh;
5100
5101       fdh->is_func_descriptor = 1;
5102       fdh->oh = fh;
5103       fh->is_func = 1;
5104       fh->oh = fdh;
5105     }
5106
5107   fdh = ppc_follow_link (fdh);
5108   fdh->is_func_descriptor = 1;
5109   fdh->oh = fh;
5110   return fdh;
5111 }
5112
5113 /* Make a fake function descriptor sym for the undefined code sym FH.  */
5114
5115 static struct ppc_link_hash_entry *
5116 make_fdh (struct bfd_link_info *info,
5117           struct ppc_link_hash_entry *fh)
5118 {
5119   bfd *abfd = fh->elf.root.u.undef.abfd;
5120   struct bfd_link_hash_entry *bh = NULL;
5121   struct ppc_link_hash_entry *fdh;
5122   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5123                     ? BSF_WEAK
5124                     : BSF_GLOBAL);
5125
5126   if (!_bfd_generic_link_add_one_symbol (info, abfd,
5127                                          fh->elf.root.root.string + 1,
5128                                          flags, bfd_und_section_ptr, 0,
5129                                          NULL, FALSE, FALSE, &bh))
5130     return NULL;
5131
5132   fdh = (struct ppc_link_hash_entry *) bh;
5133   fdh->elf.non_elf = 0;
5134   fdh->fake = 1;
5135   fdh->is_func_descriptor = 1;
5136   fdh->oh = fh;
5137   fh->is_func = 1;
5138   fh->oh = fdh;
5139   return fdh;
5140 }
5141
5142 /* Fix function descriptor symbols defined in .opd sections to be
5143    function type.  */
5144
5145 static bfd_boolean
5146 ppc64_elf_add_symbol_hook (bfd *ibfd,
5147                            struct bfd_link_info *info,
5148                            Elf_Internal_Sym *isym,
5149                            const char **name,
5150                            flagword *flags ATTRIBUTE_UNUSED,
5151                            asection **sec,
5152                            bfd_vma *value)
5153 {
5154   if (*sec != NULL
5155       && strcmp ((*sec)->name, ".opd") == 0)
5156     {
5157       asection *code_sec;
5158
5159       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5160             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5161         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5162
5163       /* If the symbol is a function defined in .opd, and the function
5164          code is in a discarded group, let it appear to be undefined.  */
5165       if (!bfd_link_relocatable (info)
5166           && (*sec)->reloc_count != 0
5167           && opd_entry_value (*sec, *value, &code_sec, NULL,
5168                               FALSE) != (bfd_vma) -1
5169           && discarded_section (code_sec))
5170         {
5171           *sec = bfd_und_section_ptr;
5172           isym->st_shndx = SHN_UNDEF;
5173         }
5174     }
5175   else if (*sec != NULL
5176            && strcmp ((*sec)->name, ".toc") == 0
5177            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5178     {
5179       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5180       if (htab != NULL)
5181         htab->params->object_in_toc = 1;
5182     }
5183
5184   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5185     {
5186       if (abiversion (ibfd) == 0)
5187         set_abiversion (ibfd, 2);
5188       else if (abiversion (ibfd) == 1)
5189         {
5190           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5191                                 " for ABI version 1"), *name);
5192           bfd_set_error (bfd_error_bad_value);
5193           return FALSE;
5194         }
5195     }
5196
5197   return TRUE;
5198 }
5199
5200 /* Merge non-visibility st_other attributes: local entry point.  */
5201
5202 static void
5203 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5204                                   const Elf_Internal_Sym *isym,
5205                                   bfd_boolean definition,
5206                                   bfd_boolean dynamic)
5207 {
5208   if (definition && (!dynamic || !h->def_regular))
5209     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5210                 | ELF_ST_VISIBILITY (h->other));
5211 }
5212
5213 /* Hook called on merging a symbol.  We use this to clear "fake" since
5214    we now have a real symbol.  */
5215
5216 static bfd_boolean
5217 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5218                         const Elf_Internal_Sym *isym,
5219                         asection **psec ATTRIBUTE_UNUSED,
5220                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5221                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5222                         bfd *oldbfd ATTRIBUTE_UNUSED,
5223                         const asection *oldsec ATTRIBUTE_UNUSED)
5224 {
5225   ((struct ppc_link_hash_entry *) h)->fake = 0;
5226   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5227     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5228   return TRUE;
5229 }
5230
5231 /* This function makes an old ABI object reference to ".bar" cause the
5232    inclusion of a new ABI object archive that defines "bar".
5233    NAME is a symbol defined in an archive.  Return a symbol in the hash
5234    table that might be satisfied by the archive symbols.  */
5235
5236 static struct elf_link_hash_entry *
5237 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5238                                  struct bfd_link_info *info,
5239                                  const char *name)
5240 {
5241   struct elf_link_hash_entry *h;
5242   char *dot_name;
5243   size_t len;
5244
5245   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5246   if (h != NULL
5247       /* Don't return this sym if it is a fake function descriptor
5248          created by add_symbol_adjust.  */
5249       && !((struct ppc_link_hash_entry *) h)->fake)
5250     return h;
5251
5252   if (name[0] == '.')
5253     return h;
5254
5255   len = strlen (name);
5256   dot_name = bfd_alloc (abfd, len + 2);
5257   if (dot_name == NULL)
5258     return (struct elf_link_hash_entry *) -1;
5259   dot_name[0] = '.';
5260   memcpy (dot_name + 1, name, len + 1);
5261   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5262   bfd_release (abfd, dot_name);
5263   return h;
5264 }
5265
5266 /* This function satisfies all old ABI object references to ".bar" if a
5267    new ABI object defines "bar".  Well, at least, undefined dot symbols
5268    are made weak.  This stops later archive searches from including an
5269    object if we already have a function descriptor definition.  It also
5270    prevents the linker complaining about undefined symbols.
5271    We also check and correct mismatched symbol visibility here.  The
5272    most restrictive visibility of the function descriptor and the
5273    function entry symbol is used.  */
5274
5275 static bfd_boolean
5276 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5277 {
5278   struct ppc_link_hash_table *htab;
5279   struct ppc_link_hash_entry *fdh;
5280
5281   if (eh->elf.root.type == bfd_link_hash_warning)
5282     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5283
5284   if (eh->elf.root.type == bfd_link_hash_indirect)
5285     return TRUE;
5286
5287   if (eh->elf.root.root.string[0] != '.')
5288     abort ();
5289
5290   htab = ppc_hash_table (info);
5291   if (htab == NULL)
5292     return FALSE;
5293
5294   fdh = lookup_fdh (eh, htab);
5295   if (fdh == NULL
5296       && !bfd_link_relocatable (info)
5297       && (eh->elf.root.type == bfd_link_hash_undefined
5298           || eh->elf.root.type == bfd_link_hash_undefweak)
5299       && eh->elf.ref_regular)
5300     {
5301       /* Make an undefined function descriptor sym, in order to
5302          pull in an --as-needed shared lib.  Archives are handled
5303          elsewhere.  */
5304       fdh = make_fdh (info, eh);
5305       if (fdh == NULL)
5306         return FALSE;
5307     }
5308
5309   if (fdh != NULL)
5310     {
5311       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5312       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5313
5314       /* Make both descriptor and entry symbol have the most
5315          constraining visibility of either symbol.  */
5316       if (entry_vis < descr_vis)
5317         fdh->elf.other += entry_vis - descr_vis;
5318       else if (entry_vis > descr_vis)
5319         eh->elf.other += descr_vis - entry_vis;
5320
5321       /* Propagate reference flags from entry symbol to function
5322          descriptor symbol.  */
5323       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5324       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5325       fdh->elf.ref_regular |= eh->elf.ref_regular;
5326       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5327
5328       if (!fdh->elf.forced_local
5329           && fdh->elf.dynindx == -1
5330           && fdh->elf.versioned != versioned_hidden
5331           && (bfd_link_dll (info)
5332               || fdh->elf.def_dynamic
5333               || fdh->elf.ref_dynamic)
5334           && (eh->elf.ref_regular
5335               || eh->elf.def_regular))
5336         {
5337           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5338             return FALSE;
5339         }
5340     }
5341
5342   return TRUE;
5343 }
5344
5345 /* Set up opd section info and abiversion for IBFD, and process list
5346    of dot-symbols we made in link_hash_newfunc.  */
5347
5348 static bfd_boolean
5349 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5350 {
5351   struct ppc_link_hash_table *htab;
5352   struct ppc_link_hash_entry **p, *eh;
5353   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5354
5355   if (opd != NULL && opd->size != 0)
5356     {
5357       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5358       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5359
5360       if (abiversion (ibfd) == 0)
5361         set_abiversion (ibfd, 1);
5362       else if (abiversion (ibfd) >= 2)
5363         {
5364           /* xgettext:c-format */
5365           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5366                               ibfd, abiversion (ibfd));
5367           bfd_set_error (bfd_error_bad_value);
5368           return FALSE;
5369         }
5370     }
5371
5372   if (is_ppc64_elf (info->output_bfd))
5373     {
5374       /* For input files without an explicit abiversion in e_flags
5375          we should have flagged any with symbol st_other bits set
5376          as ELFv1 and above flagged those with .opd as ELFv2.
5377          Set the output abiversion if not yet set, and for any input
5378          still ambiguous, take its abiversion from the output.
5379          Differences in ABI are reported later.  */
5380       if (abiversion (info->output_bfd) == 0)
5381         set_abiversion (info->output_bfd, abiversion (ibfd));
5382       else if (abiversion (ibfd) == 0)
5383         set_abiversion (ibfd, abiversion (info->output_bfd));
5384     }
5385
5386   htab = ppc_hash_table (info);
5387   if (htab == NULL)
5388     return TRUE;
5389
5390   if (opd != NULL && opd->size != 0
5391       && (ibfd->flags & DYNAMIC) == 0
5392       && (opd->flags & SEC_RELOC) != 0
5393       && opd->reloc_count != 0
5394       && !bfd_is_abs_section (opd->output_section)
5395       && info->gc_sections)
5396     {
5397       /* Garbage collection needs some extra help with .opd sections.
5398          We don't want to necessarily keep everything referenced by
5399          relocs in .opd, as that would keep all functions.  Instead,
5400          if we reference an .opd symbol (a function descriptor), we
5401          want to keep the function code symbol's section.  This is
5402          easy for global symbols, but for local syms we need to keep
5403          information about the associated function section.  */
5404       bfd_size_type amt;
5405       asection **opd_sym_map;
5406       Elf_Internal_Shdr *symtab_hdr;
5407       Elf_Internal_Rela *relocs, *rel_end, *rel;
5408
5409       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5410       opd_sym_map = bfd_zalloc (ibfd, amt);
5411       if (opd_sym_map == NULL)
5412         return FALSE;
5413       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5414       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5415                                           info->keep_memory);
5416       if (relocs == NULL)
5417         return FALSE;
5418       symtab_hdr = &elf_symtab_hdr (ibfd);
5419       rel_end = relocs + opd->reloc_count - 1;
5420       for (rel = relocs; rel < rel_end; rel++)
5421         {
5422           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5423           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5424
5425           if (r_type == R_PPC64_ADDR64
5426               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5427               && r_symndx < symtab_hdr->sh_info)
5428             {
5429               Elf_Internal_Sym *isym;
5430               asection *s;
5431
5432               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5433               if (isym == NULL)
5434                 {
5435                   if (elf_section_data (opd)->relocs != relocs)
5436                     free (relocs);
5437                   return FALSE;
5438                 }
5439
5440               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5441               if (s != NULL && s != opd)
5442                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5443             }
5444         }
5445       if (elf_section_data (opd)->relocs != relocs)
5446         free (relocs);
5447     }
5448
5449   p = &htab->dot_syms;
5450   while ((eh = *p) != NULL)
5451     {
5452       *p = NULL;
5453       if (&eh->elf == htab->elf.hgot)
5454         ;
5455       else if (htab->elf.hgot == NULL
5456                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5457         htab->elf.hgot = &eh->elf;
5458       else if (abiversion (ibfd) <= 1)
5459         {
5460           htab->need_func_desc_adj = 1;
5461           if (!add_symbol_adjust (eh, info))
5462             return FALSE;
5463         }
5464       p = &eh->u.next_dot_sym;
5465     }
5466   return TRUE;
5467 }
5468
5469 /* Undo hash table changes when an --as-needed input file is determined
5470    not to be needed.  */
5471
5472 static bfd_boolean
5473 ppc64_elf_notice_as_needed (bfd *ibfd,
5474                             struct bfd_link_info *info,
5475                             enum notice_asneeded_action act)
5476 {
5477   if (act == notice_not_needed)
5478     {
5479       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5480
5481       if (htab == NULL)
5482         return FALSE;
5483
5484       htab->dot_syms = NULL;
5485     }
5486   return _bfd_elf_notice_as_needed (ibfd, info, act);
5487 }
5488
5489 /* If --just-symbols against a final linked binary, then assume we need
5490    toc adjusting stubs when calling functions defined there.  */
5491
5492 static void
5493 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5494 {
5495   if ((sec->flags & SEC_CODE) != 0
5496       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5497       && is_ppc64_elf (sec->owner))
5498     {
5499       if (abiversion (sec->owner) >= 2
5500           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5501         sec->has_toc_reloc = 1;
5502     }
5503   _bfd_elf_link_just_syms (sec, info);
5504 }
5505
5506 static struct plt_entry **
5507 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5508                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5509 {
5510   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5511   struct plt_entry **local_plt;
5512   unsigned char *local_got_tls_masks;
5513
5514   if (local_got_ents == NULL)
5515     {
5516       bfd_size_type size = symtab_hdr->sh_info;
5517
5518       size *= (sizeof (*local_got_ents)
5519                + sizeof (*local_plt)
5520                + sizeof (*local_got_tls_masks));
5521       local_got_ents = bfd_zalloc (abfd, size);
5522       if (local_got_ents == NULL)
5523         return NULL;
5524       elf_local_got_ents (abfd) = local_got_ents;
5525     }
5526
5527   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5528     {
5529       struct got_entry *ent;
5530
5531       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5532         if (ent->addend == r_addend
5533             && ent->owner == abfd
5534             && ent->tls_type == tls_type)
5535           break;
5536       if (ent == NULL)
5537         {
5538           bfd_size_type amt = sizeof (*ent);
5539           ent = bfd_alloc (abfd, amt);
5540           if (ent == NULL)
5541             return FALSE;
5542           ent->next = local_got_ents[r_symndx];
5543           ent->addend = r_addend;
5544           ent->owner = abfd;
5545           ent->tls_type = tls_type;
5546           ent->is_indirect = FALSE;
5547           ent->got.refcount = 0;
5548           local_got_ents[r_symndx] = ent;
5549         }
5550       ent->got.refcount += 1;
5551     }
5552
5553   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5554   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5555   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5556
5557   return local_plt + r_symndx;
5558 }
5559
5560 static bfd_boolean
5561 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5562 {
5563   struct plt_entry *ent;
5564
5565   for (ent = *plist; ent != NULL; ent = ent->next)
5566     if (ent->addend == addend)
5567       break;
5568   if (ent == NULL)
5569     {
5570       bfd_size_type amt = sizeof (*ent);
5571       ent = bfd_alloc (abfd, amt);
5572       if (ent == NULL)
5573         return FALSE;
5574       ent->next = *plist;
5575       ent->addend = addend;
5576       ent->plt.refcount = 0;
5577       *plist = ent;
5578     }
5579   ent->plt.refcount += 1;
5580   return TRUE;
5581 }
5582
5583 static bfd_boolean
5584 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5585 {
5586   return (r_type == R_PPC64_REL24
5587           || r_type == R_PPC64_REL24_NOTOC
5588           || r_type == R_PPC64_REL14
5589           || r_type == R_PPC64_REL14_BRTAKEN
5590           || r_type == R_PPC64_REL14_BRNTAKEN
5591           || r_type == R_PPC64_ADDR24
5592           || r_type == R_PPC64_ADDR14
5593           || r_type == R_PPC64_ADDR14_BRTAKEN
5594           || r_type == R_PPC64_ADDR14_BRNTAKEN
5595           || r_type == R_PPC64_PLTCALL);
5596 }
5597
5598 /* Relocs on inline plt call sequence insns prior to the call.  */
5599
5600 static bfd_boolean
5601 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5602 {
5603   return (r_type == R_PPC64_PLT16_HA
5604           || r_type == R_PPC64_PLT16_HI
5605           || r_type == R_PPC64_PLT16_LO
5606           || r_type == R_PPC64_PLT16_LO_DS
5607           || r_type == R_PPC64_PLTSEQ);
5608 }
5609
5610 /* Look through the relocs for a section during the first phase, and
5611    calculate needed space in the global offset table, procedure
5612    linkage table, and dynamic reloc sections.  */
5613
5614 static bfd_boolean
5615 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5616                         asection *sec, const Elf_Internal_Rela *relocs)
5617 {
5618   struct ppc_link_hash_table *htab;
5619   Elf_Internal_Shdr *symtab_hdr;
5620   struct elf_link_hash_entry **sym_hashes;
5621   const Elf_Internal_Rela *rel;
5622   const Elf_Internal_Rela *rel_end;
5623   asection *sreloc;
5624   struct elf_link_hash_entry *tga, *dottga;
5625   bfd_boolean is_opd;
5626
5627   if (bfd_link_relocatable (info))
5628     return TRUE;
5629
5630   /* Don't do anything special with non-loaded, non-alloced sections.
5631      In particular, any relocs in such sections should not affect GOT
5632      and PLT reference counting (ie. we don't allow them to create GOT
5633      or PLT entries), there's no possibility or desire to optimize TLS
5634      relocs, and there's not much point in propagating relocs to shared
5635      libs that the dynamic linker won't relocate.  */
5636   if ((sec->flags & SEC_ALLOC) == 0)
5637     return TRUE;
5638
5639   BFD_ASSERT (is_ppc64_elf (abfd));
5640
5641   htab = ppc_hash_table (info);
5642   if (htab == NULL)
5643     return FALSE;
5644
5645   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5646                               FALSE, FALSE, TRUE);
5647   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5648                                  FALSE, FALSE, TRUE);
5649   symtab_hdr = &elf_symtab_hdr (abfd);
5650   sym_hashes = elf_sym_hashes (abfd);
5651   sreloc = NULL;
5652   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5653   rel_end = relocs + sec->reloc_count;
5654   for (rel = relocs; rel < rel_end; rel++)
5655     {
5656       unsigned long r_symndx;
5657       struct elf_link_hash_entry *h;
5658       enum elf_ppc64_reloc_type r_type;
5659       int tls_type;
5660       struct _ppc64_elf_section_data *ppc64_sec;
5661       struct plt_entry **ifunc, **plt_list;
5662
5663       r_symndx = ELF64_R_SYM (rel->r_info);
5664       if (r_symndx < symtab_hdr->sh_info)
5665         h = NULL;
5666       else
5667         {
5668           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5669           h = elf_follow_link (h);
5670
5671           if (h == htab->elf.hgot)
5672             sec->has_toc_reloc = 1;
5673         }
5674
5675       tls_type = 0;
5676       ifunc = NULL;
5677       if (h != NULL)
5678         {
5679           if (h->type == STT_GNU_IFUNC)
5680             {
5681               h->needs_plt = 1;
5682               ifunc = &h->plt.plist;
5683             }
5684         }
5685       else
5686         {
5687           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5688                                                           abfd, r_symndx);
5689           if (isym == NULL)
5690             return FALSE;
5691
5692           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5693             {
5694               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5695                                              rel->r_addend,
5696                                              NON_GOT | PLT_IFUNC);
5697               if (ifunc == NULL)
5698                 return FALSE;
5699             }
5700         }
5701
5702       r_type = ELF64_R_TYPE (rel->r_info);
5703       switch (r_type)
5704         {
5705         case R_PPC64_TLSGD:
5706         case R_PPC64_TLSLD:
5707           /* These special tls relocs tie a call to __tls_get_addr with
5708              its parameter symbol.  */
5709           if (h != NULL)
5710             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5711           else
5712             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5713                                         rel->r_addend,
5714                                         NON_GOT | TLS_TLS | TLS_MARK))
5715               return FALSE;
5716           sec->has_tls_reloc = 1;
5717           break;
5718
5719         case R_PPC64_GOT_TLSLD16:
5720         case R_PPC64_GOT_TLSLD16_LO:
5721         case R_PPC64_GOT_TLSLD16_HI:
5722         case R_PPC64_GOT_TLSLD16_HA:
5723           tls_type = TLS_TLS | TLS_LD;
5724           goto dogottls;
5725
5726         case R_PPC64_GOT_TLSGD16:
5727         case R_PPC64_GOT_TLSGD16_LO:
5728         case R_PPC64_GOT_TLSGD16_HI:
5729         case R_PPC64_GOT_TLSGD16_HA:
5730           tls_type = TLS_TLS | TLS_GD;
5731           goto dogottls;
5732
5733         case R_PPC64_GOT_TPREL16_DS:
5734         case R_PPC64_GOT_TPREL16_LO_DS:
5735         case R_PPC64_GOT_TPREL16_HI:
5736         case R_PPC64_GOT_TPREL16_HA:
5737           if (bfd_link_dll (info))
5738             info->flags |= DF_STATIC_TLS;
5739           tls_type = TLS_TLS | TLS_TPREL;
5740           goto dogottls;
5741
5742         case R_PPC64_GOT_DTPREL16_DS:
5743         case R_PPC64_GOT_DTPREL16_LO_DS:
5744         case R_PPC64_GOT_DTPREL16_HI:
5745         case R_PPC64_GOT_DTPREL16_HA:
5746           tls_type = TLS_TLS | TLS_DTPREL;
5747         dogottls:
5748           sec->has_tls_reloc = 1;
5749           /* Fall through */
5750
5751         case R_PPC64_GOT16:
5752         case R_PPC64_GOT16_DS:
5753         case R_PPC64_GOT16_HA:
5754         case R_PPC64_GOT16_HI:
5755         case R_PPC64_GOT16_LO:
5756         case R_PPC64_GOT16_LO_DS:
5757           /* This symbol requires a global offset table entry.  */
5758           sec->has_toc_reloc = 1;
5759           if (r_type == R_PPC64_GOT_TLSLD16
5760               || r_type == R_PPC64_GOT_TLSGD16
5761               || r_type == R_PPC64_GOT_TPREL16_DS
5762               || r_type == R_PPC64_GOT_DTPREL16_DS
5763               || r_type == R_PPC64_GOT16
5764               || r_type == R_PPC64_GOT16_DS)
5765             {
5766               htab->do_multi_toc = 1;
5767               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5768             }
5769
5770           if (ppc64_elf_tdata (abfd)->got == NULL
5771               && !create_got_section (abfd, info))
5772             return FALSE;
5773
5774           if (h != NULL)
5775             {
5776               struct ppc_link_hash_entry *eh;
5777               struct got_entry *ent;
5778
5779               eh = (struct ppc_link_hash_entry *) h;
5780               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5781                 if (ent->addend == rel->r_addend
5782                     && ent->owner == abfd
5783                     && ent->tls_type == tls_type)
5784                   break;
5785               if (ent == NULL)
5786                 {
5787                   bfd_size_type amt = sizeof (*ent);
5788                   ent = bfd_alloc (abfd, amt);
5789                   if (ent == NULL)
5790                     return FALSE;
5791                   ent->next = eh->elf.got.glist;
5792                   ent->addend = rel->r_addend;
5793                   ent->owner = abfd;
5794                   ent->tls_type = tls_type;
5795                   ent->is_indirect = FALSE;
5796                   ent->got.refcount = 0;
5797                   eh->elf.got.glist = ent;
5798                 }
5799               ent->got.refcount += 1;
5800               eh->tls_mask |= tls_type;
5801             }
5802           else
5803             /* This is a global offset table entry for a local symbol.  */
5804             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5805                                         rel->r_addend, tls_type))
5806               return FALSE;
5807
5808           /* We may also need a plt entry if the symbol turns out to be
5809              an ifunc.  */
5810           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5811             {
5812               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5813                 return FALSE;
5814             }
5815           break;
5816
5817         case R_PPC64_PLT16_HA:
5818         case R_PPC64_PLT16_HI:
5819         case R_PPC64_PLT16_LO:
5820         case R_PPC64_PLT16_LO_DS:
5821         case R_PPC64_PLT32:
5822         case R_PPC64_PLT64:
5823           /* This symbol requires a procedure linkage table entry.  */
5824           plt_list = ifunc;
5825           if (h != NULL)
5826             {
5827               h->needs_plt = 1;
5828               if (h->root.root.string[0] == '.'
5829                   && h->root.root.string[1] != '\0')
5830                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5831               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5832               plt_list = &h->plt.plist;
5833             }
5834           if (plt_list == NULL)
5835             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5836                                               rel->r_addend,
5837                                               NON_GOT | PLT_KEEP);
5838           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5839             return FALSE;
5840           break;
5841
5842           /* The following relocations don't need to propagate the
5843              relocation if linking a shared object since they are
5844              section relative.  */
5845         case R_PPC64_SECTOFF:
5846         case R_PPC64_SECTOFF_LO:
5847         case R_PPC64_SECTOFF_HI:
5848         case R_PPC64_SECTOFF_HA:
5849         case R_PPC64_SECTOFF_DS:
5850         case R_PPC64_SECTOFF_LO_DS:
5851         case R_PPC64_DTPREL16:
5852         case R_PPC64_DTPREL16_LO:
5853         case R_PPC64_DTPREL16_HI:
5854         case R_PPC64_DTPREL16_HA:
5855         case R_PPC64_DTPREL16_DS:
5856         case R_PPC64_DTPREL16_LO_DS:
5857         case R_PPC64_DTPREL16_HIGH:
5858         case R_PPC64_DTPREL16_HIGHA:
5859         case R_PPC64_DTPREL16_HIGHER:
5860         case R_PPC64_DTPREL16_HIGHERA:
5861         case R_PPC64_DTPREL16_HIGHEST:
5862         case R_PPC64_DTPREL16_HIGHESTA:
5863           break;
5864
5865           /* Nor do these.  */
5866         case R_PPC64_REL16:
5867         case R_PPC64_REL16_LO:
5868         case R_PPC64_REL16_HI:
5869         case R_PPC64_REL16_HA:
5870         case R_PPC64_REL16DX_HA:
5871           break;
5872
5873           /* Not supported as a dynamic relocation.  */
5874         case R_PPC64_ADDR64_LOCAL:
5875           if (bfd_link_pic (info))
5876             {
5877               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5878                 ppc_howto_init ();
5879               /* xgettext:c-format */
5880               info->callbacks->einfo (_("%H: %s reloc unsupported "
5881                                         "in shared libraries and PIEs\n"),
5882                                       abfd, sec, rel->r_offset,
5883                                       ppc64_elf_howto_table[r_type]->name);
5884               bfd_set_error (bfd_error_bad_value);
5885               return FALSE;
5886             }
5887           break;
5888
5889         case R_PPC64_TOC16:
5890         case R_PPC64_TOC16_DS:
5891           htab->do_multi_toc = 1;
5892           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5893           /* Fall through.  */
5894         case R_PPC64_TOC16_LO:
5895         case R_PPC64_TOC16_HI:
5896         case R_PPC64_TOC16_HA:
5897         case R_PPC64_TOC16_LO_DS:
5898           sec->has_toc_reloc = 1;
5899           break;
5900
5901           /* Marker reloc.  */
5902         case R_PPC64_ENTRY:
5903           break;
5904
5905           /* This relocation describes the C++ object vtable hierarchy.
5906              Reconstruct it for later use during GC.  */
5907         case R_PPC64_GNU_VTINHERIT:
5908           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5909             return FALSE;
5910           break;
5911
5912           /* This relocation describes which C++ vtable entries are actually
5913              used.  Record for later use during GC.  */
5914         case R_PPC64_GNU_VTENTRY:
5915           BFD_ASSERT (h != NULL);
5916           if (h != NULL
5917               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5918             return FALSE;
5919           break;
5920
5921         case R_PPC64_REL14:
5922         case R_PPC64_REL14_BRTAKEN:
5923         case R_PPC64_REL14_BRNTAKEN:
5924           {
5925             asection *dest = NULL;
5926
5927             /* Heuristic: If jumping outside our section, chances are
5928                we are going to need a stub.  */
5929             if (h != NULL)
5930               {
5931                 /* If the sym is weak it may be overridden later, so
5932                    don't assume we know where a weak sym lives.  */
5933                 if (h->root.type == bfd_link_hash_defined)
5934                   dest = h->root.u.def.section;
5935               }
5936             else
5937               {
5938                 Elf_Internal_Sym *isym;
5939
5940                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5941                                               abfd, r_symndx);
5942                 if (isym == NULL)
5943                   return FALSE;
5944
5945                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5946               }
5947
5948             if (dest != sec)
5949               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5950           }
5951           goto rel24;
5952
5953         case R_PPC64_PLTCALL:
5954           ppc64_elf_section_data (sec)->has_pltcall = 1;
5955           /* Fall through.  */
5956
5957         case R_PPC64_REL24:
5958         case R_PPC64_REL24_NOTOC:
5959         rel24:
5960           plt_list = ifunc;
5961           if (h != NULL)
5962             {
5963               h->needs_plt = 1;
5964               if (h->root.root.string[0] == '.'
5965                   && h->root.root.string[1] != '\0')
5966                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5967
5968               if (h == tga || h == dottga)
5969                 {
5970                   sec->has_tls_reloc = 1;
5971                   if (rel != relocs
5972                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5973                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5974                     /* We have a new-style __tls_get_addr call with
5975                        a marker reloc.  */
5976                     ;
5977                   else
5978                     /* Mark this section as having an old-style call.  */
5979                     sec->has_tls_get_addr_call = 1;
5980                 }
5981               plt_list = &h->plt.plist;
5982             }
5983
5984           /* We may need a .plt entry if the function this reloc
5985              refers to is in a shared lib.  */
5986           if (plt_list
5987               && !update_plt_info (abfd, plt_list, rel->r_addend))
5988             return FALSE;
5989           break;
5990
5991         case R_PPC64_ADDR14:
5992         case R_PPC64_ADDR14_BRNTAKEN:
5993         case R_PPC64_ADDR14_BRTAKEN:
5994         case R_PPC64_ADDR24:
5995           goto dodyn;
5996
5997         case R_PPC64_TPREL64:
5998           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5999           if (bfd_link_dll (info))
6000             info->flags |= DF_STATIC_TLS;
6001           goto dotlstoc;
6002
6003         case R_PPC64_DTPMOD64:
6004           if (rel + 1 < rel_end
6005               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
6006               && rel[1].r_offset == rel->r_offset + 8)
6007             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
6008           else
6009             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
6010           goto dotlstoc;
6011
6012         case R_PPC64_DTPREL64:
6013           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
6014           if (rel != relocs
6015               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
6016               && rel[-1].r_offset == rel->r_offset - 8)
6017             /* This is the second reloc of a dtpmod, dtprel pair.
6018                Don't mark with TLS_DTPREL.  */
6019             goto dodyn;
6020
6021         dotlstoc:
6022           sec->has_tls_reloc = 1;
6023           if (h != NULL)
6024             {
6025               struct ppc_link_hash_entry *eh;
6026               eh = (struct ppc_link_hash_entry *) h;
6027               eh->tls_mask |= tls_type;
6028             }
6029           else
6030             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
6031                                         rel->r_addend, tls_type))
6032               return FALSE;
6033
6034           ppc64_sec = ppc64_elf_section_data (sec);
6035           if (ppc64_sec->sec_type != sec_toc)
6036             {
6037               bfd_size_type amt;
6038
6039               /* One extra to simplify get_tls_mask.  */
6040               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
6041               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
6042               if (ppc64_sec->u.toc.symndx == NULL)
6043                 return FALSE;
6044               amt = sec->size * sizeof (bfd_vma) / 8;
6045               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
6046               if (ppc64_sec->u.toc.add == NULL)
6047                 return FALSE;
6048               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
6049               ppc64_sec->sec_type = sec_toc;
6050             }
6051           BFD_ASSERT (rel->r_offset % 8 == 0);
6052           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
6053           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
6054
6055           /* Mark the second slot of a GD or LD entry.
6056              -1 to indicate GD and -2 to indicate LD.  */
6057           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
6058             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
6059           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
6060             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
6061           goto dodyn;
6062
6063         case R_PPC64_TPREL16:
6064         case R_PPC64_TPREL16_LO:
6065         case R_PPC64_TPREL16_HI:
6066         case R_PPC64_TPREL16_HA:
6067         case R_PPC64_TPREL16_DS:
6068         case R_PPC64_TPREL16_LO_DS:
6069         case R_PPC64_TPREL16_HIGH:
6070         case R_PPC64_TPREL16_HIGHA:
6071         case R_PPC64_TPREL16_HIGHER:
6072         case R_PPC64_TPREL16_HIGHERA:
6073         case R_PPC64_TPREL16_HIGHEST:
6074         case R_PPC64_TPREL16_HIGHESTA:
6075           if (bfd_link_dll (info))
6076             info->flags |= DF_STATIC_TLS;
6077           goto dodyn;
6078
6079         case R_PPC64_ADDR64:
6080           if (is_opd
6081               && rel + 1 < rel_end
6082               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
6083             {
6084               if (h != NULL)
6085                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
6086             }
6087           /* Fall through.  */
6088
6089         case R_PPC64_ADDR16:
6090         case R_PPC64_ADDR16_DS:
6091         case R_PPC64_ADDR16_HA:
6092         case R_PPC64_ADDR16_HI:
6093         case R_PPC64_ADDR16_HIGH:
6094         case R_PPC64_ADDR16_HIGHA:
6095         case R_PPC64_ADDR16_HIGHER:
6096         case R_PPC64_ADDR16_HIGHERA:
6097         case R_PPC64_ADDR16_HIGHEST:
6098         case R_PPC64_ADDR16_HIGHESTA:
6099         case R_PPC64_ADDR16_LO:
6100         case R_PPC64_ADDR16_LO_DS:
6101           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6102               && rel->r_addend == 0)
6103             {
6104               /* We may need a .plt entry if this reloc refers to a
6105                  function in a shared lib.  */
6106               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
6107                 return FALSE;
6108               h->pointer_equality_needed = 1;
6109             }
6110           /* Fall through.  */
6111
6112         case R_PPC64_REL30:
6113         case R_PPC64_REL32:
6114         case R_PPC64_REL64:
6115         case R_PPC64_ADDR32:
6116         case R_PPC64_UADDR16:
6117         case R_PPC64_UADDR32:
6118         case R_PPC64_UADDR64:
6119         case R_PPC64_TOC:
6120           if (h != NULL && !bfd_link_pic (info))
6121             /* We may need a copy reloc.  */
6122             h->non_got_ref = 1;
6123
6124           /* Don't propagate .opd relocs.  */
6125           if (NO_OPD_RELOCS && is_opd)
6126             break;
6127
6128           /* If we are creating a shared library, and this is a reloc
6129              against a global symbol, or a non PC relative reloc
6130              against a local symbol, then we need to copy the reloc
6131              into the shared library.  However, if we are linking with
6132              -Bsymbolic, we do not need to copy a reloc against a
6133              global symbol which is defined in an object we are
6134              including in the link (i.e., DEF_REGULAR is set).  At
6135              this point we have not seen all the input files, so it is
6136              possible that DEF_REGULAR is not set now but will be set
6137              later (it is never cleared).  In case of a weak definition,
6138              DEF_REGULAR may be cleared later by a strong definition in
6139              a shared library.  We account for that possibility below by
6140              storing information in the dyn_relocs field of the hash
6141              table entry.  A similar situation occurs when creating
6142              shared libraries and symbol visibility changes render the
6143              symbol local.
6144
6145              If on the other hand, we are creating an executable, we
6146              may need to keep relocations for symbols satisfied by a
6147              dynamic library if we manage to avoid copy relocs for the
6148              symbol.  */
6149         dodyn:
6150           if ((bfd_link_pic (info)
6151                && (must_be_dyn_reloc (info, r_type)
6152                    || (h != NULL
6153                        && (!SYMBOLIC_BIND (info, h)
6154                            || h->root.type == bfd_link_hash_defweak
6155                            || !h->def_regular))))
6156               || (ELIMINATE_COPY_RELOCS
6157                   && !bfd_link_pic (info)
6158                   && h != NULL
6159                   && (h->root.type == bfd_link_hash_defweak
6160                       || !h->def_regular))
6161               || (!bfd_link_pic (info)
6162                   && ifunc != NULL))
6163             {
6164               /* We must copy these reloc types into the output file.
6165                  Create a reloc section in dynobj and make room for
6166                  this reloc.  */
6167               if (sreloc == NULL)
6168                 {
6169                   sreloc = _bfd_elf_make_dynamic_reloc_section
6170                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6171
6172                   if (sreloc == NULL)
6173                     return FALSE;
6174                 }
6175
6176               /* If this is a global symbol, we count the number of
6177                  relocations we need for this symbol.  */
6178               if (h != NULL)
6179                 {
6180                   struct elf_dyn_relocs *p;
6181                   struct elf_dyn_relocs **head;
6182
6183                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6184                   p = *head;
6185                   if (p == NULL || p->sec != sec)
6186                     {
6187                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6188                       if (p == NULL)
6189                         return FALSE;
6190                       p->next = *head;
6191                       *head = p;
6192                       p->sec = sec;
6193                       p->count = 0;
6194                       p->pc_count = 0;
6195                     }
6196                   p->count += 1;
6197                   if (!must_be_dyn_reloc (info, r_type))
6198                     p->pc_count += 1;
6199                 }
6200               else
6201                 {
6202                   /* Track dynamic relocs needed for local syms too.
6203                      We really need local syms available to do this
6204                      easily.  Oh well.  */
6205                   struct ppc_dyn_relocs *p;
6206                   struct ppc_dyn_relocs **head;
6207                   bfd_boolean is_ifunc;
6208                   asection *s;
6209                   void *vpp;
6210                   Elf_Internal_Sym *isym;
6211
6212                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6213                                                 abfd, r_symndx);
6214                   if (isym == NULL)
6215                     return FALSE;
6216
6217                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6218                   if (s == NULL)
6219                     s = sec;
6220
6221                   vpp = &elf_section_data (s)->local_dynrel;
6222                   head = (struct ppc_dyn_relocs **) vpp;
6223                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6224                   p = *head;
6225                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6226                     p = p->next;
6227                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6228                     {
6229                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6230                       if (p == NULL)
6231                         return FALSE;
6232                       p->next = *head;
6233                       *head = p;
6234                       p->sec = sec;
6235                       p->ifunc = is_ifunc;
6236                       p->count = 0;
6237                     }
6238                   p->count += 1;
6239                 }
6240             }
6241           break;
6242
6243         default:
6244           break;
6245         }
6246     }
6247
6248   return TRUE;
6249 }
6250
6251 /* Merge backend specific data from an object file to the output
6252    object file when linking.  */
6253
6254 static bfd_boolean
6255 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6256 {
6257   bfd *obfd = info->output_bfd;
6258   unsigned long iflags, oflags;
6259
6260   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6261     return TRUE;
6262
6263   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6264     return TRUE;
6265
6266   if (!_bfd_generic_verify_endian_match (ibfd, info))
6267     return FALSE;
6268
6269   iflags = elf_elfheader (ibfd)->e_flags;
6270   oflags = elf_elfheader (obfd)->e_flags;
6271
6272   if (iflags & ~EF_PPC64_ABI)
6273     {
6274       _bfd_error_handler
6275         /* xgettext:c-format */
6276         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6277       bfd_set_error (bfd_error_bad_value);
6278       return FALSE;
6279     }
6280   else if (iflags != oflags && iflags != 0)
6281     {
6282       _bfd_error_handler
6283         /* xgettext:c-format */
6284         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6285          ibfd, iflags, oflags);
6286       bfd_set_error (bfd_error_bad_value);
6287       return FALSE;
6288     }
6289
6290   if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
6291     return FALSE;
6292
6293   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6294   return _bfd_elf_merge_object_attributes (ibfd, info);
6295 }
6296
6297 static bfd_boolean
6298 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6299 {
6300   /* Print normal ELF private data.  */
6301   _bfd_elf_print_private_bfd_data (abfd, ptr);
6302
6303   if (elf_elfheader (abfd)->e_flags != 0)
6304     {
6305       FILE *file = ptr;
6306
6307       fprintf (file, _("private flags = 0x%lx:"),
6308                elf_elfheader (abfd)->e_flags);
6309
6310       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6311         fprintf (file, _(" [abiv%ld]"),
6312                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6313       fputc ('\n', file);
6314     }
6315
6316   return TRUE;
6317 }
6318
6319 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6320    of the code entry point, and its section, which must be in the same
6321    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6322
6323 static bfd_vma
6324 opd_entry_value (asection *opd_sec,
6325                  bfd_vma offset,
6326                  asection **code_sec,
6327                  bfd_vma *code_off,
6328                  bfd_boolean in_code_sec)
6329 {
6330   bfd *opd_bfd = opd_sec->owner;
6331   Elf_Internal_Rela *relocs;
6332   Elf_Internal_Rela *lo, *hi, *look;
6333   bfd_vma val;
6334
6335   /* No relocs implies we are linking a --just-symbols object, or looking
6336      at a final linked executable with addr2line or somesuch.  */
6337   if (opd_sec->reloc_count == 0)
6338     {
6339       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6340
6341       if (contents == NULL)
6342         {
6343           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6344             return (bfd_vma) -1;
6345           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6346         }
6347
6348       /* PR 17512: file: 64b9dfbb.  */
6349       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6350         return (bfd_vma) -1;
6351
6352       val = bfd_get_64 (opd_bfd, contents + offset);
6353       if (code_sec != NULL)
6354         {
6355           asection *sec, *likely = NULL;
6356
6357           if (in_code_sec)
6358             {
6359               sec = *code_sec;
6360               if (sec->vma <= val
6361                   && val < sec->vma + sec->size)
6362                 likely = sec;
6363               else
6364                 val = -1;
6365             }
6366           else
6367             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6368               if (sec->vma <= val
6369                   && (sec->flags & SEC_LOAD) != 0
6370                   && (sec->flags & SEC_ALLOC) != 0)
6371                 likely = sec;
6372           if (likely != NULL)
6373             {
6374               *code_sec = likely;
6375               if (code_off != NULL)
6376                 *code_off = val - likely->vma;
6377             }
6378         }
6379       return val;
6380     }
6381
6382   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6383
6384   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6385   if (relocs == NULL)
6386     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6387   /* PR 17512: file: df8e1fd6.  */
6388   if (relocs == NULL)
6389     return (bfd_vma) -1;
6390
6391   /* Go find the opd reloc at the sym address.  */
6392   lo = relocs;
6393   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6394   val = (bfd_vma) -1;
6395   while (lo < hi)
6396     {
6397       look = lo + (hi - lo) / 2;
6398       if (look->r_offset < offset)
6399         lo = look + 1;
6400       else if (look->r_offset > offset)
6401         hi = look;
6402       else
6403         {
6404           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6405
6406           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6407               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6408             {
6409               unsigned long symndx = ELF64_R_SYM (look->r_info);
6410               asection *sec = NULL;
6411
6412               if (symndx >= symtab_hdr->sh_info
6413                   && elf_sym_hashes (opd_bfd) != NULL)
6414                 {
6415                   struct elf_link_hash_entry **sym_hashes;
6416                   struct elf_link_hash_entry *rh;
6417
6418                   sym_hashes = elf_sym_hashes (opd_bfd);
6419                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6420                   if (rh != NULL)
6421                     {
6422                       rh = elf_follow_link (rh);
6423                       if (rh->root.type != bfd_link_hash_defined
6424                           && rh->root.type != bfd_link_hash_defweak)
6425                         break;
6426                       if (rh->root.u.def.section->owner == opd_bfd)
6427                         {
6428                           val = rh->root.u.def.value;
6429                           sec = rh->root.u.def.section;
6430                         }
6431                     }
6432                 }
6433
6434               if (sec == NULL)
6435                 {
6436                   Elf_Internal_Sym *sym;
6437
6438                   if (symndx < symtab_hdr->sh_info)
6439                     {
6440                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6441                       if (sym == NULL)
6442                         {
6443                           size_t symcnt = symtab_hdr->sh_info;
6444                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6445                                                       symcnt, 0,
6446                                                       NULL, NULL, NULL);
6447                           if (sym == NULL)
6448                             break;
6449                           symtab_hdr->contents = (bfd_byte *) sym;
6450                         }
6451                       sym += symndx;
6452                     }
6453                   else
6454                     {
6455                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6456                                                   1, symndx,
6457                                                   NULL, NULL, NULL);
6458                       if (sym == NULL)
6459                         break;
6460                     }
6461                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6462                   if (sec == NULL)
6463                     break;
6464                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6465                   val = sym->st_value;
6466                 }
6467
6468               val += look->r_addend;
6469               if (code_off != NULL)
6470                 *code_off = val;
6471               if (code_sec != NULL)
6472                 {
6473                   if (in_code_sec && *code_sec != sec)
6474                     return -1;
6475                   else
6476                     *code_sec = sec;
6477                 }
6478               if (sec->output_section != NULL)
6479                 val += sec->output_section->vma + sec->output_offset;
6480             }
6481           break;
6482         }
6483     }
6484
6485   return val;
6486 }
6487
6488 /* If the ELF symbol SYM might be a function in SEC, return the
6489    function size and set *CODE_OFF to the function's entry point,
6490    otherwise return zero.  */
6491
6492 static bfd_size_type
6493 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6494                               bfd_vma *code_off)
6495 {
6496   bfd_size_type size;
6497
6498   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6499                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6500     return 0;
6501
6502   size = 0;
6503   if (!(sym->flags & BSF_SYNTHETIC))
6504     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6505
6506   if (strcmp (sym->section->name, ".opd") == 0)
6507     {
6508       struct _opd_sec_data *opd = get_opd_info (sym->section);
6509       bfd_vma symval = sym->value;
6510
6511       if (opd != NULL
6512           && opd->adjust != NULL
6513           && elf_section_data (sym->section)->relocs != NULL)
6514         {
6515           /* opd_entry_value will use cached relocs that have been
6516              adjusted, but with raw symbols.  That means both local
6517              and global symbols need adjusting.  */
6518           long adjust = opd->adjust[OPD_NDX (symval)];
6519           if (adjust == -1)
6520             return 0;
6521           symval += adjust;
6522         }
6523
6524       if (opd_entry_value (sym->section, symval,
6525                            &sec, code_off, TRUE) == (bfd_vma) -1)
6526         return 0;
6527       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6528          symbol.  This size has nothing to do with the code size of the
6529          function, which is what we're supposed to return, but the
6530          code size isn't available without looking up the dot-sym.
6531          However, doing that would be a waste of time particularly
6532          since elf_find_function will look at the dot-sym anyway.
6533          Now, elf_find_function will keep the largest size of any
6534          function sym found at the code address of interest, so return
6535          1 here to avoid it incorrectly caching a larger function size
6536          for a small function.  This does mean we return the wrong
6537          size for a new-ABI function of size 24, but all that does is
6538          disable caching for such functions.  */
6539       if (size == 24)
6540         size = 1;
6541     }
6542   else
6543     {
6544       if (sym->section != sec)
6545         return 0;
6546       *code_off = sym->value;
6547     }
6548   if (size == 0)
6549     size = 1;
6550   return size;
6551 }
6552
6553 /* Return true if symbol is a strong function defined in an ELFv2
6554    object with st_other localentry bits of zero, ie. its local entry
6555    point coincides with its global entry point.  */
6556
6557 static bfd_boolean
6558 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6559 {
6560   return (h != NULL
6561           && h->type == STT_FUNC
6562           && h->root.type == bfd_link_hash_defined
6563           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6564           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6565           && is_ppc64_elf (h->root.u.def.section->owner)
6566           && abiversion (h->root.u.def.section->owner) >= 2);
6567 }
6568
6569 /* Return true if symbol is defined in a regular object file.  */
6570
6571 static bfd_boolean
6572 is_static_defined (struct elf_link_hash_entry *h)
6573 {
6574   return ((h->root.type == bfd_link_hash_defined
6575            || h->root.type == bfd_link_hash_defweak)
6576           && h->root.u.def.section != NULL
6577           && h->root.u.def.section->output_section != NULL);
6578 }
6579
6580 /* If FDH is a function descriptor symbol, return the associated code
6581    entry symbol if it is defined.  Return NULL otherwise.  */
6582
6583 static struct ppc_link_hash_entry *
6584 defined_code_entry (struct ppc_link_hash_entry *fdh)
6585 {
6586   if (fdh->is_func_descriptor)
6587     {
6588       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6589       if (fh->elf.root.type == bfd_link_hash_defined
6590           || fh->elf.root.type == bfd_link_hash_defweak)
6591         return fh;
6592     }
6593   return NULL;
6594 }
6595
6596 /* If FH is a function code entry symbol, return the associated
6597    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6598
6599 static struct ppc_link_hash_entry *
6600 defined_func_desc (struct ppc_link_hash_entry *fh)
6601 {
6602   if (fh->oh != NULL
6603       && fh->oh->is_func_descriptor)
6604     {
6605       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6606       if (fdh->elf.root.type == bfd_link_hash_defined
6607           || fdh->elf.root.type == bfd_link_hash_defweak)
6608         return fdh;
6609     }
6610   return NULL;
6611 }
6612
6613 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6614
6615 /* Garbage collect sections, after first dealing with dot-symbols.  */
6616
6617 static bfd_boolean
6618 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6619 {
6620   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6621
6622   if (htab != NULL && htab->need_func_desc_adj)
6623     {
6624       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6625       htab->need_func_desc_adj = 0;
6626     }
6627   return bfd_elf_gc_sections (abfd, info);
6628 }
6629
6630 /* Mark all our entry sym sections, both opd and code section.  */
6631
6632 static void
6633 ppc64_elf_gc_keep (struct bfd_link_info *info)
6634 {
6635   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6636   struct bfd_sym_chain *sym;
6637
6638   if (htab == NULL)
6639     return;
6640
6641   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6642     {
6643       struct ppc_link_hash_entry *eh, *fh;
6644       asection *sec;
6645
6646       eh = (struct ppc_link_hash_entry *)
6647         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6648       if (eh == NULL)
6649         continue;
6650       if (eh->elf.root.type != bfd_link_hash_defined
6651           && eh->elf.root.type != bfd_link_hash_defweak)
6652         continue;
6653
6654       fh = defined_code_entry (eh);
6655       if (fh != NULL)
6656         {
6657           sec = fh->elf.root.u.def.section;
6658           sec->flags |= SEC_KEEP;
6659         }
6660       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6661                && opd_entry_value (eh->elf.root.u.def.section,
6662                                    eh->elf.root.u.def.value,
6663                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6664         sec->flags |= SEC_KEEP;
6665
6666       sec = eh->elf.root.u.def.section;
6667       sec->flags |= SEC_KEEP;
6668     }
6669 }
6670
6671 /* Mark sections containing dynamically referenced symbols.  When
6672    building shared libraries, we must assume that any visible symbol is
6673    referenced.  */
6674
6675 static bfd_boolean
6676 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6677 {
6678   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6679   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6680   struct ppc_link_hash_entry *fdh;
6681   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6682
6683   /* Dynamic linking info is on the func descriptor sym.  */
6684   fdh = defined_func_desc (eh);
6685   if (fdh != NULL)
6686     eh = fdh;
6687
6688   if ((eh->elf.root.type == bfd_link_hash_defined
6689        || eh->elf.root.type == bfd_link_hash_defweak)
6690       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6691           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6692               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6693               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6694               && (!bfd_link_executable (info)
6695                   || info->gc_keep_exported
6696                   || info->export_dynamic
6697                   || (eh->elf.dynamic
6698                       && d != NULL
6699                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6700               && (eh->elf.versioned >= versioned
6701                   || !bfd_hide_sym_by_version (info->version_info,
6702                                                eh->elf.root.root.string)))))
6703     {
6704       asection *code_sec;
6705       struct ppc_link_hash_entry *fh;
6706
6707       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6708
6709       /* Function descriptor syms cause the associated
6710          function code sym section to be marked.  */
6711       fh = defined_code_entry (eh);
6712       if (fh != NULL)
6713         {
6714           code_sec = fh->elf.root.u.def.section;
6715           code_sec->flags |= SEC_KEEP;
6716         }
6717       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6718                && opd_entry_value (eh->elf.root.u.def.section,
6719                                    eh->elf.root.u.def.value,
6720                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6721         code_sec->flags |= SEC_KEEP;
6722     }
6723
6724   return TRUE;
6725 }
6726
6727 /* Return the section that should be marked against GC for a given
6728    relocation.  */
6729
6730 static asection *
6731 ppc64_elf_gc_mark_hook (asection *sec,
6732                         struct bfd_link_info *info,
6733                         Elf_Internal_Rela *rel,
6734                         struct elf_link_hash_entry *h,
6735                         Elf_Internal_Sym *sym)
6736 {
6737   asection *rsec;
6738
6739   /* Syms return NULL if we're marking .opd, so we avoid marking all
6740      function sections, as all functions are referenced in .opd.  */
6741   rsec = NULL;
6742   if (get_opd_info (sec) != NULL)
6743     return rsec;
6744
6745   if (h != NULL)
6746     {
6747       enum elf_ppc64_reloc_type r_type;
6748       struct ppc_link_hash_entry *eh, *fh, *fdh;
6749
6750       r_type = ELF64_R_TYPE (rel->r_info);
6751       switch (r_type)
6752         {
6753         case R_PPC64_GNU_VTINHERIT:
6754         case R_PPC64_GNU_VTENTRY:
6755           break;
6756
6757         default:
6758           switch (h->root.type)
6759             {
6760             case bfd_link_hash_defined:
6761             case bfd_link_hash_defweak:
6762               eh = (struct ppc_link_hash_entry *) h;
6763               fdh = defined_func_desc (eh);
6764               if (fdh != NULL)
6765                 {
6766                   /* -mcall-aixdesc code references the dot-symbol on
6767                      a call reloc.  Mark the function descriptor too
6768                      against garbage collection.  */
6769                   fdh->elf.mark = 1;
6770                   if (fdh->elf.is_weakalias)
6771                     weakdef (&fdh->elf)->mark = 1;
6772                   eh = fdh;
6773                 }
6774
6775               /* Function descriptor syms cause the associated
6776                  function code sym section to be marked.  */
6777               fh = defined_code_entry (eh);
6778               if (fh != NULL)
6779                 {
6780                   /* They also mark their opd section.  */
6781                   eh->elf.root.u.def.section->gc_mark = 1;
6782
6783                   rsec = fh->elf.root.u.def.section;
6784                 }
6785               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6786                        && opd_entry_value (eh->elf.root.u.def.section,
6787                                            eh->elf.root.u.def.value,
6788                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6789                 eh->elf.root.u.def.section->gc_mark = 1;
6790               else
6791                 rsec = h->root.u.def.section;
6792               break;
6793
6794             case bfd_link_hash_common:
6795               rsec = h->root.u.c.p->section;
6796               break;
6797
6798             default:
6799               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6800             }
6801         }
6802     }
6803   else
6804     {
6805       struct _opd_sec_data *opd;
6806
6807       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6808       opd = get_opd_info (rsec);
6809       if (opd != NULL && opd->func_sec != NULL)
6810         {
6811           rsec->gc_mark = 1;
6812
6813           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6814         }
6815     }
6816
6817   return rsec;
6818 }
6819
6820 /* The maximum size of .sfpr.  */
6821 #define SFPR_MAX (218*4)
6822
6823 struct sfpr_def_parms
6824 {
6825   const char name[12];
6826   unsigned char lo, hi;
6827   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6828   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6829 };
6830
6831 /* Auto-generate _save*, _rest* functions in .sfpr.
6832    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6833    instead.  */
6834
6835 static bfd_boolean
6836 sfpr_define (struct bfd_link_info *info,
6837              const struct sfpr_def_parms *parm,
6838              asection *stub_sec)
6839 {
6840   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6841   unsigned int i;
6842   size_t len = strlen (parm->name);
6843   bfd_boolean writing = FALSE;
6844   char sym[16];
6845
6846   if (htab == NULL)
6847     return FALSE;
6848
6849   memcpy (sym, parm->name, len);
6850   sym[len + 2] = 0;
6851
6852   for (i = parm->lo; i <= parm->hi; i++)
6853     {
6854       struct ppc_link_hash_entry *h;
6855
6856       sym[len + 0] = i / 10 + '0';
6857       sym[len + 1] = i % 10 + '0';
6858       h = (struct ppc_link_hash_entry *)
6859         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6860       if (stub_sec != NULL)
6861         {
6862           if (h != NULL
6863               && h->elf.root.type == bfd_link_hash_defined
6864               && h->elf.root.u.def.section == htab->sfpr)
6865             {
6866               struct elf_link_hash_entry *s;
6867               char buf[32];
6868               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6869               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6870               if (s == NULL)
6871                 return FALSE;
6872               if (s->root.type == bfd_link_hash_new
6873                   || (s->root.type = bfd_link_hash_defined
6874                       && s->root.u.def.section == stub_sec))
6875                 {
6876                   s->root.type = bfd_link_hash_defined;
6877                   s->root.u.def.section = stub_sec;
6878                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6879                                          + h->elf.root.u.def.value);
6880                   s->ref_regular = 1;
6881                   s->def_regular = 1;
6882                   s->ref_regular_nonweak = 1;
6883                   s->forced_local = 1;
6884                   s->non_elf = 0;
6885                   s->root.linker_def = 1;
6886                 }
6887             }
6888           continue;
6889         }
6890       if (h != NULL)
6891         {
6892           h->save_res = 1;
6893           if (!h->elf.def_regular)
6894             {
6895               h->elf.root.type = bfd_link_hash_defined;
6896               h->elf.root.u.def.section = htab->sfpr;
6897               h->elf.root.u.def.value = htab->sfpr->size;
6898               h->elf.type = STT_FUNC;
6899               h->elf.def_regular = 1;
6900               h->elf.non_elf = 0;
6901               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6902               writing = TRUE;
6903               if (htab->sfpr->contents == NULL)
6904                 {
6905                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6906                   if (htab->sfpr->contents == NULL)
6907                     return FALSE;
6908                 }
6909             }
6910         }
6911       if (writing)
6912         {
6913           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6914           if (i != parm->hi)
6915             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6916           else
6917             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6918           htab->sfpr->size = p - htab->sfpr->contents;
6919         }
6920     }
6921
6922   return TRUE;
6923 }
6924
6925 static bfd_byte *
6926 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6927 {
6928   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6929   return p + 4;
6930 }
6931
6932 static bfd_byte *
6933 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6934 {
6935   p = savegpr0 (abfd, p, r);
6936   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6937   p = p + 4;
6938   bfd_put_32 (abfd, BLR, p);
6939   return p + 4;
6940 }
6941
6942 static bfd_byte *
6943 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6944 {
6945   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6946   return p + 4;
6947 }
6948
6949 static bfd_byte *
6950 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6951 {
6952   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6953   p = p + 4;
6954   p = restgpr0 (abfd, p, r);
6955   bfd_put_32 (abfd, MTLR_R0, p);
6956   p = p + 4;
6957   if (r == 29)
6958     {
6959       p = restgpr0 (abfd, p, 30);
6960       p = restgpr0 (abfd, p, 31);
6961     }
6962   bfd_put_32 (abfd, BLR, p);
6963   return p + 4;
6964 }
6965
6966 static bfd_byte *
6967 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6968 {
6969   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6970   return p + 4;
6971 }
6972
6973 static bfd_byte *
6974 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6975 {
6976   p = savegpr1 (abfd, p, r);
6977   bfd_put_32 (abfd, BLR, p);
6978   return p + 4;
6979 }
6980
6981 static bfd_byte *
6982 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6983 {
6984   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6985   return p + 4;
6986 }
6987
6988 static bfd_byte *
6989 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6990 {
6991   p = restgpr1 (abfd, p, r);
6992   bfd_put_32 (abfd, BLR, p);
6993   return p + 4;
6994 }
6995
6996 static bfd_byte *
6997 savefpr (bfd *abfd, bfd_byte *p, int r)
6998 {
6999   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7000   return p + 4;
7001 }
7002
7003 static bfd_byte *
7004 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
7005 {
7006   p = savefpr (abfd, p, r);
7007   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
7008   p = p + 4;
7009   bfd_put_32 (abfd, BLR, p);
7010   return p + 4;
7011 }
7012
7013 static bfd_byte *
7014 restfpr (bfd *abfd, bfd_byte *p, int r)
7015 {
7016   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7017   return p + 4;
7018 }
7019
7020 static bfd_byte *
7021 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
7022 {
7023   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
7024   p = p + 4;
7025   p = restfpr (abfd, p, r);
7026   bfd_put_32 (abfd, MTLR_R0, p);
7027   p = p + 4;
7028   if (r == 29)
7029     {
7030       p = restfpr (abfd, p, 30);
7031       p = restfpr (abfd, p, 31);
7032     }
7033   bfd_put_32 (abfd, BLR, p);
7034   return p + 4;
7035 }
7036
7037 static bfd_byte *
7038 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7039 {
7040   p = savefpr (abfd, p, r);
7041   bfd_put_32 (abfd, BLR, p);
7042   return p + 4;
7043 }
7044
7045 static bfd_byte *
7046 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7047 {
7048   p = restfpr (abfd, p, r);
7049   bfd_put_32 (abfd, BLR, p);
7050   return p + 4;
7051 }
7052
7053 static bfd_byte *
7054 savevr (bfd *abfd, bfd_byte *p, int r)
7055 {
7056   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7057   p = p + 4;
7058   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7059   return p + 4;
7060 }
7061
7062 static bfd_byte *
7063 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7064 {
7065   p = savevr (abfd, p, r);
7066   bfd_put_32 (abfd, BLR, p);
7067   return p + 4;
7068 }
7069
7070 static bfd_byte *
7071 restvr (bfd *abfd, bfd_byte *p, int r)
7072 {
7073   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7074   p = p + 4;
7075   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7076   return p + 4;
7077 }
7078
7079 static bfd_byte *
7080 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7081 {
7082   p = restvr (abfd, p, r);
7083   bfd_put_32 (abfd, BLR, p);
7084   return p + 4;
7085 }
7086
7087 /* Called via elf_link_hash_traverse to transfer dynamic linking
7088    information on function code symbol entries to their corresponding
7089    function descriptor symbol entries.  */
7090
7091 static bfd_boolean
7092 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7093 {
7094   struct bfd_link_info *info;
7095   struct ppc_link_hash_table *htab;
7096   struct ppc_link_hash_entry *fh;
7097   struct ppc_link_hash_entry *fdh;
7098   bfd_boolean force_local;
7099
7100   fh = (struct ppc_link_hash_entry *) h;
7101   if (fh->elf.root.type == bfd_link_hash_indirect)
7102     return TRUE;
7103
7104   if (!fh->is_func)
7105     return TRUE;
7106
7107   if (fh->elf.root.root.string[0] != '.'
7108       || fh->elf.root.root.string[1] == '\0')
7109     return TRUE;
7110
7111   info = inf;
7112   htab = ppc_hash_table (info);
7113   if (htab == NULL)
7114     return FALSE;
7115
7116   /* Find the corresponding function descriptor symbol.  */
7117   fdh = lookup_fdh (fh, htab);
7118
7119   /* Resolve undefined references to dot-symbols as the value
7120      in the function descriptor, if we have one in a regular object.
7121      This is to satisfy cases like ".quad .foo".  Calls to functions
7122      in dynamic objects are handled elsewhere.  */
7123   if ((fh->elf.root.type == bfd_link_hash_undefined
7124        || fh->elf.root.type == bfd_link_hash_undefweak)
7125       && (fdh->elf.root.type == bfd_link_hash_defined
7126           || fdh->elf.root.type == bfd_link_hash_defweak)
7127       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7128       && opd_entry_value (fdh->elf.root.u.def.section,
7129                           fdh->elf.root.u.def.value,
7130                           &fh->elf.root.u.def.section,
7131                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7132     {
7133       fh->elf.root.type = fdh->elf.root.type;
7134       fh->elf.forced_local = 1;
7135       fh->elf.def_regular = fdh->elf.def_regular;
7136       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7137     }
7138
7139   if (!fh->elf.dynamic)
7140     {
7141       struct plt_entry *ent;
7142
7143       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7144         if (ent->plt.refcount > 0)
7145           break;
7146       if (ent == NULL)
7147         return TRUE;
7148     }
7149
7150   /* Create a descriptor as undefined if necessary.  */
7151   if (fdh == NULL
7152       && !bfd_link_executable (info)
7153       && (fh->elf.root.type == bfd_link_hash_undefined
7154           || fh->elf.root.type == bfd_link_hash_undefweak))
7155     {
7156       fdh = make_fdh (info, fh);
7157       if (fdh == NULL)
7158         return FALSE;
7159     }
7160
7161   /* We can't support overriding of symbols on a fake descriptor.  */
7162   if (fdh != NULL
7163       && fdh->fake
7164       && (fh->elf.root.type == bfd_link_hash_defined
7165           || fh->elf.root.type == bfd_link_hash_defweak))
7166     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7167
7168   /* Transfer dynamic linking information to the function descriptor.  */
7169   if (fdh != NULL)
7170     {
7171       fdh->elf.ref_regular |= fh->elf.ref_regular;
7172       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7173       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7174       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7175       fdh->elf.dynamic |= fh->elf.dynamic;
7176       fdh->elf.needs_plt |= (fh->elf.needs_plt
7177                              || fh->elf.type == STT_FUNC
7178                              || fh->elf.type == STT_GNU_IFUNC);
7179       move_plt_plist (fh, fdh);
7180
7181       if (!fdh->elf.forced_local
7182           && fh->elf.dynindx != -1)
7183         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7184           return FALSE;
7185     }
7186
7187   /* Now that the info is on the function descriptor, clear the
7188      function code sym info.  Any function code syms for which we
7189      don't have a definition in a regular file, we force local.
7190      This prevents a shared library from exporting syms that have
7191      been imported from another library.  Function code syms that
7192      are really in the library we must leave global to prevent the
7193      linker dragging in a definition from a static library.  */
7194   force_local = (!fh->elf.def_regular
7195                  || fdh == NULL
7196                  || !fdh->elf.def_regular
7197                  || fdh->elf.forced_local);
7198   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7199
7200   return TRUE;
7201 }
7202
7203 static const struct sfpr_def_parms save_res_funcs[] =
7204   {
7205     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7206     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7207     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7208     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7209     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7210     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7211     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7212     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7213     { "._savef", 14, 31, savefpr, savefpr1_tail },
7214     { "._restf", 14, 31, restfpr, restfpr1_tail },
7215     { "_savevr_", 20, 31, savevr, savevr_tail },
7216     { "_restvr_", 20, 31, restvr, restvr_tail }
7217   };
7218
7219 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7220    this hook to a) provide some gcc support functions, and b) transfer
7221    dynamic linking information gathered so far on function code symbol
7222    entries, to their corresponding function descriptor symbol entries.  */
7223
7224 static bfd_boolean
7225 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7226                             struct bfd_link_info *info)
7227 {
7228   struct ppc_link_hash_table *htab;
7229
7230   htab = ppc_hash_table (info);
7231   if (htab == NULL)
7232     return FALSE;
7233
7234   /* Provide any missing _save* and _rest* functions.  */
7235   if (htab->sfpr != NULL)
7236     {
7237       unsigned int i;
7238
7239       htab->sfpr->size = 0;
7240       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7241         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7242           return FALSE;
7243       if (htab->sfpr->size == 0)
7244         htab->sfpr->flags |= SEC_EXCLUDE;
7245     }
7246
7247   if (bfd_link_relocatable (info))
7248     return TRUE;
7249
7250   if (htab->elf.hgot != NULL)
7251     {
7252       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7253       /* Make .TOC. defined so as to prevent it being made dynamic.
7254          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7255       if (!htab->elf.hgot->def_regular
7256           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7257         {
7258           htab->elf.hgot->root.type = bfd_link_hash_defined;
7259           htab->elf.hgot->root.u.def.value = 0;
7260           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7261           htab->elf.hgot->def_regular = 1;
7262           htab->elf.hgot->root.linker_def = 1;
7263         }
7264       htab->elf.hgot->type = STT_OBJECT;
7265       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7266                                | STV_HIDDEN);
7267     }
7268
7269   if (htab->need_func_desc_adj)
7270     {
7271       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7272       htab->need_func_desc_adj = 0;
7273     }
7274
7275   return TRUE;
7276 }
7277
7278 /* Find dynamic relocs for H that apply to read-only sections.  */
7279
7280 static asection *
7281 readonly_dynrelocs (struct elf_link_hash_entry *h)
7282 {
7283   struct ppc_link_hash_entry *eh;
7284   struct elf_dyn_relocs *p;
7285
7286   eh = (struct ppc_link_hash_entry *) h;
7287   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7288     {
7289       asection *s = p->sec->output_section;
7290
7291       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7292         return p->sec;
7293     }
7294   return NULL;
7295 }
7296
7297 /* Return true if we have dynamic relocs against H or any of its weak
7298    aliases, that apply to read-only sections.  Cannot be used after
7299    size_dynamic_sections.  */
7300
7301 static bfd_boolean
7302 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7303 {
7304   struct ppc_link_hash_entry *eh;
7305
7306   eh = (struct ppc_link_hash_entry *) h;
7307   do
7308     {
7309       if (readonly_dynrelocs (&eh->elf))
7310         return TRUE;
7311       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7312     } while (eh != NULL && &eh->elf != h);
7313
7314   return FALSE;
7315 }
7316
7317 /* Return whether EH has pc-relative dynamic relocs.  */
7318
7319 static bfd_boolean
7320 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7321 {
7322   struct elf_dyn_relocs *p;
7323
7324   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7325     if (p->pc_count != 0)
7326       return TRUE;
7327   return FALSE;
7328 }
7329
7330 /* Return true if a global entry stub will be created for H.  Valid
7331    for ELFv2 before plt entries have been allocated.  */
7332
7333 static bfd_boolean
7334 global_entry_stub (struct elf_link_hash_entry *h)
7335 {
7336   struct plt_entry *pent;
7337
7338   if (!h->pointer_equality_needed
7339       || h->def_regular)
7340     return FALSE;
7341
7342   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7343     if (pent->plt.refcount > 0
7344         && pent->addend == 0)
7345       return TRUE;
7346
7347   return FALSE;
7348 }
7349
7350 /* Adjust a symbol defined by a dynamic object and referenced by a
7351    regular object.  The current definition is in some section of the
7352    dynamic object, but we're not including those sections.  We have to
7353    change the definition to something the rest of the link can
7354    understand.  */
7355
7356 static bfd_boolean
7357 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7358                                  struct elf_link_hash_entry *h)
7359 {
7360   struct ppc_link_hash_table *htab;
7361   asection *s, *srel;
7362
7363   htab = ppc_hash_table (info);
7364   if (htab == NULL)
7365     return FALSE;
7366
7367   /* Deal with function syms.  */
7368   if (h->type == STT_FUNC
7369       || h->type == STT_GNU_IFUNC
7370       || h->needs_plt)
7371     {
7372       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7373                            || SYMBOL_CALLS_LOCAL (info, h)
7374                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7375       /* Discard dyn_relocs when non-pic if we've decided that a
7376          function symbol is local and not an ifunc.  We keep dynamic
7377          relocs for ifuncs when local rather than always emitting a
7378          plt call stub for them and defining the symbol on the call
7379          stub.  We can't do that for ELFv1 anyway (a function symbol
7380          is defined on a descriptor, not code) and it can be faster at
7381          run-time due to not needing to bounce through a stub.  The
7382          dyn_relocs for ifuncs will be applied even in a static
7383          executable.  */
7384       if (!bfd_link_pic (info)
7385           && h->type != STT_GNU_IFUNC
7386           && local)
7387         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7388
7389       /* Clear procedure linkage table information for any symbol that
7390          won't need a .plt entry.  */
7391       struct plt_entry *ent;
7392       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7393         if (ent->plt.refcount > 0)
7394           break;
7395       if (ent == NULL
7396           || (h->type != STT_GNU_IFUNC
7397               && local
7398               && (htab->can_convert_all_inline_plt
7399                   || (((struct ppc_link_hash_entry *) h)->tls_mask
7400                       & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7401         {
7402           h->plt.plist = NULL;
7403           h->needs_plt = 0;
7404           h->pointer_equality_needed = 0;
7405         }
7406       else if (abiversion (info->output_bfd) >= 2)
7407         {
7408           /* Taking a function's address in a read/write section
7409              doesn't require us to define the function symbol in the
7410              executable on a global entry stub.  A dynamic reloc can
7411              be used instead.  The reason we prefer a few more dynamic
7412              relocs is that calling via a global entry stub costs a
7413              few more instructions, and pointer_equality_needed causes
7414              extra work in ld.so when resolving these symbols.  */
7415           if (global_entry_stub (h))
7416             {
7417               if (!readonly_dynrelocs (h))
7418                 {
7419                   h->pointer_equality_needed = 0;
7420                   /* If we haven't seen a branch reloc and the symbol
7421                      isn't an ifunc then we don't need a plt entry.  */
7422                   if (!h->needs_plt)
7423                     h->plt.plist = NULL;
7424                 }
7425               else if (!bfd_link_pic (info))
7426                 /* We are going to be defining the function symbol on the
7427                    plt stub, so no dyn_relocs needed when non-pic.  */
7428                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7429             }
7430
7431           /* ELFv2 function symbols can't have copy relocs.  */
7432           return TRUE;
7433         }
7434       else if (!h->needs_plt
7435                && !readonly_dynrelocs (h))
7436         {
7437           /* If we haven't seen a branch reloc and the symbol isn't an
7438              ifunc then we don't need a plt entry.  */
7439           h->plt.plist = NULL;
7440           h->pointer_equality_needed = 0;
7441           return TRUE;
7442         }
7443     }
7444   else
7445     h->plt.plist = NULL;
7446
7447   /* If this is a weak symbol, and there is a real definition, the
7448      processor independent code will have arranged for us to see the
7449      real definition first, and we can just use the same value.  */
7450   if (h->is_weakalias)
7451     {
7452       struct elf_link_hash_entry *def = weakdef (h);
7453       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7454       h->root.u.def.section = def->root.u.def.section;
7455       h->root.u.def.value = def->root.u.def.value;
7456       if (def->root.u.def.section == htab->elf.sdynbss
7457           || def->root.u.def.section == htab->elf.sdynrelro)
7458         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7459       return TRUE;
7460     }
7461
7462   /* If we are creating a shared library, we must presume that the
7463      only references to the symbol are via the global offset table.
7464      For such cases we need not do anything here; the relocations will
7465      be handled correctly by relocate_section.  */
7466   if (bfd_link_pic (info))
7467     return TRUE;
7468
7469   /* If there are no references to this symbol that do not use the
7470      GOT, we don't need to generate a copy reloc.  */
7471   if (!h->non_got_ref)
7472     return TRUE;
7473
7474   /* Don't generate a copy reloc for symbols defined in the executable.  */
7475   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7476
7477       /* If -z nocopyreloc was given, don't generate them either.  */
7478       || info->nocopyreloc
7479
7480       /* If we don't find any dynamic relocs in read-only sections, then
7481          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7482       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7483
7484       /* Protected variables do not work with .dynbss.  The copy in
7485          .dynbss won't be used by the shared library with the protected
7486          definition for the variable.  Text relocations are preferable
7487          to an incorrect program.  */
7488       || h->protected_def)
7489     return TRUE;
7490
7491   if (h->plt.plist != NULL)
7492     {
7493       /* We should never get here, but unfortunately there are versions
7494          of gcc out there that improperly (for this ABI) put initialized
7495          function pointers, vtable refs and suchlike in read-only
7496          sections.  Allow them to proceed, but warn that this might
7497          break at runtime.  */
7498       info->callbacks->einfo
7499         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7500            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7501          h->root.root.string);
7502     }
7503
7504   /* This is a reference to a symbol defined by a dynamic object which
7505      is not a function.  */
7506
7507   /* We must allocate the symbol in our .dynbss section, which will
7508      become part of the .bss section of the executable.  There will be
7509      an entry for this symbol in the .dynsym section.  The dynamic
7510      object will contain position independent code, so all references
7511      from the dynamic object to this symbol will go through the global
7512      offset table.  The dynamic linker will use the .dynsym entry to
7513      determine the address it must put in the global offset table, so
7514      both the dynamic object and the regular object will refer to the
7515      same memory location for the variable.  */
7516   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7517     {
7518       s = htab->elf.sdynrelro;
7519       srel = htab->elf.sreldynrelro;
7520     }
7521   else
7522     {
7523       s = htab->elf.sdynbss;
7524       srel = htab->elf.srelbss;
7525     }
7526   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7527     {
7528       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7529          linker to copy the initial value out of the dynamic object
7530          and into the runtime process image.  */
7531       srel->size += sizeof (Elf64_External_Rela);
7532       h->needs_copy = 1;
7533     }
7534
7535   /* We no longer want dyn_relocs.  */
7536   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7537   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7538 }
7539
7540 /* If given a function descriptor symbol, hide both the function code
7541    sym and the descriptor.  */
7542 static void
7543 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7544                        struct elf_link_hash_entry *h,
7545                        bfd_boolean force_local)
7546 {
7547   struct ppc_link_hash_entry *eh;
7548   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7549
7550   eh = (struct ppc_link_hash_entry *) h;
7551   if (eh->is_func_descriptor)
7552     {
7553       struct ppc_link_hash_entry *fh = eh->oh;
7554
7555       if (fh == NULL)
7556         {
7557           const char *p, *q;
7558           struct elf_link_hash_table *htab = elf_hash_table (info);
7559           char save;
7560
7561           /* We aren't supposed to use alloca in BFD because on
7562              systems which do not have alloca the version in libiberty
7563              calls xmalloc, which might cause the program to crash
7564              when it runs out of memory.  This function doesn't have a
7565              return status, so there's no way to gracefully return an
7566              error.  So cheat.  We know that string[-1] can be safely
7567              accessed;  It's either a string in an ELF string table,
7568              or allocated in an objalloc structure.  */
7569
7570           p = eh->elf.root.root.string - 1;
7571           save = *p;
7572           *(char *) p = '.';
7573           fh = (struct ppc_link_hash_entry *)
7574             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7575           *(char *) p = save;
7576
7577           /* Unfortunately, if it so happens that the string we were
7578              looking for was allocated immediately before this string,
7579              then we overwrote the string terminator.  That's the only
7580              reason the lookup should fail.  */
7581           if (fh == NULL)
7582             {
7583               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7584               while (q >= eh->elf.root.root.string && *q == *p)
7585                 --q, --p;
7586               if (q < eh->elf.root.root.string && *p == '.')
7587                 fh = (struct ppc_link_hash_entry *)
7588                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7589             }
7590           if (fh != NULL)
7591             {
7592               eh->oh = fh;
7593               fh->oh = eh;
7594             }
7595         }
7596       if (fh != NULL)
7597         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7598     }
7599 }
7600
7601 static bfd_boolean
7602 get_sym_h (struct elf_link_hash_entry **hp,
7603            Elf_Internal_Sym **symp,
7604            asection **symsecp,
7605            unsigned char **tls_maskp,
7606            Elf_Internal_Sym **locsymsp,
7607            unsigned long r_symndx,
7608            bfd *ibfd)
7609 {
7610   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7611
7612   if (r_symndx >= symtab_hdr->sh_info)
7613     {
7614       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7615       struct elf_link_hash_entry *h;
7616
7617       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7618       h = elf_follow_link (h);
7619
7620       if (hp != NULL)
7621         *hp = h;
7622
7623       if (symp != NULL)
7624         *symp = NULL;
7625
7626       if (symsecp != NULL)
7627         {
7628           asection *symsec = NULL;
7629           if (h->root.type == bfd_link_hash_defined
7630               || h->root.type == bfd_link_hash_defweak)
7631             symsec = h->root.u.def.section;
7632           *symsecp = symsec;
7633         }
7634
7635       if (tls_maskp != NULL)
7636         {
7637           struct ppc_link_hash_entry *eh;
7638
7639           eh = (struct ppc_link_hash_entry *) h;
7640           *tls_maskp = &eh->tls_mask;
7641         }
7642     }
7643   else
7644     {
7645       Elf_Internal_Sym *sym;
7646       Elf_Internal_Sym *locsyms = *locsymsp;
7647
7648       if (locsyms == NULL)
7649         {
7650           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7651           if (locsyms == NULL)
7652             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7653                                             symtab_hdr->sh_info,
7654                                             0, NULL, NULL, NULL);
7655           if (locsyms == NULL)
7656             return FALSE;
7657           *locsymsp = locsyms;
7658         }
7659       sym = locsyms + r_symndx;
7660
7661       if (hp != NULL)
7662         *hp = NULL;
7663
7664       if (symp != NULL)
7665         *symp = sym;
7666
7667       if (symsecp != NULL)
7668         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7669
7670       if (tls_maskp != NULL)
7671         {
7672           struct got_entry **lgot_ents;
7673           unsigned char *tls_mask;
7674
7675           tls_mask = NULL;
7676           lgot_ents = elf_local_got_ents (ibfd);
7677           if (lgot_ents != NULL)
7678             {
7679               struct plt_entry **local_plt = (struct plt_entry **)
7680                 (lgot_ents + symtab_hdr->sh_info);
7681               unsigned char *lgot_masks = (unsigned char *)
7682                 (local_plt + symtab_hdr->sh_info);
7683               tls_mask = &lgot_masks[r_symndx];
7684             }
7685           *tls_maskp = tls_mask;
7686         }
7687     }
7688   return TRUE;
7689 }
7690
7691 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7692    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7693    type suitable for optimization, and 1 otherwise.  */
7694
7695 static int
7696 get_tls_mask (unsigned char **tls_maskp,
7697               unsigned long *toc_symndx,
7698               bfd_vma *toc_addend,
7699               Elf_Internal_Sym **locsymsp,
7700               const Elf_Internal_Rela *rel,
7701               bfd *ibfd)
7702 {
7703   unsigned long r_symndx;
7704   int next_r;
7705   struct elf_link_hash_entry *h;
7706   Elf_Internal_Sym *sym;
7707   asection *sec;
7708   bfd_vma off;
7709
7710   r_symndx = ELF64_R_SYM (rel->r_info);
7711   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7712     return 0;
7713
7714   if ((*tls_maskp != NULL
7715        && (**tls_maskp & TLS_TLS) != 0
7716        && **tls_maskp != (TLS_TLS | TLS_MARK))
7717       || sec == NULL
7718       || ppc64_elf_section_data (sec) == NULL
7719       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7720     return 1;
7721
7722   /* Look inside a TOC section too.  */
7723   if (h != NULL)
7724     {
7725       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7726       off = h->root.u.def.value;
7727     }
7728   else
7729     off = sym->st_value;
7730   off += rel->r_addend;
7731   BFD_ASSERT (off % 8 == 0);
7732   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7733   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7734   if (toc_symndx != NULL)
7735     *toc_symndx = r_symndx;
7736   if (toc_addend != NULL)
7737     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7738   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7739     return 0;
7740   if ((h == NULL || is_static_defined (h))
7741       && (next_r == -1 || next_r == -2))
7742     return 1 - next_r;
7743   return 1;
7744 }
7745
7746 /* Find (or create) an entry in the tocsave hash table.  */
7747
7748 static struct tocsave_entry *
7749 tocsave_find (struct ppc_link_hash_table *htab,
7750               enum insert_option insert,
7751               Elf_Internal_Sym **local_syms,
7752               const Elf_Internal_Rela *irela,
7753               bfd *ibfd)
7754 {
7755   unsigned long r_indx;
7756   struct elf_link_hash_entry *h;
7757   Elf_Internal_Sym *sym;
7758   struct tocsave_entry ent, *p;
7759   hashval_t hash;
7760   struct tocsave_entry **slot;
7761
7762   r_indx = ELF64_R_SYM (irela->r_info);
7763   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7764     return NULL;
7765   if (ent.sec == NULL || ent.sec->output_section == NULL)
7766     {
7767       _bfd_error_handler
7768         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7769       return NULL;
7770     }
7771
7772   if (h != NULL)
7773     ent.offset = h->root.u.def.value;
7774   else
7775     ent.offset = sym->st_value;
7776   ent.offset += irela->r_addend;
7777
7778   hash = tocsave_htab_hash (&ent);
7779   slot = ((struct tocsave_entry **)
7780           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7781   if (slot == NULL)
7782     return NULL;
7783
7784   if (*slot == NULL)
7785     {
7786       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7787       if (p == NULL)
7788         return NULL;
7789       *p = ent;
7790       *slot = p;
7791     }
7792   return *slot;
7793 }
7794
7795 /* Adjust all global syms defined in opd sections.  In gcc generated
7796    code for the old ABI, these will already have been done.  */
7797
7798 static bfd_boolean
7799 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7800 {
7801   struct ppc_link_hash_entry *eh;
7802   asection *sym_sec;
7803   struct _opd_sec_data *opd;
7804
7805   if (h->root.type == bfd_link_hash_indirect)
7806     return TRUE;
7807
7808   if (h->root.type != bfd_link_hash_defined
7809       && h->root.type != bfd_link_hash_defweak)
7810     return TRUE;
7811
7812   eh = (struct ppc_link_hash_entry *) h;
7813   if (eh->adjust_done)
7814     return TRUE;
7815
7816   sym_sec = eh->elf.root.u.def.section;
7817   opd = get_opd_info (sym_sec);
7818   if (opd != NULL && opd->adjust != NULL)
7819     {
7820       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7821       if (adjust == -1)
7822         {
7823           /* This entry has been deleted.  */
7824           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7825           if (dsec == NULL)
7826             {
7827               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7828                 if (discarded_section (dsec))
7829                   {
7830                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7831                     break;
7832                   }
7833             }
7834           eh->elf.root.u.def.value = 0;
7835           eh->elf.root.u.def.section = dsec;
7836         }
7837       else
7838         eh->elf.root.u.def.value += adjust;
7839       eh->adjust_done = 1;
7840     }
7841   return TRUE;
7842 }
7843
7844 /* Handles decrementing dynamic reloc counts for the reloc specified by
7845    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7846    have already been determined.  */
7847
7848 static bfd_boolean
7849 dec_dynrel_count (bfd_vma r_info,
7850                   asection *sec,
7851                   struct bfd_link_info *info,
7852                   Elf_Internal_Sym **local_syms,
7853                   struct elf_link_hash_entry *h,
7854                   Elf_Internal_Sym *sym)
7855 {
7856   enum elf_ppc64_reloc_type r_type;
7857   asection *sym_sec = NULL;
7858
7859   /* Can this reloc be dynamic?  This switch, and later tests here
7860      should be kept in sync with the code in check_relocs.  */
7861   r_type = ELF64_R_TYPE (r_info);
7862   switch (r_type)
7863     {
7864     default:
7865       return TRUE;
7866
7867     case R_PPC64_TPREL16:
7868     case R_PPC64_TPREL16_LO:
7869     case R_PPC64_TPREL16_HI:
7870     case R_PPC64_TPREL16_HA:
7871     case R_PPC64_TPREL16_DS:
7872     case R_PPC64_TPREL16_LO_DS:
7873     case R_PPC64_TPREL16_HIGH:
7874     case R_PPC64_TPREL16_HIGHA:
7875     case R_PPC64_TPREL16_HIGHER:
7876     case R_PPC64_TPREL16_HIGHERA:
7877     case R_PPC64_TPREL16_HIGHEST:
7878     case R_PPC64_TPREL16_HIGHESTA:
7879     case R_PPC64_TPREL64:
7880     case R_PPC64_DTPMOD64:
7881     case R_PPC64_DTPREL64:
7882     case R_PPC64_ADDR64:
7883     case R_PPC64_REL30:
7884     case R_PPC64_REL32:
7885     case R_PPC64_REL64:
7886     case R_PPC64_ADDR14:
7887     case R_PPC64_ADDR14_BRNTAKEN:
7888     case R_PPC64_ADDR14_BRTAKEN:
7889     case R_PPC64_ADDR16:
7890     case R_PPC64_ADDR16_DS:
7891     case R_PPC64_ADDR16_HA:
7892     case R_PPC64_ADDR16_HI:
7893     case R_PPC64_ADDR16_HIGH:
7894     case R_PPC64_ADDR16_HIGHA:
7895     case R_PPC64_ADDR16_HIGHER:
7896     case R_PPC64_ADDR16_HIGHERA:
7897     case R_PPC64_ADDR16_HIGHEST:
7898     case R_PPC64_ADDR16_HIGHESTA:
7899     case R_PPC64_ADDR16_LO:
7900     case R_PPC64_ADDR16_LO_DS:
7901     case R_PPC64_ADDR24:
7902     case R_PPC64_ADDR32:
7903     case R_PPC64_UADDR16:
7904     case R_PPC64_UADDR32:
7905     case R_PPC64_UADDR64:
7906     case R_PPC64_TOC:
7907       break;
7908     }
7909
7910   if (local_syms != NULL)
7911     {
7912       unsigned long r_symndx;
7913       bfd *ibfd = sec->owner;
7914
7915       r_symndx = ELF64_R_SYM (r_info);
7916       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7917         return FALSE;
7918     }
7919
7920   if ((bfd_link_pic (info)
7921        && (must_be_dyn_reloc (info, r_type)
7922            || (h != NULL
7923                && (!SYMBOLIC_BIND (info, h)
7924                    || h->root.type == bfd_link_hash_defweak
7925                    || !h->def_regular))))
7926       || (ELIMINATE_COPY_RELOCS
7927           && !bfd_link_pic (info)
7928           && h != NULL
7929           && (h->root.type == bfd_link_hash_defweak
7930               || !h->def_regular)))
7931     ;
7932   else
7933     return TRUE;
7934
7935   if (h != NULL)
7936     {
7937       struct elf_dyn_relocs *p;
7938       struct elf_dyn_relocs **pp;
7939       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7940
7941       /* elf_gc_sweep may have already removed all dyn relocs associated
7942          with local syms for a given section.  Also, symbol flags are
7943          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7944          report a dynreloc miscount.  */
7945       if (*pp == NULL && info->gc_sections)
7946         return TRUE;
7947
7948       while ((p = *pp) != NULL)
7949         {
7950           if (p->sec == sec)
7951             {
7952               if (!must_be_dyn_reloc (info, r_type))
7953                 p->pc_count -= 1;
7954               p->count -= 1;
7955               if (p->count == 0)
7956                 *pp = p->next;
7957               return TRUE;
7958             }
7959           pp = &p->next;
7960         }
7961     }
7962   else
7963     {
7964       struct ppc_dyn_relocs *p;
7965       struct ppc_dyn_relocs **pp;
7966       void *vpp;
7967       bfd_boolean is_ifunc;
7968
7969       if (local_syms == NULL)
7970         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7971       if (sym_sec == NULL)
7972         sym_sec = sec;
7973
7974       vpp = &elf_section_data (sym_sec)->local_dynrel;
7975       pp = (struct ppc_dyn_relocs **) vpp;
7976
7977       if (*pp == NULL && info->gc_sections)
7978         return TRUE;
7979
7980       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7981       while ((p = *pp) != NULL)
7982         {
7983           if (p->sec == sec && p->ifunc == is_ifunc)
7984             {
7985               p->count -= 1;
7986               if (p->count == 0)
7987                 *pp = p->next;
7988               return TRUE;
7989             }
7990           pp = &p->next;
7991         }
7992     }
7993
7994   /* xgettext:c-format */
7995   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7996                       sec->owner, sec);
7997   bfd_set_error (bfd_error_bad_value);
7998   return FALSE;
7999 }
8000
8001 /* Remove unused Official Procedure Descriptor entries.  Currently we
8002    only remove those associated with functions in discarded link-once
8003    sections, or weakly defined functions that have been overridden.  It
8004    would be possible to remove many more entries for statically linked
8005    applications.  */
8006
8007 bfd_boolean
8008 ppc64_elf_edit_opd (struct bfd_link_info *info)
8009 {
8010   bfd *ibfd;
8011   bfd_boolean some_edited = FALSE;
8012   asection *need_pad = NULL;
8013   struct ppc_link_hash_table *htab;
8014
8015   htab = ppc_hash_table (info);
8016   if (htab == NULL)
8017     return FALSE;
8018
8019   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8020     {
8021       asection *sec;
8022       Elf_Internal_Rela *relstart, *rel, *relend;
8023       Elf_Internal_Shdr *symtab_hdr;
8024       Elf_Internal_Sym *local_syms;
8025       struct _opd_sec_data *opd;
8026       bfd_boolean need_edit, add_aux_fields, broken;
8027       bfd_size_type cnt_16b = 0;
8028
8029       if (!is_ppc64_elf (ibfd))
8030         continue;
8031
8032       sec = bfd_get_section_by_name (ibfd, ".opd");
8033       if (sec == NULL || sec->size == 0)
8034         continue;
8035
8036       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
8037         continue;
8038
8039       if (sec->output_section == bfd_abs_section_ptr)
8040         continue;
8041
8042       /* Look through the section relocs.  */
8043       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
8044         continue;
8045
8046       local_syms = NULL;
8047       symtab_hdr = &elf_symtab_hdr (ibfd);
8048
8049       /* Read the relocations.  */
8050       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8051                                             info->keep_memory);
8052       if (relstart == NULL)
8053         return FALSE;
8054
8055       /* First run through the relocs to check they are sane, and to
8056          determine whether we need to edit this opd section.  */
8057       need_edit = FALSE;
8058       broken = FALSE;
8059       need_pad = sec;
8060       relend = relstart + sec->reloc_count;
8061       for (rel = relstart; rel < relend; )
8062         {
8063           enum elf_ppc64_reloc_type r_type;
8064           unsigned long r_symndx;
8065           asection *sym_sec;
8066           struct elf_link_hash_entry *h;
8067           Elf_Internal_Sym *sym;
8068           bfd_vma offset;
8069
8070           /* .opd contains an array of 16 or 24 byte entries.  We're
8071              only interested in the reloc pointing to a function entry
8072              point.  */
8073           offset = rel->r_offset;
8074           if (rel + 1 == relend
8075               || rel[1].r_offset != offset + 8)
8076             {
8077               /* If someone messes with .opd alignment then after a
8078                  "ld -r" we might have padding in the middle of .opd.
8079                  Also, there's nothing to prevent someone putting
8080                  something silly in .opd with the assembler.  No .opd
8081                  optimization for them!  */
8082             broken_opd:
8083               _bfd_error_handler
8084                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
8085               broken = TRUE;
8086               break;
8087             }
8088
8089           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8090               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8091             {
8092               _bfd_error_handler
8093                 /* xgettext:c-format */
8094                 (_("%pB: unexpected reloc type %u in .opd section"),
8095                  ibfd, r_type);
8096               broken = TRUE;
8097               break;
8098             }
8099
8100           r_symndx = ELF64_R_SYM (rel->r_info);
8101           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8102                           r_symndx, ibfd))
8103             goto error_ret;
8104
8105           if (sym_sec == NULL || sym_sec->owner == NULL)
8106             {
8107               const char *sym_name;
8108               if (h != NULL)
8109                 sym_name = h->root.root.string;
8110               else
8111                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8112                                              sym_sec);
8113
8114               _bfd_error_handler
8115                 /* xgettext:c-format */
8116                 (_("%pB: undefined sym `%s' in .opd section"),
8117                  ibfd, sym_name);
8118               broken = TRUE;
8119               break;
8120             }
8121
8122           /* opd entries are always for functions defined in the
8123              current input bfd.  If the symbol isn't defined in the
8124              input bfd, then we won't be using the function in this
8125              bfd;  It must be defined in a linkonce section in another
8126              bfd, or is weak.  It's also possible that we are
8127              discarding the function due to a linker script /DISCARD/,
8128              which we test for via the output_section.  */
8129           if (sym_sec->owner != ibfd
8130               || sym_sec->output_section == bfd_abs_section_ptr)
8131             need_edit = TRUE;
8132
8133           rel += 2;
8134           if (rel + 1 == relend
8135               || (rel + 2 < relend
8136                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8137             ++rel;
8138
8139           if (rel == relend)
8140             {
8141               if (sec->size == offset + 24)
8142                 {
8143                   need_pad = NULL;
8144                   break;
8145                 }
8146               if (sec->size == offset + 16)
8147                 {
8148                   cnt_16b++;
8149                   break;
8150                 }
8151               goto broken_opd;
8152             }
8153           else if (rel + 1 < relend
8154                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8155                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8156             {
8157               if (rel[0].r_offset == offset + 16)
8158                 cnt_16b++;
8159               else if (rel[0].r_offset != offset + 24)
8160                 goto broken_opd;
8161             }
8162           else
8163             goto broken_opd;
8164         }
8165
8166       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8167
8168       if (!broken && (need_edit || add_aux_fields))
8169         {
8170           Elf_Internal_Rela *write_rel;
8171           Elf_Internal_Shdr *rel_hdr;
8172           bfd_byte *rptr, *wptr;
8173           bfd_byte *new_contents;
8174           bfd_size_type amt;
8175
8176           new_contents = NULL;
8177           amt = OPD_NDX (sec->size) * sizeof (long);
8178           opd = &ppc64_elf_section_data (sec)->u.opd;
8179           opd->adjust = bfd_zalloc (sec->owner, amt);
8180           if (opd->adjust == NULL)
8181             return FALSE;
8182
8183           /* This seems a waste of time as input .opd sections are all
8184              zeros as generated by gcc, but I suppose there's no reason
8185              this will always be so.  We might start putting something in
8186              the third word of .opd entries.  */
8187           if ((sec->flags & SEC_IN_MEMORY) == 0)
8188             {
8189               bfd_byte *loc;
8190               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8191                 {
8192                   if (loc != NULL)
8193                     free (loc);
8194                 error_ret:
8195                   if (local_syms != NULL
8196                       && symtab_hdr->contents != (unsigned char *) local_syms)
8197                     free (local_syms);
8198                   if (elf_section_data (sec)->relocs != relstart)
8199                     free (relstart);
8200                   return FALSE;
8201                 }
8202               sec->contents = loc;
8203               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8204             }
8205
8206           elf_section_data (sec)->relocs = relstart;
8207
8208           new_contents = sec->contents;
8209           if (add_aux_fields)
8210             {
8211               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8212               if (new_contents == NULL)
8213                 return FALSE;
8214               need_pad = NULL;
8215             }
8216           wptr = new_contents;
8217           rptr = sec->contents;
8218           write_rel = relstart;
8219           for (rel = relstart; rel < relend; )
8220             {
8221               unsigned long r_symndx;
8222               asection *sym_sec;
8223               struct elf_link_hash_entry *h;
8224               struct ppc_link_hash_entry *fdh = NULL;
8225               Elf_Internal_Sym *sym;
8226               long opd_ent_size;
8227               Elf_Internal_Rela *next_rel;
8228               bfd_boolean skip;
8229
8230               r_symndx = ELF64_R_SYM (rel->r_info);
8231               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8232                               r_symndx, ibfd))
8233                 goto error_ret;
8234
8235               next_rel = rel + 2;
8236               if (next_rel + 1 == relend
8237                   || (next_rel + 2 < relend
8238                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8239                 ++next_rel;
8240
8241               /* See if the .opd entry is full 24 byte or
8242                  16 byte (with fd_aux entry overlapped with next
8243                  fd_func).  */
8244               opd_ent_size = 24;
8245               if (next_rel == relend)
8246                 {
8247                   if (sec->size == rel->r_offset + 16)
8248                     opd_ent_size = 16;
8249                 }
8250               else if (next_rel->r_offset == rel->r_offset + 16)
8251                 opd_ent_size = 16;
8252
8253               if (h != NULL
8254                   && h->root.root.string[0] == '.')
8255                 {
8256                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8257                   if (fdh != NULL)
8258                     {
8259                       fdh = ppc_follow_link (fdh);
8260                       if (fdh->elf.root.type != bfd_link_hash_defined
8261                           && fdh->elf.root.type != bfd_link_hash_defweak)
8262                         fdh = NULL;
8263                     }
8264                 }
8265
8266               skip = (sym_sec->owner != ibfd
8267                       || sym_sec->output_section == bfd_abs_section_ptr);
8268               if (skip)
8269                 {
8270                   if (fdh != NULL && sym_sec->owner == ibfd)
8271                     {
8272                       /* Arrange for the function descriptor sym
8273                          to be dropped.  */
8274                       fdh->elf.root.u.def.value = 0;
8275                       fdh->elf.root.u.def.section = sym_sec;
8276                     }
8277                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8278
8279                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8280                     rel = next_rel;
8281                   else
8282                     while (1)
8283                       {
8284                         if (!dec_dynrel_count (rel->r_info, sec, info,
8285                                                NULL, h, sym))
8286                           goto error_ret;
8287
8288                         if (++rel == next_rel)
8289                           break;
8290
8291                         r_symndx = ELF64_R_SYM (rel->r_info);
8292                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8293                                         r_symndx, ibfd))
8294                           goto error_ret;
8295                       }
8296                 }
8297               else
8298                 {
8299                   /* We'll be keeping this opd entry.  */
8300                   long adjust;
8301
8302                   if (fdh != NULL)
8303                     {
8304                       /* Redefine the function descriptor symbol to
8305                          this location in the opd section.  It is
8306                          necessary to update the value here rather
8307                          than using an array of adjustments as we do
8308                          for local symbols, because various places
8309                          in the generic ELF code use the value
8310                          stored in u.def.value.  */
8311                       fdh->elf.root.u.def.value = wptr - new_contents;
8312                       fdh->adjust_done = 1;
8313                     }
8314
8315                   /* Local syms are a bit tricky.  We could
8316                      tweak them as they can be cached, but
8317                      we'd need to look through the local syms
8318                      for the function descriptor sym which we
8319                      don't have at the moment.  So keep an
8320                      array of adjustments.  */
8321                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8322                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8323
8324                   if (wptr != rptr)
8325                     memcpy (wptr, rptr, opd_ent_size);
8326                   wptr += opd_ent_size;
8327                   if (add_aux_fields && opd_ent_size == 16)
8328                     {
8329                       memset (wptr, '\0', 8);
8330                       wptr += 8;
8331                     }
8332
8333                   /* We need to adjust any reloc offsets to point to the
8334                      new opd entries.  */
8335                   for ( ; rel != next_rel; ++rel)
8336                     {
8337                       rel->r_offset += adjust;
8338                       if (write_rel != rel)
8339                         memcpy (write_rel, rel, sizeof (*rel));
8340                       ++write_rel;
8341                     }
8342                 }
8343
8344               rptr += opd_ent_size;
8345             }
8346
8347           sec->size = wptr - new_contents;
8348           sec->reloc_count = write_rel - relstart;
8349           if (add_aux_fields)
8350             {
8351               free (sec->contents);
8352               sec->contents = new_contents;
8353             }
8354
8355           /* Fudge the header size too, as this is used later in
8356              elf_bfd_final_link if we are emitting relocs.  */
8357           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8358           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8359           some_edited = TRUE;
8360         }
8361       else if (elf_section_data (sec)->relocs != relstart)
8362         free (relstart);
8363
8364       if (local_syms != NULL
8365           && symtab_hdr->contents != (unsigned char *) local_syms)
8366         {
8367           if (!info->keep_memory)
8368             free (local_syms);
8369           else
8370             symtab_hdr->contents = (unsigned char *) local_syms;
8371         }
8372     }
8373
8374   if (some_edited)
8375     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8376
8377   /* If we are doing a final link and the last .opd entry is just 16 byte
8378      long, add a 8 byte padding after it.  */
8379   if (need_pad != NULL && !bfd_link_relocatable (info))
8380     {
8381       bfd_byte *p;
8382
8383       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8384         {
8385           BFD_ASSERT (need_pad->size > 0);
8386
8387           p = bfd_malloc (need_pad->size + 8);
8388           if (p == NULL)
8389             return FALSE;
8390
8391           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8392                                           p, 0, need_pad->size))
8393             return FALSE;
8394
8395           need_pad->contents = p;
8396           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8397         }
8398       else
8399         {
8400           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8401           if (p == NULL)
8402             return FALSE;
8403
8404           need_pad->contents = p;
8405         }
8406
8407       memset (need_pad->contents + need_pad->size, 0, 8);
8408       need_pad->size += 8;
8409     }
8410
8411   return TRUE;
8412 }
8413
8414 /* Analyze inline PLT call relocations to see whether calls to locally
8415    defined functions can be converted to direct calls.  */
8416
8417 bfd_boolean
8418 ppc64_elf_inline_plt (struct bfd_link_info *info)
8419 {
8420   struct ppc_link_hash_table *htab;
8421   bfd *ibfd;
8422   asection *sec;
8423   bfd_vma low_vma, high_vma, limit;
8424
8425   htab = ppc_hash_table (info);
8426   if (htab == NULL)
8427     return FALSE;
8428
8429   /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
8430      reduced somewhat to cater for possible stubs that might be added
8431      between the call and its destination.  */
8432   if (htab->params->group_size < 0)
8433     {
8434       limit = -htab->params->group_size;
8435       if (limit == 1)
8436         limit = 0x1e00000;
8437     }
8438   else
8439     {
8440       limit = htab->params->group_size;
8441       if (limit == 1)
8442         limit = 0x1c00000;
8443     }
8444
8445   low_vma = -1;
8446   high_vma = 0;
8447   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8448     if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8449       {
8450         if (low_vma > sec->vma)
8451           low_vma = sec->vma;
8452         if (high_vma < sec->vma + sec->size)
8453           high_vma = sec->vma + sec->size;
8454       }
8455
8456   /* If a "bl" can reach anywhere in local code sections, then we can
8457      convert all inline PLT sequences to direct calls when the symbol
8458      is local.  */
8459   if (high_vma - low_vma < limit)
8460     {
8461       htab->can_convert_all_inline_plt = 1;
8462       return TRUE;
8463     }
8464
8465   /* Otherwise, go looking through relocs for cases where a direct
8466      call won't reach.  Mark the symbol on any such reloc to disable
8467      the optimization and keep the PLT entry as it seems likely that
8468      this will be better than creating trampolines.  Note that this
8469      will disable the optimization for all inline PLT calls to a
8470      particular symbol, not just those that won't reach.  The
8471      difficulty in doing a more precise optimization is that the
8472      linker needs to make a decision depending on whether a
8473      particular R_PPC64_PLTCALL insn can be turned into a direct
8474      call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8475      the sequence, and there is nothing that ties those relocs
8476      together except their symbol.  */
8477
8478   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8479     {
8480       Elf_Internal_Shdr *symtab_hdr;
8481       Elf_Internal_Sym *local_syms;
8482
8483       if (!is_ppc64_elf (ibfd))
8484         continue;
8485
8486       local_syms = NULL;
8487       symtab_hdr = &elf_symtab_hdr (ibfd);
8488
8489       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8490         if (ppc64_elf_section_data (sec)->has_pltcall
8491             && !bfd_is_abs_section (sec->output_section))
8492           {
8493             Elf_Internal_Rela *relstart, *rel, *relend;
8494
8495             /* Read the relocations.  */
8496             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8497                                                   info->keep_memory);
8498             if (relstart == NULL)
8499               return FALSE;
8500
8501             relend = relstart + sec->reloc_count;
8502             for (rel = relstart; rel < relend; )
8503               {
8504                 enum elf_ppc64_reloc_type r_type;
8505                 unsigned long r_symndx;
8506                 asection *sym_sec;
8507                 struct elf_link_hash_entry *h;
8508                 Elf_Internal_Sym *sym;
8509                 unsigned char *tls_maskp;
8510
8511                 r_type = ELF64_R_TYPE (rel->r_info);
8512                 if (r_type != R_PPC64_PLTCALL)
8513                   continue;
8514
8515                 r_symndx = ELF64_R_SYM (rel->r_info);
8516                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8517                                 r_symndx, ibfd))
8518                   {
8519                     if (elf_section_data (sec)->relocs != relstart)
8520                       free (relstart);
8521                     if (local_syms != NULL
8522                         && symtab_hdr->contents != (unsigned char *) local_syms)
8523                       free (local_syms);
8524                     return FALSE;
8525                   }
8526
8527                 if (sym_sec != NULL && sym_sec->output_section != NULL)
8528                   {
8529                     bfd_vma from, to;
8530                     if (h != NULL)
8531                       to = h->root.u.def.value;
8532                     else
8533                       to = sym->st_value;
8534                     to += (rel->r_addend
8535                            + sym_sec->output_offset
8536                            + sym_sec->output_section->vma);
8537                     from = (rel->r_offset
8538                             + sec->output_offset
8539                             + sec->output_section->vma);
8540                     if (to - from + limit < 2 * limit)
8541                       *tls_maskp &= ~PLT_KEEP;
8542                   }
8543               }
8544             if (elf_section_data (sec)->relocs != relstart)
8545               free (relstart);
8546           }
8547
8548       if (local_syms != NULL
8549           && symtab_hdr->contents != (unsigned char *) local_syms)
8550         {
8551           if (!info->keep_memory)
8552             free (local_syms);
8553           else
8554             symtab_hdr->contents = (unsigned char *) local_syms;
8555         }
8556     }
8557
8558   return TRUE;
8559 }
8560
8561 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8562
8563 asection *
8564 ppc64_elf_tls_setup (struct bfd_link_info *info)
8565 {
8566   struct ppc_link_hash_table *htab;
8567
8568   htab = ppc_hash_table (info);
8569   if (htab == NULL)
8570     return NULL;
8571
8572   if (abiversion (info->output_bfd) == 1)
8573     htab->opd_abi = 1;
8574
8575   if (htab->params->no_multi_toc)
8576     htab->do_multi_toc = 0;
8577   else if (!htab->do_multi_toc)
8578     htab->params->no_multi_toc = 1;
8579
8580   /* Default to --no-plt-localentry, as this option can cause problems
8581      with symbol interposition.  For example, glibc libpthread.so and
8582      libc.so duplicate many pthread symbols, with a fallback
8583      implementation in libc.so.  In some cases the fallback does more
8584      work than the pthread implementation.  __pthread_condattr_destroy
8585      is one such symbol: the libpthread.so implementation is
8586      localentry:0 while the libc.so implementation is localentry:8.
8587      An app that "cleverly" uses dlopen to only load necessary
8588      libraries at runtime may omit loading libpthread.so when not
8589      running multi-threaded, which then results in the libc.so
8590      fallback symbols being used and ld.so complaining.  Now there
8591      are workarounds in ld (see non_zero_localentry) to detect the
8592      pthread situation, but that may not be the only case where
8593      --plt-localentry can cause trouble.  */
8594   if (htab->params->plt_localentry0 < 0)
8595     htab->params->plt_localentry0 = 0;
8596   if (htab->params->plt_localentry0
8597       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8598                                FALSE, FALSE, FALSE) == NULL)
8599     _bfd_error_handler
8600       (_("warning: --plt-localentry is especially dangerous without "
8601          "ld.so support to detect ABI violations"));
8602
8603   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8604                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8605                                               FALSE, FALSE, TRUE));
8606   /* Move dynamic linking info to the function descriptor sym.  */
8607   if (htab->tls_get_addr != NULL)
8608     func_desc_adjust (&htab->tls_get_addr->elf, info);
8609   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8610                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8611                                                  FALSE, FALSE, TRUE));
8612   if (htab->params->tls_get_addr_opt)
8613     {
8614       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8615
8616       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8617                                   FALSE, FALSE, TRUE);
8618       if (opt != NULL)
8619         func_desc_adjust (opt, info);
8620       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8621                                      FALSE, FALSE, TRUE);
8622       if (opt_fd != NULL
8623           && (opt_fd->root.type == bfd_link_hash_defined
8624               || opt_fd->root.type == bfd_link_hash_defweak))
8625         {
8626           /* If glibc supports an optimized __tls_get_addr call stub,
8627              signalled by the presence of __tls_get_addr_opt, and we'll
8628              be calling __tls_get_addr via a plt call stub, then
8629              make __tls_get_addr point to __tls_get_addr_opt.  */
8630           tga_fd = &htab->tls_get_addr_fd->elf;
8631           if (htab->elf.dynamic_sections_created
8632               && tga_fd != NULL
8633               && (tga_fd->type == STT_FUNC
8634                   || tga_fd->needs_plt)
8635               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8636                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8637             {
8638               struct plt_entry *ent;
8639
8640               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8641                 if (ent->plt.refcount > 0)
8642                   break;
8643               if (ent != NULL)
8644                 {
8645                   tga_fd->root.type = bfd_link_hash_indirect;
8646                   tga_fd->root.u.i.link = &opt_fd->root;
8647                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8648                   opt_fd->mark = 1;
8649                   if (opt_fd->dynindx != -1)
8650                     {
8651                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8652                       opt_fd->dynindx = -1;
8653                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8654                                               opt_fd->dynstr_index);
8655                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8656                         return NULL;
8657                     }
8658                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8659                   tga = &htab->tls_get_addr->elf;
8660                   if (opt != NULL && tga != NULL)
8661                     {
8662                       tga->root.type = bfd_link_hash_indirect;
8663                       tga->root.u.i.link = &opt->root;
8664                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8665                       opt->mark = 1;
8666                       _bfd_elf_link_hash_hide_symbol (info, opt,
8667                                                       tga->forced_local);
8668                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8669                     }
8670                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8671                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8672                   if (htab->tls_get_addr != NULL)
8673                     {
8674                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8675                       htab->tls_get_addr->is_func = 1;
8676                     }
8677                 }
8678             }
8679         }
8680       else if (htab->params->tls_get_addr_opt < 0)
8681         htab->params->tls_get_addr_opt = 0;
8682     }
8683   return _bfd_elf_tls_setup (info->output_bfd, info);
8684 }
8685
8686 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8687    HASH1 or HASH2.  */
8688
8689 static bfd_boolean
8690 branch_reloc_hash_match (const bfd *ibfd,
8691                          const Elf_Internal_Rela *rel,
8692                          const struct ppc_link_hash_entry *hash1,
8693                          const struct ppc_link_hash_entry *hash2)
8694 {
8695   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8696   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8697   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8698
8699   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8700     {
8701       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8702       struct elf_link_hash_entry *h;
8703
8704       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8705       h = elf_follow_link (h);
8706       if (h == &hash1->elf || h == &hash2->elf)
8707         return TRUE;
8708     }
8709   return FALSE;
8710 }
8711
8712 /* Run through all the TLS relocs looking for optimization
8713    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8714    a preliminary section layout so that we know the TLS segment
8715    offsets.  We can't optimize earlier because some optimizations need
8716    to know the tp offset, and we need to optimize before allocating
8717    dynamic relocations.  */
8718
8719 bfd_boolean
8720 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8721 {
8722   bfd *ibfd;
8723   asection *sec;
8724   struct ppc_link_hash_table *htab;
8725   unsigned char *toc_ref;
8726   int pass;
8727
8728   if (!bfd_link_executable (info))
8729     return TRUE;
8730
8731   htab = ppc_hash_table (info);
8732   if (htab == NULL)
8733     return FALSE;
8734
8735   /* Make two passes over the relocs.  On the first pass, mark toc
8736      entries involved with tls relocs, and check that tls relocs
8737      involved in setting up a tls_get_addr call are indeed followed by
8738      such a call.  If they are not, we can't do any tls optimization.
8739      On the second pass twiddle tls_mask flags to notify
8740      relocate_section that optimization can be done, and adjust got
8741      and plt refcounts.  */
8742   toc_ref = NULL;
8743   for (pass = 0; pass < 2; ++pass)
8744     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8745       {
8746         Elf_Internal_Sym *locsyms = NULL;
8747         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8748
8749         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8750           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8751             {
8752               Elf_Internal_Rela *relstart, *rel, *relend;
8753               bfd_boolean found_tls_get_addr_arg = 0;
8754
8755               /* Read the relocations.  */
8756               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8757                                                     info->keep_memory);
8758               if (relstart == NULL)
8759                 {
8760                   free (toc_ref);
8761                   return FALSE;
8762                 }
8763
8764               relend = relstart + sec->reloc_count;
8765               for (rel = relstart; rel < relend; rel++)
8766                 {
8767                   enum elf_ppc64_reloc_type r_type;
8768                   unsigned long r_symndx;
8769                   struct elf_link_hash_entry *h;
8770                   Elf_Internal_Sym *sym;
8771                   asection *sym_sec;
8772                   unsigned char *tls_mask;
8773                   unsigned char tls_set, tls_clear, tls_type = 0;
8774                   bfd_vma value;
8775                   bfd_boolean ok_tprel, is_local;
8776                   long toc_ref_index = 0;
8777                   int expecting_tls_get_addr = 0;
8778                   bfd_boolean ret = FALSE;
8779
8780                   r_symndx = ELF64_R_SYM (rel->r_info);
8781                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8782                                   r_symndx, ibfd))
8783                     {
8784                     err_free_rel:
8785                       if (elf_section_data (sec)->relocs != relstart)
8786                         free (relstart);
8787                       if (toc_ref != NULL)
8788                         free (toc_ref);
8789                       if (locsyms != NULL
8790                           && (elf_symtab_hdr (ibfd).contents
8791                               != (unsigned char *) locsyms))
8792                         free (locsyms);
8793                       return ret;
8794                     }
8795
8796                   if (h != NULL)
8797                     {
8798                       if (h->root.type == bfd_link_hash_defined
8799                           || h->root.type == bfd_link_hash_defweak)
8800                         value = h->root.u.def.value;
8801                       else if (h->root.type == bfd_link_hash_undefweak)
8802                         value = 0;
8803                       else
8804                         {
8805                           found_tls_get_addr_arg = 0;
8806                           continue;
8807                         }
8808                     }
8809                   else
8810                     /* Symbols referenced by TLS relocs must be of type
8811                        STT_TLS.  So no need for .opd local sym adjust.  */
8812                     value = sym->st_value;
8813
8814                   ok_tprel = FALSE;
8815                   is_local = FALSE;
8816                   if (h == NULL
8817                       || !h->def_dynamic)
8818                     {
8819                       is_local = TRUE;
8820                       if (h != NULL
8821                           && h->root.type == bfd_link_hash_undefweak)
8822                         ok_tprel = TRUE;
8823                       else if (sym_sec != NULL
8824                                && sym_sec->output_section != NULL)
8825                         {
8826                           value += sym_sec->output_offset;
8827                           value += sym_sec->output_section->vma;
8828                           value -= htab->elf.tls_sec->vma;
8829                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8830                                       < (bfd_vma) 1 << 32);
8831                         }
8832                     }
8833
8834                   r_type = ELF64_R_TYPE (rel->r_info);
8835                   /* If this section has old-style __tls_get_addr calls
8836                      without marker relocs, then check that each
8837                      __tls_get_addr call reloc is preceded by a reloc
8838                      that conceivably belongs to the __tls_get_addr arg
8839                      setup insn.  If we don't find matching arg setup
8840                      relocs, don't do any tls optimization.  */
8841                   if (pass == 0
8842                       && sec->has_tls_get_addr_call
8843                       && h != NULL
8844                       && (h == &htab->tls_get_addr->elf
8845                           || h == &htab->tls_get_addr_fd->elf)
8846                       && !found_tls_get_addr_arg
8847                       && is_branch_reloc (r_type))
8848                     {
8849                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8850                                                 "TLS optimization disabled\n"),
8851                                               ibfd, sec, rel->r_offset);
8852                       ret = TRUE;
8853                       goto err_free_rel;
8854                     }
8855
8856                   found_tls_get_addr_arg = 0;
8857                   switch (r_type)
8858                     {
8859                     case R_PPC64_GOT_TLSLD16:
8860                     case R_PPC64_GOT_TLSLD16_LO:
8861                       expecting_tls_get_addr = 1;
8862                       found_tls_get_addr_arg = 1;
8863                       /* Fall through.  */
8864
8865                     case R_PPC64_GOT_TLSLD16_HI:
8866                     case R_PPC64_GOT_TLSLD16_HA:
8867                       /* These relocs should never be against a symbol
8868                          defined in a shared lib.  Leave them alone if
8869                          that turns out to be the case.  */
8870                       if (!is_local)
8871                         continue;
8872
8873                       /* LD -> LE */
8874                       tls_set = 0;
8875                       tls_clear = TLS_LD;
8876                       tls_type = TLS_TLS | TLS_LD;
8877                       break;
8878
8879                     case R_PPC64_GOT_TLSGD16:
8880                     case R_PPC64_GOT_TLSGD16_LO:
8881                       expecting_tls_get_addr = 1;
8882                       found_tls_get_addr_arg = 1;
8883                       /* Fall through. */
8884
8885                     case R_PPC64_GOT_TLSGD16_HI:
8886                     case R_PPC64_GOT_TLSGD16_HA:
8887                       if (ok_tprel)
8888                         /* GD -> LE */
8889                         tls_set = 0;
8890                       else
8891                         /* GD -> IE */
8892                         tls_set = TLS_TLS | TLS_TPRELGD;
8893                       tls_clear = TLS_GD;
8894                       tls_type = TLS_TLS | TLS_GD;
8895                       break;
8896
8897                     case R_PPC64_GOT_TPREL16_DS:
8898                     case R_PPC64_GOT_TPREL16_LO_DS:
8899                     case R_PPC64_GOT_TPREL16_HI:
8900                     case R_PPC64_GOT_TPREL16_HA:
8901                       if (ok_tprel)
8902                         {
8903                           /* IE -> LE */
8904                           tls_set = 0;
8905                           tls_clear = TLS_TPREL;
8906                           tls_type = TLS_TLS | TLS_TPREL;
8907                           break;
8908                         }
8909                       continue;
8910
8911                     case R_PPC64_TLSGD:
8912                     case R_PPC64_TLSLD:
8913                       if (rel + 1 < relend
8914                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8915                         {
8916                           if (pass != 0
8917                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8918                             {
8919                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8920                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8921                                   r_symndx, ibfd))
8922                                 goto err_free_rel;
8923                               if (h != NULL)
8924                                 {
8925                                   struct plt_entry *ent = NULL;
8926
8927                                   for (ent = h->plt.plist;
8928                                        ent != NULL;
8929                                        ent = ent->next)
8930                                     if (ent->addend == rel[1].r_addend)
8931                                       break;
8932
8933                                   if (ent != NULL
8934                                       && ent->plt.refcount > 0)
8935                                     ent->plt.refcount -= 1;
8936                                 }
8937                             }
8938                           continue;
8939                         }
8940                       found_tls_get_addr_arg = 1;
8941                       /* Fall through.  */
8942
8943                     case R_PPC64_TLS:
8944                     case R_PPC64_TOC16:
8945                     case R_PPC64_TOC16_LO:
8946                       if (sym_sec == NULL || sym_sec != toc)
8947                         continue;
8948
8949                       /* Mark this toc entry as referenced by a TLS
8950                          code sequence.  We can do that now in the
8951                          case of R_PPC64_TLS, and after checking for
8952                          tls_get_addr for the TOC16 relocs.  */
8953                       if (toc_ref == NULL)
8954                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8955                       if (toc_ref == NULL)
8956                         goto err_free_rel;
8957
8958                       if (h != NULL)
8959                         value = h->root.u.def.value;
8960                       else
8961                         value = sym->st_value;
8962                       value += rel->r_addend;
8963                       if (value % 8 != 0)
8964                         continue;
8965                       BFD_ASSERT (value < toc->size
8966                                   && toc->output_offset % 8 == 0);
8967                       toc_ref_index = (value + toc->output_offset) / 8;
8968                       if (r_type == R_PPC64_TLS
8969                           || r_type == R_PPC64_TLSGD
8970                           || r_type == R_PPC64_TLSLD)
8971                         {
8972                           toc_ref[toc_ref_index] = 1;
8973                           continue;
8974                         }
8975
8976                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8977                         continue;
8978
8979                       tls_set = 0;
8980                       tls_clear = 0;
8981                       expecting_tls_get_addr = 2;
8982                       break;
8983
8984                     case R_PPC64_TPREL64:
8985                       if (pass == 0
8986                           || sec != toc
8987                           || toc_ref == NULL
8988                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8989                         continue;
8990                       if (ok_tprel)
8991                         {
8992                           /* IE -> LE */
8993                           tls_set = TLS_EXPLICIT;
8994                           tls_clear = TLS_TPREL;
8995                           break;
8996                         }
8997                       continue;
8998
8999                     case R_PPC64_DTPMOD64:
9000                       if (pass == 0
9001                           || sec != toc
9002                           || toc_ref == NULL
9003                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
9004                         continue;
9005                       if (rel + 1 < relend
9006                           && (rel[1].r_info
9007                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
9008                           && rel[1].r_offset == rel->r_offset + 8)
9009                         {
9010                           if (ok_tprel)
9011                             /* GD -> LE */
9012                             tls_set = TLS_EXPLICIT | TLS_GD;
9013                           else
9014                             /* GD -> IE */
9015                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
9016                           tls_clear = TLS_GD;
9017                         }
9018                       else
9019                         {
9020                           if (!is_local)
9021                             continue;
9022
9023                           /* LD -> LE */
9024                           tls_set = TLS_EXPLICIT;
9025                           tls_clear = TLS_LD;
9026                         }
9027                       break;
9028
9029                     default:
9030                       continue;
9031                     }
9032
9033                   if (pass == 0)
9034                     {
9035                       if (!expecting_tls_get_addr
9036                           || !sec->has_tls_get_addr_call)
9037                         continue;
9038
9039                       if (rel + 1 < relend
9040                           && branch_reloc_hash_match (ibfd, rel + 1,
9041                                                       htab->tls_get_addr,
9042                                                       htab->tls_get_addr_fd))
9043                         {
9044                           if (expecting_tls_get_addr == 2)
9045                             {
9046                               /* Check for toc tls entries.  */
9047                               unsigned char *toc_tls;
9048                               int retval;
9049
9050                               retval = get_tls_mask (&toc_tls, NULL, NULL,
9051                                                      &locsyms,
9052                                                      rel, ibfd);
9053                               if (retval == 0)
9054                                 goto err_free_rel;
9055                               if (toc_tls != NULL)
9056                                 {
9057                                   if ((*toc_tls & TLS_TLS) != 0
9058                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
9059                                     found_tls_get_addr_arg = 1;
9060                                   if (retval > 1)
9061                                     toc_ref[toc_ref_index] = 1;
9062                                 }
9063                             }
9064                           continue;
9065                         }
9066
9067                       /* Uh oh, we didn't find the expected call.  We
9068                          could just mark this symbol to exclude it
9069                          from tls optimization but it's safer to skip
9070                          the entire optimization.  */
9071                       /* xgettext:c-format */
9072                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
9073                                                 "TLS optimization disabled\n"),
9074                                               ibfd, sec, rel->r_offset);
9075                       ret = TRUE;
9076                       goto err_free_rel;
9077                     }
9078
9079                   /* If we don't have old-style __tls_get_addr calls
9080                      without TLSGD/TLSLD marker relocs, and we haven't
9081                      found a new-style __tls_get_addr call with a
9082                      marker for this symbol, then we either have a
9083                      broken object file or an -mlongcall style
9084                      indirect call to __tls_get_addr without a marker.
9085                      Disable optimization in this case.  */
9086                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
9087                       && (tls_set & TLS_EXPLICIT) == 0
9088                       && !sec->has_tls_get_addr_call
9089                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
9090                           != (TLS_TLS | TLS_MARK)))
9091                     continue;
9092
9093                   if (expecting_tls_get_addr)
9094                     {
9095                       struct plt_entry *ent = NULL;
9096
9097                       if (htab->tls_get_addr != NULL)
9098                         for (ent = htab->tls_get_addr->elf.plt.plist;
9099                              ent != NULL;
9100                              ent = ent->next)
9101                           if (ent->addend == 0)
9102                             break;
9103
9104                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
9105                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
9106                              ent != NULL;
9107                              ent = ent->next)
9108                           if (ent->addend == 0)
9109                             break;
9110
9111                       if (ent != NULL
9112                           && ent->plt.refcount > 0)
9113                         ent->plt.refcount -= 1;
9114                     }
9115
9116                   if (tls_clear == 0)
9117                     continue;
9118
9119                   if ((tls_set & TLS_EXPLICIT) == 0)
9120                     {
9121                       struct got_entry *ent;
9122
9123                       /* Adjust got entry for this reloc.  */
9124                       if (h != NULL)
9125                         ent = h->got.glist;
9126                       else
9127                         ent = elf_local_got_ents (ibfd)[r_symndx];
9128
9129                       for (; ent != NULL; ent = ent->next)
9130                         if (ent->addend == rel->r_addend
9131                             && ent->owner == ibfd
9132                             && ent->tls_type == tls_type)
9133                           break;
9134                       if (ent == NULL)
9135                         abort ();
9136
9137                       if (tls_set == 0)
9138                         {
9139                           /* We managed to get rid of a got entry.  */
9140                           if (ent->got.refcount > 0)
9141                             ent->got.refcount -= 1;
9142                         }
9143                     }
9144                   else
9145                     {
9146                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
9147                          we'll lose one or two dyn relocs.  */
9148                       if (!dec_dynrel_count (rel->r_info, sec, info,
9149                                              NULL, h, sym))
9150                         return FALSE;
9151
9152                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
9153                         {
9154                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9155                                                  NULL, h, sym))
9156                             return FALSE;
9157                         }
9158                     }
9159
9160                   *tls_mask |= tls_set;
9161                   *tls_mask &= ~tls_clear;
9162                 }
9163
9164               if (elf_section_data (sec)->relocs != relstart)
9165                 free (relstart);
9166             }
9167
9168         if (locsyms != NULL
9169             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9170           {
9171             if (!info->keep_memory)
9172               free (locsyms);
9173             else
9174               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9175           }
9176       }
9177
9178   if (toc_ref != NULL)
9179     free (toc_ref);
9180   htab->do_tls_opt = 1;
9181   return TRUE;
9182 }
9183
9184 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9185    the values of any global symbols in a toc section that has been
9186    edited.  Globals in toc sections should be a rarity, so this function
9187    sets a flag if any are found in toc sections other than the one just
9188    edited, so that further hash table traversals can be avoided.  */
9189
9190 struct adjust_toc_info
9191 {
9192   asection *toc;
9193   unsigned long *skip;
9194   bfd_boolean global_toc_syms;
9195 };
9196
9197 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9198
9199 static bfd_boolean
9200 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9201 {
9202   struct ppc_link_hash_entry *eh;
9203   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9204   unsigned long i;
9205
9206   if (h->root.type != bfd_link_hash_defined
9207       && h->root.type != bfd_link_hash_defweak)
9208     return TRUE;
9209
9210   eh = (struct ppc_link_hash_entry *) h;
9211   if (eh->adjust_done)
9212     return TRUE;
9213
9214   if (eh->elf.root.u.def.section == toc_inf->toc)
9215     {
9216       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9217         i = toc_inf->toc->rawsize >> 3;
9218       else
9219         i = eh->elf.root.u.def.value >> 3;
9220
9221       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9222         {
9223           _bfd_error_handler
9224             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9225           do
9226             ++i;
9227           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9228           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9229         }
9230
9231       eh->elf.root.u.def.value -= toc_inf->skip[i];
9232       eh->adjust_done = 1;
9233     }
9234   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9235     toc_inf->global_toc_syms = TRUE;
9236
9237   return TRUE;
9238 }
9239
9240 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9241    on a _LO variety toc/got reloc.  */
9242
9243 static bfd_boolean
9244 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9245 {
9246   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9247           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9248           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9249           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9250           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9251           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9252           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9253           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9254           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9255           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9256           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9257           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9258           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9259           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9260           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9261           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9262           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9263               /* Exclude lfqu by testing reloc.  If relocs are ever
9264                  defined for the reduced D field in psq_lu then those
9265                  will need testing too.  */
9266               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9267           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9268               && (insn & 1) == 0)
9269           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9270           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9271               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9272               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9273           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9274               && (insn & 1) == 0));
9275 }
9276
9277 /* Examine all relocs referencing .toc sections in order to remove
9278    unused .toc entries.  */
9279
9280 bfd_boolean
9281 ppc64_elf_edit_toc (struct bfd_link_info *info)
9282 {
9283   bfd *ibfd;
9284   struct adjust_toc_info toc_inf;
9285   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9286
9287   htab->do_toc_opt = 1;
9288   toc_inf.global_toc_syms = TRUE;
9289   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9290     {
9291       asection *toc, *sec;
9292       Elf_Internal_Shdr *symtab_hdr;
9293       Elf_Internal_Sym *local_syms;
9294       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9295       unsigned long *skip, *drop;
9296       unsigned char *used;
9297       unsigned char *keep, last, some_unused;
9298
9299       if (!is_ppc64_elf (ibfd))
9300         continue;
9301
9302       toc = bfd_get_section_by_name (ibfd, ".toc");
9303       if (toc == NULL
9304           || toc->size == 0
9305           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9306           || discarded_section (toc))
9307         continue;
9308
9309       toc_relocs = NULL;
9310       local_syms = NULL;
9311       symtab_hdr = &elf_symtab_hdr (ibfd);
9312
9313       /* Look at sections dropped from the final link.  */
9314       skip = NULL;
9315       relstart = NULL;
9316       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9317         {
9318           if (sec->reloc_count == 0
9319               || !discarded_section (sec)
9320               || get_opd_info (sec)
9321               || (sec->flags & SEC_ALLOC) == 0
9322               || (sec->flags & SEC_DEBUGGING) != 0)
9323             continue;
9324
9325           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9326           if (relstart == NULL)
9327             goto error_ret;
9328
9329           /* Run through the relocs to see which toc entries might be
9330              unused.  */
9331           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9332             {
9333               enum elf_ppc64_reloc_type r_type;
9334               unsigned long r_symndx;
9335               asection *sym_sec;
9336               struct elf_link_hash_entry *h;
9337               Elf_Internal_Sym *sym;
9338               bfd_vma val;
9339
9340               r_type = ELF64_R_TYPE (rel->r_info);
9341               switch (r_type)
9342                 {
9343                 default:
9344                   continue;
9345
9346                 case R_PPC64_TOC16:
9347                 case R_PPC64_TOC16_LO:
9348                 case R_PPC64_TOC16_HI:
9349                 case R_PPC64_TOC16_HA:
9350                 case R_PPC64_TOC16_DS:
9351                 case R_PPC64_TOC16_LO_DS:
9352                   break;
9353                 }
9354
9355               r_symndx = ELF64_R_SYM (rel->r_info);
9356               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9357                               r_symndx, ibfd))
9358                 goto error_ret;
9359
9360               if (sym_sec != toc)
9361                 continue;
9362
9363               if (h != NULL)
9364                 val = h->root.u.def.value;
9365               else
9366                 val = sym->st_value;
9367               val += rel->r_addend;
9368
9369               if (val >= toc->size)
9370                 continue;
9371
9372               /* Anything in the toc ought to be aligned to 8 bytes.
9373                  If not, don't mark as unused.  */
9374               if (val & 7)
9375                 continue;
9376
9377               if (skip == NULL)
9378                 {
9379                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9380                   if (skip == NULL)
9381                     goto error_ret;
9382                 }
9383
9384               skip[val >> 3] = ref_from_discarded;
9385             }
9386
9387           if (elf_section_data (sec)->relocs != relstart)
9388             free (relstart);
9389         }
9390
9391       /* For largetoc loads of address constants, we can convert
9392          .  addis rx,2,addr@got@ha
9393          .  ld ry,addr@got@l(rx)
9394          to
9395          .  addis rx,2,addr@toc@ha
9396          .  addi ry,rx,addr@toc@l
9397          when addr is within 2G of the toc pointer.  This then means
9398          that the word storing "addr" in the toc is no longer needed.  */
9399
9400       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9401           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9402           && toc->reloc_count != 0)
9403         {
9404           /* Read toc relocs.  */
9405           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9406                                                   info->keep_memory);
9407           if (toc_relocs == NULL)
9408             goto error_ret;
9409
9410           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9411             {
9412               enum elf_ppc64_reloc_type r_type;
9413               unsigned long r_symndx;
9414               asection *sym_sec;
9415               struct elf_link_hash_entry *h;
9416               Elf_Internal_Sym *sym;
9417               bfd_vma val, addr;
9418
9419               r_type = ELF64_R_TYPE (rel->r_info);
9420               if (r_type != R_PPC64_ADDR64)
9421                 continue;
9422
9423               r_symndx = ELF64_R_SYM (rel->r_info);
9424               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9425                               r_symndx, ibfd))
9426                 goto error_ret;
9427
9428               if (sym_sec == NULL
9429                   || sym_sec->output_section == NULL
9430                   || discarded_section (sym_sec))
9431                 continue;
9432
9433               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9434                 continue;
9435
9436               if (h != NULL)
9437                 {
9438                   if (h->type == STT_GNU_IFUNC)
9439                     continue;
9440                   val = h->root.u.def.value;
9441                 }
9442               else
9443                 {
9444                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9445                     continue;
9446                   val = sym->st_value;
9447                 }
9448               val += rel->r_addend;
9449               val += sym_sec->output_section->vma + sym_sec->output_offset;
9450
9451               /* We don't yet know the exact toc pointer value, but we
9452                  know it will be somewhere in the toc section.  Don't
9453                  optimize if the difference from any possible toc
9454                  pointer is outside [ff..f80008000, 7fff7fff].  */
9455               addr = toc->output_section->vma + TOC_BASE_OFF;
9456               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9457                 continue;
9458
9459               addr = toc->output_section->vma + toc->output_section->rawsize;
9460               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9461                 continue;
9462
9463               if (skip == NULL)
9464                 {
9465                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9466                   if (skip == NULL)
9467                     goto error_ret;
9468                 }
9469
9470               skip[rel->r_offset >> 3]
9471                 |= can_optimize | ((rel - toc_relocs) << 2);
9472             }
9473         }
9474
9475       if (skip == NULL)
9476         continue;
9477
9478       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9479       if (used == NULL)
9480         {
9481         error_ret:
9482           if (local_syms != NULL
9483               && symtab_hdr->contents != (unsigned char *) local_syms)
9484             free (local_syms);
9485           if (sec != NULL
9486               && relstart != NULL
9487               && elf_section_data (sec)->relocs != relstart)
9488             free (relstart);
9489           if (toc_relocs != NULL
9490               && elf_section_data (toc)->relocs != toc_relocs)
9491             free (toc_relocs);
9492           if (skip != NULL)
9493             free (skip);
9494           return FALSE;
9495         }
9496
9497       /* Now check all kept sections that might reference the toc.
9498          Check the toc itself last.  */
9499       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9500                   : ibfd->sections);
9501            sec != NULL;
9502            sec = (sec == toc ? NULL
9503                   : sec->next == NULL ? toc
9504                   : sec->next == toc && toc->next ? toc->next
9505                   : sec->next))
9506         {
9507           int repeat;
9508
9509           if (sec->reloc_count == 0
9510               || discarded_section (sec)
9511               || get_opd_info (sec)
9512               || (sec->flags & SEC_ALLOC) == 0
9513               || (sec->flags & SEC_DEBUGGING) != 0)
9514             continue;
9515
9516           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9517                                                 info->keep_memory);
9518           if (relstart == NULL)
9519             {
9520               free (used);
9521               goto error_ret;
9522             }
9523
9524           /* Mark toc entries referenced as used.  */
9525           do
9526             {
9527               repeat = 0;
9528               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9529                 {
9530                   enum elf_ppc64_reloc_type r_type;
9531                   unsigned long r_symndx;
9532                   asection *sym_sec;
9533                   struct elf_link_hash_entry *h;
9534                   Elf_Internal_Sym *sym;
9535                   bfd_vma val;
9536                   enum {no_check, check_lo, check_ha} insn_check;
9537
9538                   r_type = ELF64_R_TYPE (rel->r_info);
9539                   switch (r_type)
9540                     {
9541                     default:
9542                       insn_check = no_check;
9543                       break;
9544
9545                     case R_PPC64_GOT_TLSLD16_HA:
9546                     case R_PPC64_GOT_TLSGD16_HA:
9547                     case R_PPC64_GOT_TPREL16_HA:
9548                     case R_PPC64_GOT_DTPREL16_HA:
9549                     case R_PPC64_GOT16_HA:
9550                     case R_PPC64_TOC16_HA:
9551                       insn_check = check_ha;
9552                       break;
9553
9554                     case R_PPC64_GOT_TLSLD16_LO:
9555                     case R_PPC64_GOT_TLSGD16_LO:
9556                     case R_PPC64_GOT_TPREL16_LO_DS:
9557                     case R_PPC64_GOT_DTPREL16_LO_DS:
9558                     case R_PPC64_GOT16_LO:
9559                     case R_PPC64_GOT16_LO_DS:
9560                     case R_PPC64_TOC16_LO:
9561                     case R_PPC64_TOC16_LO_DS:
9562                       insn_check = check_lo;
9563                       break;
9564                     }
9565
9566                   if (insn_check != no_check)
9567                     {
9568                       bfd_vma off = rel->r_offset & ~3;
9569                       unsigned char buf[4];
9570                       unsigned int insn;
9571
9572                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9573                         {
9574                           free (used);
9575                           goto error_ret;
9576                         }
9577                       insn = bfd_get_32 (ibfd, buf);
9578                       if (insn_check == check_lo
9579                           ? !ok_lo_toc_insn (insn, r_type)
9580                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9581                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9582                         {
9583                           char str[12];
9584
9585                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9586                           sprintf (str, "%#08x", insn);
9587                           info->callbacks->einfo
9588                             /* xgettext:c-format */
9589                             (_("%H: toc optimization is not supported for"
9590                                " %s instruction\n"),
9591                              ibfd, sec, rel->r_offset & ~3, str);
9592                         }
9593                     }
9594
9595                   switch (r_type)
9596                     {
9597                     case R_PPC64_TOC16:
9598                     case R_PPC64_TOC16_LO:
9599                     case R_PPC64_TOC16_HI:
9600                     case R_PPC64_TOC16_HA:
9601                     case R_PPC64_TOC16_DS:
9602                     case R_PPC64_TOC16_LO_DS:
9603                       /* In case we're taking addresses of toc entries.  */
9604                     case R_PPC64_ADDR64:
9605                       break;
9606
9607                     default:
9608                       continue;
9609                     }
9610
9611                   r_symndx = ELF64_R_SYM (rel->r_info);
9612                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9613                                   r_symndx, ibfd))
9614                     {
9615                       free (used);
9616                       goto error_ret;
9617                     }
9618
9619                   if (sym_sec != toc)
9620                     continue;
9621
9622                   if (h != NULL)
9623                     val = h->root.u.def.value;
9624                   else
9625                     val = sym->st_value;
9626                   val += rel->r_addend;
9627
9628                   if (val >= toc->size)
9629                     continue;
9630
9631                   if ((skip[val >> 3] & can_optimize) != 0)
9632                     {
9633                       bfd_vma off;
9634                       unsigned char opc;
9635
9636                       switch (r_type)
9637                         {
9638                         case R_PPC64_TOC16_HA:
9639                           break;
9640
9641                         case R_PPC64_TOC16_LO_DS:
9642                           off = rel->r_offset;
9643                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9644                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9645                                                          off, 1))
9646                             {
9647                               free (used);
9648                               goto error_ret;
9649                             }
9650                           if ((opc & (0x3f << 2)) == (58u << 2))
9651                             break;
9652                           /* Fall through.  */
9653
9654                         default:
9655                           /* Wrong sort of reloc, or not a ld.  We may
9656                              as well clear ref_from_discarded too.  */
9657                           skip[val >> 3] = 0;
9658                         }
9659                     }
9660
9661                   if (sec != toc)
9662                     used[val >> 3] = 1;
9663                   /* For the toc section, we only mark as used if this
9664                      entry itself isn't unused.  */
9665                   else if ((used[rel->r_offset >> 3]
9666                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9667                            && !used[val >> 3])
9668                     {
9669                       /* Do all the relocs again, to catch reference
9670                          chains.  */
9671                       repeat = 1;
9672                       used[val >> 3] = 1;
9673                     }
9674                 }
9675             }
9676           while (repeat);
9677
9678           if (elf_section_data (sec)->relocs != relstart)
9679             free (relstart);
9680         }
9681
9682       /* Merge the used and skip arrays.  Assume that TOC
9683          doublewords not appearing as either used or unused belong
9684          to an entry more than one doubleword in size.  */
9685       for (drop = skip, keep = used, last = 0, some_unused = 0;
9686            drop < skip + (toc->size + 7) / 8;
9687            ++drop, ++keep)
9688         {
9689           if (*keep)
9690             {
9691               *drop &= ~ref_from_discarded;
9692               if ((*drop & can_optimize) != 0)
9693                 some_unused = 1;
9694               last = 0;
9695             }
9696           else if ((*drop & ref_from_discarded) != 0)
9697             {
9698               some_unused = 1;
9699               last = ref_from_discarded;
9700             }
9701           else
9702             *drop = last;
9703         }
9704
9705       free (used);
9706
9707       if (some_unused)
9708         {
9709           bfd_byte *contents, *src;
9710           unsigned long off;
9711           Elf_Internal_Sym *sym;
9712           bfd_boolean local_toc_syms = FALSE;
9713
9714           /* Shuffle the toc contents, and at the same time convert the
9715              skip array from booleans into offsets.  */
9716           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9717             goto error_ret;
9718
9719           elf_section_data (toc)->this_hdr.contents = contents;
9720
9721           for (src = contents, off = 0, drop = skip;
9722                src < contents + toc->size;
9723                src += 8, ++drop)
9724             {
9725               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9726                 off += 8;
9727               else if (off != 0)
9728                 {
9729                   *drop = off;
9730                   memcpy (src - off, src, 8);
9731                 }
9732             }
9733           *drop = off;
9734           toc->rawsize = toc->size;
9735           toc->size = src - contents - off;
9736
9737           /* Adjust addends for relocs against the toc section sym,
9738              and optimize any accesses we can.  */
9739           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9740             {
9741               if (sec->reloc_count == 0
9742                   || discarded_section (sec))
9743                 continue;
9744
9745               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9746                                                     info->keep_memory);
9747               if (relstart == NULL)
9748                 goto error_ret;
9749
9750               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9751                 {
9752                   enum elf_ppc64_reloc_type r_type;
9753                   unsigned long r_symndx;
9754                   asection *sym_sec;
9755                   struct elf_link_hash_entry *h;
9756                   bfd_vma val;
9757
9758                   r_type = ELF64_R_TYPE (rel->r_info);
9759                   switch (r_type)
9760                     {
9761                     default:
9762                       continue;
9763
9764                     case R_PPC64_TOC16:
9765                     case R_PPC64_TOC16_LO:
9766                     case R_PPC64_TOC16_HI:
9767                     case R_PPC64_TOC16_HA:
9768                     case R_PPC64_TOC16_DS:
9769                     case R_PPC64_TOC16_LO_DS:
9770                     case R_PPC64_ADDR64:
9771                       break;
9772                     }
9773
9774                   r_symndx = ELF64_R_SYM (rel->r_info);
9775                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9776                                   r_symndx, ibfd))
9777                     goto error_ret;
9778
9779                   if (sym_sec != toc)
9780                     continue;
9781
9782                   if (h != NULL)
9783                     val = h->root.u.def.value;
9784                   else
9785                     {
9786                       val = sym->st_value;
9787                       if (val != 0)
9788                         local_toc_syms = TRUE;
9789                     }
9790
9791                   val += rel->r_addend;
9792
9793                   if (val > toc->rawsize)
9794                     val = toc->rawsize;
9795                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9796                     continue;
9797                   else if ((skip[val >> 3] & can_optimize) != 0)
9798                     {
9799                       Elf_Internal_Rela *tocrel
9800                         = toc_relocs + (skip[val >> 3] >> 2);
9801                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9802
9803                       switch (r_type)
9804                         {
9805                         case R_PPC64_TOC16_HA:
9806                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9807                           break;
9808
9809                         case R_PPC64_TOC16_LO_DS:
9810                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9811                           break;
9812
9813                         default:
9814                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9815                             ppc_howto_init ();
9816                           info->callbacks->einfo
9817                             /* xgettext:c-format */
9818                             (_("%H: %s references "
9819                                "optimized away TOC entry\n"),
9820                              ibfd, sec, rel->r_offset,
9821                              ppc64_elf_howto_table[r_type]->name);
9822                           bfd_set_error (bfd_error_bad_value);
9823                           goto error_ret;
9824                         }
9825                       rel->r_addend = tocrel->r_addend;
9826                       elf_section_data (sec)->relocs = relstart;
9827                       continue;
9828                     }
9829
9830                   if (h != NULL || sym->st_value != 0)
9831                     continue;
9832
9833                   rel->r_addend -= skip[val >> 3];
9834                   elf_section_data (sec)->relocs = relstart;
9835                 }
9836
9837               if (elf_section_data (sec)->relocs != relstart)
9838                 free (relstart);
9839             }
9840
9841           /* We shouldn't have local or global symbols defined in the TOC,
9842              but handle them anyway.  */
9843           if (local_syms != NULL)
9844             for (sym = local_syms;
9845                  sym < local_syms + symtab_hdr->sh_info;
9846                  ++sym)
9847               if (sym->st_value != 0
9848                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9849                 {
9850                   unsigned long i;
9851
9852                   if (sym->st_value > toc->rawsize)
9853                     i = toc->rawsize >> 3;
9854                   else
9855                     i = sym->st_value >> 3;
9856
9857                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9858                     {
9859                       if (local_toc_syms)
9860                         _bfd_error_handler
9861                           (_("%s defined on removed toc entry"),
9862                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9863                       do
9864                         ++i;
9865                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9866                       sym->st_value = (bfd_vma) i << 3;
9867                     }
9868
9869                   sym->st_value -= skip[i];
9870                   symtab_hdr->contents = (unsigned char *) local_syms;
9871                 }
9872
9873           /* Adjust any global syms defined in this toc input section.  */
9874           if (toc_inf.global_toc_syms)
9875             {
9876               toc_inf.toc = toc;
9877               toc_inf.skip = skip;
9878               toc_inf.global_toc_syms = FALSE;
9879               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9880                                       &toc_inf);
9881             }
9882
9883           if (toc->reloc_count != 0)
9884             {
9885               Elf_Internal_Shdr *rel_hdr;
9886               Elf_Internal_Rela *wrel;
9887               bfd_size_type sz;
9888
9889               /* Remove unused toc relocs, and adjust those we keep.  */
9890               if (toc_relocs == NULL)
9891                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9892                                                         info->keep_memory);
9893               if (toc_relocs == NULL)
9894                 goto error_ret;
9895
9896               wrel = toc_relocs;
9897               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9898                 if ((skip[rel->r_offset >> 3]
9899                      & (ref_from_discarded | can_optimize)) == 0)
9900                   {
9901                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9902                     wrel->r_info = rel->r_info;
9903                     wrel->r_addend = rel->r_addend;
9904                     ++wrel;
9905                   }
9906                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9907                                             &local_syms, NULL, NULL))
9908                   goto error_ret;
9909
9910               elf_section_data (toc)->relocs = toc_relocs;
9911               toc->reloc_count = wrel - toc_relocs;
9912               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9913               sz = rel_hdr->sh_entsize;
9914               rel_hdr->sh_size = toc->reloc_count * sz;
9915             }
9916         }
9917       else if (toc_relocs != NULL
9918                && elf_section_data (toc)->relocs != toc_relocs)
9919         free (toc_relocs);
9920
9921       if (local_syms != NULL
9922           && symtab_hdr->contents != (unsigned char *) local_syms)
9923         {
9924           if (!info->keep_memory)
9925             free (local_syms);
9926           else
9927             symtab_hdr->contents = (unsigned char *) local_syms;
9928         }
9929       free (skip);
9930     }
9931
9932   return TRUE;
9933 }
9934
9935 /* Return true iff input section I references the TOC using
9936    instructions limited to +/-32k offsets.  */
9937
9938 bfd_boolean
9939 ppc64_elf_has_small_toc_reloc (asection *i)
9940 {
9941   return (is_ppc64_elf (i->owner)
9942           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9943 }
9944
9945 /* Allocate space for one GOT entry.  */
9946
9947 static void
9948 allocate_got (struct elf_link_hash_entry *h,
9949               struct bfd_link_info *info,
9950               struct got_entry *gent)
9951 {
9952   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9953   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9954   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9955                  ? 16 : 8);
9956   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9957                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9958   asection *got = ppc64_elf_tdata (gent->owner)->got;
9959
9960   gent->got.offset = got->size;
9961   got->size += entsize;
9962
9963   if (h->type == STT_GNU_IFUNC)
9964     {
9965       htab->elf.irelplt->size += rentsize;
9966       htab->got_reli_size += rentsize;
9967     }
9968   else if (((bfd_link_pic (info)
9969              && !((gent->tls_type & TLS_TPREL) != 0
9970                   && bfd_link_executable (info)
9971                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9972             || (htab->elf.dynamic_sections_created
9973                 && h->dynindx != -1
9974                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9975            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9976     {
9977       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9978       relgot->size += rentsize;
9979     }
9980 }
9981
9982 /* This function merges got entries in the same toc group.  */
9983
9984 static void
9985 merge_got_entries (struct got_entry **pent)
9986 {
9987   struct got_entry *ent, *ent2;
9988
9989   for (ent = *pent; ent != NULL; ent = ent->next)
9990     if (!ent->is_indirect)
9991       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9992         if (!ent2->is_indirect
9993             && ent2->addend == ent->addend
9994             && ent2->tls_type == ent->tls_type
9995             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9996           {
9997             ent2->is_indirect = TRUE;
9998             ent2->got.ent = ent;
9999           }
10000 }
10001
10002 /* If H is undefined, make it dynamic if that makes sense.  */
10003
10004 static bfd_boolean
10005 ensure_undef_dynamic (struct bfd_link_info *info,
10006                       struct elf_link_hash_entry *h)
10007 {
10008   struct elf_link_hash_table *htab = elf_hash_table (info);
10009
10010   if (htab->dynamic_sections_created
10011       && ((info->dynamic_undefined_weak != 0
10012            && h->root.type == bfd_link_hash_undefweak)
10013           || h->root.type == bfd_link_hash_undefined)
10014       && h->dynindx == -1
10015       && !h->forced_local
10016       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
10017     return bfd_elf_link_record_dynamic_symbol (info, h);
10018   return TRUE;
10019 }
10020
10021 /* Allocate space in .plt, .got and associated reloc sections for
10022    dynamic relocs.  */
10023
10024 static bfd_boolean
10025 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
10026 {
10027   struct bfd_link_info *info;
10028   struct ppc_link_hash_table *htab;
10029   asection *s;
10030   struct ppc_link_hash_entry *eh;
10031   struct got_entry **pgent, *gent;
10032
10033   if (h->root.type == bfd_link_hash_indirect)
10034     return TRUE;
10035
10036   info = (struct bfd_link_info *) inf;
10037   htab = ppc_hash_table (info);
10038   if (htab == NULL)
10039     return FALSE;
10040
10041   eh = (struct ppc_link_hash_entry *) h;
10042   /* Run through the TLS GD got entries first if we're changing them
10043      to TPREL.  */
10044   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
10045     for (gent = h->got.glist; gent != NULL; gent = gent->next)
10046       if (gent->got.refcount > 0
10047           && (gent->tls_type & TLS_GD) != 0)
10048         {
10049           /* This was a GD entry that has been converted to TPREL.  If
10050              there happens to be a TPREL entry we can use that one.  */
10051           struct got_entry *ent;
10052           for (ent = h->got.glist; ent != NULL; ent = ent->next)
10053             if (ent->got.refcount > 0
10054                 && (ent->tls_type & TLS_TPREL) != 0
10055                 && ent->addend == gent->addend
10056                 && ent->owner == gent->owner)
10057               {
10058                 gent->got.refcount = 0;
10059                 break;
10060               }
10061
10062           /* If not, then we'll be using our own TPREL entry.  */
10063           if (gent->got.refcount != 0)
10064             gent->tls_type = TLS_TLS | TLS_TPREL;
10065         }
10066
10067   /* Remove any list entry that won't generate a word in the GOT before
10068      we call merge_got_entries.  Otherwise we risk merging to empty
10069      entries.  */
10070   pgent = &h->got.glist;
10071   while ((gent = *pgent) != NULL)
10072     if (gent->got.refcount > 0)
10073       {
10074         if ((gent->tls_type & TLS_LD) != 0
10075             && !h->def_dynamic)
10076           {
10077             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
10078             *pgent = gent->next;
10079           }
10080         else
10081           pgent = &gent->next;
10082       }
10083     else
10084       *pgent = gent->next;
10085
10086   if (!htab->do_multi_toc)
10087     merge_got_entries (&h->got.glist);
10088
10089   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10090     if (!gent->is_indirect)
10091       {
10092         /* Make sure this symbol is output as a dynamic symbol.  */
10093         if (!ensure_undef_dynamic (info, h))
10094           return FALSE;
10095
10096         if (!is_ppc64_elf (gent->owner))
10097           abort ();
10098
10099         allocate_got (h, info, gent);
10100       }
10101
10102   /* If no dynamic sections we can't have dynamic relocs, except for
10103      IFUNCs which are handled even in static executables.  */
10104   if (!htab->elf.dynamic_sections_created
10105       && h->type != STT_GNU_IFUNC)
10106     eh->dyn_relocs = NULL;
10107
10108   /* Discard relocs on undefined symbols that must be local.  */
10109   else if (h->root.type == bfd_link_hash_undefined
10110            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10111     eh->dyn_relocs = NULL;
10112
10113   /* Also discard relocs on undefined weak syms with non-default
10114      visibility, or when dynamic_undefined_weak says so.  */
10115   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10116     eh->dyn_relocs = NULL;
10117
10118   if (eh->dyn_relocs != NULL)
10119     {
10120       struct elf_dyn_relocs *p, **pp;
10121
10122       /* In the shared -Bsymbolic case, discard space allocated for
10123          dynamic pc-relative relocs against symbols which turn out to
10124          be defined in regular objects.  For the normal shared case,
10125          discard space for relocs that have become local due to symbol
10126          visibility changes.  */
10127
10128       if (bfd_link_pic (info))
10129         {
10130           /* Relocs that use pc_count are those that appear on a call
10131              insn, or certain REL relocs (see must_be_dyn_reloc) that
10132              can be generated via assembly.  We want calls to
10133              protected symbols to resolve directly to the function
10134              rather than going via the plt.  If people want function
10135              pointer comparisons to work as expected then they should
10136              avoid writing weird assembly.  */
10137           if (SYMBOL_CALLS_LOCAL (info, h))
10138             {
10139               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10140                 {
10141                   p->count -= p->pc_count;
10142                   p->pc_count = 0;
10143                   if (p->count == 0)
10144                     *pp = p->next;
10145                   else
10146                     pp = &p->next;
10147                 }
10148             }
10149
10150           if (eh->dyn_relocs != NULL)
10151             {
10152               /* Make sure this symbol is output as a dynamic symbol.  */
10153               if (!ensure_undef_dynamic (info, h))
10154                 return FALSE;
10155             }
10156         }
10157       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10158         {
10159           /* For the non-pic case, discard space for relocs against
10160              symbols which turn out to need copy relocs or are not
10161              dynamic.  */
10162           if (h->dynamic_adjusted
10163               && !h->def_regular
10164               && !ELF_COMMON_DEF_P (h))
10165             {
10166               /* Make sure this symbol is output as a dynamic symbol.  */
10167               if (!ensure_undef_dynamic (info, h))
10168                 return FALSE;
10169
10170               if (h->dynindx == -1)
10171                 eh->dyn_relocs = NULL;
10172             }
10173           else
10174             eh->dyn_relocs = NULL;
10175         }
10176
10177       /* Finally, allocate space.  */
10178       for (p = eh->dyn_relocs; p != NULL; p = p->next)
10179         {
10180           asection *sreloc = elf_section_data (p->sec)->sreloc;
10181           if (eh->elf.type == STT_GNU_IFUNC)
10182             sreloc = htab->elf.irelplt;
10183           sreloc->size += p->count * sizeof (Elf64_External_Rela);
10184         }
10185     }
10186
10187   /* We might need a PLT entry when the symbol
10188      a) is dynamic, or
10189      b) is an ifunc, or
10190      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10191      d) has plt16 relocs and we are linking statically.  */
10192   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10193       || h->type == STT_GNU_IFUNC
10194       || (h->needs_plt && h->dynamic_adjusted)
10195       || (h->needs_plt
10196           && h->def_regular
10197           && !htab->elf.dynamic_sections_created
10198           && !htab->can_convert_all_inline_plt
10199           && (((struct ppc_link_hash_entry *) h)->tls_mask
10200               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10201     {
10202       struct plt_entry *pent;
10203       bfd_boolean doneone = FALSE;
10204       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10205         if (pent->plt.refcount > 0)
10206           {
10207             if (!htab->elf.dynamic_sections_created
10208                 || h->dynindx == -1)
10209               {
10210                 if (h->type == STT_GNU_IFUNC)
10211                   {
10212                     s = htab->elf.iplt;
10213                     pent->plt.offset = s->size;
10214                     s->size += PLT_ENTRY_SIZE (htab);
10215                     s = htab->elf.irelplt;
10216                   }
10217                 else
10218                   {
10219                     s = htab->pltlocal;
10220                     pent->plt.offset = s->size;
10221                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10222                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10223                   }
10224               }
10225             else
10226               {
10227                 /* If this is the first .plt entry, make room for the special
10228                    first entry.  */
10229                 s = htab->elf.splt;
10230                 if (s->size == 0)
10231                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10232
10233                 pent->plt.offset = s->size;
10234
10235                 /* Make room for this entry.  */
10236                 s->size += PLT_ENTRY_SIZE (htab);
10237
10238                 /* Make room for the .glink code.  */
10239                 s = htab->glink;
10240                 if (s->size == 0)
10241                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
10242                 if (htab->opd_abi)
10243                   {
10244                     /* We need bigger stubs past index 32767.  */
10245                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10246                       s->size += 4;
10247                     s->size += 2*4;
10248                   }
10249                 else
10250                   s->size += 4;
10251
10252                 /* We also need to make an entry in the .rela.plt section.  */
10253                 s = htab->elf.srelplt;
10254               }
10255             if (s != NULL)
10256               s->size += sizeof (Elf64_External_Rela);
10257             doneone = TRUE;
10258           }
10259         else
10260           pent->plt.offset = (bfd_vma) -1;
10261       if (!doneone)
10262         {
10263           h->plt.plist = NULL;
10264           h->needs_plt = 0;
10265         }
10266     }
10267   else
10268     {
10269       h->plt.plist = NULL;
10270       h->needs_plt = 0;
10271     }
10272
10273   return TRUE;
10274 }
10275
10276 #define PPC_LO(v) ((v) & 0xffff)
10277 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10278 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10279
10280 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10281    to set up space for global entry stubs.  These are put in glink,
10282    after the branch table.  */
10283
10284 static bfd_boolean
10285 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10286 {
10287   struct bfd_link_info *info;
10288   struct ppc_link_hash_table *htab;
10289   struct plt_entry *pent;
10290   asection *s, *plt;
10291
10292   if (h->root.type == bfd_link_hash_indirect)
10293     return TRUE;
10294
10295   if (!h->pointer_equality_needed)
10296     return TRUE;
10297
10298   if (h->def_regular)
10299     return TRUE;
10300
10301   info = inf;
10302   htab = ppc_hash_table (info);
10303   if (htab == NULL)
10304     return FALSE;
10305
10306   s = htab->global_entry;
10307   plt = htab->elf.splt;
10308   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10309     if (pent->plt.offset != (bfd_vma) -1
10310         && pent->addend == 0)
10311       {
10312         /* For ELFv2, if this symbol is not defined in a regular file
10313            and we are not generating a shared library or pie, then we
10314            need to define the symbol in the executable on a call stub.
10315            This is to avoid text relocations.  */
10316         bfd_vma off, stub_align, stub_off, stub_size;
10317         unsigned int align_power;
10318
10319         stub_size = 16;
10320         stub_off = s->size;
10321         if (htab->params->plt_stub_align >= 0)
10322           align_power = htab->params->plt_stub_align;
10323         else
10324           align_power = -htab->params->plt_stub_align;
10325         /* Setting section alignment is delayed until we know it is
10326            non-empty.  Otherwise the .text output section will be
10327            aligned at least to plt_stub_align even when no global
10328            entry stubs are needed.  */
10329         if (s->alignment_power < align_power)
10330           s->alignment_power = align_power;
10331         stub_align = (bfd_vma) 1 << align_power;
10332         if (htab->params->plt_stub_align >= 0
10333             || ((((stub_off + stub_size - 1) & -stub_align)
10334                  - (stub_off & -stub_align))
10335                 > ((stub_size - 1) & -stub_align)))
10336           stub_off = (stub_off + stub_align - 1) & -stub_align;
10337         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10338         off -= stub_off + s->output_offset + s->output_section->vma;
10339         /* Note that for --plt-stub-align negative we have a possible
10340            dependency between stub offset and size.  Break that
10341            dependency by assuming the max stub size when calculating
10342            the stub offset.  */
10343         if (PPC_HA (off) == 0)
10344           stub_size -= 4;
10345         h->root.type = bfd_link_hash_defined;
10346         h->root.u.def.section = s;
10347         h->root.u.def.value = stub_off;
10348         s->size = stub_off + stub_size;
10349         break;
10350       }
10351   return TRUE;
10352 }
10353
10354 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10355    read-only sections.  */
10356
10357 static bfd_boolean
10358 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10359 {
10360   asection *sec;
10361
10362   if (h->root.type == bfd_link_hash_indirect)
10363     return TRUE;
10364
10365   sec = readonly_dynrelocs (h);
10366   if (sec != NULL)
10367     {
10368       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10369
10370       info->flags |= DF_TEXTREL;
10371       info->callbacks->minfo
10372         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10373          sec->owner, h->root.root.string, sec);
10374
10375       /* Not an error, just cut short the traversal.  */
10376       return FALSE;
10377     }
10378   return TRUE;
10379 }
10380
10381 /* Set the sizes of the dynamic sections.  */
10382
10383 static bfd_boolean
10384 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10385                                  struct bfd_link_info *info)
10386 {
10387   struct ppc_link_hash_table *htab;
10388   bfd *dynobj;
10389   asection *s;
10390   bfd_boolean relocs;
10391   bfd *ibfd;
10392   struct got_entry *first_tlsld;
10393
10394   htab = ppc_hash_table (info);
10395   if (htab == NULL)
10396     return FALSE;
10397
10398   dynobj = htab->elf.dynobj;
10399   if (dynobj == NULL)
10400     abort ();
10401
10402   if (htab->elf.dynamic_sections_created)
10403     {
10404       /* Set the contents of the .interp section to the interpreter.  */
10405       if (bfd_link_executable (info) && !info->nointerp)
10406         {
10407           s = bfd_get_linker_section (dynobj, ".interp");
10408           if (s == NULL)
10409             abort ();
10410           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10411           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10412         }
10413     }
10414
10415   /* Set up .got offsets for local syms, and space for local dynamic
10416      relocs.  */
10417   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10418     {
10419       struct got_entry **lgot_ents;
10420       struct got_entry **end_lgot_ents;
10421       struct plt_entry **local_plt;
10422       struct plt_entry **end_local_plt;
10423       unsigned char *lgot_masks;
10424       bfd_size_type locsymcount;
10425       Elf_Internal_Shdr *symtab_hdr;
10426
10427       if (!is_ppc64_elf (ibfd))
10428         continue;
10429
10430       for (s = ibfd->sections; s != NULL; s = s->next)
10431         {
10432           struct ppc_dyn_relocs *p;
10433
10434           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10435             {
10436               if (!bfd_is_abs_section (p->sec)
10437                   && bfd_is_abs_section (p->sec->output_section))
10438                 {
10439                   /* Input section has been discarded, either because
10440                      it is a copy of a linkonce section or due to
10441                      linker script /DISCARD/, so we'll be discarding
10442                      the relocs too.  */
10443                 }
10444               else if (p->count != 0)
10445                 {
10446                   asection *srel = elf_section_data (p->sec)->sreloc;
10447                   if (p->ifunc)
10448                     srel = htab->elf.irelplt;
10449                   srel->size += p->count * sizeof (Elf64_External_Rela);
10450                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10451                     info->flags |= DF_TEXTREL;
10452                 }
10453             }
10454         }
10455
10456       lgot_ents = elf_local_got_ents (ibfd);
10457       if (!lgot_ents)
10458         continue;
10459
10460       symtab_hdr = &elf_symtab_hdr (ibfd);
10461       locsymcount = symtab_hdr->sh_info;
10462       end_lgot_ents = lgot_ents + locsymcount;
10463       local_plt = (struct plt_entry **) end_lgot_ents;
10464       end_local_plt = local_plt + locsymcount;
10465       lgot_masks = (unsigned char *) end_local_plt;
10466       s = ppc64_elf_tdata (ibfd)->got;
10467       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10468         {
10469           struct got_entry **pent, *ent;
10470
10471           pent = lgot_ents;
10472           while ((ent = *pent) != NULL)
10473             if (ent->got.refcount > 0)
10474               {
10475                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10476                   {
10477                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10478                     *pent = ent->next;
10479                   }
10480                 else
10481                   {
10482                     unsigned int ent_size = 8;
10483                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10484
10485                     ent->got.offset = s->size;
10486                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10487                       {
10488                         ent_size *= 2;
10489                         rel_size *= 2;
10490                       }
10491                     s->size += ent_size;
10492                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10493                       {
10494                         htab->elf.irelplt->size += rel_size;
10495                         htab->got_reli_size += rel_size;
10496                       }
10497                     else if (bfd_link_pic (info)
10498                              && !((ent->tls_type & TLS_TPREL) != 0
10499                                   && bfd_link_executable (info)))
10500                       {
10501                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10502                         srel->size += rel_size;
10503                       }
10504                     pent = &ent->next;
10505                   }
10506               }
10507             else
10508               *pent = ent->next;
10509         }
10510
10511       /* Allocate space for plt calls to local syms.  */
10512       lgot_masks = (unsigned char *) end_local_plt;
10513       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10514         {
10515           struct plt_entry *ent;
10516
10517           for (ent = *local_plt; ent != NULL; ent = ent->next)
10518             if (ent->plt.refcount > 0)
10519               {
10520                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10521                   {
10522                     s = htab->elf.iplt;
10523                     ent->plt.offset = s->size;
10524                     s->size += PLT_ENTRY_SIZE (htab);
10525                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10526                   }
10527                 else if (htab->can_convert_all_inline_plt
10528                          || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10529                   ent->plt.offset = (bfd_vma) -1;
10530                 else
10531                   {
10532                     s = htab->pltlocal;
10533                     ent->plt.offset = s->size;
10534                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10535                     if (bfd_link_pic (info))
10536                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10537                   }
10538               }
10539             else
10540               ent->plt.offset = (bfd_vma) -1;
10541         }
10542     }
10543
10544   /* Allocate global sym .plt and .got entries, and space for global
10545      sym dynamic relocs.  */
10546   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10547
10548   if (!htab->opd_abi && !bfd_link_pic (info))
10549     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10550
10551   first_tlsld = NULL;
10552   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10553     {
10554       struct got_entry *ent;
10555
10556       if (!is_ppc64_elf (ibfd))
10557         continue;
10558
10559       ent = ppc64_tlsld_got (ibfd);
10560       if (ent->got.refcount > 0)
10561         {
10562           if (!htab->do_multi_toc && first_tlsld != NULL)
10563             {
10564               ent->is_indirect = TRUE;
10565               ent->got.ent = first_tlsld;
10566             }
10567           else
10568             {
10569               if (first_tlsld == NULL)
10570                 first_tlsld = ent;
10571               s = ppc64_elf_tdata (ibfd)->got;
10572               ent->got.offset = s->size;
10573               ent->owner = ibfd;
10574               s->size += 16;
10575               if (bfd_link_pic (info))
10576                 {
10577                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10578                   srel->size += sizeof (Elf64_External_Rela);
10579                 }
10580             }
10581         }
10582       else
10583         ent->got.offset = (bfd_vma) -1;
10584     }
10585
10586   /* We now have determined the sizes of the various dynamic sections.
10587      Allocate memory for them.  */
10588   relocs = FALSE;
10589   for (s = dynobj->sections; s != NULL; s = s->next)
10590     {
10591       if ((s->flags & SEC_LINKER_CREATED) == 0)
10592         continue;
10593
10594       if (s == htab->brlt || s == htab->relbrlt)
10595         /* These haven't been allocated yet;  don't strip.  */
10596         continue;
10597       else if (s == htab->elf.sgot
10598                || s == htab->elf.splt
10599                || s == htab->elf.iplt
10600                || s == htab->pltlocal
10601                || s == htab->glink
10602                || s == htab->global_entry
10603                || s == htab->elf.sdynbss
10604                || s == htab->elf.sdynrelro)
10605         {
10606           /* Strip this section if we don't need it; see the
10607              comment below.  */
10608         }
10609       else if (s == htab->glink_eh_frame)
10610         {
10611           if (!bfd_is_abs_section (s->output_section))
10612             /* Not sized yet.  */
10613             continue;
10614         }
10615       else if (CONST_STRNEQ (s->name, ".rela"))
10616         {
10617           if (s->size != 0)
10618             {
10619               if (s != htab->elf.srelplt)
10620                 relocs = TRUE;
10621
10622               /* We use the reloc_count field as a counter if we need
10623                  to copy relocs into the output file.  */
10624               s->reloc_count = 0;
10625             }
10626         }
10627       else
10628         {
10629           /* It's not one of our sections, so don't allocate space.  */
10630           continue;
10631         }
10632
10633       if (s->size == 0)
10634         {
10635           /* If we don't need this section, strip it from the
10636              output file.  This is mostly to handle .rela.bss and
10637              .rela.plt.  We must create both sections in
10638              create_dynamic_sections, because they must be created
10639              before the linker maps input sections to output
10640              sections.  The linker does that before
10641              adjust_dynamic_symbol is called, and it is that
10642              function which decides whether anything needs to go
10643              into these sections.  */
10644           s->flags |= SEC_EXCLUDE;
10645           continue;
10646         }
10647
10648       if (bfd_is_abs_section (s->output_section))
10649         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10650                             s->name);
10651
10652       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10653         continue;
10654
10655       /* Allocate memory for the section contents.  We use bfd_zalloc
10656          here in case unused entries are not reclaimed before the
10657          section's contents are written out.  This should not happen,
10658          but this way if it does we get a R_PPC64_NONE reloc in .rela
10659          sections instead of garbage.
10660          We also rely on the section contents being zero when writing
10661          the GOT and .dynrelro.  */
10662       s->contents = bfd_zalloc (dynobj, s->size);
10663       if (s->contents == NULL)
10664         return FALSE;
10665     }
10666
10667   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10668     {
10669       if (!is_ppc64_elf (ibfd))
10670         continue;
10671
10672       s = ppc64_elf_tdata (ibfd)->got;
10673       if (s != NULL && s != htab->elf.sgot)
10674         {
10675           if (s->size == 0)
10676             s->flags |= SEC_EXCLUDE;
10677           else
10678             {
10679               s->contents = bfd_zalloc (ibfd, s->size);
10680               if (s->contents == NULL)
10681                 return FALSE;
10682             }
10683         }
10684       s = ppc64_elf_tdata (ibfd)->relgot;
10685       if (s != NULL)
10686         {
10687           if (s->size == 0)
10688             s->flags |= SEC_EXCLUDE;
10689           else
10690             {
10691               s->contents = bfd_zalloc (ibfd, s->size);
10692               if (s->contents == NULL)
10693                 return FALSE;
10694               relocs = TRUE;
10695               s->reloc_count = 0;
10696             }
10697         }
10698     }
10699
10700   if (htab->elf.dynamic_sections_created)
10701     {
10702       bfd_boolean tls_opt;
10703
10704       /* Add some entries to the .dynamic section.  We fill in the
10705          values later, in ppc64_elf_finish_dynamic_sections, but we
10706          must add the entries now so that we get the correct size for
10707          the .dynamic section.  The DT_DEBUG entry is filled in by the
10708          dynamic linker and used by the debugger.  */
10709 #define add_dynamic_entry(TAG, VAL) \
10710   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10711
10712       if (bfd_link_executable (info))
10713         {
10714           if (!add_dynamic_entry (DT_DEBUG, 0))
10715             return FALSE;
10716         }
10717
10718       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10719         {
10720           if (!add_dynamic_entry (DT_PLTGOT, 0)
10721               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10722               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10723               || !add_dynamic_entry (DT_JMPREL, 0)
10724               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10725             return FALSE;
10726         }
10727
10728       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10729         {
10730           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10731               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10732             return FALSE;
10733         }
10734
10735       tls_opt = (htab->params->tls_get_addr_opt
10736                  && htab->tls_get_addr_fd != NULL
10737                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10738       if (tls_opt || !htab->opd_abi)
10739         {
10740           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10741             return FALSE;
10742         }
10743
10744       if (relocs)
10745         {
10746           if (!add_dynamic_entry (DT_RELA, 0)
10747               || !add_dynamic_entry (DT_RELASZ, 0)
10748               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10749             return FALSE;
10750
10751           /* If any dynamic relocs apply to a read-only section,
10752              then we need a DT_TEXTREL entry.  */
10753           if ((info->flags & DF_TEXTREL) == 0)
10754             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10755
10756           if ((info->flags & DF_TEXTREL) != 0)
10757             {
10758               if (!add_dynamic_entry (DT_TEXTREL, 0))
10759                 return FALSE;
10760             }
10761         }
10762     }
10763 #undef add_dynamic_entry
10764
10765   return TRUE;
10766 }
10767
10768 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10769
10770 static bfd_boolean
10771 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10772 {
10773   if (h->plt.plist != NULL
10774       && !h->def_regular
10775       && !h->pointer_equality_needed)
10776     return FALSE;
10777
10778   return _bfd_elf_hash_symbol (h);
10779 }
10780
10781 /* Determine the type of stub needed, if any, for a call.  */
10782
10783 static inline enum ppc_stub_type
10784 ppc_type_of_stub (asection *input_sec,
10785                   const Elf_Internal_Rela *rel,
10786                   struct ppc_link_hash_entry **hash,
10787                   struct plt_entry **plt_ent,
10788                   bfd_vma destination,
10789                   unsigned long local_off)
10790 {
10791   struct ppc_link_hash_entry *h = *hash;
10792   bfd_vma location;
10793   bfd_vma branch_offset;
10794   bfd_vma max_branch_offset;
10795   enum elf_ppc64_reloc_type r_type;
10796
10797   if (h != NULL)
10798     {
10799       struct plt_entry *ent;
10800       struct ppc_link_hash_entry *fdh = h;
10801       if (h->oh != NULL
10802           && h->oh->is_func_descriptor)
10803         {
10804           fdh = ppc_follow_link (h->oh);
10805           *hash = fdh;
10806         }
10807
10808       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10809         if (ent->addend == rel->r_addend
10810             && ent->plt.offset != (bfd_vma) -1)
10811           {
10812             *plt_ent = ent;
10813             return ppc_stub_plt_call;
10814           }
10815
10816       /* Here, we know we don't have a plt entry.  If we don't have a
10817          either a defined function descriptor or a defined entry symbol
10818          in a regular object file, then it is pointless trying to make
10819          any other type of stub.  */
10820       if (!is_static_defined (&fdh->elf)
10821           && !is_static_defined (&h->elf))
10822         return ppc_stub_none;
10823     }
10824   else if (elf_local_got_ents (input_sec->owner) != NULL)
10825     {
10826       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10827       struct plt_entry **local_plt = (struct plt_entry **)
10828         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10829       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10830
10831       if (local_plt[r_symndx] != NULL)
10832         {
10833           struct plt_entry *ent;
10834
10835           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10836             if (ent->addend == rel->r_addend
10837                 && ent->plt.offset != (bfd_vma) -1)
10838               {
10839                 *plt_ent = ent;
10840                 return ppc_stub_plt_call;
10841               }
10842         }
10843     }
10844
10845   /* Determine where the call point is.  */
10846   location = (input_sec->output_offset
10847               + input_sec->output_section->vma
10848               + rel->r_offset);
10849
10850   branch_offset = destination - location;
10851   r_type = ELF64_R_TYPE (rel->r_info);
10852
10853   /* Determine if a long branch stub is needed.  */
10854   max_branch_offset = 1 << 25;
10855   if (r_type == R_PPC64_REL14
10856       || r_type == R_PPC64_REL14_BRTAKEN
10857       || r_type == R_PPC64_REL14_BRNTAKEN)
10858     max_branch_offset = 1 << 15;
10859
10860   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10861     /* We need a stub.  Figure out whether a long_branch or plt_branch
10862        is needed later.  */
10863     return ppc_stub_long_branch;
10864
10865   return ppc_stub_none;
10866 }
10867
10868 /* Builds a 64-bit offset in r12 then adds it to r11 (LOAD false) or
10869    loads r12 from r11+r12 (LOAD true).
10870    .    lis     %r12,xxx-1b@highest
10871    .    ori     %r12,xxx-1b@higher
10872    .    sldi    %r12,%r12,32
10873    .    oris    %r12,%r12,xxx-1b@hi
10874    .    ori     %r12,%r12,xxx-1b@l
10875    .    add     %r12,%r11,%r12  */
10876
10877 static bfd_byte *
10878 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10879 {
10880   if (off + 0x8000 < 0x10000)
10881     {
10882       if (load)
10883         bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10884       else
10885         bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10886       p += 4;
10887     }
10888   else if (off + 0x80008000ULL < 0x100000000ULL)
10889     {
10890       bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10891       p += 4;
10892       if (load)
10893         bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10894       else
10895         bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10896       p += 4;
10897     }
10898   else
10899     {
10900       if (off + 0x800000000000ULL < 0x1000000000000ULL)
10901         {
10902           bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10903           p += 4;
10904         }
10905       else
10906         {
10907           bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10908           p += 4;
10909           if (((off >> 32) & 0xffff) != 0)
10910             {
10911               bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10912               p += 4;
10913             }
10914         }
10915       if (((off >> 32) & 0xffffffffULL) != 0)
10916         {
10917           bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10918           p += 4;
10919         }
10920       if (PPC_HI (off) != 0)
10921         {
10922           bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10923           p += 4;
10924         }
10925       if (PPC_LO (off) != 0)
10926         {
10927           bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10928           p += 4;
10929         }
10930       if (load)
10931         bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10932       else
10933         bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10934       p += 4;
10935     }
10936   return p;
10937 }
10938
10939 static unsigned int
10940 size_offset (bfd_vma off)
10941 {
10942   unsigned int size;
10943   if (off + 0x8000 < 0x10000)
10944     size = 4;
10945   else if (off + 0x80008000ULL < 0x100000000ULL)
10946     size = 8;
10947   else
10948     {
10949       if (off + 0x800000000000ULL < 0x1000000000000ULL)
10950         size = 4;
10951       else
10952         {
10953           size = 4;
10954           if (((off >> 32) & 0xffff) != 0)
10955             size += 4;
10956         }
10957       if (((off >> 32) & 0xffffffffULL) != 0)
10958         size += 4;
10959       if (PPC_HI (off) != 0)
10960         size += 4;
10961       if (PPC_LO (off) != 0)
10962         size += 4;
10963       size += 4;
10964     }
10965   return size;
10966 }
10967
10968 /* With power7 weakly ordered memory model, it is possible for ld.so
10969    to update a plt entry in one thread and have another thread see a
10970    stale zero toc entry.  To avoid this we need some sort of acquire
10971    barrier in the call stub.  One solution is to make the load of the
10972    toc word seem to appear to depend on the load of the function entry
10973    word.  Another solution is to test for r2 being zero, and branch to
10974    the appropriate glink entry if so.
10975
10976    .    fake dep barrier        compare
10977    .    ld 12,xxx(2)            ld 12,xxx(2)
10978    .    mtctr 12                mtctr 12
10979    .    xor 11,12,12            ld 2,xxx+8(2)
10980    .    add 2,2,11              cmpldi 2,0
10981    .    ld 2,xxx+8(2)           bnectr+
10982    .    bctr                    b <glink_entry>
10983
10984    The solution involving the compare turns out to be faster, so
10985    that's what we use unless the branch won't reach.  */
10986
10987 #define ALWAYS_USE_FAKE_DEP 0
10988 #define ALWAYS_EMIT_R2SAVE 0
10989
10990 static inline unsigned int
10991 plt_stub_size (struct ppc_link_hash_table *htab,
10992                struct ppc_stub_hash_entry *stub_entry,
10993                bfd_vma off)
10994 {
10995   unsigned size;
10996
10997   if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
10998     {
10999       size = 24 + size_offset (off);
11000       if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11001         size += 4;
11002       return size;
11003     }
11004
11005   size = 12;
11006   if (ALWAYS_EMIT_R2SAVE
11007       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11008     size += 4;
11009   if (PPC_HA (off) != 0)
11010     size += 4;
11011   if (htab->opd_abi)
11012     {
11013       size += 4;
11014       if (htab->params->plt_static_chain)
11015         size += 4;
11016       if (htab->params->plt_thread_safe
11017           && htab->elf.dynamic_sections_created
11018           && stub_entry->h != NULL
11019           && stub_entry->h->elf.dynindx != -1)
11020         size += 8;
11021       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
11022         size += 4;
11023     }
11024   if (stub_entry->h != NULL
11025       && (stub_entry->h == htab->tls_get_addr_fd
11026           || stub_entry->h == htab->tls_get_addr)
11027       && htab->params->tls_get_addr_opt)
11028     {
11029       size += 7 * 4;
11030       if (ALWAYS_EMIT_R2SAVE
11031           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11032         size += 6 * 4;
11033     }
11034   return size;
11035 }
11036
11037 /* Depending on the sign of plt_stub_align:
11038    If positive, return the padding to align to a 2**plt_stub_align
11039    boundary.
11040    If negative, if this stub would cross fewer 2**plt_stub_align
11041    boundaries if we align, then return the padding needed to do so.  */
11042
11043 static inline unsigned int
11044 plt_stub_pad (struct ppc_link_hash_table *htab,
11045               struct ppc_stub_hash_entry *stub_entry,
11046               bfd_vma plt_off)
11047 {
11048   int stub_align;
11049   unsigned stub_size;
11050   bfd_vma stub_off = stub_entry->group->stub_sec->size;
11051
11052   if (htab->params->plt_stub_align >= 0)
11053     {
11054       stub_align = 1 << htab->params->plt_stub_align;
11055       if ((stub_off & (stub_align - 1)) != 0)
11056         return stub_align - (stub_off & (stub_align - 1));
11057       return 0;
11058     }
11059
11060   stub_align = 1 << -htab->params->plt_stub_align;
11061   stub_size = plt_stub_size (htab, stub_entry, plt_off);
11062   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11063       > ((stub_size - 1) & -stub_align))
11064     return stub_align - (stub_off & (stub_align - 1));
11065   return 0;
11066 }
11067
11068 /* Build a .plt call stub.  */
11069
11070 static inline bfd_byte *
11071 build_plt_stub (struct ppc_link_hash_table *htab,
11072                 struct ppc_stub_hash_entry *stub_entry,
11073                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11074 {
11075   bfd *obfd = htab->params->stub_bfd;
11076   bfd_boolean plt_load_toc = htab->opd_abi;
11077   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
11078   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
11079                                  && htab->elf.dynamic_sections_created
11080                                  && stub_entry->h != NULL
11081                                  && stub_entry->h->elf.dynindx != -1);
11082   bfd_boolean use_fake_dep = plt_thread_safe;
11083   bfd_vma cmp_branch_off = 0;
11084
11085   if (!ALWAYS_USE_FAKE_DEP
11086       && plt_load_toc
11087       && plt_thread_safe
11088       && !((stub_entry->h == htab->tls_get_addr_fd
11089             || stub_entry->h == htab->tls_get_addr)
11090            && htab->params->tls_get_addr_opt))
11091     {
11092       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11093       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11094                           / PLT_ENTRY_SIZE (htab));
11095       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11096       bfd_vma to, from;
11097
11098       if (pltindex > 32768)
11099         glinkoff += (pltindex - 32768) * 4;
11100       to = (glinkoff
11101             + htab->glink->output_offset
11102             + htab->glink->output_section->vma);
11103       from = (p - stub_entry->group->stub_sec->contents
11104               + 4 * (ALWAYS_EMIT_R2SAVE
11105                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11106               + 4 * (PPC_HA (offset) != 0)
11107               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11108                      != PPC_HA (offset))
11109               + 4 * (plt_static_chain != 0)
11110               + 20
11111               + stub_entry->group->stub_sec->output_offset
11112               + stub_entry->group->stub_sec->output_section->vma);
11113       cmp_branch_off = to - from;
11114       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11115     }
11116
11117   if (PPC_HA (offset) != 0)
11118     {
11119       if (r != NULL)
11120         {
11121           if (ALWAYS_EMIT_R2SAVE
11122               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11123             r[0].r_offset += 4;
11124           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11125           r[1].r_offset = r[0].r_offset + 4;
11126           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11127           r[1].r_addend = r[0].r_addend;
11128           if (plt_load_toc)
11129             {
11130               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11131                 {
11132                   r[2].r_offset = r[1].r_offset + 4;
11133                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11134                   r[2].r_addend = r[0].r_addend;
11135                 }
11136               else
11137                 {
11138                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11139                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11140                   r[2].r_addend = r[0].r_addend + 8;
11141                   if (plt_static_chain)
11142                     {
11143                       r[3].r_offset = r[2].r_offset + 4;
11144                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11145                       r[3].r_addend = r[0].r_addend + 16;
11146                     }
11147                 }
11148             }
11149         }
11150       if (ALWAYS_EMIT_R2SAVE
11151           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11152         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
11153       if (plt_load_toc)
11154         {
11155           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11156           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
11157         }
11158       else
11159         {
11160           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11161           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
11162         }
11163       if (plt_load_toc
11164           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11165         {
11166           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11167           offset = 0;
11168         }
11169       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11170       if (plt_load_toc)
11171         {
11172           if (use_fake_dep)
11173             {
11174               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
11175               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
11176             }
11177           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11178           if (plt_static_chain)
11179             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11180         }
11181     }
11182   else
11183     {
11184       if (r != NULL)
11185         {
11186           if (ALWAYS_EMIT_R2SAVE
11187               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11188             r[0].r_offset += 4;
11189           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11190           if (plt_load_toc)
11191             {
11192               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11193                 {
11194                   r[1].r_offset = r[0].r_offset + 4;
11195                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11196                   r[1].r_addend = r[0].r_addend;
11197                 }
11198               else
11199                 {
11200                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11201                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11202                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11203                   if (plt_static_chain)
11204                     {
11205                       r[2].r_offset = r[1].r_offset + 4;
11206                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11207                       r[2].r_addend = r[0].r_addend + 8;
11208                     }
11209                 }
11210             }
11211         }
11212       if (ALWAYS_EMIT_R2SAVE
11213           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11214         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
11215       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
11216       if (plt_load_toc
11217           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11218         {
11219           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
11220           offset = 0;
11221         }
11222       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11223       if (plt_load_toc)
11224         {
11225           if (use_fake_dep)
11226             {
11227               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
11228               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
11229             }
11230           if (plt_static_chain)
11231             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11232           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11233         }
11234     }
11235   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11236     {
11237       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11238       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11239       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11240     }
11241   else
11242     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11243   return p;
11244 }
11245
11246 /* Build a special .plt call stub for __tls_get_addr.  */
11247
11248 #define LD_R11_0R3      0xe9630000
11249 #define LD_R12_0R3      0xe9830000
11250 #define MR_R0_R3        0x7c601b78
11251 #define CMPDI_R11_0     0x2c2b0000
11252 #define ADD_R3_R12_R13  0x7c6c6a14
11253 #define BEQLR           0x4d820020
11254 #define MR_R3_R0        0x7c030378
11255 #define STD_R11_0R1     0xf9610000
11256 #define BCTRL           0x4e800421
11257 #define LD_R11_0R1      0xe9610000
11258 #define MTLR_R11        0x7d6803a6
11259
11260 static inline bfd_byte *
11261 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11262                          struct ppc_stub_hash_entry *stub_entry,
11263                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11264 {
11265   bfd *obfd = htab->params->stub_bfd;
11266
11267   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11268   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11269   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11270   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11271   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11272   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11273   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11274   if (r != NULL)
11275     r[0].r_offset += 7 * 4;
11276   if (!ALWAYS_EMIT_R2SAVE
11277       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
11278     return build_plt_stub (htab, stub_entry, p, offset, r);
11279
11280   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11281   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11282
11283   if (r != NULL)
11284     r[0].r_offset += 2 * 4;
11285   p = build_plt_stub (htab, stub_entry, p, offset, r);
11286   bfd_put_32 (obfd, BCTRL, p - 4);
11287
11288   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11289   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11290   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11291   bfd_put_32 (obfd, BLR, p),                    p += 4;
11292
11293   return p;
11294 }
11295
11296 static Elf_Internal_Rela *
11297 get_relocs (asection *sec, int count)
11298 {
11299   Elf_Internal_Rela *relocs;
11300   struct bfd_elf_section_data *elfsec_data;
11301
11302   elfsec_data = elf_section_data (sec);
11303   relocs = elfsec_data->relocs;
11304   if (relocs == NULL)
11305     {
11306       bfd_size_type relsize;
11307       relsize = sec->reloc_count * sizeof (*relocs);
11308       relocs = bfd_alloc (sec->owner, relsize);
11309       if (relocs == NULL)
11310         return NULL;
11311       elfsec_data->relocs = relocs;
11312       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11313                                           sizeof (Elf_Internal_Shdr));
11314       if (elfsec_data->rela.hdr == NULL)
11315         return NULL;
11316       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11317                                         * sizeof (Elf64_External_Rela));
11318       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11319       sec->reloc_count = 0;
11320     }
11321   relocs += sec->reloc_count;
11322   sec->reloc_count += count;
11323   return relocs;
11324 }
11325
11326 static bfd_vma
11327 get_r2off (struct bfd_link_info *info,
11328            struct ppc_stub_hash_entry *stub_entry)
11329 {
11330   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11331   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11332
11333   if (r2off == 0)
11334     {
11335       /* Support linking -R objects.  Get the toc pointer from the
11336          opd entry.  */
11337       char buf[8];
11338       if (!htab->opd_abi)
11339         return r2off;
11340       asection *opd = stub_entry->h->elf.root.u.def.section;
11341       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11342
11343       if (strcmp (opd->name, ".opd") != 0
11344           || opd->reloc_count != 0)
11345         {
11346           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11347                                   stub_entry->h->elf.root.root.string);
11348           bfd_set_error (bfd_error_bad_value);
11349           return (bfd_vma) -1;
11350         }
11351       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11352         return (bfd_vma) -1;
11353       r2off = bfd_get_64 (opd->owner, buf);
11354       r2off -= elf_gp (info->output_bfd);
11355     }
11356   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11357   return r2off;
11358 }
11359
11360 static bfd_boolean
11361 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11362 {
11363   struct ppc_stub_hash_entry *stub_entry;
11364   struct ppc_branch_hash_entry *br_entry;
11365   struct bfd_link_info *info;
11366   struct ppc_link_hash_table *htab;
11367   bfd_byte *loc;
11368   bfd_byte *p;
11369   bfd_vma targ, off;
11370   Elf_Internal_Rela *r;
11371   asection *plt;
11372
11373   /* Massage our args to the form they really have.  */
11374   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11375   info = in_arg;
11376
11377   htab = ppc_hash_table (info);
11378   if (htab == NULL)
11379     return FALSE;
11380
11381   BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11382   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11383
11384   htab->stub_count[stub_entry->stub_type - 1] += 1;
11385   switch (stub_entry->stub_type)
11386     {
11387     case ppc_stub_long_branch:
11388     case ppc_stub_long_branch_r2off:
11389       /* Branches are relative.  This is where we are going to.  */
11390       targ = (stub_entry->target_value
11391               + stub_entry->target_section->output_offset
11392               + stub_entry->target_section->output_section->vma);
11393       targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11394
11395       /* And this is where we are coming from.  */
11396       off = (stub_entry->stub_offset
11397              + stub_entry->group->stub_sec->output_offset
11398              + stub_entry->group->stub_sec->output_section->vma);
11399       off = targ - off;
11400
11401       p = loc;
11402       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11403         {
11404           bfd_vma r2off = get_r2off (info, stub_entry);
11405
11406           if (r2off == (bfd_vma) -1)
11407             {
11408               htab->stub_error = TRUE;
11409               return FALSE;
11410             }
11411           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11412           p += 4;
11413           if (PPC_HA (r2off) != 0)
11414             {
11415               bfd_put_32 (htab->params->stub_bfd,
11416                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11417               p += 4;
11418             }
11419           if (PPC_LO (r2off) != 0)
11420             {
11421               bfd_put_32 (htab->params->stub_bfd,
11422                           ADDI_R2_R2 | PPC_LO (r2off), p);
11423               p += 4;
11424             }
11425           off -= p - loc;
11426         }
11427       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11428       p += 4;
11429
11430       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11431         {
11432           _bfd_error_handler
11433             (_("long branch stub `%s' offset overflow"),
11434              stub_entry->root.string);
11435           htab->stub_error = TRUE;
11436           return FALSE;
11437         }
11438
11439       if (info->emitrelocations)
11440         {
11441           r = get_relocs (stub_entry->group->stub_sec, 1);
11442           if (r == NULL)
11443             return FALSE;
11444           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11445           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11446           r->r_addend = targ;
11447           if (stub_entry->h != NULL)
11448             {
11449               struct elf_link_hash_entry **hashes;
11450               unsigned long symndx;
11451               struct ppc_link_hash_entry *h;
11452
11453               hashes = elf_sym_hashes (htab->params->stub_bfd);
11454               if (hashes == NULL)
11455                 {
11456                   bfd_size_type hsize;
11457
11458                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11459                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11460                   if (hashes == NULL)
11461                     return FALSE;
11462                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11463                   htab->stub_globals = 1;
11464                 }
11465               symndx = htab->stub_globals++;
11466               h = stub_entry->h;
11467               hashes[symndx] = &h->elf;
11468               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11469               if (h->oh != NULL && h->oh->is_func)
11470                 h = ppc_follow_link (h->oh);
11471               if (h->elf.root.u.def.section != stub_entry->target_section)
11472                 /* H is an opd symbol.  The addend must be zero.  */
11473                 r->r_addend = 0;
11474               else
11475                 {
11476                   off = (h->elf.root.u.def.value
11477                          + h->elf.root.u.def.section->output_offset
11478                          + h->elf.root.u.def.section->output_section->vma);
11479                   r->r_addend -= off;
11480                 }
11481             }
11482         }
11483       break;
11484
11485     case ppc_stub_plt_branch:
11486     case ppc_stub_plt_branch_r2off:
11487       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11488                                          stub_entry->root.string + 9,
11489                                          FALSE, FALSE);
11490       if (br_entry == NULL)
11491         {
11492           _bfd_error_handler (_("can't find branch stub `%s'"),
11493                               stub_entry->root.string);
11494           htab->stub_error = TRUE;
11495           return FALSE;
11496         }
11497
11498       targ = (stub_entry->target_value
11499               + stub_entry->target_section->output_offset
11500               + stub_entry->target_section->output_section->vma);
11501       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11502         targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11503
11504       bfd_put_64 (htab->brlt->owner, targ,
11505                   htab->brlt->contents + br_entry->offset);
11506
11507       if (br_entry->iter == htab->stub_iteration)
11508         {
11509           br_entry->iter = 0;
11510
11511           if (htab->relbrlt != NULL)
11512             {
11513               /* Create a reloc for the branch lookup table entry.  */
11514               Elf_Internal_Rela rela;
11515               bfd_byte *rl;
11516
11517               rela.r_offset = (br_entry->offset
11518                                + htab->brlt->output_offset
11519                                + htab->brlt->output_section->vma);
11520               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11521               rela.r_addend = targ;
11522
11523               rl = htab->relbrlt->contents;
11524               rl += (htab->relbrlt->reloc_count++
11525                      * sizeof (Elf64_External_Rela));
11526               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11527             }
11528           else if (info->emitrelocations)
11529             {
11530               r = get_relocs (htab->brlt, 1);
11531               if (r == NULL)
11532                 return FALSE;
11533               /* brlt, being SEC_LINKER_CREATED does not go through the
11534                  normal reloc processing.  Symbols and offsets are not
11535                  translated from input file to output file form, so
11536                  set up the offset per the output file.  */
11537               r->r_offset = (br_entry->offset
11538                              + htab->brlt->output_offset
11539                              + htab->brlt->output_section->vma);
11540               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11541               r->r_addend = targ;
11542             }
11543         }
11544
11545       targ = (br_entry->offset
11546               + htab->brlt->output_offset
11547               + htab->brlt->output_section->vma);
11548
11549       off = (elf_gp (info->output_bfd)
11550              + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11551       off = targ - off;
11552
11553       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11554         {
11555           info->callbacks->einfo
11556             (_("%P: linkage table error against `%pT'\n"),
11557              stub_entry->root.string);
11558           bfd_set_error (bfd_error_bad_value);
11559           htab->stub_error = TRUE;
11560           return FALSE;
11561         }
11562
11563       if (info->emitrelocations)
11564         {
11565           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11566           if (r == NULL)
11567             return FALSE;
11568           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11569           if (bfd_big_endian (info->output_bfd))
11570             r[0].r_offset += 2;
11571           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11572             r[0].r_offset += 4;
11573           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11574           r[0].r_addend = targ;
11575           if (PPC_HA (off) != 0)
11576             {
11577               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11578               r[1].r_offset = r[0].r_offset + 4;
11579               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11580               r[1].r_addend = r[0].r_addend;
11581             }
11582         }
11583
11584       p = loc;
11585       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11586         {
11587           if (PPC_HA (off) != 0)
11588             {
11589               bfd_put_32 (htab->params->stub_bfd,
11590                           ADDIS_R12_R2 | PPC_HA (off), p);
11591               p += 4;
11592               bfd_put_32 (htab->params->stub_bfd,
11593                           LD_R12_0R12 | PPC_LO (off), p);
11594             }
11595           else
11596             bfd_put_32 (htab->params->stub_bfd,
11597                         LD_R12_0R2 | PPC_LO (off), p);
11598         }
11599       else
11600         {
11601           bfd_vma r2off = get_r2off (info, stub_entry);
11602
11603           if (r2off == (bfd_vma) -1)
11604             {
11605               htab->stub_error = TRUE;
11606               return FALSE;
11607             }
11608
11609           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11610           p += 4;
11611           if (PPC_HA (off) != 0)
11612             {
11613               bfd_put_32 (htab->params->stub_bfd,
11614                           ADDIS_R12_R2 | PPC_HA (off), p);
11615               p += 4;
11616               bfd_put_32 (htab->params->stub_bfd,
11617                           LD_R12_0R12 | PPC_LO (off), p);
11618             }
11619           else
11620             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11621
11622           if (PPC_HA (r2off) != 0)
11623             {
11624               p += 4;
11625               bfd_put_32 (htab->params->stub_bfd,
11626                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11627             }
11628           if (PPC_LO (r2off) != 0)
11629             {
11630               p += 4;
11631               bfd_put_32 (htab->params->stub_bfd,
11632                           ADDI_R2_R2 | PPC_LO (r2off), p);
11633             }
11634         }
11635       p += 4;
11636       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11637       p += 4;
11638       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11639       p += 4;
11640       break;
11641
11642     case ppc_stub_long_branch_notoc:
11643     case ppc_stub_long_branch_both:
11644     case ppc_stub_plt_branch_notoc:
11645     case ppc_stub_plt_branch_both:
11646     case ppc_stub_plt_call_notoc:
11647     case ppc_stub_plt_call_both:
11648       p = loc;
11649       off = (8 + stub_entry->stub_offset
11650              + stub_entry->group->stub_sec->output_offset
11651              + stub_entry->group->stub_sec->output_section->vma);
11652       if (stub_entry->stub_type == ppc_stub_long_branch_both
11653           || stub_entry->stub_type == ppc_stub_plt_branch_both
11654           || stub_entry->stub_type == ppc_stub_plt_call_both)
11655         {
11656           off += 4;
11657           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11658           p += 4;
11659         }
11660       if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11661         {
11662           targ = stub_entry->plt_ent->plt.offset & ~1;
11663           if (targ >= (bfd_vma) -2)
11664             abort ();
11665
11666           plt = htab->elf.splt;
11667           if (!htab->elf.dynamic_sections_created
11668               || stub_entry->h == NULL
11669               || stub_entry->h->elf.dynindx == -1)
11670             {
11671               if (stub_entry->symtype == STT_GNU_IFUNC)
11672                 plt = htab->elf.iplt;
11673               else
11674                 plt = htab->pltlocal;
11675             }
11676           targ += plt->output_offset + plt->output_section->vma;
11677         }
11678       else
11679         targ = (stub_entry->target_value
11680                 + stub_entry->target_section->output_offset
11681                 + stub_entry->target_section->output_section->vma);
11682       off = targ - off;
11683       bfd_put_32 (htab->params->stub_bfd, MFLR_R12, p);
11684       p += 4;
11685       bfd_put_32 (htab->params->stub_bfd, BCL_20_31, p);
11686       p += 4;
11687       bfd_put_32 (htab->params->stub_bfd, MFLR_R11, p);
11688       p += 4;
11689       bfd_put_32 (htab->params->stub_bfd, MTLR_R12, p);
11690       p += 4;
11691       p = build_offset (htab->params->stub_bfd, p, off,
11692                         stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11693       if (stub_entry->stub_type == ppc_stub_long_branch_notoc)
11694         {
11695           off += 8;
11696           bfd_put_32 (htab->params->stub_bfd,
11697                       B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11698         }
11699       else if (stub_entry->stub_type == ppc_stub_long_branch_both)
11700         {
11701           off += 12;
11702           bfd_put_32 (htab->params->stub_bfd,
11703                       B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11704         }
11705       else
11706         {
11707           bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11708           p += 4;
11709           bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11710         }
11711       p += 4;
11712       break;
11713
11714     case ppc_stub_plt_call:
11715     case ppc_stub_plt_call_r2save:
11716       if (stub_entry->h != NULL
11717           && stub_entry->h->is_func_descriptor
11718           && stub_entry->h->oh != NULL)
11719         {
11720           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11721
11722           /* If the old-ABI "dot-symbol" is undefined make it weak so
11723              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11724           if (fh->elf.root.type == bfd_link_hash_undefined
11725               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11726                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11727             fh->elf.root.type = bfd_link_hash_undefweak;
11728         }
11729
11730       /* Now build the stub.  */
11731       targ = stub_entry->plt_ent->plt.offset & ~1;
11732       if (targ >= (bfd_vma) -2)
11733         abort ();
11734
11735       plt = htab->elf.splt;
11736       if (!htab->elf.dynamic_sections_created
11737           || stub_entry->h == NULL
11738           || stub_entry->h->elf.dynindx == -1)
11739         {
11740           if (stub_entry->symtype == STT_GNU_IFUNC)
11741             plt = htab->elf.iplt;
11742           else
11743             plt = htab->pltlocal;
11744         }
11745       targ += plt->output_offset + plt->output_section->vma;
11746
11747       off = (elf_gp (info->output_bfd)
11748              + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11749       off = targ - off;
11750
11751       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11752         {
11753           info->callbacks->einfo
11754             /* xgettext:c-format */
11755             (_("%P: linkage table error against `%pT'\n"),
11756              stub_entry->h != NULL
11757              ? stub_entry->h->elf.root.root.string
11758              : "<local sym>");
11759           bfd_set_error (bfd_error_bad_value);
11760           htab->stub_error = TRUE;
11761           return FALSE;
11762         }
11763
11764       r = NULL;
11765       if (info->emitrelocations)
11766         {
11767           r = get_relocs (stub_entry->group->stub_sec,
11768                           ((PPC_HA (off) != 0)
11769                            + (htab->opd_abi
11770                               ? 2 + (htab->params->plt_static_chain
11771                                      && PPC_HA (off + 16) == PPC_HA (off))
11772                               : 1)));
11773           if (r == NULL)
11774             return FALSE;
11775           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11776           if (bfd_big_endian (info->output_bfd))
11777             r[0].r_offset += 2;
11778           r[0].r_addend = targ;
11779         }
11780       if (stub_entry->h != NULL
11781           && (stub_entry->h == htab->tls_get_addr_fd
11782               || stub_entry->h == htab->tls_get_addr)
11783           && htab->params->tls_get_addr_opt)
11784         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11785       else
11786         p = build_plt_stub (htab, stub_entry, loc, off, r);
11787       break;
11788
11789     case ppc_stub_save_res:
11790       return TRUE;
11791
11792     default:
11793       BFD_FAIL ();
11794       return FALSE;
11795     }
11796
11797   stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11798
11799   if (htab->params->emit_stub_syms)
11800     {
11801       struct elf_link_hash_entry *h;
11802       size_t len1, len2;
11803       char *name;
11804       const char *const stub_str[] = { "long_branch",
11805                                        "long_branch",
11806                                        "long_branch",
11807                                        "long_branch",
11808                                        "plt_branch",
11809                                        "plt_branch",
11810                                        "plt_branch",
11811                                        "plt_branch",
11812                                        "plt_call",
11813                                        "plt_call",
11814                                        "plt_call",
11815                                        "plt_call" };
11816
11817       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11818       len2 = strlen (stub_entry->root.string);
11819       name = bfd_malloc (len1 + len2 + 2);
11820       if (name == NULL)
11821         return FALSE;
11822       memcpy (name, stub_entry->root.string, 9);
11823       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11824       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11825       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11826       if (h == NULL)
11827         return FALSE;
11828       if (h->root.type == bfd_link_hash_new)
11829         {
11830           h->root.type = bfd_link_hash_defined;
11831           h->root.u.def.section = stub_entry->group->stub_sec;
11832           h->root.u.def.value = stub_entry->stub_offset;
11833           h->ref_regular = 1;
11834           h->def_regular = 1;
11835           h->ref_regular_nonweak = 1;
11836           h->forced_local = 1;
11837           h->non_elf = 0;
11838           h->root.linker_def = 1;
11839         }
11840     }
11841
11842   return TRUE;
11843 }
11844
11845 /* As above, but don't actually build the stub.  Just bump offset so
11846    we know stub section sizes, and select plt_branch stubs where
11847    long_branch stubs won't do.  */
11848
11849 static bfd_boolean
11850 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11851 {
11852   struct ppc_stub_hash_entry *stub_entry;
11853   struct bfd_link_info *info;
11854   struct ppc_link_hash_table *htab;
11855   bfd_vma targ, off;
11856   int size;
11857
11858   /* Massage our args to the form they really have.  */
11859   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11860   info = in_arg;
11861
11862   htab = ppc_hash_table (info);
11863   if (htab == NULL)
11864     return FALSE;
11865
11866   /* Make a note of the offset within the stubs for this entry.  */
11867   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11868
11869   if (stub_entry->h != NULL
11870       && stub_entry->h->save_res
11871       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11872       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11873     {
11874       /* Don't make stubs to out-of-line register save/restore
11875          functions.  Instead, emit copies of the functions.  */
11876       stub_entry->group->needs_save_res = 1;
11877       stub_entry->stub_type = ppc_stub_save_res;
11878       return TRUE;
11879     }
11880
11881   if (stub_entry->stub_type >= ppc_stub_plt_call
11882       && stub_entry->stub_type <= ppc_stub_plt_call_both)
11883     {
11884       asection *plt;
11885       targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11886       if (targ >= (bfd_vma) -2)
11887         abort ();
11888       plt = htab->elf.splt;
11889       if (!htab->elf.dynamic_sections_created
11890           || stub_entry->h == NULL
11891           || stub_entry->h->elf.dynindx == -1)
11892         {
11893           if (stub_entry->symtype == STT_GNU_IFUNC)
11894             plt = htab->elf.iplt;
11895           else
11896             plt = htab->pltlocal;
11897         }
11898       targ += plt->output_offset + plt->output_section->vma;
11899
11900       if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11901         {
11902           off = (8 + stub_entry->stub_offset
11903                  + stub_entry->group->stub_sec->output_offset
11904                  + stub_entry->group->stub_sec->output_section->vma);
11905           if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11906             off += 4;
11907         }
11908       else
11909         off = (elf_gp (info->output_bfd)
11910                + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11911
11912       if (htab->params->plt_stub_align != 0)
11913         {
11914           unsigned pad = plt_stub_pad (htab, stub_entry, targ - off);
11915
11916           stub_entry->group->stub_sec->size += pad;
11917           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11918           if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11919             off += pad;
11920         }
11921
11922       off = targ - off;
11923       size = plt_stub_size (htab, stub_entry, off);
11924
11925       if (stub_entry->stub_type < ppc_stub_plt_call_notoc)
11926         {
11927           if (stub_entry->h != NULL
11928               && (stub_entry->h == htab->tls_get_addr_fd
11929                   || stub_entry->h == htab->tls_get_addr)
11930               && htab->params->tls_get_addr_opt
11931               && (ALWAYS_EMIT_R2SAVE
11932                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11933             stub_entry->group->tls_get_addr_opt_bctrl
11934               = stub_entry->stub_offset + size - 5 * 4;
11935
11936           if (info->emitrelocations)
11937             {
11938               stub_entry->group->stub_sec->reloc_count
11939                 += ((PPC_HA (off) != 0)
11940                     + (htab->opd_abi
11941                        ? 2 + (htab->params->plt_static_chain
11942                               && PPC_HA (off + 16) == PPC_HA (off))
11943                        : 1));
11944               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11945             }
11946         }
11947     }
11948   else
11949     {
11950       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11951          variants.  */
11952       bfd_vma r2off = 0;
11953       bfd_vma local_off = 0;
11954
11955       targ = (stub_entry->target_value
11956               + stub_entry->target_section->output_offset
11957               + stub_entry->target_section->output_section->vma);
11958       off = (stub_entry->stub_offset
11959              + stub_entry->group->stub_sec->output_offset
11960              + stub_entry->group->stub_sec->output_section->vma);
11961
11962       /* Reset the stub type from the plt variant in case we now
11963          can reach with a shorter stub.  */
11964       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11965         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11966
11967       size = 4;
11968       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11969         {
11970           r2off = get_r2off (info, stub_entry);
11971           if (r2off == (bfd_vma) -1)
11972             {
11973               htab->stub_error = TRUE;
11974               return FALSE;
11975             }
11976           size = 8;
11977           if (PPC_HA (r2off) != 0)
11978             size += 4;
11979           if (PPC_LO (r2off) != 0)
11980             size += 4;
11981           off += size - 4;
11982         }
11983       else if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
11984         {
11985           size = 20 + size_offset (targ - (off + 8));
11986           if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
11987             size += 4;
11988           off += size - 4;
11989         }
11990       off = targ - off;
11991
11992       if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
11993         {
11994           if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11995             {
11996               stub_entry->stub_type += (ppc_stub_plt_branch_notoc
11997                                         - ppc_stub_long_branch_notoc);
11998               size += 4;
11999             }
12000         }
12001       else
12002         {
12003           local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12004
12005           /* If the branch offset is too big, use a ppc_stub_plt_branch.
12006              Do the same for -R objects without function descriptors.  */
12007           if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
12008                && r2off == 0
12009                && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12010               || off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off)
12011             {
12012               struct ppc_branch_hash_entry *br_entry;
12013
12014               br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12015                                                  stub_entry->root.string + 9,
12016                                                  TRUE, FALSE);
12017               if (br_entry == NULL)
12018                 {
12019                   _bfd_error_handler (_("can't build branch stub `%s'"),
12020                                       stub_entry->root.string);
12021                   htab->stub_error = TRUE;
12022                   return FALSE;
12023                 }
12024
12025               if (br_entry->iter != htab->stub_iteration)
12026                 {
12027                   br_entry->iter = htab->stub_iteration;
12028                   br_entry->offset = htab->brlt->size;
12029                   htab->brlt->size += 8;
12030
12031                   if (htab->relbrlt != NULL)
12032                     htab->relbrlt->size += sizeof (Elf64_External_Rela);
12033                   else if (info->emitrelocations)
12034                     {
12035                       htab->brlt->reloc_count += 1;
12036                       htab->brlt->flags |= SEC_RELOC;
12037                     }
12038                 }
12039
12040               targ = (br_entry->offset
12041                       + htab->brlt->output_offset
12042                       + htab->brlt->output_section->vma);
12043               off = (elf_gp (info->output_bfd)
12044                      + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12045               off = targ - off;
12046
12047               if (info->emitrelocations)
12048                 {
12049                   stub_entry->group->stub_sec->reloc_count
12050                     += 1 + (PPC_HA (off) != 0);
12051                   stub_entry->group->stub_sec->flags |= SEC_RELOC;
12052                 }
12053
12054               stub_entry->stub_type
12055                 += ppc_stub_plt_branch - ppc_stub_long_branch;
12056               if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
12057                 {
12058                   size = 12;
12059                   if (PPC_HA (off) != 0)
12060                     size = 16;
12061                 }
12062               else
12063                 {
12064                   size = 16;
12065                   if (PPC_HA (off) != 0)
12066                     size += 4;
12067
12068                   if (PPC_HA (r2off) != 0)
12069                     size += 4;
12070                   if (PPC_LO (r2off) != 0)
12071                     size += 4;
12072                 }
12073             }
12074           else if (info->emitrelocations)
12075             {
12076               stub_entry->group->stub_sec->reloc_count += 1;
12077               stub_entry->group->stub_sec->flags |= SEC_RELOC;
12078             }
12079         }
12080     }
12081
12082   stub_entry->group->stub_sec->size += size;
12083   return TRUE;
12084 }
12085
12086 /* Set up various things so that we can make a list of input sections
12087    for each output section included in the link.  Returns -1 on error,
12088    0 when no stubs will be needed, and 1 on success.  */
12089
12090 int
12091 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12092 {
12093   unsigned int id;
12094   bfd_size_type amt;
12095   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12096
12097   if (htab == NULL)
12098     return -1;
12099
12100   htab->sec_info_arr_size = _bfd_section_id;
12101   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12102   htab->sec_info = bfd_zmalloc (amt);
12103   if (htab->sec_info == NULL)
12104     return -1;
12105
12106   /* Set toc_off for com, und, abs and ind sections.  */
12107   for (id = 0; id < 3; id++)
12108     htab->sec_info[id].toc_off = TOC_BASE_OFF;
12109
12110   return 1;
12111 }
12112
12113 /* Set up for first pass at multitoc partitioning.  */
12114
12115 void
12116 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12117 {
12118   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12119
12120   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12121   htab->toc_bfd = NULL;
12122   htab->toc_first_sec = NULL;
12123 }
12124
12125 /* The linker repeatedly calls this function for each TOC input section
12126    and linker generated GOT section.  Group input bfds such that the toc
12127    within a group is less than 64k in size.  */
12128
12129 bfd_boolean
12130 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12131 {
12132   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12133   bfd_vma addr, off, limit;
12134
12135   if (htab == NULL)
12136     return FALSE;
12137
12138   if (!htab->second_toc_pass)
12139     {
12140       /* Keep track of the first .toc or .got section for this input bfd.  */
12141       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
12142
12143       if (new_bfd)
12144         {
12145           htab->toc_bfd = isec->owner;
12146           htab->toc_first_sec = isec;
12147         }
12148
12149       addr = isec->output_offset + isec->output_section->vma;
12150       off = addr - htab->toc_curr;
12151       limit = 0x80008000;
12152       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12153         limit = 0x10000;
12154       if (off + isec->size > limit)
12155         {
12156           addr = (htab->toc_first_sec->output_offset
12157                   + htab->toc_first_sec->output_section->vma);
12158           htab->toc_curr = addr;
12159           htab->toc_curr &= -TOC_BASE_ALIGN;
12160         }
12161
12162       /* toc_curr is the base address of this toc group.  Set elf_gp
12163          for the input section to be the offset relative to the
12164          output toc base plus 0x8000.  Making the input elf_gp an
12165          offset allows us to move the toc as a whole without
12166          recalculating input elf_gp.  */
12167       off = htab->toc_curr - elf_gp (info->output_bfd);
12168       off += TOC_BASE_OFF;
12169
12170       /* Die if someone uses a linker script that doesn't keep input
12171          file .toc and .got together.  */
12172       if (new_bfd
12173           && elf_gp (isec->owner) != 0
12174           && elf_gp (isec->owner) != off)
12175         return FALSE;
12176
12177       elf_gp (isec->owner) = off;
12178       return TRUE;
12179     }
12180
12181   /* During the second pass toc_first_sec points to the start of
12182      a toc group, and toc_curr is used to track the old elf_gp.
12183      We use toc_bfd to ensure we only look at each bfd once.  */
12184   if (htab->toc_bfd == isec->owner)
12185     return TRUE;
12186   htab->toc_bfd = isec->owner;
12187
12188   if (htab->toc_first_sec == NULL
12189       || htab->toc_curr != elf_gp (isec->owner))
12190     {
12191       htab->toc_curr = elf_gp (isec->owner);
12192       htab->toc_first_sec = isec;
12193     }
12194   addr = (htab->toc_first_sec->output_offset
12195           + htab->toc_first_sec->output_section->vma);
12196   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12197   elf_gp (isec->owner) = off;
12198
12199   return TRUE;
12200 }
12201
12202 /* Called via elf_link_hash_traverse to merge GOT entries for global
12203    symbol H.  */
12204
12205 static bfd_boolean
12206 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12207 {
12208   if (h->root.type == bfd_link_hash_indirect)
12209     return TRUE;
12210
12211   merge_got_entries (&h->got.glist);
12212
12213   return TRUE;
12214 }
12215
12216 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12217    symbol H.  */
12218
12219 static bfd_boolean
12220 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12221 {
12222   struct got_entry *gent;
12223
12224   if (h->root.type == bfd_link_hash_indirect)
12225     return TRUE;
12226
12227   for (gent = h->got.glist; gent != NULL; gent = gent->next)
12228     if (!gent->is_indirect)
12229       allocate_got (h, (struct bfd_link_info *) inf, gent);
12230   return TRUE;
12231 }
12232
12233 /* Called on the first multitoc pass after the last call to
12234    ppc64_elf_next_toc_section.  This function removes duplicate GOT
12235    entries.  */
12236
12237 bfd_boolean
12238 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12239 {
12240   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12241   struct bfd *ibfd, *ibfd2;
12242   bfd_boolean done_something;
12243
12244   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12245
12246   if (!htab->do_multi_toc)
12247     return FALSE;
12248
12249   /* Merge global sym got entries within a toc group.  */
12250   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12251
12252   /* And tlsld_got.  */
12253   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12254     {
12255       struct got_entry *ent, *ent2;
12256
12257       if (!is_ppc64_elf (ibfd))
12258         continue;
12259
12260       ent = ppc64_tlsld_got (ibfd);
12261       if (!ent->is_indirect
12262           && ent->got.offset != (bfd_vma) -1)
12263         {
12264           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12265             {
12266               if (!is_ppc64_elf (ibfd2))
12267                 continue;
12268
12269               ent2 = ppc64_tlsld_got (ibfd2);
12270               if (!ent2->is_indirect
12271                   && ent2->got.offset != (bfd_vma) -1
12272                   && elf_gp (ibfd2) == elf_gp (ibfd))
12273                 {
12274                   ent2->is_indirect = TRUE;
12275                   ent2->got.ent = ent;
12276                 }
12277             }
12278         }
12279     }
12280
12281   /* Zap sizes of got sections.  */
12282   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12283   htab->elf.irelplt->size -= htab->got_reli_size;
12284   htab->got_reli_size = 0;
12285
12286   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12287     {
12288       asection *got, *relgot;
12289
12290       if (!is_ppc64_elf (ibfd))
12291         continue;
12292
12293       got = ppc64_elf_tdata (ibfd)->got;
12294       if (got != NULL)
12295         {
12296           got->rawsize = got->size;
12297           got->size = 0;
12298           relgot = ppc64_elf_tdata (ibfd)->relgot;
12299           relgot->rawsize = relgot->size;
12300           relgot->size = 0;
12301         }
12302     }
12303
12304   /* Now reallocate the got, local syms first.  We don't need to
12305      allocate section contents again since we never increase size.  */
12306   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12307     {
12308       struct got_entry **lgot_ents;
12309       struct got_entry **end_lgot_ents;
12310       struct plt_entry **local_plt;
12311       struct plt_entry **end_local_plt;
12312       unsigned char *lgot_masks;
12313       bfd_size_type locsymcount;
12314       Elf_Internal_Shdr *symtab_hdr;
12315       asection *s;
12316
12317       if (!is_ppc64_elf (ibfd))
12318         continue;
12319
12320       lgot_ents = elf_local_got_ents (ibfd);
12321       if (!lgot_ents)
12322         continue;
12323
12324       symtab_hdr = &elf_symtab_hdr (ibfd);
12325       locsymcount = symtab_hdr->sh_info;
12326       end_lgot_ents = lgot_ents + locsymcount;
12327       local_plt = (struct plt_entry **) end_lgot_ents;
12328       end_local_plt = local_plt + locsymcount;
12329       lgot_masks = (unsigned char *) end_local_plt;
12330       s = ppc64_elf_tdata (ibfd)->got;
12331       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12332         {
12333           struct got_entry *ent;
12334
12335           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12336             {
12337               unsigned int ent_size = 8;
12338               unsigned int rel_size = sizeof (Elf64_External_Rela);
12339
12340               ent->got.offset = s->size;
12341               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12342                 {
12343                   ent_size *= 2;
12344                   rel_size *= 2;
12345                 }
12346               s->size += ent_size;
12347               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12348                 {
12349                   htab->elf.irelplt->size += rel_size;
12350                   htab->got_reli_size += rel_size;
12351                 }
12352               else if (bfd_link_pic (info)
12353                        && !((ent->tls_type & TLS_TPREL) != 0
12354                             && bfd_link_executable (info)))
12355                 {
12356                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12357                   srel->size += rel_size;
12358                 }
12359             }
12360         }
12361     }
12362
12363   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12364
12365   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12366     {
12367       struct got_entry *ent;
12368
12369       if (!is_ppc64_elf (ibfd))
12370         continue;
12371
12372       ent = ppc64_tlsld_got (ibfd);
12373       if (!ent->is_indirect
12374           && ent->got.offset != (bfd_vma) -1)
12375         {
12376           asection *s = ppc64_elf_tdata (ibfd)->got;
12377           ent->got.offset = s->size;
12378           s->size += 16;
12379           if (bfd_link_pic (info))
12380             {
12381               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12382               srel->size += sizeof (Elf64_External_Rela);
12383             }
12384         }
12385     }
12386
12387   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12388   if (!done_something)
12389     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12390       {
12391         asection *got;
12392
12393         if (!is_ppc64_elf (ibfd))
12394           continue;
12395
12396         got = ppc64_elf_tdata (ibfd)->got;
12397         if (got != NULL)
12398           {
12399             done_something = got->rawsize != got->size;
12400             if (done_something)
12401               break;
12402           }
12403       }
12404
12405   if (done_something)
12406     (*htab->params->layout_sections_again) ();
12407
12408   /* Set up for second pass over toc sections to recalculate elf_gp
12409      on input sections.  */
12410   htab->toc_bfd = NULL;
12411   htab->toc_first_sec = NULL;
12412   htab->second_toc_pass = TRUE;
12413   return done_something;
12414 }
12415
12416 /* Called after second pass of multitoc partitioning.  */
12417
12418 void
12419 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12420 {
12421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12422
12423   /* After the second pass, toc_curr tracks the TOC offset used
12424      for code sections below in ppc64_elf_next_input_section.  */
12425   htab->toc_curr = TOC_BASE_OFF;
12426 }
12427
12428 /* No toc references were found in ISEC.  If the code in ISEC makes no
12429    calls, then there's no need to use toc adjusting stubs when branching
12430    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12431    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12432    needed, and 2 if a cyclical call-graph was found but no other reason
12433    for a stub was detected.  If called from the top level, a return of
12434    2 means the same as a return of 0.  */
12435
12436 static int
12437 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12438 {
12439   int ret;
12440
12441   /* Mark this section as checked.  */
12442   isec->call_check_done = 1;
12443
12444   /* We know none of our code bearing sections will need toc stubs.  */
12445   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12446     return 0;
12447
12448   if (isec->size == 0)
12449     return 0;
12450
12451   if (isec->output_section == NULL)
12452     return 0;
12453
12454   ret = 0;
12455   if (isec->reloc_count != 0)
12456     {
12457       Elf_Internal_Rela *relstart, *rel;
12458       Elf_Internal_Sym *local_syms;
12459       struct ppc_link_hash_table *htab;
12460
12461       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12462                                             info->keep_memory);
12463       if (relstart == NULL)
12464         return -1;
12465
12466       /* Look for branches to outside of this section.  */
12467       local_syms = NULL;
12468       htab = ppc_hash_table (info);
12469       if (htab == NULL)
12470         return -1;
12471
12472       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12473         {
12474           enum elf_ppc64_reloc_type r_type;
12475           unsigned long r_symndx;
12476           struct elf_link_hash_entry *h;
12477           struct ppc_link_hash_entry *eh;
12478           Elf_Internal_Sym *sym;
12479           asection *sym_sec;
12480           struct _opd_sec_data *opd;
12481           bfd_vma sym_value;
12482           bfd_vma dest;
12483
12484           r_type = ELF64_R_TYPE (rel->r_info);
12485           if (r_type != R_PPC64_REL24
12486               && r_type != R_PPC64_REL24_NOTOC
12487               && r_type != R_PPC64_REL14
12488               && r_type != R_PPC64_REL14_BRTAKEN
12489               && r_type != R_PPC64_REL14_BRNTAKEN
12490               && r_type != R_PPC64_PLTCALL)
12491             continue;
12492
12493           r_symndx = ELF64_R_SYM (rel->r_info);
12494           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12495                           isec->owner))
12496             {
12497               ret = -1;
12498               break;
12499             }
12500
12501           /* Calls to dynamic lib functions go through a plt call stub
12502              that uses r2.  */
12503           eh = (struct ppc_link_hash_entry *) h;
12504           if (eh != NULL
12505               && (eh->elf.plt.plist != NULL
12506                   || (eh->oh != NULL
12507                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12508             {
12509               ret = 1;
12510               break;
12511             }
12512
12513           if (sym_sec == NULL)
12514             /* Ignore other undefined symbols.  */
12515             continue;
12516
12517           /* Assume branches to other sections not included in the
12518              link need stubs too, to cover -R and absolute syms.  */
12519           if (sym_sec->output_section == NULL)
12520             {
12521               ret = 1;
12522               break;
12523             }
12524
12525           if (h == NULL)
12526             sym_value = sym->st_value;
12527           else
12528             {
12529               if (h->root.type != bfd_link_hash_defined
12530                   && h->root.type != bfd_link_hash_defweak)
12531                 abort ();
12532               sym_value = h->root.u.def.value;
12533             }
12534           sym_value += rel->r_addend;
12535
12536           /* If this branch reloc uses an opd sym, find the code section.  */
12537           opd = get_opd_info (sym_sec);
12538           if (opd != NULL)
12539             {
12540               if (h == NULL && opd->adjust != NULL)
12541                 {
12542                   long adjust;
12543
12544                   adjust = opd->adjust[OPD_NDX (sym_value)];
12545                   if (adjust == -1)
12546                     /* Assume deleted functions won't ever be called.  */
12547                     continue;
12548                   sym_value += adjust;
12549                 }
12550
12551               dest = opd_entry_value (sym_sec, sym_value,
12552                                       &sym_sec, NULL, FALSE);
12553               if (dest == (bfd_vma) -1)
12554                 continue;
12555             }
12556           else
12557             dest = (sym_value
12558                     + sym_sec->output_offset
12559                     + sym_sec->output_section->vma);
12560
12561           /* Ignore branch to self.  */
12562           if (sym_sec == isec)
12563             continue;
12564
12565           /* If the called function uses the toc, we need a stub.  */
12566           if (sym_sec->has_toc_reloc
12567               || sym_sec->makes_toc_func_call)
12568             {
12569               ret = 1;
12570               break;
12571             }
12572
12573           /* Assume any branch that needs a long branch stub might in fact
12574              need a plt_branch stub.  A plt_branch stub uses r2.  */
12575           else if (dest - (isec->output_offset
12576                            + isec->output_section->vma
12577                            + rel->r_offset) + (1 << 25)
12578                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12579                                                              ? h->other
12580                                                              : sym->st_other))
12581             {
12582               ret = 1;
12583               break;
12584             }
12585
12586           /* If calling back to a section in the process of being
12587              tested, we can't say for sure that no toc adjusting stubs
12588              are needed, so don't return zero.  */
12589           else if (sym_sec->call_check_in_progress)
12590             ret = 2;
12591
12592           /* Branches to another section that itself doesn't have any TOC
12593              references are OK.  Recursively call ourselves to check.  */
12594           else if (!sym_sec->call_check_done)
12595             {
12596               int recur;
12597
12598               /* Mark current section as indeterminate, so that other
12599                  sections that call back to current won't be marked as
12600                  known.  */
12601               isec->call_check_in_progress = 1;
12602               recur = toc_adjusting_stub_needed (info, sym_sec);
12603               isec->call_check_in_progress = 0;
12604
12605               if (recur != 0)
12606                 {
12607                   ret = recur;
12608                   if (recur != 2)
12609                     break;
12610                 }
12611             }
12612         }
12613
12614       if (local_syms != NULL
12615           && (elf_symtab_hdr (isec->owner).contents
12616               != (unsigned char *) local_syms))
12617         free (local_syms);
12618       if (elf_section_data (isec)->relocs != relstart)
12619         free (relstart);
12620     }
12621
12622   if ((ret & 1) == 0
12623       && isec->map_head.s != NULL
12624       && (strcmp (isec->output_section->name, ".init") == 0
12625           || strcmp (isec->output_section->name, ".fini") == 0))
12626     {
12627       if (isec->map_head.s->has_toc_reloc
12628           || isec->map_head.s->makes_toc_func_call)
12629         ret = 1;
12630       else if (!isec->map_head.s->call_check_done)
12631         {
12632           int recur;
12633           isec->call_check_in_progress = 1;
12634           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12635           isec->call_check_in_progress = 0;
12636           if (recur != 0)
12637             ret = recur;
12638         }
12639     }
12640
12641   if (ret == 1)
12642     isec->makes_toc_func_call = 1;
12643
12644   return ret;
12645 }
12646
12647 /* The linker repeatedly calls this function for each input section,
12648    in the order that input sections are linked into output sections.
12649    Build lists of input sections to determine groupings between which
12650    we may insert linker stubs.  */
12651
12652 bfd_boolean
12653 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12654 {
12655   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12656
12657   if (htab == NULL)
12658     return FALSE;
12659
12660   if ((isec->output_section->flags & SEC_CODE) != 0
12661       && isec->output_section->id < htab->sec_info_arr_size)
12662     {
12663       /* This happens to make the list in reverse order,
12664          which is what we want.  */
12665       htab->sec_info[isec->id].u.list
12666         = htab->sec_info[isec->output_section->id].u.list;
12667       htab->sec_info[isec->output_section->id].u.list = isec;
12668     }
12669
12670   if (htab->multi_toc_needed)
12671     {
12672       /* Analyse sections that aren't already flagged as needing a
12673          valid toc pointer.  Exclude .fixup for the linux kernel.
12674          .fixup contains branches, but only back to the function that
12675          hit an exception.  */
12676       if (!(isec->has_toc_reloc
12677             || (isec->flags & SEC_CODE) == 0
12678             || strcmp (isec->name, ".fixup") == 0
12679             || isec->call_check_done))
12680         {
12681           if (toc_adjusting_stub_needed (info, isec) < 0)
12682             return FALSE;
12683         }
12684       /* Make all sections use the TOC assigned for this object file.
12685          This will be wrong for pasted sections;  We fix that in
12686          check_pasted_section().  */
12687       if (elf_gp (isec->owner) != 0)
12688         htab->toc_curr = elf_gp (isec->owner);
12689     }
12690
12691   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12692   return TRUE;
12693 }
12694
12695 /* Check that all .init and .fini sections use the same toc, if they
12696    have toc relocs.  */
12697
12698 static bfd_boolean
12699 check_pasted_section (struct bfd_link_info *info, const char *name)
12700 {
12701   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12702
12703   if (o != NULL)
12704     {
12705       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12706       bfd_vma toc_off = 0;
12707       asection *i;
12708
12709       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12710         if (i->has_toc_reloc)
12711           {
12712             if (toc_off == 0)
12713               toc_off = htab->sec_info[i->id].toc_off;
12714             else if (toc_off != htab->sec_info[i->id].toc_off)
12715               return FALSE;
12716           }
12717
12718       if (toc_off == 0)
12719         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12720           if (i->makes_toc_func_call)
12721             {
12722               toc_off = htab->sec_info[i->id].toc_off;
12723               break;
12724             }
12725
12726       /* Make sure the whole pasted function uses the same toc offset.  */
12727       if (toc_off != 0)
12728         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12729           htab->sec_info[i->id].toc_off = toc_off;
12730     }
12731   return TRUE;
12732 }
12733
12734 bfd_boolean
12735 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12736 {
12737   return (check_pasted_section (info, ".init")
12738           & check_pasted_section (info, ".fini"));
12739 }
12740
12741 /* See whether we can group stub sections together.  Grouping stub
12742    sections may result in fewer stubs.  More importantly, we need to
12743    put all .init* and .fini* stubs at the beginning of the .init or
12744    .fini output sections respectively, because glibc splits the
12745    _init and _fini functions into multiple parts.  Putting a stub in
12746    the middle of a function is not a good idea.  */
12747
12748 static bfd_boolean
12749 group_sections (struct bfd_link_info *info,
12750                 bfd_size_type stub_group_size,
12751                 bfd_boolean stubs_always_before_branch)
12752 {
12753   struct ppc_link_hash_table *htab;
12754   asection *osec;
12755   bfd_boolean suppress_size_errors;
12756
12757   htab = ppc_hash_table (info);
12758   if (htab == NULL)
12759     return FALSE;
12760
12761   suppress_size_errors = FALSE;
12762   if (stub_group_size == 1)
12763     {
12764       /* Default values.  */
12765       if (stubs_always_before_branch)
12766         stub_group_size = 0x1e00000;
12767       else
12768         stub_group_size = 0x1c00000;
12769       suppress_size_errors = TRUE;
12770     }
12771
12772   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12773     {
12774       asection *tail;
12775
12776       if (osec->id >= htab->sec_info_arr_size)
12777         continue;
12778
12779       tail = htab->sec_info[osec->id].u.list;
12780       while (tail != NULL)
12781         {
12782           asection *curr;
12783           asection *prev;
12784           bfd_size_type total;
12785           bfd_boolean big_sec;
12786           bfd_vma curr_toc;
12787           struct map_stub *group;
12788           bfd_size_type group_size;
12789
12790           curr = tail;
12791           total = tail->size;
12792           group_size = (ppc64_elf_section_data (tail) != NULL
12793                         && ppc64_elf_section_data (tail)->has_14bit_branch
12794                         ? stub_group_size >> 10 : stub_group_size);
12795
12796           big_sec = total > group_size;
12797           if (big_sec && !suppress_size_errors)
12798             /* xgettext:c-format */
12799             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12800                                 tail->owner, tail);
12801           curr_toc = htab->sec_info[tail->id].toc_off;
12802
12803           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12804                  && ((total += curr->output_offset - prev->output_offset)
12805                      < (ppc64_elf_section_data (prev) != NULL
12806                         && ppc64_elf_section_data (prev)->has_14bit_branch
12807                         ? (group_size = stub_group_size >> 10) : group_size))
12808                  && htab->sec_info[prev->id].toc_off == curr_toc)
12809             curr = prev;
12810
12811           /* OK, the size from the start of CURR to the end is less
12812              than group_size and thus can be handled by one stub
12813              section.  (or the tail section is itself larger than
12814              group_size, in which case we may be toast.)  We should
12815              really be keeping track of the total size of stubs added
12816              here, as stubs contribute to the final output section
12817              size.  That's a little tricky, and this way will only
12818              break if stubs added make the total size more than 2^25,
12819              ie. for the default stub_group_size, if stubs total more
12820              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12821           group = bfd_alloc (curr->owner, sizeof (*group));
12822           if (group == NULL)
12823             return FALSE;
12824           group->link_sec = curr;
12825           group->stub_sec = NULL;
12826           group->needs_save_res = 0;
12827           group->tls_get_addr_opt_bctrl = -1u;
12828           group->next = htab->group;
12829           htab->group = group;
12830           do
12831             {
12832               prev = htab->sec_info[tail->id].u.list;
12833               /* Set up this stub group.  */
12834               htab->sec_info[tail->id].u.group = group;
12835             }
12836           while (tail != curr && (tail = prev) != NULL);
12837
12838           /* But wait, there's more!  Input sections up to group_size
12839              bytes before the stub section can be handled by it too.
12840              Don't do this if we have a really large section after the
12841              stubs, as adding more stubs increases the chance that
12842              branches may not reach into the stub section.  */
12843           if (!stubs_always_before_branch && !big_sec)
12844             {
12845               total = 0;
12846               while (prev != NULL
12847                      && ((total += tail->output_offset - prev->output_offset)
12848                          < (ppc64_elf_section_data (prev) != NULL
12849                             && ppc64_elf_section_data (prev)->has_14bit_branch
12850                             ? (group_size = stub_group_size >> 10) : group_size))
12851                      && htab->sec_info[prev->id].toc_off == curr_toc)
12852                 {
12853                   tail = prev;
12854                   prev = htab->sec_info[tail->id].u.list;
12855                   htab->sec_info[tail->id].u.group = group;
12856                 }
12857             }
12858           tail = prev;
12859         }
12860     }
12861   return TRUE;
12862 }
12863
12864 static const unsigned char glink_eh_frame_cie[] =
12865 {
12866   0, 0, 0, 16,                          /* length.  */
12867   0, 0, 0, 0,                           /* id.  */
12868   1,                                    /* CIE version.  */
12869   'z', 'R', 0,                          /* Augmentation string.  */
12870   4,                                    /* Code alignment.  */
12871   0x78,                                 /* Data alignment.  */
12872   65,                                   /* RA reg.  */
12873   1,                                    /* Augmentation size.  */
12874   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12875   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12876 };
12877
12878 static size_t
12879 stub_eh_frame_size (struct map_stub *group, size_t align)
12880 {
12881   size_t this_size = 17;
12882   if (group->tls_get_addr_opt_bctrl != -1u)
12883     {
12884       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12885       if (to_bctrl < 64)
12886         this_size += 1;
12887       else if (to_bctrl < 256)
12888         this_size += 2;
12889       else if (to_bctrl < 65536)
12890         this_size += 3;
12891       else
12892         this_size += 5;
12893       this_size += 6;
12894     }
12895   this_size = (this_size + align - 1) & -align;
12896   return this_size;
12897 }
12898
12899 /* Stripping output sections is normally done before dynamic section
12900    symbols have been allocated.  This function is called later, and
12901    handles cases like htab->brlt which is mapped to its own output
12902    section.  */
12903
12904 static void
12905 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12906 {
12907   if (isec->size == 0
12908       && isec->output_section->size == 0
12909       && !(isec->output_section->flags & SEC_KEEP)
12910       && !bfd_section_removed_from_list (info->output_bfd,
12911                                          isec->output_section)
12912       && elf_section_data (isec->output_section)->dynindx == 0)
12913     {
12914       isec->output_section->flags |= SEC_EXCLUDE;
12915       bfd_section_list_remove (info->output_bfd, isec->output_section);
12916       info->output_bfd->section_count--;
12917     }
12918 }
12919
12920 /* Determine and set the size of the stub section for a final link.
12921
12922    The basic idea here is to examine all the relocations looking for
12923    PC-relative calls to a target that is unreachable with a "bl"
12924    instruction.  */
12925
12926 bfd_boolean
12927 ppc64_elf_size_stubs (struct bfd_link_info *info)
12928 {
12929   bfd_size_type stub_group_size;
12930   bfd_boolean stubs_always_before_branch;
12931   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12932
12933   if (htab == NULL)
12934     return FALSE;
12935
12936   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12937     htab->params->plt_thread_safe = 1;
12938   if (!htab->opd_abi)
12939     htab->params->plt_thread_safe = 0;
12940   else if (htab->params->plt_thread_safe == -1)
12941     {
12942       static const char *const thread_starter[] =
12943         {
12944           "pthread_create",
12945           /* libstdc++ */
12946           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12947           /* librt */
12948           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12949           "mq_notify", "create_timer",
12950           /* libanl */
12951           "getaddrinfo_a",
12952           /* libgomp */
12953           "GOMP_parallel",
12954           "GOMP_parallel_start",
12955           "GOMP_parallel_loop_static",
12956           "GOMP_parallel_loop_static_start",
12957           "GOMP_parallel_loop_dynamic",
12958           "GOMP_parallel_loop_dynamic_start",
12959           "GOMP_parallel_loop_guided",
12960           "GOMP_parallel_loop_guided_start",
12961           "GOMP_parallel_loop_runtime",
12962           "GOMP_parallel_loop_runtime_start",
12963           "GOMP_parallel_sections",
12964           "GOMP_parallel_sections_start",
12965           /* libgo */
12966           "__go_go",
12967         };
12968       unsigned i;
12969
12970       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12971         {
12972           struct elf_link_hash_entry *h;
12973           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12974                                     FALSE, FALSE, TRUE);
12975           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12976           if (htab->params->plt_thread_safe)
12977             break;
12978         }
12979     }
12980   stubs_always_before_branch = htab->params->group_size < 0;
12981   if (htab->params->group_size < 0)
12982     stub_group_size = -htab->params->group_size;
12983   else
12984     stub_group_size = htab->params->group_size;
12985
12986   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12987     return FALSE;
12988
12989 #define STUB_SHRINK_ITER 20
12990   /* Loop until no stubs added.  After iteration 20 of this loop we may
12991      exit on a stub section shrinking.  This is to break out of a
12992      pathological case where adding stubs on one iteration decreases
12993      section gaps (perhaps due to alignment), which then requires
12994      fewer or smaller stubs on the next iteration.  */
12995
12996   while (1)
12997     {
12998       bfd *input_bfd;
12999       unsigned int bfd_indx;
13000       struct map_stub *group;
13001
13002       htab->stub_iteration += 1;
13003
13004       for (input_bfd = info->input_bfds, bfd_indx = 0;
13005            input_bfd != NULL;
13006            input_bfd = input_bfd->link.next, bfd_indx++)
13007         {
13008           Elf_Internal_Shdr *symtab_hdr;
13009           asection *section;
13010           Elf_Internal_Sym *local_syms = NULL;
13011
13012           if (!is_ppc64_elf (input_bfd))
13013             continue;
13014
13015           /* We'll need the symbol table in a second.  */
13016           symtab_hdr = &elf_symtab_hdr (input_bfd);
13017           if (symtab_hdr->sh_info == 0)
13018             continue;
13019
13020           /* Walk over each section attached to the input bfd.  */
13021           for (section = input_bfd->sections;
13022                section != NULL;
13023                section = section->next)
13024             {
13025               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13026
13027               /* If there aren't any relocs, then there's nothing more
13028                  to do.  */
13029               if ((section->flags & SEC_RELOC) == 0
13030                   || (section->flags & SEC_ALLOC) == 0
13031                   || (section->flags & SEC_LOAD) == 0
13032                   || (section->flags & SEC_CODE) == 0
13033                   || section->reloc_count == 0)
13034                 continue;
13035
13036               /* If this section is a link-once section that will be
13037                  discarded, then don't create any stubs.  */
13038               if (section->output_section == NULL
13039                   || section->output_section->owner != info->output_bfd)
13040                 continue;
13041
13042               /* Get the relocs.  */
13043               internal_relocs
13044                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13045                                              info->keep_memory);
13046               if (internal_relocs == NULL)
13047                 goto error_ret_free_local;
13048
13049               /* Now examine each relocation.  */
13050               irela = internal_relocs;
13051               irelaend = irela + section->reloc_count;
13052               for (; irela < irelaend; irela++)
13053                 {
13054                   enum elf_ppc64_reloc_type r_type;
13055                   unsigned int r_indx;
13056                   enum ppc_stub_type stub_type;
13057                   struct ppc_stub_hash_entry *stub_entry;
13058                   asection *sym_sec, *code_sec;
13059                   bfd_vma sym_value, code_value;
13060                   bfd_vma destination;
13061                   unsigned long local_off;
13062                   bfd_boolean ok_dest;
13063                   struct ppc_link_hash_entry *hash;
13064                   struct ppc_link_hash_entry *fdh;
13065                   struct elf_link_hash_entry *h;
13066                   Elf_Internal_Sym *sym;
13067                   char *stub_name;
13068                   const asection *id_sec;
13069                   struct _opd_sec_data *opd;
13070                   struct plt_entry *plt_ent;
13071
13072                   r_type = ELF64_R_TYPE (irela->r_info);
13073                   r_indx = ELF64_R_SYM (irela->r_info);
13074
13075                   if (r_type >= R_PPC64_max)
13076                     {
13077                       bfd_set_error (bfd_error_bad_value);
13078                       goto error_ret_free_internal;
13079                     }
13080
13081                   /* Only look for stubs on branch instructions.  */
13082                   if (r_type != R_PPC64_REL24
13083                       && r_type != R_PPC64_REL24_NOTOC
13084                       && r_type != R_PPC64_REL14
13085                       && r_type != R_PPC64_REL14_BRTAKEN
13086                       && r_type != R_PPC64_REL14_BRNTAKEN)
13087                     continue;
13088
13089                   /* Now determine the call target, its name, value,
13090                      section.  */
13091                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13092                                   r_indx, input_bfd))
13093                     goto error_ret_free_internal;
13094                   hash = (struct ppc_link_hash_entry *) h;
13095
13096                   ok_dest = FALSE;
13097                   fdh = NULL;
13098                   sym_value = 0;
13099                   if (hash == NULL)
13100                     {
13101                       sym_value = sym->st_value;
13102                       if (sym_sec != NULL
13103                           && sym_sec->output_section != NULL)
13104                         ok_dest = TRUE;
13105                     }
13106                   else if (hash->elf.root.type == bfd_link_hash_defined
13107                            || hash->elf.root.type == bfd_link_hash_defweak)
13108                     {
13109                       sym_value = hash->elf.root.u.def.value;
13110                       if (sym_sec->output_section != NULL)
13111                         ok_dest = TRUE;
13112                     }
13113                   else if (hash->elf.root.type == bfd_link_hash_undefweak
13114                            || hash->elf.root.type == bfd_link_hash_undefined)
13115                     {
13116                       /* Recognise an old ABI func code entry sym, and
13117                          use the func descriptor sym instead if it is
13118                          defined.  */
13119                       if (hash->elf.root.root.string[0] == '.'
13120                           && hash->oh != NULL)
13121                         {
13122                           fdh = ppc_follow_link (hash->oh);
13123                           if (fdh->elf.root.type == bfd_link_hash_defined
13124                               || fdh->elf.root.type == bfd_link_hash_defweak)
13125                             {
13126                               sym_sec = fdh->elf.root.u.def.section;
13127                               sym_value = fdh->elf.root.u.def.value;
13128                               if (sym_sec->output_section != NULL)
13129                                 ok_dest = TRUE;
13130                             }
13131                           else
13132                             fdh = NULL;
13133                         }
13134                     }
13135                   else
13136                     {
13137                       bfd_set_error (bfd_error_bad_value);
13138                       goto error_ret_free_internal;
13139                     }
13140
13141                   destination = 0;
13142                   local_off = 0;
13143                   if (ok_dest)
13144                     {
13145                       sym_value += irela->r_addend;
13146                       destination = (sym_value
13147                                      + sym_sec->output_offset
13148                                      + sym_sec->output_section->vma);
13149                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
13150                                                             ? hash->elf.other
13151                                                             : sym->st_other);
13152                     }
13153
13154                   code_sec = sym_sec;
13155                   code_value = sym_value;
13156                   opd = get_opd_info (sym_sec);
13157                   if (opd != NULL)
13158                     {
13159                       bfd_vma dest;
13160
13161                       if (hash == NULL && opd->adjust != NULL)
13162                         {
13163                           long adjust = opd->adjust[OPD_NDX (sym_value)];
13164                           if (adjust == -1)
13165                             continue;
13166                           code_value += adjust;
13167                           sym_value += adjust;
13168                         }
13169                       dest = opd_entry_value (sym_sec, sym_value,
13170                                               &code_sec, &code_value, FALSE);
13171                       if (dest != (bfd_vma) -1)
13172                         {
13173                           destination = dest;
13174                           if (fdh != NULL)
13175                             {
13176                               /* Fixup old ABI sym to point at code
13177                                  entry.  */
13178                               hash->elf.root.type = bfd_link_hash_defweak;
13179                               hash->elf.root.u.def.section = code_sec;
13180                               hash->elf.root.u.def.value = code_value;
13181                             }
13182                         }
13183                     }
13184
13185                   /* Determine what (if any) linker stub is needed.  */
13186                   plt_ent = NULL;
13187                   stub_type = ppc_type_of_stub (section, irela, &hash,
13188                                                 &plt_ent, destination,
13189                                                 local_off);
13190
13191                   if (r_type == R_PPC64_REL24_NOTOC)
13192                     {
13193                       if (stub_type == ppc_stub_plt_call)
13194                         stub_type = ppc_stub_plt_call_notoc;
13195                       else if (stub_type == ppc_stub_long_branch
13196                                || (code_sec != NULL
13197                                    && code_sec->output_section != NULL
13198                                    && (((hash ? hash->elf.other : sym->st_other)
13199                                         & STO_PPC64_LOCAL_MASK)
13200                                        != 1 << STO_PPC64_LOCAL_BIT)))
13201                         stub_type = ppc_stub_long_branch_notoc;
13202                     }
13203                   else if (stub_type != ppc_stub_plt_call)
13204                     {
13205                       /* Check whether we need a TOC adjusting stub.
13206                          Since the linker pastes together pieces from
13207                          different object files when creating the
13208                          _init and _fini functions, it may be that a
13209                          call to what looks like a local sym is in
13210                          fact a call needing a TOC adjustment.  */
13211                       if ((code_sec != NULL
13212                            && code_sec->output_section != NULL
13213                            && (htab->sec_info[code_sec->id].toc_off
13214                                != htab->sec_info[section->id].toc_off)
13215                            && (code_sec->has_toc_reloc
13216                                || code_sec->makes_toc_func_call))
13217                           || (((hash ? hash->elf.other : sym->st_other)
13218                                & STO_PPC64_LOCAL_MASK)
13219                               == 1 << STO_PPC64_LOCAL_BIT))
13220                         stub_type = ppc_stub_long_branch_r2off;
13221                     }
13222
13223                   if (stub_type == ppc_stub_none)
13224                     continue;
13225
13226                   /* __tls_get_addr calls might be eliminated.  */
13227                   if (stub_type != ppc_stub_plt_call
13228                       && stub_type != ppc_stub_plt_call_notoc
13229                       && hash != NULL
13230                       && (hash == htab->tls_get_addr
13231                           || hash == htab->tls_get_addr_fd)
13232                       && section->has_tls_reloc
13233                       && irela != internal_relocs)
13234                     {
13235                       /* Get tls info.  */
13236                       unsigned char *tls_mask;
13237
13238                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13239                                          irela - 1, input_bfd))
13240                         goto error_ret_free_internal;
13241                       if ((*tls_mask & TLS_TLS) != 0)
13242                         continue;
13243                     }
13244
13245                   if (stub_type == ppc_stub_plt_call)
13246                     {
13247                       if (!htab->opd_abi
13248                           && htab->params->plt_localentry0 != 0
13249                           && is_elfv2_localentry0 (&hash->elf))
13250                         htab->has_plt_localentry0 = 1;
13251                       else if (irela + 1 < irelaend
13252                                && irela[1].r_offset == irela->r_offset + 4
13253                                && (ELF64_R_TYPE (irela[1].r_info)
13254                                    == R_PPC64_TOCSAVE))
13255                         {
13256                           if (!tocsave_find (htab, INSERT,
13257                                              &local_syms, irela + 1, input_bfd))
13258                             goto error_ret_free_internal;
13259                         }
13260                       else
13261                         stub_type = ppc_stub_plt_call_r2save;
13262                     }
13263
13264                   /* Support for grouping stub sections.  */
13265                   id_sec = htab->sec_info[section->id].u.group->link_sec;
13266
13267                   /* Get the name of this stub.  */
13268                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13269                   if (!stub_name)
13270                     goto error_ret_free_internal;
13271
13272                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13273                                                      stub_name, FALSE, FALSE);
13274                   if (stub_entry != NULL)
13275                     {
13276                       enum ppc_stub_type old_type;
13277                       /* A stub has already been created, but it may
13278                          not be the required type.  We shouldn't be
13279                          transitioning from plt_call to long_branch
13280                          stubs or vice versa, but we might be
13281                          upgrading from plt_call to plt_call_r2save or
13282                          from long_branch to long_branch_r2off.  */
13283                       free (stub_name);
13284                       old_type = stub_entry->stub_type;
13285                       switch (old_type)
13286                         {
13287                         default:
13288                           abort ();
13289
13290                         case ppc_stub_save_res:
13291                           continue;
13292
13293                         case ppc_stub_plt_call:
13294                         case ppc_stub_plt_call_r2save:
13295                         case ppc_stub_plt_call_notoc:
13296                         case ppc_stub_plt_call_both:
13297                           if (stub_type == ppc_stub_plt_call)
13298                             continue;
13299                           else if (stub_type == ppc_stub_plt_call_r2save)
13300                             {
13301                               if (old_type == ppc_stub_plt_call_notoc)
13302                                 stub_type = ppc_stub_plt_call_both;
13303                             }
13304                           else if (stub_type == ppc_stub_plt_call_notoc)
13305                             {
13306                               if (old_type == ppc_stub_plt_call_r2save)
13307                                 stub_type = ppc_stub_plt_call_both;
13308                             }
13309                           else
13310                             abort ();
13311                           break;
13312
13313                         case ppc_stub_plt_branch:
13314                         case ppc_stub_plt_branch_r2off:
13315                         case ppc_stub_plt_branch_notoc:
13316                         case ppc_stub_plt_branch_both:
13317                           old_type += (ppc_stub_long_branch
13318                                        - ppc_stub_plt_branch);
13319                           /* Fall through.  */
13320                         case ppc_stub_long_branch:
13321                         case ppc_stub_long_branch_r2off:
13322                         case ppc_stub_long_branch_notoc:
13323                         case ppc_stub_long_branch_both:
13324                           if (stub_type == ppc_stub_long_branch)
13325                             continue;
13326                           else if (stub_type == ppc_stub_long_branch_r2off)
13327                             {
13328                               if (old_type == ppc_stub_long_branch_notoc)
13329                                 stub_type = ppc_stub_long_branch_both;
13330                             }
13331                           else if (stub_type == ppc_stub_long_branch_notoc)
13332                             {
13333                               if (old_type == ppc_stub_long_branch_r2off)
13334                                 stub_type = ppc_stub_long_branch_both;
13335                             }
13336                           else
13337                             abort ();
13338                           break;
13339                         }
13340                       if (old_type < stub_type)
13341                         stub_entry->stub_type = stub_type;
13342                       continue;
13343                     }
13344
13345                   stub_entry = ppc_add_stub (stub_name, section, info);
13346                   if (stub_entry == NULL)
13347                     {
13348                       free (stub_name);
13349                     error_ret_free_internal:
13350                       if (elf_section_data (section)->relocs == NULL)
13351                         free (internal_relocs);
13352                     error_ret_free_local:
13353                       if (local_syms != NULL
13354                           && (symtab_hdr->contents
13355                               != (unsigned char *) local_syms))
13356                         free (local_syms);
13357                       return FALSE;
13358                     }
13359
13360                   stub_entry->stub_type = stub_type;
13361                   if (stub_type >= ppc_stub_plt_call
13362                       && stub_type <= ppc_stub_plt_call_both)
13363                     {
13364                       stub_entry->target_value = sym_value;
13365                       stub_entry->target_section = sym_sec;
13366                     }
13367                   else
13368                     {
13369                       stub_entry->target_value = code_value;
13370                       stub_entry->target_section = code_sec;
13371                     }
13372                   stub_entry->h = hash;
13373                   stub_entry->plt_ent = plt_ent;
13374                   stub_entry->symtype
13375                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13376                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
13377
13378                   if (stub_entry->h != NULL)
13379                     htab->stub_globals += 1;
13380                 }
13381
13382               /* We're done with the internal relocs, free them.  */
13383               if (elf_section_data (section)->relocs != internal_relocs)
13384                 free (internal_relocs);
13385             }
13386
13387           if (local_syms != NULL
13388               && symtab_hdr->contents != (unsigned char *) local_syms)
13389             {
13390               if (!info->keep_memory)
13391                 free (local_syms);
13392               else
13393                 symtab_hdr->contents = (unsigned char *) local_syms;
13394             }
13395         }
13396
13397       /* We may have added some stubs.  Find out the new size of the
13398          stub sections.  */
13399       for (group = htab->group; group != NULL; group = group->next)
13400         if (group->stub_sec != NULL)
13401           {
13402             asection *stub_sec = group->stub_sec;
13403
13404             if (htab->stub_iteration <= STUB_SHRINK_ITER
13405                 || stub_sec->rawsize < stub_sec->size)
13406               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
13407               stub_sec->rawsize = stub_sec->size;
13408             stub_sec->size = 0;
13409             stub_sec->reloc_count = 0;
13410             stub_sec->flags &= ~SEC_RELOC;
13411           }
13412
13413       if (htab->stub_iteration <= STUB_SHRINK_ITER
13414           || htab->brlt->rawsize < htab->brlt->size)
13415         htab->brlt->rawsize = htab->brlt->size;
13416       htab->brlt->size = 0;
13417       htab->brlt->reloc_count = 0;
13418       htab->brlt->flags &= ~SEC_RELOC;
13419       if (htab->relbrlt != NULL)
13420         htab->relbrlt->size = 0;
13421
13422       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13423
13424       for (group = htab->group; group != NULL; group = group->next)
13425         if (group->needs_save_res)
13426           group->stub_sec->size += htab->sfpr->size;
13427
13428       if (info->emitrelocations
13429           && htab->glink != NULL && htab->glink->size != 0)
13430         {
13431           htab->glink->reloc_count = 1;
13432           htab->glink->flags |= SEC_RELOC;
13433         }
13434
13435       if (htab->glink_eh_frame != NULL
13436           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13437           && htab->glink_eh_frame->output_section->size > 8)
13438         {
13439           size_t size = 0, align = 4;
13440
13441           for (group = htab->group; group != NULL; group = group->next)
13442             if (group->stub_sec != NULL)
13443               size += stub_eh_frame_size (group, align);
13444           if (htab->glink != NULL && htab->glink->size != 0)
13445             size += (24 + align - 1) & -align;
13446           if (size != 0)
13447             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13448           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13449           size = (size + align - 1) & -align;
13450           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13451           htab->glink_eh_frame->size = size;
13452         }
13453
13454       if (htab->params->plt_stub_align != 0)
13455         for (group = htab->group; group != NULL; group = group->next)
13456           if (group->stub_sec != NULL)
13457             {
13458               int align = abs (htab->params->plt_stub_align);
13459               group->stub_sec->size
13460                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13461             }
13462
13463       for (group = htab->group; group != NULL; group = group->next)
13464         if (group->stub_sec != NULL
13465             && group->stub_sec->rawsize != group->stub_sec->size
13466             && (htab->stub_iteration <= STUB_SHRINK_ITER
13467                 || group->stub_sec->rawsize < group->stub_sec->size))
13468           break;
13469
13470       if (group == NULL
13471           && (htab->brlt->rawsize == htab->brlt->size
13472               || (htab->stub_iteration > STUB_SHRINK_ITER
13473                   && htab->brlt->rawsize > htab->brlt->size))
13474           && (htab->glink_eh_frame == NULL
13475               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13476         break;
13477
13478       /* Ask the linker to do its stuff.  */
13479       (*htab->params->layout_sections_again) ();
13480     }
13481
13482   if (htab->glink_eh_frame != NULL
13483       && htab->glink_eh_frame->size != 0)
13484     {
13485       bfd_vma val;
13486       bfd_byte *p, *last_fde;
13487       size_t last_fde_len, size, align, pad;
13488       struct map_stub *group;
13489
13490       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13491       if (p == NULL)
13492         return FALSE;
13493       htab->glink_eh_frame->contents = p;
13494       last_fde = p;
13495       align = 4;
13496
13497       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13498       /* CIE length (rewrite in case little-endian).  */
13499       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13500       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13501       p += last_fde_len + 4;
13502
13503       for (group = htab->group; group != NULL; group = group->next)
13504         if (group->stub_sec != NULL)
13505           {
13506             last_fde = p;
13507             last_fde_len = stub_eh_frame_size (group, align) - 4;
13508             /* FDE length.  */
13509             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13510             p += 4;
13511             /* CIE pointer.  */
13512             val = p - htab->glink_eh_frame->contents;
13513             bfd_put_32 (htab->elf.dynobj, val, p);
13514             p += 4;
13515             /* Offset to stub section, written later.  */
13516             p += 4;
13517             /* stub section size.  */
13518             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13519             p += 4;
13520             /* Augmentation.  */
13521             p += 1;
13522             if (group->tls_get_addr_opt_bctrl != -1u)
13523               {
13524                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13525
13526                 /* This FDE needs more than just the default.
13527                    Describe __tls_get_addr_opt stub LR.  */
13528                 if (to_bctrl < 64)
13529                   *p++ = DW_CFA_advance_loc + to_bctrl;
13530                 else if (to_bctrl < 256)
13531                   {
13532                     *p++ = DW_CFA_advance_loc1;
13533                     *p++ = to_bctrl;
13534                   }
13535                 else if (to_bctrl < 65536)
13536                   {
13537                     *p++ = DW_CFA_advance_loc2;
13538                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13539                     p += 2;
13540                   }
13541                 else
13542                   {
13543                     *p++ = DW_CFA_advance_loc4;
13544                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13545                     p += 4;
13546                   }
13547                 *p++ = DW_CFA_offset_extended_sf;
13548                 *p++ = 65;
13549                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13550                 *p++ = DW_CFA_advance_loc + 4;
13551                 *p++ = DW_CFA_restore_extended;
13552                 *p++ = 65;
13553               }
13554             /* Pad.  */
13555             p = last_fde + last_fde_len + 4;
13556           }
13557       if (htab->glink != NULL && htab->glink->size != 0)
13558         {
13559           last_fde = p;
13560           last_fde_len = ((24 + align - 1) & -align) - 4;
13561           /* FDE length.  */
13562           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13563           p += 4;
13564           /* CIE pointer.  */
13565           val = p - htab->glink_eh_frame->contents;
13566           bfd_put_32 (htab->elf.dynobj, val, p);
13567           p += 4;
13568           /* Offset to .glink, written later.  */
13569           p += 4;
13570           /* .glink size.  */
13571           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13572           p += 4;
13573           /* Augmentation.  */
13574           p += 1;
13575
13576           *p++ = DW_CFA_advance_loc + 1;
13577           *p++ = DW_CFA_register;
13578           *p++ = 65;
13579           *p++ = htab->opd_abi ? 12 : 0;
13580           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13581           *p++ = DW_CFA_restore_extended;
13582           *p++ = 65;
13583           p += ((24 + align - 1) & -align) - 24;
13584         }
13585       /* Subsume any padding into the last FDE if user .eh_frame
13586          sections are aligned more than glink_eh_frame.  Otherwise any
13587          zero padding will be seen as a terminator.  */
13588       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13589       size = p - htab->glink_eh_frame->contents;
13590       pad = ((size + align - 1) & -align) - size;
13591       htab->glink_eh_frame->size = size + pad;
13592       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13593     }
13594
13595   maybe_strip_output (info, htab->brlt);
13596   if (htab->glink_eh_frame != NULL)
13597     maybe_strip_output (info, htab->glink_eh_frame);
13598
13599   return TRUE;
13600 }
13601
13602 /* Called after we have determined section placement.  If sections
13603    move, we'll be called again.  Provide a value for TOCstart.  */
13604
13605 bfd_vma
13606 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13607 {
13608   asection *s;
13609   bfd_vma TOCstart, adjust;
13610
13611   if (info != NULL)
13612     {
13613       struct elf_link_hash_entry *h;
13614       struct elf_link_hash_table *htab = elf_hash_table (info);
13615
13616       if (is_elf_hash_table (htab)
13617           && htab->hgot != NULL)
13618         h = htab->hgot;
13619       else
13620         {
13621           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13622           if (is_elf_hash_table (htab))
13623             htab->hgot = h;
13624         }
13625       if (h != NULL
13626           && h->root.type == bfd_link_hash_defined
13627           && !h->root.linker_def
13628           && (!is_elf_hash_table (htab)
13629               || h->def_regular))
13630         {
13631           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13632                       + h->root.u.def.section->output_offset
13633                       + h->root.u.def.section->output_section->vma);
13634           _bfd_set_gp_value (obfd, TOCstart);
13635           return TOCstart;
13636         }
13637     }
13638
13639   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13640      order.  The TOC starts where the first of these sections starts.  */
13641   s = bfd_get_section_by_name (obfd, ".got");
13642   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13643     s = bfd_get_section_by_name (obfd, ".toc");
13644   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13645     s = bfd_get_section_by_name (obfd, ".tocbss");
13646   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13647     s = bfd_get_section_by_name (obfd, ".plt");
13648   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13649     {
13650       /* This may happen for
13651          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13652          .toc directive
13653          o  bad linker script
13654          o --gc-sections and empty TOC sections
13655
13656          FIXME: Warn user?  */
13657
13658       /* Look for a likely section.  We probably won't even be
13659          using TOCstart.  */
13660       for (s = obfd->sections; s != NULL; s = s->next)
13661         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13662                          | SEC_EXCLUDE))
13663             == (SEC_ALLOC | SEC_SMALL_DATA))
13664           break;
13665       if (s == NULL)
13666         for (s = obfd->sections; s != NULL; s = s->next)
13667           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13668               == (SEC_ALLOC | SEC_SMALL_DATA))
13669             break;
13670       if (s == NULL)
13671         for (s = obfd->sections; s != NULL; s = s->next)
13672           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13673               == SEC_ALLOC)
13674             break;
13675       if (s == NULL)
13676         for (s = obfd->sections; s != NULL; s = s->next)
13677           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13678             break;
13679     }
13680
13681   TOCstart = 0;
13682   if (s != NULL)
13683     TOCstart = s->output_section->vma + s->output_offset;
13684
13685   /* Force alignment.  */
13686   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13687   TOCstart -= adjust;
13688   _bfd_set_gp_value (obfd, TOCstart);
13689
13690   if (info != NULL && s != NULL)
13691     {
13692       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13693
13694       if (htab != NULL)
13695         {
13696           if (htab->elf.hgot != NULL)
13697             {
13698               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13699               htab->elf.hgot->root.u.def.section = s;
13700             }
13701         }
13702       else
13703         {
13704           struct bfd_link_hash_entry *bh = NULL;
13705           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13706                                             s, TOC_BASE_OFF - adjust,
13707                                             NULL, FALSE, FALSE, &bh);
13708         }
13709     }
13710   return TOCstart;
13711 }
13712
13713 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13714    write out any global entry stubs, and PLT relocations.  */
13715
13716 static bfd_boolean
13717 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13718 {
13719   struct bfd_link_info *info;
13720   struct ppc_link_hash_table *htab;
13721   struct plt_entry *ent;
13722   asection *s;
13723
13724   if (h->root.type == bfd_link_hash_indirect)
13725     return TRUE;
13726
13727   info = inf;
13728   htab = ppc_hash_table (info);
13729   if (htab == NULL)
13730     return FALSE;
13731
13732   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13733     if (ent->plt.offset != (bfd_vma) -1)
13734       {
13735         /* This symbol has an entry in the procedure linkage
13736            table.  Set it up.  */
13737         Elf_Internal_Rela rela;
13738         asection *plt, *relplt;
13739         bfd_byte *loc;
13740
13741         if (!htab->elf.dynamic_sections_created
13742             || h->dynindx == -1)
13743           {
13744             if (!(h->def_regular
13745                   && (h->root.type == bfd_link_hash_defined
13746                       || h->root.type == bfd_link_hash_defweak)))
13747               continue;
13748             if (h->type == STT_GNU_IFUNC)
13749               {
13750                 plt = htab->elf.iplt;
13751                 relplt = htab->elf.irelplt;
13752                 htab->local_ifunc_resolver = 1;
13753                 if (htab->opd_abi)
13754                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13755                 else
13756                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13757               }
13758             else
13759               {
13760                 plt = htab->pltlocal;
13761                 if (bfd_link_pic (info))
13762                   {
13763                     relplt = htab->relpltlocal;
13764                     if (htab->opd_abi)
13765                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13766                     else
13767                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13768                   }
13769                 else
13770                   relplt = NULL;
13771               }
13772             rela.r_addend = (h->root.u.def.value
13773                              + h->root.u.def.section->output_offset
13774                              + h->root.u.def.section->output_section->vma
13775                              + ent->addend);
13776
13777             if (relplt == NULL)
13778               {
13779                 loc = plt->contents + ent->plt.offset;
13780                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13781                 if (htab->opd_abi)
13782                   {
13783                     bfd_vma toc = elf_gp (info->output_bfd);
13784                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13785                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13786                   }
13787               }
13788             else
13789               {
13790                 rela.r_offset = (plt->output_section->vma
13791                                  + plt->output_offset
13792                                  + ent->plt.offset);
13793                 loc = relplt->contents + (relplt->reloc_count++
13794                                           * sizeof (Elf64_External_Rela));
13795                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13796               }
13797           }
13798         else
13799           {
13800             rela.r_offset = (htab->elf.splt->output_section->vma
13801                              + htab->elf.splt->output_offset
13802                              + ent->plt.offset);
13803             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13804             rela.r_addend = ent->addend;
13805             loc = (htab->elf.srelplt->contents
13806                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13807                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13808             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13809               htab->maybe_local_ifunc_resolver = 1;
13810             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13811           }
13812       }
13813
13814   if (!h->pointer_equality_needed)
13815     return TRUE;
13816
13817   if (h->def_regular)
13818     return TRUE;
13819
13820   s = htab->global_entry;
13821   if (s == NULL || s->size == 0)
13822     return TRUE;
13823
13824   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13825     if (ent->plt.offset != (bfd_vma) -1
13826         && ent->addend == 0)
13827       {
13828         bfd_byte *p;
13829         asection *plt;
13830         bfd_vma off;
13831
13832         p = s->contents + h->root.u.def.value;
13833         plt = htab->elf.splt;
13834         if (!htab->elf.dynamic_sections_created
13835             || h->dynindx == -1)
13836           {
13837             if (h->type == STT_GNU_IFUNC)
13838               plt = htab->elf.iplt;
13839             else
13840               plt = htab->pltlocal;
13841           }
13842         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13843         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13844
13845         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13846           {
13847             info->callbacks->einfo
13848               (_("%P: linkage table error against `%pT'\n"),
13849                h->root.root.string);
13850             bfd_set_error (bfd_error_bad_value);
13851             htab->stub_error = TRUE;
13852           }
13853
13854         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13855         if (htab->params->emit_stub_syms)
13856           {
13857             size_t len = strlen (h->root.root.string);
13858             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13859
13860             if (name == NULL)
13861               return FALSE;
13862
13863             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13864             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13865             if (h == NULL)
13866               return FALSE;
13867             if (h->root.type == bfd_link_hash_new)
13868               {
13869                 h->root.type = bfd_link_hash_defined;
13870                 h->root.u.def.section = s;
13871                 h->root.u.def.value = p - s->contents;
13872                 h->ref_regular = 1;
13873                 h->def_regular = 1;
13874                 h->ref_regular_nonweak = 1;
13875                 h->forced_local = 1;
13876                 h->non_elf = 0;
13877                 h->root.linker_def = 1;
13878               }
13879           }
13880
13881         if (PPC_HA (off) != 0)
13882           {
13883             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13884             p += 4;
13885           }
13886         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13887         p += 4;
13888         bfd_put_32 (s->owner, MTCTR_R12, p);
13889         p += 4;
13890         bfd_put_32 (s->owner, BCTR, p);
13891         break;
13892       }
13893   return TRUE;
13894 }
13895
13896 /* Write PLT relocs for locals.  */
13897
13898 static bfd_boolean
13899 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13900 {
13901   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13902   bfd *ibfd;
13903
13904   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13905     {
13906       struct got_entry **lgot_ents, **end_lgot_ents;
13907       struct plt_entry **local_plt, **lplt, **end_local_plt;
13908       Elf_Internal_Shdr *symtab_hdr;
13909       bfd_size_type locsymcount;
13910       Elf_Internal_Sym *local_syms = NULL;
13911       struct plt_entry *ent;
13912
13913       if (!is_ppc64_elf (ibfd))
13914         continue;
13915
13916       lgot_ents = elf_local_got_ents (ibfd);
13917       if (!lgot_ents)
13918         continue;
13919
13920       symtab_hdr = &elf_symtab_hdr (ibfd);
13921       locsymcount = symtab_hdr->sh_info;
13922       end_lgot_ents = lgot_ents + locsymcount;
13923       local_plt = (struct plt_entry **) end_lgot_ents;
13924       end_local_plt = local_plt + locsymcount;
13925       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13926         for (ent = *lplt; ent != NULL; ent = ent->next)
13927           if (ent->plt.offset != (bfd_vma) -1)
13928             {
13929               Elf_Internal_Sym *sym;
13930               asection *sym_sec;
13931               asection *plt, *relplt;
13932               bfd_byte *loc;
13933               bfd_vma val;
13934
13935               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13936                               lplt - local_plt, ibfd))
13937                 {
13938                   if (local_syms != NULL
13939                       && symtab_hdr->contents != (unsigned char *) local_syms)
13940                     free (local_syms);
13941                   return FALSE;
13942                 }
13943
13944               val = sym->st_value + ent->addend;
13945               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13946               if (sym_sec != NULL && sym_sec->output_section != NULL)
13947                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13948
13949               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13950                 {
13951                   htab->local_ifunc_resolver = 1;
13952                   plt = htab->elf.iplt;
13953                   relplt = htab->elf.irelplt;
13954                 }
13955               else
13956                 {
13957                   plt = htab->pltlocal;
13958                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13959                 }
13960
13961               if (relplt == NULL)
13962                 {
13963                   loc = plt->contents + ent->plt.offset;
13964                   bfd_put_64 (info->output_bfd, val, loc);
13965                   if (htab->opd_abi)
13966                     {
13967                       bfd_vma toc = elf_gp (ibfd);
13968                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13969                     }
13970                 }
13971               else
13972                 {
13973                   Elf_Internal_Rela rela;
13974                   rela.r_offset = (ent->plt.offset
13975                                    + plt->output_offset
13976                                    + plt->output_section->vma);
13977                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13978                     {
13979                       if (htab->opd_abi)
13980                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13981                       else
13982                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13983                     }
13984                   else
13985                     {
13986                       if (htab->opd_abi)
13987                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13988                       else
13989                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13990                     }
13991                   rela.r_addend = val;
13992                   loc = relplt->contents + (relplt->reloc_count++
13993                                             * sizeof (Elf64_External_Rela));
13994                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13995                 }
13996             }
13997
13998       if (local_syms != NULL
13999           && symtab_hdr->contents != (unsigned char *) local_syms)
14000         {
14001           if (!info->keep_memory)
14002             free (local_syms);
14003           else
14004             symtab_hdr->contents = (unsigned char *) local_syms;
14005         }
14006     }
14007   return TRUE;
14008 }
14009
14010 /* Build all the stubs associated with the current output file.
14011    The stubs are kept in a hash table attached to the main linker
14012    hash table.  This function is called via gldelf64ppc_finish.  */
14013
14014 bfd_boolean
14015 ppc64_elf_build_stubs (struct bfd_link_info *info,
14016                        char **stats)
14017 {
14018   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14019   struct map_stub *group;
14020   asection *stub_sec;
14021   bfd_byte *p;
14022   int stub_sec_count = 0;
14023
14024   if (htab == NULL)
14025     return FALSE;
14026
14027   /* Allocate memory to hold the linker stubs.  */
14028   for (group = htab->group; group != NULL; group = group->next)
14029     if ((stub_sec = group->stub_sec) != NULL
14030         && stub_sec->size != 0)
14031       {
14032         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
14033         if (stub_sec->contents == NULL)
14034           return FALSE;
14035         stub_sec->size = 0;
14036       }
14037
14038   if (htab->glink != NULL && htab->glink->size != 0)
14039     {
14040       unsigned int indx;
14041       bfd_vma plt0;
14042
14043       /* Build the .glink plt call stub.  */
14044       if (htab->params->emit_stub_syms)
14045         {
14046           struct elf_link_hash_entry *h;
14047           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
14048                                     TRUE, FALSE, FALSE);
14049           if (h == NULL)
14050             return FALSE;
14051           if (h->root.type == bfd_link_hash_new)
14052             {
14053               h->root.type = bfd_link_hash_defined;
14054               h->root.u.def.section = htab->glink;
14055               h->root.u.def.value = 8;
14056               h->ref_regular = 1;
14057               h->def_regular = 1;
14058               h->ref_regular_nonweak = 1;
14059               h->forced_local = 1;
14060               h->non_elf = 0;
14061               h->root.linker_def = 1;
14062             }
14063         }
14064       plt0 = (htab->elf.splt->output_section->vma
14065               + htab->elf.splt->output_offset
14066               - 16);
14067       if (info->emitrelocations)
14068         {
14069           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
14070           if (r == NULL)
14071             return FALSE;
14072           r->r_offset = (htab->glink->output_offset
14073                          + htab->glink->output_section->vma);
14074           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
14075           r->r_addend = plt0;
14076         }
14077       p = htab->glink->contents;
14078       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
14079       bfd_put_64 (htab->glink->owner, plt0, p);
14080       p += 8;
14081       if (htab->opd_abi)
14082         {
14083           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
14084           p += 4;
14085           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14086           p += 4;
14087           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14088           p += 4;
14089           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14090           p += 4;
14091           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
14092           p += 4;
14093           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14094           p += 4;
14095           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14096           p += 4;
14097           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
14098           p += 4;
14099           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14100           p += 4;
14101           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
14102           p += 4;
14103         }
14104       else
14105         {
14106           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
14107           p += 4;
14108           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14109           p += 4;
14110           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14111           p += 4;
14112           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
14113           p += 4;
14114           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14115           p += 4;
14116           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
14117           p += 4;
14118           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
14119           p += 4;
14120           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14121           p += 4;
14122           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
14123           p += 4;
14124           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14125           p += 4;
14126           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
14127           p += 4;
14128           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14129           p += 4;
14130           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
14131           p += 4;
14132         }
14133       bfd_put_32 (htab->glink->owner, BCTR, p);
14134       p += 4;
14135       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
14136
14137       /* Build the .glink lazy link call stubs.  */
14138       indx = 0;
14139       while (p < htab->glink->contents + htab->glink->size)
14140         {
14141           if (htab->opd_abi)
14142             {
14143               if (indx < 0x8000)
14144                 {
14145                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
14146                   p += 4;
14147                 }
14148               else
14149                 {
14150                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
14151                   p += 4;
14152                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
14153                               p);
14154                   p += 4;
14155                 }
14156             }
14157           bfd_put_32 (htab->glink->owner,
14158                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
14159           indx++;
14160           p += 4;
14161         }
14162     }
14163
14164   /* Build .glink global entry stubs, and PLT relocs for globals.  */
14165   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
14166
14167   if (!write_plt_relocs_for_local_syms (info))
14168     return FALSE;
14169
14170   if (htab->brlt != NULL && htab->brlt->size != 0)
14171     {
14172       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
14173                                          htab->brlt->size);
14174       if (htab->brlt->contents == NULL)
14175         return FALSE;
14176     }
14177   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
14178     {
14179       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
14180                                             htab->relbrlt->size);
14181       if (htab->relbrlt->contents == NULL)
14182         return FALSE;
14183     }
14184
14185   /* Build the stubs as directed by the stub hash table.  */
14186   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
14187
14188   for (group = htab->group; group != NULL; group = group->next)
14189     if (group->needs_save_res)
14190       group->stub_sec->size += htab->sfpr->size;
14191
14192   if (htab->relbrlt != NULL)
14193     htab->relbrlt->reloc_count = 0;
14194
14195   if (htab->params->plt_stub_align != 0)
14196     for (group = htab->group; group != NULL; group = group->next)
14197       if ((stub_sec = group->stub_sec) != NULL)
14198         {
14199           int align = abs (htab->params->plt_stub_align);
14200           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
14201         }
14202
14203   for (group = htab->group; group != NULL; group = group->next)
14204     if (group->needs_save_res)
14205       {
14206         stub_sec = group->stub_sec;
14207         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
14208                 htab->sfpr->contents, htab->sfpr->size);
14209         if (htab->params->emit_stub_syms)
14210           {
14211             unsigned int i;
14212
14213             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
14214               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
14215                 return FALSE;
14216           }
14217       }
14218
14219   for (group = htab->group; group != NULL; group = group->next)
14220     if ((stub_sec = group->stub_sec) != NULL)
14221       {
14222         stub_sec_count += 1;
14223         if (stub_sec->rawsize != stub_sec->size
14224             && (htab->stub_iteration <= STUB_SHRINK_ITER
14225                 || stub_sec->rawsize < stub_sec->size))
14226           break;
14227       }
14228
14229   if (group != NULL)
14230     {
14231       htab->stub_error = TRUE;
14232       _bfd_error_handler (_("stubs don't match calculated size"));
14233     }
14234
14235   if (htab->stub_error)
14236     return FALSE;
14237
14238   if (stats != NULL)
14239     {
14240       size_t len;
14241       *stats = bfd_malloc (500);
14242       if (*stats == NULL)
14243         return FALSE;
14244
14245       len = sprintf (*stats,
14246                      ngettext ("linker stubs in %u group\n",
14247                                "linker stubs in %u groups\n",
14248                                stub_sec_count),
14249                      stub_sec_count);
14250       sprintf (*stats + len, _("  branch         %lu\n"
14251                                "  branch toc adj %lu\n"
14252                                "  branch notoc   %lu\n"
14253                                "  branch both    %lu\n"
14254                                "  long branch    %lu\n"
14255                                "  long toc adj   %lu\n"
14256                                "  long notoc     %lu\n"
14257                                "  long both      %lu\n"
14258                                "  plt call       %lu\n"
14259                                "  plt call save  %lu\n"
14260                                "  plt call notoc %lu\n"
14261                                "  plt call both  %lu\n"
14262                                "  global entry   %lu"),
14263                htab->stub_count[ppc_stub_long_branch - 1],
14264                htab->stub_count[ppc_stub_long_branch_r2off - 1],
14265                htab->stub_count[ppc_stub_long_branch_notoc - 1],
14266                htab->stub_count[ppc_stub_long_branch_both - 1],
14267                htab->stub_count[ppc_stub_plt_branch - 1],
14268                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14269                htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14270                htab->stub_count[ppc_stub_plt_branch_both - 1],
14271                htab->stub_count[ppc_stub_plt_call - 1],
14272                htab->stub_count[ppc_stub_plt_call_r2save - 1],
14273                htab->stub_count[ppc_stub_plt_call_notoc - 1],
14274                htab->stub_count[ppc_stub_plt_call_both - 1],
14275                htab->stub_count[ppc_stub_global_entry - 1]);
14276     }
14277   return TRUE;
14278 }
14279
14280 /* What to do when ld finds relocations against symbols defined in
14281    discarded sections.  */
14282
14283 static unsigned int
14284 ppc64_elf_action_discarded (asection *sec)
14285 {
14286   if (strcmp (".opd", sec->name) == 0)
14287     return 0;
14288
14289   if (strcmp (".toc", sec->name) == 0)
14290     return 0;
14291
14292   if (strcmp (".toc1", sec->name) == 0)
14293     return 0;
14294
14295   return _bfd_elf_default_action_discarded (sec);
14296 }
14297
14298 /* The RELOCATE_SECTION function is called by the ELF backend linker
14299    to handle the relocations for a section.
14300
14301    The relocs are always passed as Rela structures; if the section
14302    actually uses Rel structures, the r_addend field will always be
14303    zero.
14304
14305    This function is responsible for adjust the section contents as
14306    necessary, and (if using Rela relocs and generating a
14307    relocatable output file) adjusting the reloc addend as
14308    necessary.
14309
14310    This function does not have to worry about setting the reloc
14311    address or the reloc symbol index.
14312
14313    LOCAL_SYMS is a pointer to the swapped in local symbols.
14314
14315    LOCAL_SECTIONS is an array giving the section in the input file
14316    corresponding to the st_shndx field of each local symbol.
14317
14318    The global hash table entry for the global symbols can be found
14319    via elf_sym_hashes (input_bfd).
14320
14321    When generating relocatable output, this function must handle
14322    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
14323    going to be the section symbol corresponding to the output
14324    section, which means that the addend must be adjusted
14325    accordingly.  */
14326
14327 static bfd_boolean
14328 ppc64_elf_relocate_section (bfd *output_bfd,
14329                             struct bfd_link_info *info,
14330                             bfd *input_bfd,
14331                             asection *input_section,
14332                             bfd_byte *contents,
14333                             Elf_Internal_Rela *relocs,
14334                             Elf_Internal_Sym *local_syms,
14335                             asection **local_sections)
14336 {
14337   struct ppc_link_hash_table *htab;
14338   Elf_Internal_Shdr *symtab_hdr;
14339   struct elf_link_hash_entry **sym_hashes;
14340   Elf_Internal_Rela *rel;
14341   Elf_Internal_Rela *wrel;
14342   Elf_Internal_Rela *relend;
14343   Elf_Internal_Rela outrel;
14344   bfd_byte *loc;
14345   struct got_entry **local_got_ents;
14346   bfd_vma TOCstart;
14347   bfd_boolean ret = TRUE;
14348   bfd_boolean is_opd;
14349   /* Assume 'at' branch hints.  */
14350   bfd_boolean is_isa_v2 = TRUE;
14351   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14352
14353   /* Initialize howto table if needed.  */
14354   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14355     ppc_howto_init ();
14356
14357   htab = ppc_hash_table (info);
14358   if (htab == NULL)
14359     return FALSE;
14360
14361   /* Don't relocate stub sections.  */
14362   if (input_section->owner == htab->params->stub_bfd)
14363     return TRUE;
14364
14365   BFD_ASSERT (is_ppc64_elf (input_bfd));
14366
14367   local_got_ents = elf_local_got_ents (input_bfd);
14368   TOCstart = elf_gp (output_bfd);
14369   symtab_hdr = &elf_symtab_hdr (input_bfd);
14370   sym_hashes = elf_sym_hashes (input_bfd);
14371   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14372
14373   rel = wrel = relocs;
14374   relend = relocs + input_section->reloc_count;
14375   for (; rel < relend; wrel++, rel++)
14376     {
14377       enum elf_ppc64_reloc_type r_type;
14378       bfd_vma addend;
14379       bfd_reloc_status_type r;
14380       Elf_Internal_Sym *sym;
14381       asection *sec;
14382       struct elf_link_hash_entry *h_elf;
14383       struct ppc_link_hash_entry *h;
14384       struct ppc_link_hash_entry *fdh;
14385       const char *sym_name;
14386       unsigned long r_symndx, toc_symndx;
14387       bfd_vma toc_addend;
14388       unsigned char tls_mask, tls_gd, tls_type;
14389       unsigned char sym_type;
14390       bfd_vma relocation;
14391       bfd_boolean unresolved_reloc, save_unresolved_reloc;
14392       bfd_boolean warned;
14393       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14394       unsigned int insn;
14395       unsigned int mask;
14396       struct ppc_stub_hash_entry *stub_entry;
14397       bfd_vma max_br_offset;
14398       bfd_vma from;
14399       Elf_Internal_Rela orig_rel;
14400       reloc_howto_type *howto;
14401       struct reloc_howto_struct alt_howto;
14402
14403     again:
14404       orig_rel = *rel;
14405
14406       r_type = ELF64_R_TYPE (rel->r_info);
14407       r_symndx = ELF64_R_SYM (rel->r_info);
14408
14409       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14410          symbol of the previous ADDR64 reloc.  The symbol gives us the
14411          proper TOC base to use.  */
14412       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14413           && wrel != relocs
14414           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14415           && is_opd)
14416         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14417
14418       sym = NULL;
14419       sec = NULL;
14420       h_elf = NULL;
14421       sym_name = NULL;
14422       unresolved_reloc = FALSE;
14423       warned = FALSE;
14424
14425       if (r_symndx < symtab_hdr->sh_info)
14426         {
14427           /* It's a local symbol.  */
14428           struct _opd_sec_data *opd;
14429
14430           sym = local_syms + r_symndx;
14431           sec = local_sections[r_symndx];
14432           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14433           sym_type = ELF64_ST_TYPE (sym->st_info);
14434           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14435           opd = get_opd_info (sec);
14436           if (opd != NULL && opd->adjust != NULL)
14437             {
14438               long adjust = opd->adjust[OPD_NDX (sym->st_value
14439                                                  + rel->r_addend)];
14440               if (adjust == -1)
14441                 relocation = 0;
14442               else
14443                 {
14444                   /* If this is a relocation against the opd section sym
14445                      and we have edited .opd, adjust the reloc addend so
14446                      that ld -r and ld --emit-relocs output is correct.
14447                      If it is a reloc against some other .opd symbol,
14448                      then the symbol value will be adjusted later.  */
14449                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14450                     rel->r_addend += adjust;
14451                   else
14452                     relocation += adjust;
14453                 }
14454             }
14455         }
14456       else
14457         {
14458           bfd_boolean ignored;
14459
14460           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14461                                    r_symndx, symtab_hdr, sym_hashes,
14462                                    h_elf, sec, relocation,
14463                                    unresolved_reloc, warned, ignored);
14464           sym_name = h_elf->root.root.string;
14465           sym_type = h_elf->type;
14466           if (sec != NULL
14467               && sec->owner == output_bfd
14468               && strcmp (sec->name, ".opd") == 0)
14469             {
14470               /* This is a symbol defined in a linker script.  All
14471                  such are defined in output sections, even those
14472                  defined by simple assignment from a symbol defined in
14473                  an input section.  Transfer the symbol to an
14474                  appropriate input .opd section, so that a branch to
14475                  this symbol will be mapped to the location specified
14476                  by the opd entry.  */
14477               struct bfd_link_order *lo;
14478               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14479                 if (lo->type == bfd_indirect_link_order)
14480                   {
14481                     asection *isec = lo->u.indirect.section;
14482                     if (h_elf->root.u.def.value >= isec->output_offset
14483                         && h_elf->root.u.def.value < (isec->output_offset
14484                                                       + isec->size))
14485                       {
14486                         h_elf->root.u.def.value -= isec->output_offset;
14487                         h_elf->root.u.def.section = isec;
14488                         sec = isec;
14489                         break;
14490                       }
14491                   }
14492             }
14493         }
14494       h = (struct ppc_link_hash_entry *) h_elf;
14495
14496       if (sec != NULL && discarded_section (sec))
14497         {
14498           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14499                                input_bfd, input_section,
14500                                contents + rel->r_offset);
14501           wrel->r_offset = rel->r_offset;
14502           wrel->r_info = 0;
14503           wrel->r_addend = 0;
14504
14505           /* For ld -r, remove relocations in debug sections against
14506              symbols defined in discarded sections.  Not done for
14507              non-debug to preserve relocs in .eh_frame which the
14508              eh_frame editing code expects to be present.  */
14509           if (bfd_link_relocatable (info)
14510               && (input_section->flags & SEC_DEBUGGING))
14511             wrel--;
14512
14513           continue;
14514         }
14515
14516       if (bfd_link_relocatable (info))
14517         goto copy_reloc;
14518
14519       if (h != NULL && &h->elf == htab->elf.hgot)
14520         {
14521           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14522           sec = bfd_abs_section_ptr;
14523           unresolved_reloc = FALSE;
14524         }
14525
14526       /* TLS optimizations.  Replace instruction sequences and relocs
14527          based on information we collected in tls_optimize.  We edit
14528          RELOCS so that --emit-relocs will output something sensible
14529          for the final instruction stream.  */
14530       tls_mask = 0;
14531       tls_gd = 0;
14532       toc_symndx = 0;
14533       if (h != NULL)
14534         tls_mask = h->tls_mask;
14535       else if (local_got_ents != NULL)
14536         {
14537           struct plt_entry **local_plt = (struct plt_entry **)
14538             (local_got_ents + symtab_hdr->sh_info);
14539           unsigned char *lgot_masks = (unsigned char *)
14540             (local_plt + symtab_hdr->sh_info);
14541           tls_mask = lgot_masks[r_symndx];
14542         }
14543       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14544           && (r_type == R_PPC64_TLS
14545               || r_type == R_PPC64_TLSGD
14546               || r_type == R_PPC64_TLSLD))
14547         {
14548           /* Check for toc tls entries.  */
14549           unsigned char *toc_tls;
14550
14551           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14552                              &local_syms, rel, input_bfd))
14553             return FALSE;
14554
14555           if (toc_tls)
14556             tls_mask = *toc_tls;
14557         }
14558
14559       /* Check that tls relocs are used with tls syms, and non-tls
14560          relocs are used with non-tls syms.  */
14561       if (r_symndx != STN_UNDEF
14562           && r_type != R_PPC64_NONE
14563           && (h == NULL
14564               || h->elf.root.type == bfd_link_hash_defined
14565               || h->elf.root.type == bfd_link_hash_defweak)
14566           && (IS_PPC64_TLS_RELOC (r_type)
14567               != (sym_type == STT_TLS
14568                   || (sym_type == STT_SECTION
14569                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14570         {
14571           if ((tls_mask & TLS_TLS) != 0
14572               && (r_type == R_PPC64_TLS
14573                   || r_type == R_PPC64_TLSGD
14574                   || r_type == R_PPC64_TLSLD))
14575             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14576             ;
14577           else
14578             info->callbacks->einfo
14579               (!IS_PPC64_TLS_RELOC (r_type)
14580                /* xgettext:c-format */
14581                ? _("%H: %s used with TLS symbol `%pT'\n")
14582                /* xgettext:c-format */
14583                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14584                input_bfd, input_section, rel->r_offset,
14585                ppc64_elf_howto_table[r_type]->name,
14586                sym_name);
14587         }
14588
14589       /* Ensure reloc mapping code below stays sane.  */
14590       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14591           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14592           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14593           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14594           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14595           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14596           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14597           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14598           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14599           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14600         abort ();
14601
14602       switch (r_type)
14603         {
14604         default:
14605           break;
14606
14607         case R_PPC64_LO_DS_OPT:
14608           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14609           if ((insn & (0x3f << 26)) != 58u << 26)
14610             abort ();
14611           insn += (14u << 26) - (58u << 26);
14612           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14613           r_type = R_PPC64_TOC16_LO;
14614           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14615           break;
14616
14617         case R_PPC64_TOC16:
14618         case R_PPC64_TOC16_LO:
14619         case R_PPC64_TOC16_DS:
14620         case R_PPC64_TOC16_LO_DS:
14621           {
14622             /* Check for toc tls entries.  */
14623             unsigned char *toc_tls;
14624             int retval;
14625
14626             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14627                                    &local_syms, rel, input_bfd);
14628             if (retval == 0)
14629               return FALSE;
14630
14631             if (toc_tls)
14632               {
14633                 tls_mask = *toc_tls;
14634                 if (r_type == R_PPC64_TOC16_DS
14635                     || r_type == R_PPC64_TOC16_LO_DS)
14636                   {
14637                     if ((tls_mask & TLS_TLS) != 0
14638                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14639                       goto toctprel;
14640                   }
14641                 else
14642                   {
14643                     /* If we found a GD reloc pair, then we might be
14644                        doing a GD->IE transition.  */
14645                     if (retval == 2)
14646                       {
14647                         tls_gd = TLS_TPRELGD;
14648                         if ((tls_mask & TLS_TLS) != 0
14649                             && (tls_mask & TLS_GD) == 0)
14650                           goto tls_ldgd_opt;
14651                       }
14652                     else if (retval == 3)
14653                       {
14654                         if ((tls_mask & TLS_TLS) != 0
14655                             && (tls_mask & TLS_LD) == 0)
14656                           goto tls_ldgd_opt;
14657                       }
14658                   }
14659               }
14660           }
14661           break;
14662
14663         case R_PPC64_GOT_TPREL16_HI:
14664         case R_PPC64_GOT_TPREL16_HA:
14665           if ((tls_mask & TLS_TLS) != 0
14666               && (tls_mask & TLS_TPREL) == 0)
14667             {
14668               rel->r_offset -= d_offset;
14669               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14670               r_type = R_PPC64_NONE;
14671               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14672             }
14673           break;
14674
14675         case R_PPC64_GOT_TPREL16_DS:
14676         case R_PPC64_GOT_TPREL16_LO_DS:
14677           if ((tls_mask & TLS_TLS) != 0
14678               && (tls_mask & TLS_TPREL) == 0)
14679             {
14680             toctprel:
14681               insn = bfd_get_32 (input_bfd,
14682                                  contents + rel->r_offset - d_offset);
14683               insn &= 31 << 21;
14684               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14685               bfd_put_32 (input_bfd, insn,
14686                           contents + rel->r_offset - d_offset);
14687               r_type = R_PPC64_TPREL16_HA;
14688               if (toc_symndx != 0)
14689                 {
14690                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14691                   rel->r_addend = toc_addend;
14692                   /* We changed the symbol.  Start over in order to
14693                      get h, sym, sec etc. right.  */
14694                   goto again;
14695                 }
14696               else
14697                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14698             }
14699           break;
14700
14701         case R_PPC64_TLS:
14702           if ((tls_mask & TLS_TLS) != 0
14703               && (tls_mask & TLS_TPREL) == 0)
14704             {
14705               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14706               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14707               if (insn == 0)
14708                 abort ();
14709               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14710               /* Was PPC64_TLS which sits on insn boundary, now
14711                  PPC64_TPREL16_LO which is at low-order half-word.  */
14712               rel->r_offset += d_offset;
14713               r_type = R_PPC64_TPREL16_LO;
14714               if (toc_symndx != 0)
14715                 {
14716                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14717                   rel->r_addend = toc_addend;
14718                   /* We changed the symbol.  Start over in order to
14719                      get h, sym, sec etc. right.  */
14720                   goto again;
14721                 }
14722               else
14723                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14724             }
14725           break;
14726
14727         case R_PPC64_GOT_TLSGD16_HI:
14728         case R_PPC64_GOT_TLSGD16_HA:
14729           tls_gd = TLS_TPRELGD;
14730           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14731             goto tls_gdld_hi;
14732           break;
14733
14734         case R_PPC64_GOT_TLSLD16_HI:
14735         case R_PPC64_GOT_TLSLD16_HA:
14736           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14737             {
14738             tls_gdld_hi:
14739               if ((tls_mask & tls_gd) != 0)
14740                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14741                           + R_PPC64_GOT_TPREL16_DS);
14742               else
14743                 {
14744                   rel->r_offset -= d_offset;
14745                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14746                   r_type = R_PPC64_NONE;
14747                 }
14748               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14749             }
14750           break;
14751
14752         case R_PPC64_GOT_TLSGD16:
14753         case R_PPC64_GOT_TLSGD16_LO:
14754           tls_gd = TLS_TPRELGD;
14755           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14756             goto tls_ldgd_opt;
14757           break;
14758
14759         case R_PPC64_GOT_TLSLD16:
14760         case R_PPC64_GOT_TLSLD16_LO:
14761           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14762             {
14763               unsigned int insn1, insn2;
14764               bfd_vma offset;
14765
14766             tls_ldgd_opt:
14767               offset = (bfd_vma) -1;
14768               /* If not using the newer R_PPC64_TLSGD/LD to mark
14769                  __tls_get_addr calls, we must trust that the call
14770                  stays with its arg setup insns, ie. that the next
14771                  reloc is the __tls_get_addr call associated with
14772                  the current reloc.  Edit both insns.  */
14773               if (input_section->has_tls_get_addr_call
14774                   && rel + 1 < relend
14775                   && branch_reloc_hash_match (input_bfd, rel + 1,
14776                                               htab->tls_get_addr,
14777                                               htab->tls_get_addr_fd))
14778                 offset = rel[1].r_offset;
14779               /* We read the low GOT_TLS (or TOC16) insn because we
14780                  need to keep the destination reg.  It may be
14781                  something other than the usual r3, and moved to r3
14782                  before the call by intervening code.  */
14783               insn1 = bfd_get_32 (input_bfd,
14784                                   contents + rel->r_offset - d_offset);
14785               if ((tls_mask & tls_gd) != 0)
14786                 {
14787                   /* IE */
14788                   insn1 &= (0x1f << 21) | (0x1f << 16);
14789                   insn1 |= 58 << 26;    /* ld */
14790                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14791                   if (offset != (bfd_vma) -1)
14792                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14793                   if ((tls_mask & TLS_EXPLICIT) == 0)
14794                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14795                               + R_PPC64_GOT_TPREL16_DS);
14796                   else
14797                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14798                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14799                 }
14800               else
14801                 {
14802                   /* LE */
14803                   insn1 &= 0x1f << 21;
14804                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14805                   insn2 = 0x38630000;   /* addi 3,3,0 */
14806                   if (tls_gd == 0)
14807                     {
14808                       /* Was an LD reloc.  */
14809                       if (toc_symndx)
14810                         sec = local_sections[toc_symndx];
14811                       for (r_symndx = 0;
14812                            r_symndx < symtab_hdr->sh_info;
14813                            r_symndx++)
14814                         if (local_sections[r_symndx] == sec)
14815                           break;
14816                       if (r_symndx >= symtab_hdr->sh_info)
14817                         r_symndx = STN_UNDEF;
14818                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14819                       if (r_symndx != STN_UNDEF)
14820                         rel->r_addend -= (local_syms[r_symndx].st_value
14821                                           + sec->output_offset
14822                                           + sec->output_section->vma);
14823                     }
14824                   else if (toc_symndx != 0)
14825                     {
14826                       r_symndx = toc_symndx;
14827                       rel->r_addend = toc_addend;
14828                     }
14829                   r_type = R_PPC64_TPREL16_HA;
14830                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14831                   if (offset != (bfd_vma) -1)
14832                     {
14833                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14834                                                     R_PPC64_TPREL16_LO);
14835                       rel[1].r_offset = offset + d_offset;
14836                       rel[1].r_addend = rel->r_addend;
14837                     }
14838                 }
14839               bfd_put_32 (input_bfd, insn1,
14840                           contents + rel->r_offset - d_offset);
14841               if (offset != (bfd_vma) -1)
14842                 bfd_put_32 (input_bfd, insn2, contents + offset);
14843               if ((tls_mask & tls_gd) == 0
14844                   && (tls_gd == 0 || toc_symndx != 0))
14845                 {
14846                   /* We changed the symbol.  Start over in order
14847                      to get h, sym, sec etc. right.  */
14848                   goto again;
14849                 }
14850             }
14851           break;
14852
14853         case R_PPC64_TLSGD:
14854           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14855               && rel + 1 < relend)
14856             {
14857               unsigned int insn2;
14858               bfd_vma offset = rel->r_offset;
14859
14860               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14861                 {
14862                   bfd_put_32 (output_bfd, NOP, contents + offset);
14863                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14864                   break;
14865                 }
14866
14867               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14868                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14869
14870               if ((tls_mask & TLS_TPRELGD) != 0)
14871                 {
14872                   /* IE */
14873                   r_type = R_PPC64_NONE;
14874                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14875                 }
14876               else
14877                 {
14878                   /* LE */
14879                   if (toc_symndx != 0)
14880                     {
14881                       r_symndx = toc_symndx;
14882                       rel->r_addend = toc_addend;
14883                     }
14884                   r_type = R_PPC64_TPREL16_LO;
14885                   rel->r_offset = offset + d_offset;
14886                   insn2 = 0x38630000;   /* addi 3,3,0 */
14887                 }
14888               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14889               /* Zap the reloc on the _tls_get_addr call too.  */
14890               BFD_ASSERT (offset == rel[1].r_offset);
14891               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14892               bfd_put_32 (input_bfd, insn2, contents + offset);
14893               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14894                 goto again;
14895             }
14896           break;
14897
14898         case R_PPC64_TLSLD:
14899           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14900               && rel + 1 < relend)
14901             {
14902               unsigned int insn2;
14903               bfd_vma offset = rel->r_offset;
14904
14905               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14906                 {
14907                   bfd_put_32 (output_bfd, NOP, contents + offset);
14908                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14909                   break;
14910                 }
14911
14912               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14913                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14914
14915               if (toc_symndx)
14916                 sec = local_sections[toc_symndx];
14917               for (r_symndx = 0;
14918                    r_symndx < symtab_hdr->sh_info;
14919                    r_symndx++)
14920                 if (local_sections[r_symndx] == sec)
14921                   break;
14922               if (r_symndx >= symtab_hdr->sh_info)
14923                 r_symndx = STN_UNDEF;
14924               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14925               if (r_symndx != STN_UNDEF)
14926                 rel->r_addend -= (local_syms[r_symndx].st_value
14927                                   + sec->output_offset
14928                                   + sec->output_section->vma);
14929
14930               r_type = R_PPC64_TPREL16_LO;
14931               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14932               rel->r_offset = offset + d_offset;
14933               /* Zap the reloc on the _tls_get_addr call too.  */
14934               BFD_ASSERT (offset == rel[1].r_offset);
14935               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14936               insn2 = 0x38630000;       /* addi 3,3,0 */
14937               bfd_put_32 (input_bfd, insn2, contents + offset);
14938               goto again;
14939             }
14940           break;
14941
14942         case R_PPC64_DTPMOD64:
14943           if (rel + 1 < relend
14944               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14945               && rel[1].r_offset == rel->r_offset + 8)
14946             {
14947               if ((tls_mask & TLS_GD) == 0)
14948                 {
14949                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14950                   if ((tls_mask & TLS_TPRELGD) != 0)
14951                     r_type = R_PPC64_TPREL64;
14952                   else
14953                     {
14954                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14955                       r_type = R_PPC64_NONE;
14956                     }
14957                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14958                 }
14959             }
14960           else
14961             {
14962               if ((tls_mask & TLS_LD) == 0)
14963                 {
14964                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14965                   r_type = R_PPC64_NONE;
14966                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14967                 }
14968             }
14969           break;
14970
14971         case R_PPC64_TPREL64:
14972           if ((tls_mask & TLS_TPREL) == 0)
14973             {
14974               r_type = R_PPC64_NONE;
14975               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14976             }
14977           break;
14978
14979         case R_PPC64_ENTRY:
14980           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14981           if (!bfd_link_pic (info)
14982               && !info->traditional_format
14983               && relocation + 0x80008000 <= 0xffffffff)
14984             {
14985               unsigned int insn1, insn2;
14986
14987               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14988               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14989               if ((insn1 & ~0xfffc) == LD_R2_0R12
14990                   && insn2 == ADD_R2_R2_R12)
14991                 {
14992                   bfd_put_32 (input_bfd,
14993                               LIS_R2 + PPC_HA (relocation),
14994                               contents + rel->r_offset);
14995                   bfd_put_32 (input_bfd,
14996                               ADDI_R2_R2 + PPC_LO (relocation),
14997                               contents + rel->r_offset + 4);
14998                 }
14999             }
15000           else
15001             {
15002               relocation -= (rel->r_offset
15003                              + input_section->output_offset
15004                              + input_section->output_section->vma);
15005               if (relocation + 0x80008000 <= 0xffffffff)
15006                 {
15007                   unsigned int insn1, insn2;
15008
15009                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15010                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15011                   if ((insn1 & ~0xfffc) == LD_R2_0R12
15012                       && insn2 == ADD_R2_R2_R12)
15013                     {
15014                       bfd_put_32 (input_bfd,
15015                                   ADDIS_R2_R12 + PPC_HA (relocation),
15016                                   contents + rel->r_offset);
15017                       bfd_put_32 (input_bfd,
15018                                   ADDI_R2_R2 + PPC_LO (relocation),
15019                                   contents + rel->r_offset + 4);
15020                     }
15021                 }
15022             }
15023           break;
15024
15025         case R_PPC64_REL16_HA:
15026           /* If we are generating a non-PIC executable, edit
15027              .  0:      addis 2,12,.TOC.-0b@ha
15028              .          addi 2,2,.TOC.-0b@l
15029              used by ELFv2 global entry points to set up r2, to
15030              .          lis 2,.TOC.@ha
15031              .          addi 2,2,.TOC.@l
15032              if .TOC. is in range.  */
15033           if (!bfd_link_pic (info)
15034               && !info->traditional_format
15035               && !htab->opd_abi
15036               && rel->r_addend == d_offset
15037               && h != NULL && &h->elf == htab->elf.hgot
15038               && rel + 1 < relend
15039               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
15040               && rel[1].r_offset == rel->r_offset + 4
15041               && rel[1].r_addend == rel->r_addend + 4
15042               && relocation + 0x80008000 <= 0xffffffff)
15043             {
15044               unsigned int insn1, insn2;
15045               bfd_vma offset = rel->r_offset - d_offset;
15046               insn1 = bfd_get_32 (input_bfd, contents + offset);
15047               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
15048               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
15049                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
15050                 {
15051                   r_type = R_PPC64_ADDR16_HA;
15052                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15053                   rel->r_addend -= d_offset;
15054                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
15055                   rel[1].r_addend -= d_offset + 4;
15056                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
15057                 }
15058             }
15059           break;
15060         }
15061
15062       /* Handle other relocations that tweak non-addend part of insn.  */
15063       insn = 0;
15064       max_br_offset = 1 << 25;
15065       addend = rel->r_addend;
15066       reloc_dest = DEST_NORMAL;
15067       switch (r_type)
15068         {
15069         default:
15070           break;
15071
15072         case R_PPC64_TOCSAVE:
15073           if (relocation + addend == (rel->r_offset
15074                                       + input_section->output_offset
15075                                       + input_section->output_section->vma)
15076               && tocsave_find (htab, NO_INSERT,
15077                                &local_syms, rel, input_bfd))
15078             {
15079               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15080               if (insn == NOP
15081                   || insn == CROR_151515 || insn == CROR_313131)
15082                 bfd_put_32 (input_bfd,
15083                             STD_R2_0R1 + STK_TOC (htab),
15084                             contents + rel->r_offset);
15085             }
15086           break;
15087
15088           /* Branch taken prediction relocations.  */
15089         case R_PPC64_ADDR14_BRTAKEN:
15090         case R_PPC64_REL14_BRTAKEN:
15091           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
15092           /* Fall through.  */
15093
15094           /* Branch not taken prediction relocations.  */
15095         case R_PPC64_ADDR14_BRNTAKEN:
15096         case R_PPC64_REL14_BRNTAKEN:
15097           insn |= bfd_get_32 (input_bfd,
15098                               contents + rel->r_offset) & ~(0x01 << 21);
15099           /* Fall through.  */
15100
15101         case R_PPC64_REL14:
15102           max_br_offset = 1 << 15;
15103           /* Fall through.  */
15104
15105         case R_PPC64_REL24:
15106         case R_PPC64_REL24_NOTOC:
15107         case R_PPC64_PLTCALL:
15108           /* Calls to functions with a different TOC, such as calls to
15109              shared objects, need to alter the TOC pointer.  This is
15110              done using a linkage stub.  A REL24 branching to these
15111              linkage stubs needs to be followed by a nop, as the nop
15112              will be replaced with an instruction to restore the TOC
15113              base pointer.  */
15114           fdh = h;
15115           if (h != NULL
15116               && h->oh != NULL
15117               && h->oh->is_func_descriptor)
15118             fdh = ppc_follow_link (h->oh);
15119           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15120                                            htab);
15121           if (r_type == R_PPC64_PLTCALL
15122               && stub_entry != NULL
15123               && stub_entry->stub_type >= ppc_stub_plt_call
15124               && stub_entry->stub_type <= ppc_stub_plt_call_both)
15125             stub_entry = NULL;
15126
15127           if (stub_entry != NULL
15128               && (stub_entry->stub_type == ppc_stub_plt_call
15129                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
15130                   || stub_entry->stub_type == ppc_stub_plt_call_both
15131                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15132                   || stub_entry->stub_type == ppc_stub_plt_branch_both
15133                   || stub_entry->stub_type == ppc_stub_long_branch_r2off
15134                   || stub_entry->stub_type == ppc_stub_long_branch_both))
15135             {
15136               bfd_boolean can_plt_call = FALSE;
15137
15138               if (stub_entry->stub_type == ppc_stub_plt_call
15139                   && !htab->opd_abi
15140                   && htab->params->plt_localentry0 != 0
15141                   && is_elfv2_localentry0 (&h->elf))
15142                 {
15143                   /* The function doesn't use or change r2.  */
15144                   can_plt_call = TRUE;
15145                 }
15146               else if (r_type == R_PPC64_REL24_NOTOC)
15147                 {
15148                   /* NOTOC calls don't need to restore r2.  */
15149                   can_plt_call = TRUE;
15150                 }
15151
15152               /* All of these stubs may modify r2, so there must be a
15153                  branch and link followed by a nop.  The nop is
15154                  replaced by an insn to restore r2.  */
15155               else if (rel->r_offset + 8 <= input_section->size)
15156                 {
15157                   unsigned long br;
15158
15159                   br = bfd_get_32 (input_bfd,
15160                                    contents + rel->r_offset);
15161                   if ((br & 1) != 0)
15162                     {
15163                       unsigned long nop;
15164
15165                       nop = bfd_get_32 (input_bfd,
15166                                         contents + rel->r_offset + 4);
15167                       if (nop == LD_R2_0R1 + STK_TOC (htab))
15168                         can_plt_call = TRUE;
15169                       else if (nop == NOP
15170                                || nop == CROR_151515
15171                                || nop == CROR_313131)
15172                         {
15173                           if (h != NULL
15174                               && (h == htab->tls_get_addr_fd
15175                                   || h == htab->tls_get_addr)
15176                               && htab->params->tls_get_addr_opt)
15177                             {
15178                               /* Special stub used, leave nop alone.  */
15179                             }
15180                           else
15181                             bfd_put_32 (input_bfd,
15182                                         LD_R2_0R1 + STK_TOC (htab),
15183                                         contents + rel->r_offset + 4);
15184                           can_plt_call = TRUE;
15185                         }
15186                     }
15187                 }
15188
15189               if (!can_plt_call && h != NULL)
15190                 {
15191                   const char *name = h->elf.root.root.string;
15192
15193                   if (*name == '.')
15194                     ++name;
15195
15196                   if (strncmp (name, "__libc_start_main", 17) == 0
15197                       && (name[17] == 0 || name[17] == '@'))
15198                     {
15199                       /* Allow crt1 branch to go via a toc adjusting
15200                          stub.  Other calls that never return could do
15201                          the same, if we could detect such.  */
15202                       can_plt_call = TRUE;
15203                     }
15204                 }
15205
15206               if (!can_plt_call)
15207                 {
15208                   /* g++ as of 20130507 emits self-calls without a
15209                      following nop.  This is arguably wrong since we
15210                      have conflicting information.  On the one hand a
15211                      global symbol and on the other a local call
15212                      sequence, but don't error for this special case.
15213                      It isn't possible to cheaply verify we have
15214                      exactly such a call.  Allow all calls to the same
15215                      section.  */
15216                   asection *code_sec = sec;
15217
15218                   if (get_opd_info (sec) != NULL)
15219                     {
15220                       bfd_vma off = (relocation + addend
15221                                      - sec->output_section->vma
15222                                      - sec->output_offset);
15223
15224                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15225                     }
15226                   if (code_sec == input_section)
15227                     can_plt_call = TRUE;
15228                 }
15229
15230               if (!can_plt_call)
15231                 {
15232                   if (stub_entry->stub_type >= ppc_stub_plt_call
15233                       && stub_entry->stub_type <= ppc_stub_plt_call_both)
15234                     info->callbacks->einfo
15235                       /* xgettext:c-format */
15236                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
15237                          "recompile with -fPIC\n"),
15238                        input_bfd, input_section, rel->r_offset, sym_name);
15239                   else
15240                     info->callbacks->einfo
15241                       /* xgettext:c-format */
15242                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
15243                          "(-mcmodel=small toc adjust stub)\n"),
15244                        input_bfd, input_section, rel->r_offset, sym_name);
15245
15246                   bfd_set_error (bfd_error_bad_value);
15247                   ret = FALSE;
15248                 }
15249
15250               if (can_plt_call
15251                   && stub_entry->stub_type >= ppc_stub_plt_call
15252                   && stub_entry->stub_type <= ppc_stub_plt_call_both)
15253                 unresolved_reloc = FALSE;
15254             }
15255
15256           if ((stub_entry == NULL
15257                || stub_entry->stub_type == ppc_stub_long_branch
15258                || stub_entry->stub_type == ppc_stub_plt_branch)
15259               && get_opd_info (sec) != NULL)
15260             {
15261               /* The branch destination is the value of the opd entry. */
15262               bfd_vma off = (relocation + addend
15263                              - sec->output_section->vma
15264                              - sec->output_offset);
15265               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15266               if (dest != (bfd_vma) -1)
15267                 {
15268                   relocation = dest;
15269                   addend = 0;
15270                   reloc_dest = DEST_OPD;
15271                 }
15272             }
15273
15274           /* If the branch is out of reach we ought to have a long
15275              branch stub.  */
15276           from = (rel->r_offset
15277                   + input_section->output_offset
15278                   + input_section->output_section->vma);
15279
15280           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15281                                                   ? fdh->elf.other
15282                                                   : sym->st_other);
15283
15284           if (stub_entry != NULL
15285               && (stub_entry->stub_type == ppc_stub_long_branch
15286                   || stub_entry->stub_type == ppc_stub_plt_branch)
15287               && (r_type == R_PPC64_ADDR14_BRTAKEN
15288                   || r_type == R_PPC64_ADDR14_BRNTAKEN
15289                   || (relocation + addend - from + max_br_offset
15290                       < 2 * max_br_offset)))
15291             /* Don't use the stub if this branch is in range.  */
15292             stub_entry = NULL;
15293
15294           if (stub_entry != NULL
15295               && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15296                   || stub_entry->stub_type == ppc_stub_long_branch_both
15297                   || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15298                   || stub_entry->stub_type == ppc_stub_plt_branch_both)
15299               && (r_type != R_PPC64_REL24_NOTOC
15300                   || ((fdh ? fdh->elf.other : sym->st_other)
15301                       & STO_PPC64_LOCAL_MASK) == 1 << STO_PPC64_LOCAL_BIT)
15302               && (relocation + addend - from + max_br_offset
15303                   < 2 * max_br_offset))
15304             stub_entry = NULL;
15305
15306           if (stub_entry != NULL
15307               && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15308                   || stub_entry->stub_type == ppc_stub_long_branch_both
15309                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15310                   || stub_entry->stub_type == ppc_stub_plt_branch_both)
15311               && r_type == R_PPC64_REL24_NOTOC
15312               && (relocation + addend - from + max_br_offset
15313                   < 2 * max_br_offset))
15314             stub_entry = NULL;
15315
15316           if (stub_entry != NULL)
15317             {
15318               /* Munge up the value and addend so that we call the stub
15319                  rather than the procedure directly.  */
15320               asection *stub_sec = stub_entry->group->stub_sec;
15321
15322               if (stub_entry->stub_type == ppc_stub_save_res)
15323                 relocation += (stub_sec->output_offset
15324                                + stub_sec->output_section->vma
15325                                + stub_sec->size - htab->sfpr->size
15326                                - htab->sfpr->output_offset
15327                                - htab->sfpr->output_section->vma);
15328               else
15329                 relocation = (stub_entry->stub_offset
15330                               + stub_sec->output_offset
15331                               + stub_sec->output_section->vma);
15332               addend = 0;
15333               reloc_dest = DEST_STUB;
15334
15335               if (((stub_entry->stub_type == ppc_stub_plt_call
15336                     && ALWAYS_EMIT_R2SAVE)
15337                    || stub_entry->stub_type == ppc_stub_plt_call_r2save
15338                    || stub_entry->stub_type == ppc_stub_plt_call_both)
15339                   && rel + 1 < relend
15340                   && rel[1].r_offset == rel->r_offset + 4
15341                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15342                 relocation += 4;
15343               else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15344                         || stub_entry->stub_type == ppc_stub_plt_branch_both
15345                         || stub_entry->stub_type == ppc_stub_plt_call_both)
15346                        && r_type == R_PPC64_REL24_NOTOC)
15347                 relocation += 4;
15348             }
15349
15350           if (insn != 0)
15351             {
15352               if (is_isa_v2)
15353                 {
15354                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
15355                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
15356                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
15357                   if ((insn & (0x14 << 21)) == (0x04 << 21))
15358                     insn |= 0x02 << 21;
15359                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
15360                     insn |= 0x08 << 21;
15361                   else
15362                     break;
15363                 }
15364               else
15365                 {
15366                   /* Invert 'y' bit if not the default.  */
15367                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
15368                     insn ^= 0x01 << 21;
15369                 }
15370
15371               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15372             }
15373
15374           /* NOP out calls to undefined weak functions.
15375              We can thus call a weak function without first
15376              checking whether the function is defined.  */
15377           else if (h != NULL
15378                    && h->elf.root.type == bfd_link_hash_undefweak
15379                    && h->elf.dynindx == -1
15380                    && (r_type == R_PPC64_REL24
15381                        || r_type == R_PPC64_REL24_NOTOC)
15382                    && relocation == 0
15383                    && addend == 0)
15384             {
15385               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15386               goto copy_reloc;
15387             }
15388           break;
15389         }
15390
15391       /* Set `addend'.  */
15392       tls_type = 0;
15393       save_unresolved_reloc = unresolved_reloc;
15394       switch (r_type)
15395         {
15396         default:
15397           /* xgettext:c-format */
15398           _bfd_error_handler (_("%pB: %s unsupported"),
15399                               input_bfd, ppc64_elf_howto_table[r_type]->name);
15400
15401           bfd_set_error (bfd_error_bad_value);
15402           ret = FALSE;
15403           goto copy_reloc;
15404
15405         case R_PPC64_NONE:
15406         case R_PPC64_TLS:
15407         case R_PPC64_TLSGD:
15408         case R_PPC64_TLSLD:
15409         case R_PPC64_TOCSAVE:
15410         case R_PPC64_GNU_VTINHERIT:
15411         case R_PPC64_GNU_VTENTRY:
15412         case R_PPC64_ENTRY:
15413           goto copy_reloc;
15414
15415           /* GOT16 relocations.  Like an ADDR16 using the symbol's
15416              address in the GOT as relocation value instead of the
15417              symbol's value itself.  Also, create a GOT entry for the
15418              symbol and put the symbol value there.  */
15419         case R_PPC64_GOT_TLSGD16:
15420         case R_PPC64_GOT_TLSGD16_LO:
15421         case R_PPC64_GOT_TLSGD16_HI:
15422         case R_PPC64_GOT_TLSGD16_HA:
15423           tls_type = TLS_TLS | TLS_GD;
15424           goto dogot;
15425
15426         case R_PPC64_GOT_TLSLD16:
15427         case R_PPC64_GOT_TLSLD16_LO:
15428         case R_PPC64_GOT_TLSLD16_HI:
15429         case R_PPC64_GOT_TLSLD16_HA:
15430           tls_type = TLS_TLS | TLS_LD;
15431           goto dogot;
15432
15433         case R_PPC64_GOT_TPREL16_DS:
15434         case R_PPC64_GOT_TPREL16_LO_DS:
15435         case R_PPC64_GOT_TPREL16_HI:
15436         case R_PPC64_GOT_TPREL16_HA:
15437           tls_type = TLS_TLS | TLS_TPREL;
15438           goto dogot;
15439
15440         case R_PPC64_GOT_DTPREL16_DS:
15441         case R_PPC64_GOT_DTPREL16_LO_DS:
15442         case R_PPC64_GOT_DTPREL16_HI:
15443         case R_PPC64_GOT_DTPREL16_HA:
15444           tls_type = TLS_TLS | TLS_DTPREL;
15445           goto dogot;
15446
15447         case R_PPC64_GOT16:
15448         case R_PPC64_GOT16_LO:
15449         case R_PPC64_GOT16_HI:
15450         case R_PPC64_GOT16_HA:
15451         case R_PPC64_GOT16_DS:
15452         case R_PPC64_GOT16_LO_DS:
15453         dogot:
15454           {
15455             /* Relocation is to the entry for this symbol in the global
15456                offset table.  */
15457             asection *got;
15458             bfd_vma *offp;
15459             bfd_vma off;
15460             unsigned long indx = 0;
15461             struct got_entry *ent;
15462
15463             if (tls_type == (TLS_TLS | TLS_LD)
15464                 && (h == NULL
15465                     || !h->elf.def_dynamic))
15466               ent = ppc64_tlsld_got (input_bfd);
15467             else
15468               {
15469                 if (h != NULL)
15470                   {
15471                     if (!htab->elf.dynamic_sections_created
15472                         || h->elf.dynindx == -1
15473                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15474                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15475                       /* This is actually a static link, or it is a
15476                          -Bsymbolic link and the symbol is defined
15477                          locally, or the symbol was forced to be local
15478                          because of a version file.  */
15479                       ;
15480                     else
15481                       {
15482                         indx = h->elf.dynindx;
15483                         unresolved_reloc = FALSE;
15484                       }
15485                     ent = h->elf.got.glist;
15486                   }
15487                 else
15488                   {
15489                     if (local_got_ents == NULL)
15490                       abort ();
15491                     ent = local_got_ents[r_symndx];
15492                   }
15493
15494                 for (; ent != NULL; ent = ent->next)
15495                   if (ent->addend == orig_rel.r_addend
15496                       && ent->owner == input_bfd
15497                       && ent->tls_type == tls_type)
15498                     break;
15499               }
15500
15501             if (ent == NULL)
15502               abort ();
15503             if (ent->is_indirect)
15504               ent = ent->got.ent;
15505             offp = &ent->got.offset;
15506             got = ppc64_elf_tdata (ent->owner)->got;
15507             if (got == NULL)
15508               abort ();
15509
15510             /* The offset must always be a multiple of 8.  We use the
15511                least significant bit to record whether we have already
15512                processed this entry.  */
15513             off = *offp;
15514             if ((off & 1) != 0)
15515               off &= ~1;
15516             else
15517               {
15518                 /* Generate relocs for the dynamic linker, except in
15519                    the case of TLSLD where we'll use one entry per
15520                    module.  */
15521                 asection *relgot;
15522                 bfd_boolean ifunc;
15523
15524                 *offp = off | 1;
15525                 relgot = NULL;
15526                 ifunc = (h != NULL
15527                          ? h->elf.type == STT_GNU_IFUNC
15528                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15529                 if (ifunc)
15530                   {
15531                     relgot = htab->elf.irelplt;
15532                     if (indx == 0)
15533                       htab->local_ifunc_resolver = 1;
15534                     else if (is_static_defined (&h->elf))
15535                       htab->maybe_local_ifunc_resolver = 1;
15536                   }
15537                 else if (indx != 0
15538                          || (bfd_link_pic (info)
15539                              && (h == NULL
15540                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15541                                  || (tls_type == (TLS_TLS | TLS_LD)
15542                                      && !h->elf.def_dynamic))
15543                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15544                                   && bfd_link_executable (info)
15545                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15546                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15547                 if (relgot != NULL)
15548                   {
15549                     outrel.r_offset = (got->output_section->vma
15550                                        + got->output_offset
15551                                        + off);
15552                     outrel.r_addend = addend;
15553                     if (tls_type & (TLS_LD | TLS_GD))
15554                       {
15555                         outrel.r_addend = 0;
15556                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15557                         if (tls_type == (TLS_TLS | TLS_GD))
15558                           {
15559                             loc = relgot->contents;
15560                             loc += (relgot->reloc_count++
15561                                     * sizeof (Elf64_External_Rela));
15562                             bfd_elf64_swap_reloca_out (output_bfd,
15563                                                        &outrel, loc);
15564                             outrel.r_offset += 8;
15565                             outrel.r_addend = addend;
15566                             outrel.r_info
15567                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15568                           }
15569                       }
15570                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15571                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15572                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15573                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15574                     else if (indx != 0)
15575                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15576                     else
15577                       {
15578                         if (ifunc)
15579                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15580                         else
15581                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15582
15583                         /* Write the .got section contents for the sake
15584                            of prelink.  */
15585                         loc = got->contents + off;
15586                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15587                                     loc);
15588                       }
15589
15590                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15591                       {
15592                         outrel.r_addend += relocation;
15593                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15594                           {
15595                             if (htab->elf.tls_sec == NULL)
15596                               outrel.r_addend = 0;
15597                             else
15598                               outrel.r_addend -= htab->elf.tls_sec->vma;
15599                           }
15600                       }
15601                     loc = relgot->contents;
15602                     loc += (relgot->reloc_count++
15603                             * sizeof (Elf64_External_Rela));
15604                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15605                   }
15606
15607                 /* Init the .got section contents here if we're not
15608                    emitting a reloc.  */
15609                 else
15610                   {
15611                     relocation += addend;
15612                     if (tls_type != 0)
15613                       {
15614                         if (htab->elf.tls_sec == NULL)
15615                           relocation = 0;
15616                         else
15617                           {
15618                             if (tls_type & TLS_LD)
15619                               relocation = 0;
15620                             else
15621                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15622                             if (tls_type & TLS_TPREL)
15623                               relocation += DTP_OFFSET - TP_OFFSET;
15624                           }
15625
15626                         if (tls_type & (TLS_GD | TLS_LD))
15627                           {
15628                             bfd_put_64 (output_bfd, relocation,
15629                                         got->contents + off + 8);
15630                             relocation = 1;
15631                           }
15632                       }
15633                     bfd_put_64 (output_bfd, relocation,
15634                                 got->contents + off);
15635                   }
15636               }
15637
15638             if (off >= (bfd_vma) -2)
15639               abort ();
15640
15641             relocation = got->output_section->vma + got->output_offset + off;
15642             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15643           }
15644           break;
15645
15646         case R_PPC64_PLT16_HA:
15647         case R_PPC64_PLT16_HI:
15648         case R_PPC64_PLT16_LO:
15649         case R_PPC64_PLT16_LO_DS:
15650         case R_PPC64_PLT32:
15651         case R_PPC64_PLT64:
15652         case R_PPC64_PLTSEQ:
15653         case R_PPC64_PLTCALL:
15654           /* Relocation is to the entry for this symbol in the
15655              procedure linkage table.  */
15656           unresolved_reloc = TRUE;
15657           {
15658             struct plt_entry **plt_list = NULL;
15659             if (h != NULL)
15660               plt_list = &h->elf.plt.plist;
15661             else if (local_got_ents != NULL)
15662               {
15663                 struct plt_entry **local_plt = (struct plt_entry **)
15664                   (local_got_ents + symtab_hdr->sh_info);
15665                 plt_list = local_plt + r_symndx;
15666               }
15667             if (plt_list)
15668               {
15669                 struct plt_entry *ent;
15670
15671                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15672                   if (ent->plt.offset != (bfd_vma) -1
15673                       && ent->addend == orig_rel.r_addend)
15674                     {
15675                       asection *plt;
15676                       bfd_vma got;
15677
15678                       plt = htab->elf.splt;
15679                       if (!htab->elf.dynamic_sections_created
15680                           || h == NULL
15681                           || h->elf.dynindx == -1)
15682                         {
15683                           if (h != NULL
15684                               ? h->elf.type == STT_GNU_IFUNC
15685                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15686                             plt = htab->elf.iplt;
15687                           else
15688                             plt = htab->pltlocal;
15689                         }
15690                       relocation = (plt->output_section->vma
15691                                     + plt->output_offset
15692                                     + ent->plt.offset);
15693                       if (r_type == R_PPC64_PLT16_HA
15694                           || r_type ==R_PPC64_PLT16_HI
15695                           || r_type ==R_PPC64_PLT16_LO
15696                           || r_type ==R_PPC64_PLT16_LO_DS)
15697                         {
15698                           got = (elf_gp (output_bfd)
15699                                  + htab->sec_info[input_section->id].toc_off);
15700                           relocation -= got;
15701                         }
15702                       addend = 0;
15703                       unresolved_reloc = FALSE;
15704                       break;
15705                     }
15706               }
15707           }
15708           break;
15709
15710         case R_PPC64_TOC:
15711           /* Relocation value is TOC base.  */
15712           relocation = TOCstart;
15713           if (r_symndx == STN_UNDEF)
15714             relocation += htab->sec_info[input_section->id].toc_off;
15715           else if (unresolved_reloc)
15716             ;
15717           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15718             relocation += htab->sec_info[sec->id].toc_off;
15719           else
15720             unresolved_reloc = TRUE;
15721           goto dodyn;
15722
15723           /* TOC16 relocs.  We want the offset relative to the TOC base,
15724              which is the address of the start of the TOC plus 0x8000.
15725              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15726              in this order.  */
15727         case R_PPC64_TOC16:
15728         case R_PPC64_TOC16_LO:
15729         case R_PPC64_TOC16_HI:
15730         case R_PPC64_TOC16_DS:
15731         case R_PPC64_TOC16_LO_DS:
15732         case R_PPC64_TOC16_HA:
15733           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15734           break;
15735
15736           /* Relocate against the beginning of the section.  */
15737         case R_PPC64_SECTOFF:
15738         case R_PPC64_SECTOFF_LO:
15739         case R_PPC64_SECTOFF_HI:
15740         case R_PPC64_SECTOFF_DS:
15741         case R_PPC64_SECTOFF_LO_DS:
15742         case R_PPC64_SECTOFF_HA:
15743           if (sec != NULL)
15744             addend -= sec->output_section->vma;
15745           break;
15746
15747         case R_PPC64_REL16:
15748         case R_PPC64_REL16_LO:
15749         case R_PPC64_REL16_HI:
15750         case R_PPC64_REL16_HA:
15751         case R_PPC64_REL16DX_HA:
15752           break;
15753
15754         case R_PPC64_REL14:
15755         case R_PPC64_REL14_BRNTAKEN:
15756         case R_PPC64_REL14_BRTAKEN:
15757         case R_PPC64_REL24:
15758         case R_PPC64_REL24_NOTOC:
15759           break;
15760
15761         case R_PPC64_TPREL16:
15762         case R_PPC64_TPREL16_LO:
15763         case R_PPC64_TPREL16_HI:
15764         case R_PPC64_TPREL16_HA:
15765         case R_PPC64_TPREL16_DS:
15766         case R_PPC64_TPREL16_LO_DS:
15767         case R_PPC64_TPREL16_HIGH:
15768         case R_PPC64_TPREL16_HIGHA:
15769         case R_PPC64_TPREL16_HIGHER:
15770         case R_PPC64_TPREL16_HIGHERA:
15771         case R_PPC64_TPREL16_HIGHEST:
15772         case R_PPC64_TPREL16_HIGHESTA:
15773           if (h != NULL
15774               && h->elf.root.type == bfd_link_hash_undefweak
15775               && h->elf.dynindx == -1)
15776             {
15777               /* Make this relocation against an undefined weak symbol
15778                  resolve to zero.  This is really just a tweak, since
15779                  code using weak externs ought to check that they are
15780                  defined before using them.  */
15781               bfd_byte *p = contents + rel->r_offset - d_offset;
15782
15783               insn = bfd_get_32 (input_bfd, p);
15784               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15785               if (insn != 0)
15786                 bfd_put_32 (input_bfd, insn, p);
15787               break;
15788             }
15789           if (htab->elf.tls_sec != NULL)
15790             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15791           /* The TPREL16 relocs shouldn't really be used in shared
15792              libs or with non-local symbols as that will result in
15793              DT_TEXTREL being set, but support them anyway.  */
15794           goto dodyn;
15795
15796         case R_PPC64_DTPREL16:
15797         case R_PPC64_DTPREL16_LO:
15798         case R_PPC64_DTPREL16_HI:
15799         case R_PPC64_DTPREL16_HA:
15800         case R_PPC64_DTPREL16_DS:
15801         case R_PPC64_DTPREL16_LO_DS:
15802         case R_PPC64_DTPREL16_HIGH:
15803         case R_PPC64_DTPREL16_HIGHA:
15804         case R_PPC64_DTPREL16_HIGHER:
15805         case R_PPC64_DTPREL16_HIGHERA:
15806         case R_PPC64_DTPREL16_HIGHEST:
15807         case R_PPC64_DTPREL16_HIGHESTA:
15808           if (htab->elf.tls_sec != NULL)
15809             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15810           break;
15811
15812         case R_PPC64_ADDR64_LOCAL:
15813           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15814                                               ? h->elf.other
15815                                               : sym->st_other);
15816           break;
15817
15818         case R_PPC64_DTPMOD64:
15819           relocation = 1;
15820           addend = 0;
15821           goto dodyn;
15822
15823         case R_PPC64_TPREL64:
15824           if (htab->elf.tls_sec != NULL)
15825             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15826           goto dodyn;
15827
15828         case R_PPC64_DTPREL64:
15829           if (htab->elf.tls_sec != NULL)
15830             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15831           /* Fall through.  */
15832
15833           /* Relocations that may need to be propagated if this is a
15834              dynamic object.  */
15835         case R_PPC64_REL30:
15836         case R_PPC64_REL32:
15837         case R_PPC64_REL64:
15838         case R_PPC64_ADDR14:
15839         case R_PPC64_ADDR14_BRNTAKEN:
15840         case R_PPC64_ADDR14_BRTAKEN:
15841         case R_PPC64_ADDR16:
15842         case R_PPC64_ADDR16_DS:
15843         case R_PPC64_ADDR16_HA:
15844         case R_PPC64_ADDR16_HI:
15845         case R_PPC64_ADDR16_HIGH:
15846         case R_PPC64_ADDR16_HIGHA:
15847         case R_PPC64_ADDR16_HIGHER:
15848         case R_PPC64_ADDR16_HIGHERA:
15849         case R_PPC64_ADDR16_HIGHEST:
15850         case R_PPC64_ADDR16_HIGHESTA:
15851         case R_PPC64_ADDR16_LO:
15852         case R_PPC64_ADDR16_LO_DS:
15853         case R_PPC64_ADDR24:
15854         case R_PPC64_ADDR32:
15855         case R_PPC64_ADDR64:
15856         case R_PPC64_UADDR16:
15857         case R_PPC64_UADDR32:
15858         case R_PPC64_UADDR64:
15859         dodyn:
15860           if ((input_section->flags & SEC_ALLOC) == 0)
15861             break;
15862
15863           if (NO_OPD_RELOCS && is_opd)
15864             break;
15865
15866           if (bfd_link_pic (info)
15867               ? ((h == NULL
15868                   || h->dyn_relocs != NULL)
15869                  && ((h != NULL && pc_dynrelocs (h))
15870                      || must_be_dyn_reloc (info, r_type)))
15871               : (h != NULL
15872                  ? h->dyn_relocs != NULL
15873                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15874             {
15875               bfd_boolean skip, relocate;
15876               asection *sreloc;
15877               bfd_vma out_off;
15878               long indx = 0;
15879
15880               /* When generating a dynamic object, these relocations
15881                  are copied into the output file to be resolved at run
15882                  time.  */
15883
15884               skip = FALSE;
15885               relocate = FALSE;
15886
15887               out_off = _bfd_elf_section_offset (output_bfd, info,
15888                                                  input_section, rel->r_offset);
15889               if (out_off == (bfd_vma) -1)
15890                 skip = TRUE;
15891               else if (out_off == (bfd_vma) -2)
15892                 skip = TRUE, relocate = TRUE;
15893               out_off += (input_section->output_section->vma
15894                           + input_section->output_offset);
15895               outrel.r_offset = out_off;
15896               outrel.r_addend = rel->r_addend;
15897
15898               /* Optimize unaligned reloc use.  */
15899               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15900                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15901                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15902               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15903                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15904                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15905               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15906                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15907                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15908
15909               if (skip)
15910                 memset (&outrel, 0, sizeof outrel);
15911               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15912                        && !is_opd
15913                        && r_type != R_PPC64_TOC)
15914                 {
15915                   indx = h->elf.dynindx;
15916                   BFD_ASSERT (indx != -1);
15917                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15918                 }
15919               else
15920                 {
15921                   /* This symbol is local, or marked to become local,
15922                      or this is an opd section reloc which must point
15923                      at a local function.  */
15924                   outrel.r_addend += relocation;
15925                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15926                     {
15927                       if (is_opd && h != NULL)
15928                         {
15929                           /* Lie about opd entries.  This case occurs
15930                              when building shared libraries and we
15931                              reference a function in another shared
15932                              lib.  The same thing happens for a weak
15933                              definition in an application that's
15934                              overridden by a strong definition in a
15935                              shared lib.  (I believe this is a generic
15936                              bug in binutils handling of weak syms.)
15937                              In these cases we won't use the opd
15938                              entry in this lib.  */
15939                           unresolved_reloc = FALSE;
15940                         }
15941                       if (!is_opd
15942                           && r_type == R_PPC64_ADDR64
15943                           && (h != NULL
15944                               ? h->elf.type == STT_GNU_IFUNC
15945                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15946                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15947                       else
15948                         {
15949                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15950
15951                           /* We need to relocate .opd contents for ld.so.
15952                              Prelink also wants simple and consistent rules
15953                              for relocs.  This make all RELATIVE relocs have
15954                              *r_offset equal to r_addend.  */
15955                           relocate = TRUE;
15956                         }
15957                     }
15958                   else
15959                     {
15960                       if (h != NULL
15961                           ? h->elf.type == STT_GNU_IFUNC
15962                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15963                         {
15964                           info->callbacks->einfo
15965                             /* xgettext:c-format */
15966                             (_("%H: %s for indirect "
15967                                "function `%pT' unsupported\n"),
15968                              input_bfd, input_section, rel->r_offset,
15969                              ppc64_elf_howto_table[r_type]->name,
15970                              sym_name);
15971                           ret = FALSE;
15972                         }
15973                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15974                         ;
15975                       else if (sec == NULL || sec->owner == NULL)
15976                         {
15977                           bfd_set_error (bfd_error_bad_value);
15978                           return FALSE;
15979                         }
15980                       else
15981                         {
15982                           asection *osec;
15983
15984                           osec = sec->output_section;
15985                           indx = elf_section_data (osec)->dynindx;
15986
15987                           if (indx == 0)
15988                             {
15989                               if ((osec->flags & SEC_READONLY) == 0
15990                                   && htab->elf.data_index_section != NULL)
15991                                 osec = htab->elf.data_index_section;
15992                               else
15993                                 osec = htab->elf.text_index_section;
15994                               indx = elf_section_data (osec)->dynindx;
15995                             }
15996                           BFD_ASSERT (indx != 0);
15997
15998                           /* We are turning this relocation into one
15999                              against a section symbol, so subtract out
16000                              the output section's address but not the
16001                              offset of the input section in the output
16002                              section.  */
16003                           outrel.r_addend -= osec->vma;
16004                         }
16005
16006                       outrel.r_info = ELF64_R_INFO (indx, r_type);
16007                     }
16008                 }
16009
16010               sreloc = elf_section_data (input_section)->sreloc;
16011               if (h != NULL
16012                   ? h->elf.type == STT_GNU_IFUNC
16013                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16014                 {
16015                   sreloc = htab->elf.irelplt;
16016                   if (indx == 0)
16017                     htab->local_ifunc_resolver = 1;
16018                   else if (is_static_defined (&h->elf))
16019                     htab->maybe_local_ifunc_resolver = 1;
16020                 }
16021               if (sreloc == NULL)
16022                 abort ();
16023
16024               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16025                   >= sreloc->size)
16026                 abort ();
16027               loc = sreloc->contents;
16028               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16029               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16030
16031               /* If this reloc is against an external symbol, it will
16032                  be computed at runtime, so there's no need to do
16033                  anything now.  However, for the sake of prelink ensure
16034                  that the section contents are a known value.  */
16035               if (! relocate)
16036                 {
16037                   unresolved_reloc = FALSE;
16038                   /* The value chosen here is quite arbitrary as ld.so
16039                      ignores section contents except for the special
16040                      case of .opd where the contents might be accessed
16041                      before relocation.  Choose zero, as that won't
16042                      cause reloc overflow.  */
16043                   relocation = 0;
16044                   addend = 0;
16045                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16046                      to improve backward compatibility with older
16047                      versions of ld.  */
16048                   if (r_type == R_PPC64_ADDR64)
16049                     addend = outrel.r_addend;
16050                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
16051                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
16052                     addend = outrel.r_offset;
16053                 }
16054             }
16055           break;
16056
16057         case R_PPC64_COPY:
16058         case R_PPC64_GLOB_DAT:
16059         case R_PPC64_JMP_SLOT:
16060         case R_PPC64_JMP_IREL:
16061         case R_PPC64_RELATIVE:
16062           /* We shouldn't ever see these dynamic relocs in relocatable
16063              files.  */
16064           /* Fall through.  */
16065
16066         case R_PPC64_PLTGOT16:
16067         case R_PPC64_PLTGOT16_DS:
16068         case R_PPC64_PLTGOT16_HA:
16069         case R_PPC64_PLTGOT16_HI:
16070         case R_PPC64_PLTGOT16_LO:
16071         case R_PPC64_PLTGOT16_LO_DS:
16072         case R_PPC64_PLTREL32:
16073         case R_PPC64_PLTREL64:
16074           /* These ones haven't been implemented yet.  */
16075
16076           info->callbacks->einfo
16077             /* xgettext:c-format */
16078             (_("%P: %pB: %s is not supported for `%pT'\n"),
16079              input_bfd,
16080              ppc64_elf_howto_table[r_type]->name, sym_name);
16081
16082           bfd_set_error (bfd_error_invalid_operation);
16083           ret = FALSE;
16084           goto copy_reloc;
16085         }
16086
16087       /* Multi-instruction sequences that access the TOC can be
16088          optimized, eg. addis ra,r2,0; addi rb,ra,x;
16089          to             nop;           addi rb,r2,x;  */
16090       switch (r_type)
16091         {
16092         default:
16093           break;
16094
16095         case R_PPC64_GOT_TLSLD16_HI:
16096         case R_PPC64_GOT_TLSGD16_HI:
16097         case R_PPC64_GOT_TPREL16_HI:
16098         case R_PPC64_GOT_DTPREL16_HI:
16099         case R_PPC64_GOT16_HI:
16100         case R_PPC64_TOC16_HI:
16101           /* These relocs would only be useful if building up an
16102              offset to later add to r2, perhaps in an indexed
16103              addressing mode instruction.  Don't try to optimize.
16104              Unfortunately, the possibility of someone building up an
16105              offset like this or even with the HA relocs, means that
16106              we need to check the high insn when optimizing the low
16107              insn.  */
16108           break;
16109
16110         case R_PPC64_PLTCALL:
16111           if (unresolved_reloc)
16112             {
16113               /* No plt entry.  Make this into a direct call.  */
16114               bfd_byte *p = contents + rel->r_offset;
16115               insn = bfd_get_32 (input_bfd, p);
16116               insn &= 1;
16117               bfd_put_32 (input_bfd, B_DOT | insn, p);
16118               bfd_put_32 (input_bfd, NOP, p + 4);
16119               unresolved_reloc = save_unresolved_reloc;
16120               r_type = R_PPC64_REL24;
16121             }
16122           break;
16123
16124         case R_PPC64_PLTSEQ:
16125           if (unresolved_reloc)
16126             {
16127               unresolved_reloc = FALSE;
16128               goto nop_it;
16129             }
16130           break;
16131
16132         case R_PPC64_PLT16_HA:
16133           if (unresolved_reloc)
16134             {
16135               unresolved_reloc = FALSE;
16136               goto nop_it;
16137             }
16138           /* Fall through.  */
16139         case R_PPC64_GOT_TLSLD16_HA:
16140         case R_PPC64_GOT_TLSGD16_HA:
16141         case R_PPC64_GOT_TPREL16_HA:
16142         case R_PPC64_GOT_DTPREL16_HA:
16143         case R_PPC64_GOT16_HA:
16144         case R_PPC64_TOC16_HA:
16145           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16146               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16147             {
16148               bfd_byte *p;
16149             nop_it:
16150               p = contents + (rel->r_offset & ~3);
16151               bfd_put_32 (input_bfd, NOP, p);
16152               goto copy_reloc;
16153             }
16154           break;
16155
16156         case R_PPC64_PLT16_LO:
16157         case R_PPC64_PLT16_LO_DS:
16158           if (unresolved_reloc)
16159             {
16160               unresolved_reloc = FALSE;
16161               goto nop_it;
16162             }
16163           /* Fall through.  */
16164         case R_PPC64_GOT_TLSLD16_LO:
16165         case R_PPC64_GOT_TLSGD16_LO:
16166         case R_PPC64_GOT_TPREL16_LO_DS:
16167         case R_PPC64_GOT_DTPREL16_LO_DS:
16168         case R_PPC64_GOT16_LO:
16169         case R_PPC64_GOT16_LO_DS:
16170         case R_PPC64_TOC16_LO:
16171         case R_PPC64_TOC16_LO_DS:
16172           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16173               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16174             {
16175               bfd_byte *p = contents + (rel->r_offset & ~3);
16176               insn = bfd_get_32 (input_bfd, p);
16177               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16178                 {
16179                   /* Transform addic to addi when we change reg.  */
16180                   insn &= ~((0x3f << 26) | (0x1f << 16));
16181                   insn |= (14u << 26) | (2 << 16);
16182                 }
16183               else
16184                 {
16185                   insn &= ~(0x1f << 16);
16186                   insn |= 2 << 16;
16187                 }
16188               bfd_put_32 (input_bfd, insn, p);
16189             }
16190           break;
16191
16192         case R_PPC64_TPREL16_HA:
16193           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16194             {
16195               bfd_byte *p = contents + (rel->r_offset & ~3);
16196               insn = bfd_get_32 (input_bfd, p);
16197               if ((insn & ((0x3f << 26) | 0x1f << 16))
16198                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16199                 /* xgettext:c-format */
16200                 info->callbacks->minfo
16201                   (_("%H: warning: %s unexpected insn %#x.\n"),
16202                    input_bfd, input_section, rel->r_offset,
16203                    ppc64_elf_howto_table[r_type]->name, insn);
16204               else
16205                 {
16206                   bfd_put_32 (input_bfd, NOP, p);
16207                   goto copy_reloc;
16208                 }
16209             }
16210           break;
16211
16212         case R_PPC64_TPREL16_LO:
16213         case R_PPC64_TPREL16_LO_DS:
16214           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16215             {
16216               bfd_byte *p = contents + (rel->r_offset & ~3);
16217               insn = bfd_get_32 (input_bfd, p);
16218               insn &= ~(0x1f << 16);
16219               insn |= 13 << 16;
16220               bfd_put_32 (input_bfd, insn, p);
16221             }
16222           break;
16223         }
16224
16225       /* Do any further special processing.  */
16226       switch (r_type)
16227         {
16228         default:
16229           break;
16230
16231         case R_PPC64_REL16_HA:
16232         case R_PPC64_REL16DX_HA:
16233         case R_PPC64_ADDR16_HA:
16234         case R_PPC64_ADDR16_HIGHA:
16235         case R_PPC64_ADDR16_HIGHERA:
16236         case R_PPC64_ADDR16_HIGHESTA:
16237         case R_PPC64_TOC16_HA:
16238         case R_PPC64_SECTOFF_HA:
16239         case R_PPC64_TPREL16_HA:
16240         case R_PPC64_TPREL16_HIGHA:
16241         case R_PPC64_TPREL16_HIGHERA:
16242         case R_PPC64_TPREL16_HIGHESTA:
16243         case R_PPC64_DTPREL16_HA:
16244         case R_PPC64_DTPREL16_HIGHA:
16245         case R_PPC64_DTPREL16_HIGHERA:
16246         case R_PPC64_DTPREL16_HIGHESTA:
16247           /* It's just possible that this symbol is a weak symbol
16248              that's not actually defined anywhere. In that case,
16249              'sec' would be NULL, and we should leave the symbol
16250              alone (it will be set to zero elsewhere in the link).  */
16251           if (sec == NULL)
16252             break;
16253           /* Fall through.  */
16254
16255         case R_PPC64_GOT16_HA:
16256         case R_PPC64_PLTGOT16_HA:
16257         case R_PPC64_PLT16_HA:
16258         case R_PPC64_GOT_TLSGD16_HA:
16259         case R_PPC64_GOT_TLSLD16_HA:
16260         case R_PPC64_GOT_TPREL16_HA:
16261         case R_PPC64_GOT_DTPREL16_HA:
16262           /* Add 0x10000 if sign bit in 0:15 is set.
16263              Bits 0:15 are not used.  */
16264           addend += 0x8000;
16265           break;
16266
16267         case R_PPC64_ADDR16_DS:
16268         case R_PPC64_ADDR16_LO_DS:
16269         case R_PPC64_GOT16_DS:
16270         case R_PPC64_GOT16_LO_DS:
16271         case R_PPC64_PLT16_LO_DS:
16272         case R_PPC64_SECTOFF_DS:
16273         case R_PPC64_SECTOFF_LO_DS:
16274         case R_PPC64_TOC16_DS:
16275         case R_PPC64_TOC16_LO_DS:
16276         case R_PPC64_PLTGOT16_DS:
16277         case R_PPC64_PLTGOT16_LO_DS:
16278         case R_PPC64_GOT_TPREL16_DS:
16279         case R_PPC64_GOT_TPREL16_LO_DS:
16280         case R_PPC64_GOT_DTPREL16_DS:
16281         case R_PPC64_GOT_DTPREL16_LO_DS:
16282         case R_PPC64_TPREL16_DS:
16283         case R_PPC64_TPREL16_LO_DS:
16284         case R_PPC64_DTPREL16_DS:
16285         case R_PPC64_DTPREL16_LO_DS:
16286           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16287           mask = 3;
16288           /* If this reloc is against an lq, lxv, or stxv insn, then
16289              the value must be a multiple of 16.  This is somewhat of
16290              a hack, but the "correct" way to do this by defining _DQ
16291              forms of all the _DS relocs bloats all reloc switches in
16292              this file.  It doesn't make much sense to use these
16293              relocs in data, so testing the insn should be safe.  */
16294           if ((insn & (0x3f << 26)) == (56u << 26)
16295               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16296             mask = 15;
16297           relocation += addend;
16298           addend = insn & (mask ^ 3);
16299           if ((relocation & mask) != 0)
16300             {
16301               relocation ^= relocation & mask;
16302               info->callbacks->einfo
16303                 /* xgettext:c-format */
16304                 (_("%H: error: %s not a multiple of %u\n"),
16305                  input_bfd, input_section, rel->r_offset,
16306                  ppc64_elf_howto_table[r_type]->name,
16307                  mask + 1);
16308               bfd_set_error (bfd_error_bad_value);
16309               ret = FALSE;
16310               goto copy_reloc;
16311             }
16312           break;
16313         }
16314
16315       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16316          because such sections are not SEC_ALLOC and thus ld.so will
16317          not process them.  */
16318       howto = ppc64_elf_howto_table[(int) r_type];
16319       if (unresolved_reloc
16320           && !((input_section->flags & SEC_DEBUGGING) != 0
16321                && h->elf.def_dynamic)
16322           && _bfd_elf_section_offset (output_bfd, info, input_section,
16323                                       rel->r_offset) != (bfd_vma) -1)
16324         {
16325           info->callbacks->einfo
16326             /* xgettext:c-format */
16327             (_("%H: unresolvable %s against `%pT'\n"),
16328              input_bfd, input_section, rel->r_offset,
16329              howto->name,
16330              h->elf.root.root.string);
16331           ret = FALSE;
16332         }
16333
16334       /* 16-bit fields in insns mostly have signed values, but a
16335          few insns have 16-bit unsigned values.  Really, we should
16336          have different reloc types.  */
16337       if (howto->complain_on_overflow != complain_overflow_dont
16338           && howto->dst_mask == 0xffff
16339           && (input_section->flags & SEC_CODE) != 0)
16340         {
16341           enum complain_overflow complain = complain_overflow_signed;
16342
16343           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16344           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16345             complain = complain_overflow_bitfield;
16346           else if (howto->rightshift == 0
16347                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16348                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16349                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16350                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16351                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16352                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16353             complain = complain_overflow_unsigned;
16354           if (howto->complain_on_overflow != complain)
16355             {
16356               alt_howto = *howto;
16357               alt_howto.complain_on_overflow = complain;
16358               howto = &alt_howto;
16359             }
16360         }
16361
16362       if (r_type == R_PPC64_REL16DX_HA)
16363         {
16364           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
16365           if (rel->r_offset + 4 > input_section->size)
16366             r = bfd_reloc_outofrange;
16367           else
16368             {
16369               relocation += addend;
16370               relocation -= (rel->r_offset
16371                              + input_section->output_offset
16372                              + input_section->output_section->vma);
16373               relocation = (bfd_signed_vma) relocation >> 16;
16374               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16375               insn &= ~0x1fffc1;
16376               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16377               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16378               r = bfd_reloc_ok;
16379               if (relocation + 0x8000 > 0xffff)
16380                 r = bfd_reloc_overflow;
16381             }
16382         }
16383       else
16384         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
16385                                       rel->r_offset, relocation, addend);
16386
16387       if (r != bfd_reloc_ok)
16388         {
16389           char *more_info = NULL;
16390           const char *reloc_name = howto->name;
16391
16392           if (reloc_dest != DEST_NORMAL)
16393             {
16394               more_info = bfd_malloc (strlen (reloc_name) + 8);
16395               if (more_info != NULL)
16396                 {
16397                   strcpy (more_info, reloc_name);
16398                   strcat (more_info, (reloc_dest == DEST_OPD
16399                                       ? " (OPD)" : " (stub)"));
16400                   reloc_name = more_info;
16401                 }
16402             }
16403
16404           if (r == bfd_reloc_overflow)
16405             {
16406               /* On code like "if (foo) foo();" don't report overflow
16407                  on a branch to zero when foo is undefined.  */
16408               if (!warned
16409                   && (reloc_dest == DEST_STUB
16410                       || !(h != NULL
16411                            && (h->elf.root.type == bfd_link_hash_undefweak
16412                                || h->elf.root.type == bfd_link_hash_undefined)
16413                            && is_branch_reloc (r_type))))
16414                 info->callbacks->reloc_overflow (info, &h->elf.root,
16415                                                  sym_name, reloc_name,
16416                                                  orig_rel.r_addend,
16417                                                  input_bfd, input_section,
16418                                                  rel->r_offset);
16419             }
16420           else
16421             {
16422               info->callbacks->einfo
16423                 /* xgettext:c-format */
16424                 (_("%H: %s against `%pT': error %d\n"),
16425                  input_bfd, input_section, rel->r_offset,
16426                  reloc_name, sym_name, (int) r);
16427               ret = FALSE;
16428             }
16429           if (more_info != NULL)
16430             free (more_info);
16431         }
16432     copy_reloc:
16433       if (wrel != rel)
16434         *wrel = *rel;
16435     }
16436
16437   if (wrel != rel)
16438     {
16439       Elf_Internal_Shdr *rel_hdr;
16440       size_t deleted = rel - wrel;
16441
16442       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16443       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16444       if (rel_hdr->sh_size == 0)
16445         {
16446           /* It is too late to remove an empty reloc section.  Leave
16447              one NONE reloc.
16448              ??? What is wrong with an empty section???  */
16449           rel_hdr->sh_size = rel_hdr->sh_entsize;
16450           deleted -= 1;
16451         }
16452       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16453       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16454       input_section->reloc_count -= deleted;
16455     }
16456
16457   /* If we're emitting relocations, then shortly after this function
16458      returns, reloc offsets and addends for this section will be
16459      adjusted.  Worse, reloc symbol indices will be for the output
16460      file rather than the input.  Save a copy of the relocs for
16461      opd_entry_value.  */
16462   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16463     {
16464       bfd_size_type amt;
16465       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16466       rel = bfd_alloc (input_bfd, amt);
16467       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16468       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16469       if (rel == NULL)
16470         return FALSE;
16471       memcpy (rel, relocs, amt);
16472     }
16473   return ret;
16474 }
16475
16476 /* Adjust the value of any local symbols in opd sections.  */
16477
16478 static int
16479 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16480                               const char *name ATTRIBUTE_UNUSED,
16481                               Elf_Internal_Sym *elfsym,
16482                               asection *input_sec,
16483                               struct elf_link_hash_entry *h)
16484 {
16485   struct _opd_sec_data *opd;
16486   long adjust;
16487   bfd_vma value;
16488
16489   if (h != NULL)
16490     return 1;
16491
16492   opd = get_opd_info (input_sec);
16493   if (opd == NULL || opd->adjust == NULL)
16494     return 1;
16495
16496   value = elfsym->st_value - input_sec->output_offset;
16497   if (!bfd_link_relocatable (info))
16498     value -= input_sec->output_section->vma;
16499
16500   adjust = opd->adjust[OPD_NDX (value)];
16501   if (adjust == -1)
16502     return 2;
16503
16504   elfsym->st_value += adjust;
16505   return 1;
16506 }
16507
16508 /* Finish up dynamic symbol handling.  We set the contents of various
16509    dynamic sections here.  */
16510
16511 static bfd_boolean
16512 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16513                                  struct bfd_link_info *info,
16514                                  struct elf_link_hash_entry *h,
16515                                  Elf_Internal_Sym *sym)
16516 {
16517   struct ppc_link_hash_table *htab;
16518   struct plt_entry *ent;
16519
16520   htab = ppc_hash_table (info);
16521   if (htab == NULL)
16522     return FALSE;
16523
16524   if (!htab->opd_abi && !h->def_regular)
16525     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16526       if (ent->plt.offset != (bfd_vma) -1)
16527         {
16528           /* Mark the symbol as undefined, rather than as
16529              defined in glink.  Leave the value if there were
16530              any relocations where pointer equality matters
16531              (this is a clue for the dynamic linker, to make
16532              function pointer comparisons work between an
16533              application and shared library), otherwise set it
16534              to zero.  */
16535           sym->st_shndx = SHN_UNDEF;
16536           if (!h->pointer_equality_needed)
16537             sym->st_value = 0;
16538           else if (!h->ref_regular_nonweak)
16539             {
16540               /* This breaks function pointer comparisons, but
16541                  that is better than breaking tests for a NULL
16542                  function pointer.  */
16543               sym->st_value = 0;
16544             }
16545           break;
16546         }
16547
16548   if (h->needs_copy)
16549     {
16550       /* This symbol needs a copy reloc.  Set it up.  */
16551       Elf_Internal_Rela rela;
16552       asection *srel;
16553       bfd_byte *loc;
16554
16555       if (h->dynindx == -1
16556           || (h->root.type != bfd_link_hash_defined
16557               && h->root.type != bfd_link_hash_defweak)
16558           || htab->elf.srelbss == NULL
16559           || htab->elf.sreldynrelro == NULL)
16560         abort ();
16561
16562       rela.r_offset = (h->root.u.def.value
16563                        + h->root.u.def.section->output_section->vma
16564                        + h->root.u.def.section->output_offset);
16565       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16566       rela.r_addend = 0;
16567       if (h->root.u.def.section == htab->elf.sdynrelro)
16568         srel = htab->elf.sreldynrelro;
16569       else
16570         srel = htab->elf.srelbss;
16571       loc = srel->contents;
16572       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16573       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16574     }
16575
16576   return TRUE;
16577 }
16578
16579 /* Used to decide how to sort relocs in an optimal manner for the
16580    dynamic linker, before writing them out.  */
16581
16582 static enum elf_reloc_type_class
16583 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16584                             const asection *rel_sec,
16585                             const Elf_Internal_Rela *rela)
16586 {
16587   enum elf_ppc64_reloc_type r_type;
16588   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16589
16590   if (rel_sec == htab->elf.irelplt)
16591     return reloc_class_ifunc;
16592
16593   r_type = ELF64_R_TYPE (rela->r_info);
16594   switch (r_type)
16595     {
16596     case R_PPC64_RELATIVE:
16597       return reloc_class_relative;
16598     case R_PPC64_JMP_SLOT:
16599       return reloc_class_plt;
16600     case R_PPC64_COPY:
16601       return reloc_class_copy;
16602     default:
16603       return reloc_class_normal;
16604     }
16605 }
16606
16607 /* Finish up the dynamic sections.  */
16608
16609 static bfd_boolean
16610 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16611                                    struct bfd_link_info *info)
16612 {
16613   struct ppc_link_hash_table *htab;
16614   bfd *dynobj;
16615   asection *sdyn;
16616
16617   htab = ppc_hash_table (info);
16618   if (htab == NULL)
16619     return FALSE;
16620
16621   dynobj = htab->elf.dynobj;
16622   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16623
16624   if (htab->elf.dynamic_sections_created)
16625     {
16626       Elf64_External_Dyn *dyncon, *dynconend;
16627
16628       if (sdyn == NULL || htab->elf.sgot == NULL)
16629         abort ();
16630
16631       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16632       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16633       for (; dyncon < dynconend; dyncon++)
16634         {
16635           Elf_Internal_Dyn dyn;
16636           asection *s;
16637
16638           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16639
16640           switch (dyn.d_tag)
16641             {
16642             default:
16643               continue;
16644
16645             case DT_PPC64_GLINK:
16646               s = htab->glink;
16647               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16648               /* We stupidly defined DT_PPC64_GLINK to be the start
16649                  of glink rather than the first entry point, which is
16650                  what ld.so needs, and now have a bigger stub to
16651                  support automatic multiple TOCs.  */
16652               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16653               break;
16654
16655             case DT_PPC64_OPD:
16656               s = bfd_get_section_by_name (output_bfd, ".opd");
16657               if (s == NULL)
16658                 continue;
16659               dyn.d_un.d_ptr = s->vma;
16660               break;
16661
16662             case DT_PPC64_OPT:
16663               if (htab->do_multi_toc && htab->multi_toc_needed)
16664                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16665               if (htab->has_plt_localentry0)
16666                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16667               break;
16668
16669             case DT_PPC64_OPDSZ:
16670               s = bfd_get_section_by_name (output_bfd, ".opd");
16671               if (s == NULL)
16672                 continue;
16673               dyn.d_un.d_val = s->size;
16674               break;
16675
16676             case DT_PLTGOT:
16677               s = htab->elf.splt;
16678               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16679               break;
16680
16681             case DT_JMPREL:
16682               s = htab->elf.srelplt;
16683               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16684               break;
16685
16686             case DT_PLTRELSZ:
16687               dyn.d_un.d_val = htab->elf.srelplt->size;
16688               break;
16689
16690             case DT_TEXTREL:
16691               if (htab->local_ifunc_resolver)
16692                 info->callbacks->einfo
16693                   (_("%X%P: text relocations and GNU indirect "
16694                      "functions will result in a segfault at runtime\n"));
16695               else if (htab->maybe_local_ifunc_resolver)
16696                 info->callbacks->einfo
16697                   (_("%P: warning: text relocations and GNU indirect "
16698                      "functions may result in a segfault at runtime\n"));
16699               continue;
16700             }
16701
16702           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16703         }
16704     }
16705
16706   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16707       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16708     {
16709       /* Fill in the first entry in the global offset table.
16710          We use it to hold the link-time TOCbase.  */
16711       bfd_put_64 (output_bfd,
16712                   elf_gp (output_bfd) + TOC_BASE_OFF,
16713                   htab->elf.sgot->contents);
16714
16715       /* Set .got entry size.  */
16716       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16717     }
16718
16719   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16720       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16721     {
16722       /* Set .plt entry size.  */
16723       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16724         = PLT_ENTRY_SIZE (htab);
16725     }
16726
16727   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16728      brlt ourselves if emitrelocations.  */
16729   if (htab->brlt != NULL
16730       && htab->brlt->reloc_count != 0
16731       && !_bfd_elf_link_output_relocs (output_bfd,
16732                                        htab->brlt,
16733                                        elf_section_data (htab->brlt)->rela.hdr,
16734                                        elf_section_data (htab->brlt)->relocs,
16735                                        NULL))
16736     return FALSE;
16737
16738   if (htab->glink != NULL
16739       && htab->glink->reloc_count != 0
16740       && !_bfd_elf_link_output_relocs (output_bfd,
16741                                        htab->glink,
16742                                        elf_section_data (htab->glink)->rela.hdr,
16743                                        elf_section_data (htab->glink)->relocs,
16744                                        NULL))
16745     return FALSE;
16746
16747   if (htab->glink_eh_frame != NULL
16748       && htab->glink_eh_frame->size != 0)
16749     {
16750       bfd_vma val;
16751       bfd_byte *p;
16752       struct map_stub *group;
16753       size_t align = 4;
16754
16755       p = htab->glink_eh_frame->contents;
16756       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16757
16758       for (group = htab->group; group != NULL; group = group->next)
16759         if (group->stub_sec != NULL)
16760           {
16761             /* Offset to stub section.  */
16762             val = (group->stub_sec->output_section->vma
16763                    + group->stub_sec->output_offset);
16764             val -= (htab->glink_eh_frame->output_section->vma
16765                     + htab->glink_eh_frame->output_offset
16766                     + (p + 8 - htab->glink_eh_frame->contents));
16767             if (val + 0x80000000 > 0xffffffff)
16768               {
16769                 _bfd_error_handler
16770                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16771                    group->stub_sec->name);
16772                 return FALSE;
16773               }
16774             bfd_put_32 (dynobj, val, p + 8);
16775             p += stub_eh_frame_size (group, align);
16776           }
16777       if (htab->glink != NULL && htab->glink->size != 0)
16778         {
16779           /* Offset to .glink.  */
16780           val = (htab->glink->output_section->vma
16781                  + htab->glink->output_offset
16782                  + 8);
16783           val -= (htab->glink_eh_frame->output_section->vma
16784                   + htab->glink_eh_frame->output_offset
16785                   + (p + 8 - htab->glink_eh_frame->contents));
16786           if (val + 0x80000000 > 0xffffffff)
16787             {
16788               _bfd_error_handler
16789                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16790                  htab->glink->name);
16791               return FALSE;
16792             }
16793           bfd_put_32 (dynobj, val, p + 8);
16794           p += (24 + align - 1) & -align;
16795         }
16796
16797       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16798           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16799                                                htab->glink_eh_frame,
16800                                                htab->glink_eh_frame->contents))
16801         return FALSE;
16802     }
16803
16804   /* We need to handle writing out multiple GOT sections ourselves,
16805      since we didn't add them to DYNOBJ.  We know dynobj is the first
16806      bfd.  */
16807   while ((dynobj = dynobj->link.next) != NULL)
16808     {
16809       asection *s;
16810
16811       if (!is_ppc64_elf (dynobj))
16812         continue;
16813
16814       s = ppc64_elf_tdata (dynobj)->got;
16815       if (s != NULL
16816           && s->size != 0
16817           && s->output_section != bfd_abs_section_ptr
16818           && !bfd_set_section_contents (output_bfd, s->output_section,
16819                                         s->contents, s->output_offset,
16820                                         s->size))
16821         return FALSE;
16822       s = ppc64_elf_tdata (dynobj)->relgot;
16823       if (s != NULL
16824           && s->size != 0
16825           && s->output_section != bfd_abs_section_ptr
16826           && !bfd_set_section_contents (output_bfd, s->output_section,
16827                                         s->contents, s->output_offset,
16828                                         s->size))
16829         return FALSE;
16830     }
16831
16832   return TRUE;
16833 }
16834
16835 #include "elf64-target.h"
16836
16837 /* FreeBSD support */
16838
16839 #undef  TARGET_LITTLE_SYM
16840 #undef  TARGET_LITTLE_NAME
16841
16842 #undef  TARGET_BIG_SYM
16843 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16844 #undef  TARGET_BIG_NAME
16845 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16846
16847 #undef  ELF_OSABI
16848 #define ELF_OSABI       ELFOSABI_FREEBSD
16849
16850 #undef  elf64_bed
16851 #define elf64_bed       elf64_powerpc_fbsd_bed
16852
16853 #include "elf64-target.h"