bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2018 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define ELF_RELROPAGESIZE       ELF_MAXPAGESIZE
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_want_dynrelro 1
  77 #define elf_backend_can_gc_sections 1
  78 #define elf_backend_can_refcount 1
  79 #define elf_backend_rela_normal 1
  80 #define elf_backend_dtrel_excludes_plt 1
  81 #define elf_backend_default_execstack 0
  82
  83 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  84 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  85 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  86 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  87 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  88 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  89 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  90 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  91 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  92 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  93
  94 #define elf_backend_object_p                  ppc64_elf_object_p
  95 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  96 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  97 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  98 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  99 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
 100 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 101 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 102 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 103 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 104 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 105 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
 106 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 107 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 108 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 109 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 110 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 111 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 112 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 113 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 114 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 115 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 116 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 117 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 118 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 119 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 120 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 121 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 122 #define elf_backend_special_sections          ppc64_elf_special_sections
 123 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 124 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 125 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 126
 127 /* The name of the dynamic interpreter.  This is put in the .interp
 128    section.  */
 129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 130
 131 /* The size in bytes of an entry in the procedure linkage table.  */
 132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
 134
 135 /* The initial size of the plt reserved for the dynamic linker.  */
 136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 137
 138 /* Offsets to some stack save slots.  */
 139 #define STK_LR 16
 140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 141 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 142    CR save slot.  Used only by optimised __tls_get_addr call stub,
 143    relying on __tls_get_addr_opt not saving CR..  */
 144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 145
 146 /* TOC base pointers offset from start of TOC.  */
 147 #define TOC_BASE_OFF    0x8000
 148 /* TOC base alignment.  */
 149 #define TOC_BASE_ALIGN  256
 150
 151 /* Offset of tp and dtp pointers from start of TLS block.  */
 152 #define TP_OFFSET       0x7000
 153 #define DTP_OFFSET      0x8000
 154
 155 /* .plt call stub instructions.  The normal stub is like this, but
 156    sometimes the .plt entry crosses a 64k boundary and we need to
 157    insert an addi to adjust r11.  */
 158 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 159 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 160 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 161 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 162 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 163 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 164 #define BCTR            0x4e800420      /* bctr                      */
 165
 166 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 167 #define 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 (stub_entry->stub_type == ppc_stub_plt_call_r2save)
11031         size += 6 * 4;
11032     }
11033   return size;
11034 }
11035
11036 /* Depending on the sign of plt_stub_align:
11037    If positive, return the padding to align to a 2**plt_stub_align
11038    boundary.
11039    If negative, if this stub would cross fewer 2**plt_stub_align
11040    boundaries if we align, then return the padding needed to do so.  */
11041
11042 static inline unsigned int
11043 plt_stub_pad (struct ppc_link_hash_table *htab,
11044               struct ppc_stub_hash_entry *stub_entry,
11045               bfd_vma plt_off)
11046 {
11047   int stub_align;
11048   unsigned stub_size;
11049   bfd_vma stub_off = stub_entry->group->stub_sec->size;
11050
11051   if (htab->params->plt_stub_align >= 0)
11052     {
11053       stub_align = 1 << htab->params->plt_stub_align;
11054       if ((stub_off & (stub_align - 1)) != 0)
11055         return stub_align - (stub_off & (stub_align - 1));
11056       return 0;
11057     }
11058
11059   stub_align = 1 << -htab->params->plt_stub_align;
11060   stub_size = plt_stub_size (htab, stub_entry, plt_off);
11061   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11062       > ((stub_size - 1) & -stub_align))
11063     return stub_align - (stub_off & (stub_align - 1));
11064   return 0;
11065 }
11066
11067 /* Build a .plt call stub.  */
11068
11069 static inline bfd_byte *
11070 build_plt_stub (struct ppc_link_hash_table *htab,
11071                 struct ppc_stub_hash_entry *stub_entry,
11072                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11073 {
11074   bfd *obfd = htab->params->stub_bfd;
11075   bfd_boolean plt_load_toc = htab->opd_abi;
11076   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
11077   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
11078                                  && htab->elf.dynamic_sections_created
11079                                  && stub_entry->h != NULL
11080                                  && stub_entry->h->elf.dynindx != -1);
11081   bfd_boolean use_fake_dep = plt_thread_safe;
11082   bfd_vma cmp_branch_off = 0;
11083
11084   if (!ALWAYS_USE_FAKE_DEP
11085       && plt_load_toc
11086       && plt_thread_safe
11087       && !((stub_entry->h == htab->tls_get_addr_fd
11088             || stub_entry->h == htab->tls_get_addr)
11089            && htab->params->tls_get_addr_opt))
11090     {
11091       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11092       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11093                           / PLT_ENTRY_SIZE (htab));
11094       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11095       bfd_vma to, from;
11096
11097       if (pltindex > 32768)
11098         glinkoff += (pltindex - 32768) * 4;
11099       to = (glinkoff
11100             + htab->glink->output_offset
11101             + htab->glink->output_section->vma);
11102       from = (p - stub_entry->group->stub_sec->contents
11103               + 4 * (ALWAYS_EMIT_R2SAVE
11104                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11105               + 4 * (PPC_HA (offset) != 0)
11106               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11107                      != PPC_HA (offset))
11108               + 4 * (plt_static_chain != 0)
11109               + 20
11110               + stub_entry->group->stub_sec->output_offset
11111               + stub_entry->group->stub_sec->output_section->vma);
11112       cmp_branch_off = to - from;
11113       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11114     }
11115
11116   if (PPC_HA (offset) != 0)
11117     {
11118       if (r != NULL)
11119         {
11120           if (ALWAYS_EMIT_R2SAVE
11121               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11122             r[0].r_offset += 4;
11123           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11124           r[1].r_offset = r[0].r_offset + 4;
11125           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11126           r[1].r_addend = r[0].r_addend;
11127           if (plt_load_toc)
11128             {
11129               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11130                 {
11131                   r[2].r_offset = r[1].r_offset + 4;
11132                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11133                   r[2].r_addend = r[0].r_addend;
11134                 }
11135               else
11136                 {
11137                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11138                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11139                   r[2].r_addend = r[0].r_addend + 8;
11140                   if (plt_static_chain)
11141                     {
11142                       r[3].r_offset = r[2].r_offset + 4;
11143                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11144                       r[3].r_addend = r[0].r_addend + 16;
11145                     }
11146                 }
11147             }
11148         }
11149       if (ALWAYS_EMIT_R2SAVE
11150           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11151         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
11152       if (plt_load_toc)
11153         {
11154           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11155           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
11156         }
11157       else
11158         {
11159           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11160           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
11161         }
11162       if (plt_load_toc
11163           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11164         {
11165           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11166           offset = 0;
11167         }
11168       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11169       if (plt_load_toc)
11170         {
11171           if (use_fake_dep)
11172             {
11173               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
11174               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
11175             }
11176           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11177           if (plt_static_chain)
11178             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11179         }
11180     }
11181   else
11182     {
11183       if (r != NULL)
11184         {
11185           if (ALWAYS_EMIT_R2SAVE
11186               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11187             r[0].r_offset += 4;
11188           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11189           if (plt_load_toc)
11190             {
11191               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11192                 {
11193                   r[1].r_offset = r[0].r_offset + 4;
11194                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11195                   r[1].r_addend = r[0].r_addend;
11196                 }
11197               else
11198                 {
11199                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11200                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11201                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11202                   if (plt_static_chain)
11203                     {
11204                       r[2].r_offset = r[1].r_offset + 4;
11205                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11206                       r[2].r_addend = r[0].r_addend + 8;
11207                     }
11208                 }
11209             }
11210         }
11211       if (ALWAYS_EMIT_R2SAVE
11212           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11213         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
11214       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
11215       if (plt_load_toc
11216           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11217         {
11218           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
11219           offset = 0;
11220         }
11221       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11222       if (plt_load_toc)
11223         {
11224           if (use_fake_dep)
11225             {
11226               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
11227               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
11228             }
11229           if (plt_static_chain)
11230             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11231           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11232         }
11233     }
11234   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11235     {
11236       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11237       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11238       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11239     }
11240   else
11241     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11242   return p;
11243 }
11244
11245 /* Build a special .plt call stub for __tls_get_addr.  */
11246
11247 #define LD_R11_0R3      0xe9630000
11248 #define LD_R12_0R3      0xe9830000
11249 #define MR_R0_R3        0x7c601b78
11250 #define CMPDI_R11_0     0x2c2b0000
11251 #define ADD_R3_R12_R13  0x7c6c6a14
11252 #define BEQLR           0x4d820020
11253 #define MR_R3_R0        0x7c030378
11254 #define STD_R11_0R1     0xf9610000
11255 #define BCTRL           0x4e800421
11256 #define LD_R11_0R1      0xe9610000
11257 #define MTLR_R11        0x7d6803a6
11258
11259 static inline bfd_byte *
11260 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11261                          struct ppc_stub_hash_entry *stub_entry,
11262                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11263 {
11264   bfd *obfd = htab->params->stub_bfd;
11265
11266   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11267   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11268   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11269   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11270   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11271   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11272   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11273   if (r != NULL)
11274     r[0].r_offset += 7 * 4;
11275   if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
11276     return build_plt_stub (htab, stub_entry, p, offset, r);
11277
11278   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11279   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11280
11281   if (r != NULL)
11282     r[0].r_offset += 2 * 4;
11283   p = build_plt_stub (htab, stub_entry, p, offset, r);
11284   bfd_put_32 (obfd, BCTRL, p - 4);
11285
11286   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11287   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11288   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11289   bfd_put_32 (obfd, BLR, p),                    p += 4;
11290
11291   return p;
11292 }
11293
11294 static Elf_Internal_Rela *
11295 get_relocs (asection *sec, int count)
11296 {
11297   Elf_Internal_Rela *relocs;
11298   struct bfd_elf_section_data *elfsec_data;
11299
11300   elfsec_data = elf_section_data (sec);
11301   relocs = elfsec_data->relocs;
11302   if (relocs == NULL)
11303     {
11304       bfd_size_type relsize;
11305       relsize = sec->reloc_count * sizeof (*relocs);
11306       relocs = bfd_alloc (sec->owner, relsize);
11307       if (relocs == NULL)
11308         return NULL;
11309       elfsec_data->relocs = relocs;
11310       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11311                                           sizeof (Elf_Internal_Shdr));
11312       if (elfsec_data->rela.hdr == NULL)
11313         return NULL;
11314       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11315                                         * sizeof (Elf64_External_Rela));
11316       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11317       sec->reloc_count = 0;
11318     }
11319   relocs += sec->reloc_count;
11320   sec->reloc_count += count;
11321   return relocs;
11322 }
11323
11324 static bfd_vma
11325 get_r2off (struct bfd_link_info *info,
11326            struct ppc_stub_hash_entry *stub_entry)
11327 {
11328   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11329   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11330
11331   if (r2off == 0)
11332     {
11333       /* Support linking -R objects.  Get the toc pointer from the
11334          opd entry.  */
11335       char buf[8];
11336       if (!htab->opd_abi)
11337         return r2off;
11338       asection *opd = stub_entry->h->elf.root.u.def.section;
11339       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11340
11341       if (strcmp (opd->name, ".opd") != 0
11342           || opd->reloc_count != 0)
11343         {
11344           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11345                                   stub_entry->h->elf.root.root.string);
11346           bfd_set_error (bfd_error_bad_value);
11347           return (bfd_vma) -1;
11348         }
11349       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11350         return (bfd_vma) -1;
11351       r2off = bfd_get_64 (opd->owner, buf);
11352       r2off -= elf_gp (info->output_bfd);
11353     }
11354   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11355   return r2off;
11356 }
11357
11358 static bfd_boolean
11359 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11360 {
11361   struct ppc_stub_hash_entry *stub_entry;
11362   struct ppc_branch_hash_entry *br_entry;
11363   struct bfd_link_info *info;
11364   struct ppc_link_hash_table *htab;
11365   bfd_byte *loc;
11366   bfd_byte *p;
11367   bfd_vma targ, off;
11368   Elf_Internal_Rela *r;
11369   asection *plt;
11370
11371   /* Massage our args to the form they really have.  */
11372   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11373   info = in_arg;
11374
11375   htab = ppc_hash_table (info);
11376   if (htab == NULL)
11377     return FALSE;
11378
11379   BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11380   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11381
11382   htab->stub_count[stub_entry->stub_type - 1] += 1;
11383   switch (stub_entry->stub_type)
11384     {
11385     case ppc_stub_long_branch:
11386     case ppc_stub_long_branch_r2off:
11387       /* Branches are relative.  This is where we are going to.  */
11388       targ = (stub_entry->target_value
11389               + stub_entry->target_section->output_offset
11390               + stub_entry->target_section->output_section->vma);
11391       targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11392
11393       /* And this is where we are coming from.  */
11394       off = (stub_entry->stub_offset
11395              + stub_entry->group->stub_sec->output_offset
11396              + stub_entry->group->stub_sec->output_section->vma);
11397       off = targ - off;
11398
11399       p = loc;
11400       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11401         {
11402           bfd_vma r2off = get_r2off (info, stub_entry);
11403
11404           if (r2off == (bfd_vma) -1)
11405             {
11406               htab->stub_error = TRUE;
11407               return FALSE;
11408             }
11409           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11410           p += 4;
11411           if (PPC_HA (r2off) != 0)
11412             {
11413               bfd_put_32 (htab->params->stub_bfd,
11414                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11415               p += 4;
11416             }
11417           if (PPC_LO (r2off) != 0)
11418             {
11419               bfd_put_32 (htab->params->stub_bfd,
11420                           ADDI_R2_R2 | PPC_LO (r2off), p);
11421               p += 4;
11422             }
11423           off -= p - loc;
11424         }
11425       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11426       p += 4;
11427
11428       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11429         {
11430           _bfd_error_handler
11431             (_("long branch stub `%s' offset overflow"),
11432              stub_entry->root.string);
11433           htab->stub_error = TRUE;
11434           return FALSE;
11435         }
11436
11437       if (info->emitrelocations)
11438         {
11439           r = get_relocs (stub_entry->group->stub_sec, 1);
11440           if (r == NULL)
11441             return FALSE;
11442           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11443           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11444           r->r_addend = targ;
11445           if (stub_entry->h != NULL)
11446             {
11447               struct elf_link_hash_entry **hashes;
11448               unsigned long symndx;
11449               struct ppc_link_hash_entry *h;
11450
11451               hashes = elf_sym_hashes (htab->params->stub_bfd);
11452               if (hashes == NULL)
11453                 {
11454                   bfd_size_type hsize;
11455
11456                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11457                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11458                   if (hashes == NULL)
11459                     return FALSE;
11460                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11461                   htab->stub_globals = 1;
11462                 }
11463               symndx = htab->stub_globals++;
11464               h = stub_entry->h;
11465               hashes[symndx] = &h->elf;
11466               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11467               if (h->oh != NULL && h->oh->is_func)
11468                 h = ppc_follow_link (h->oh);
11469               if (h->elf.root.u.def.section != stub_entry->target_section)
11470                 /* H is an opd symbol.  The addend must be zero.  */
11471                 r->r_addend = 0;
11472               else
11473                 {
11474                   off = (h->elf.root.u.def.value
11475                          + h->elf.root.u.def.section->output_offset
11476                          + h->elf.root.u.def.section->output_section->vma);
11477                   r->r_addend -= off;
11478                 }
11479             }
11480         }
11481       break;
11482
11483     case ppc_stub_plt_branch:
11484     case ppc_stub_plt_branch_r2off:
11485       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11486                                          stub_entry->root.string + 9,
11487                                          FALSE, FALSE);
11488       if (br_entry == NULL)
11489         {
11490           _bfd_error_handler (_("can't find branch stub `%s'"),
11491                               stub_entry->root.string);
11492           htab->stub_error = TRUE;
11493           return FALSE;
11494         }
11495
11496       targ = (stub_entry->target_value
11497               + stub_entry->target_section->output_offset
11498               + stub_entry->target_section->output_section->vma);
11499       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11500         targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11501
11502       bfd_put_64 (htab->brlt->owner, targ,
11503                   htab->brlt->contents + br_entry->offset);
11504
11505       if (br_entry->iter == htab->stub_iteration)
11506         {
11507           br_entry->iter = 0;
11508
11509           if (htab->relbrlt != NULL)
11510             {
11511               /* Create a reloc for the branch lookup table entry.  */
11512               Elf_Internal_Rela rela;
11513               bfd_byte *rl;
11514
11515               rela.r_offset = (br_entry->offset
11516                                + htab->brlt->output_offset
11517                                + htab->brlt->output_section->vma);
11518               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11519               rela.r_addend = targ;
11520
11521               rl = htab->relbrlt->contents;
11522               rl += (htab->relbrlt->reloc_count++
11523                      * sizeof (Elf64_External_Rela));
11524               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11525             }
11526           else if (info->emitrelocations)
11527             {
11528               r = get_relocs (htab->brlt, 1);
11529               if (r == NULL)
11530                 return FALSE;
11531               /* brlt, being SEC_LINKER_CREATED does not go through the
11532                  normal reloc processing.  Symbols and offsets are not
11533                  translated from input file to output file form, so
11534                  set up the offset per the output file.  */
11535               r->r_offset = (br_entry->offset
11536                              + htab->brlt->output_offset
11537                              + htab->brlt->output_section->vma);
11538               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11539               r->r_addend = targ;
11540             }
11541         }
11542
11543       targ = (br_entry->offset
11544               + htab->brlt->output_offset
11545               + htab->brlt->output_section->vma);
11546
11547       off = (elf_gp (info->output_bfd)
11548              + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11549       off = targ - off;
11550
11551       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11552         {
11553           info->callbacks->einfo
11554             (_("%P: linkage table error against `%pT'\n"),
11555              stub_entry->root.string);
11556           bfd_set_error (bfd_error_bad_value);
11557           htab->stub_error = TRUE;
11558           return FALSE;
11559         }
11560
11561       if (info->emitrelocations)
11562         {
11563           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11564           if (r == NULL)
11565             return FALSE;
11566           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11567           if (bfd_big_endian (info->output_bfd))
11568             r[0].r_offset += 2;
11569           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11570             r[0].r_offset += 4;
11571           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11572           r[0].r_addend = targ;
11573           if (PPC_HA (off) != 0)
11574             {
11575               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11576               r[1].r_offset = r[0].r_offset + 4;
11577               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11578               r[1].r_addend = r[0].r_addend;
11579             }
11580         }
11581
11582       p = loc;
11583       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11584         {
11585           if (PPC_HA (off) != 0)
11586             {
11587               bfd_put_32 (htab->params->stub_bfd,
11588                           ADDIS_R12_R2 | PPC_HA (off), p);
11589               p += 4;
11590               bfd_put_32 (htab->params->stub_bfd,
11591                           LD_R12_0R12 | PPC_LO (off), p);
11592             }
11593           else
11594             bfd_put_32 (htab->params->stub_bfd,
11595                         LD_R12_0R2 | PPC_LO (off), p);
11596         }
11597       else
11598         {
11599           bfd_vma r2off = get_r2off (info, stub_entry);
11600
11601           if (r2off == (bfd_vma) -1)
11602             {
11603               htab->stub_error = TRUE;
11604               return FALSE;
11605             }
11606
11607           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11608           p += 4;
11609           if (PPC_HA (off) != 0)
11610             {
11611               bfd_put_32 (htab->params->stub_bfd,
11612                           ADDIS_R12_R2 | PPC_HA (off), p);
11613               p += 4;
11614               bfd_put_32 (htab->params->stub_bfd,
11615                           LD_R12_0R12 | PPC_LO (off), p);
11616             }
11617           else
11618             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11619
11620           if (PPC_HA (r2off) != 0)
11621             {
11622               p += 4;
11623               bfd_put_32 (htab->params->stub_bfd,
11624                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11625             }
11626           if (PPC_LO (r2off) != 0)
11627             {
11628               p += 4;
11629               bfd_put_32 (htab->params->stub_bfd,
11630                           ADDI_R2_R2 | PPC_LO (r2off), p);
11631             }
11632         }
11633       p += 4;
11634       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11635       p += 4;
11636       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11637       p += 4;
11638       break;
11639
11640     case ppc_stub_long_branch_notoc:
11641     case ppc_stub_long_branch_both:
11642     case ppc_stub_plt_branch_notoc:
11643     case ppc_stub_plt_branch_both:
11644     case ppc_stub_plt_call_notoc:
11645     case ppc_stub_plt_call_both:
11646       p = loc;
11647       off = (8 + stub_entry->stub_offset
11648              + stub_entry->group->stub_sec->output_offset
11649              + stub_entry->group->stub_sec->output_section->vma);
11650       if (stub_entry->stub_type == ppc_stub_long_branch_both
11651           || stub_entry->stub_type == ppc_stub_plt_branch_both
11652           || stub_entry->stub_type == ppc_stub_plt_call_both)
11653         {
11654           off += 4;
11655           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11656           p += 4;
11657         }
11658       if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11659         {
11660           targ = stub_entry->plt_ent->plt.offset & ~1;
11661           if (targ >= (bfd_vma) -2)
11662             abort ();
11663
11664           plt = htab->elf.splt;
11665           if (!htab->elf.dynamic_sections_created
11666               || stub_entry->h == NULL
11667               || stub_entry->h->elf.dynindx == -1)
11668             {
11669               if (stub_entry->symtype == STT_GNU_IFUNC)
11670                 plt = htab->elf.iplt;
11671               else
11672                 plt = htab->pltlocal;
11673             }
11674           targ += plt->output_offset + plt->output_section->vma;
11675         }
11676       else
11677         targ = (stub_entry->target_value
11678                 + stub_entry->target_section->output_offset
11679                 + stub_entry->target_section->output_section->vma);
11680       off = targ - off;
11681       bfd_put_32 (htab->params->stub_bfd, MFLR_R12, p);
11682       p += 4;
11683       bfd_put_32 (htab->params->stub_bfd, BCL_20_31, p);
11684       p += 4;
11685       bfd_put_32 (htab->params->stub_bfd, MFLR_R11, p);
11686       p += 4;
11687       bfd_put_32 (htab->params->stub_bfd, MTLR_R12, p);
11688       p += 4;
11689       p = build_offset (htab->params->stub_bfd, p, off,
11690                         stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11691       if (stub_entry->stub_type == ppc_stub_long_branch_notoc)
11692         {
11693           off += 8;
11694           bfd_put_32 (htab->params->stub_bfd,
11695                       B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11696         }
11697       else if (stub_entry->stub_type == ppc_stub_long_branch_both)
11698         {
11699           off += 12;
11700           bfd_put_32 (htab->params->stub_bfd,
11701                       B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11702         }
11703       else
11704         {
11705           bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11706           p += 4;
11707           bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11708         }
11709       p += 4;
11710       break;
11711
11712     case ppc_stub_plt_call:
11713     case ppc_stub_plt_call_r2save:
11714       if (stub_entry->h != NULL
11715           && stub_entry->h->is_func_descriptor
11716           && stub_entry->h->oh != NULL)
11717         {
11718           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11719
11720           /* If the old-ABI "dot-symbol" is undefined make it weak so
11721              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11722           if (fh->elf.root.type == bfd_link_hash_undefined
11723               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11724                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11725             fh->elf.root.type = bfd_link_hash_undefweak;
11726         }
11727
11728       /* Now build the stub.  */
11729       targ = stub_entry->plt_ent->plt.offset & ~1;
11730       if (targ >= (bfd_vma) -2)
11731         abort ();
11732
11733       plt = htab->elf.splt;
11734       if (!htab->elf.dynamic_sections_created
11735           || stub_entry->h == NULL
11736           || stub_entry->h->elf.dynindx == -1)
11737         {
11738           if (stub_entry->symtype == STT_GNU_IFUNC)
11739             plt = htab->elf.iplt;
11740           else
11741             plt = htab->pltlocal;
11742         }
11743       targ += plt->output_offset + plt->output_section->vma;
11744
11745       off = (elf_gp (info->output_bfd)
11746              + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11747       off = targ - off;
11748
11749       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11750         {
11751           info->callbacks->einfo
11752             /* xgettext:c-format */
11753             (_("%P: linkage table error against `%pT'\n"),
11754              stub_entry->h != NULL
11755              ? stub_entry->h->elf.root.root.string
11756              : "<local sym>");
11757           bfd_set_error (bfd_error_bad_value);
11758           htab->stub_error = TRUE;
11759           return FALSE;
11760         }
11761
11762       r = NULL;
11763       if (info->emitrelocations)
11764         {
11765           r = get_relocs (stub_entry->group->stub_sec,
11766                           ((PPC_HA (off) != 0)
11767                            + (htab->opd_abi
11768                               ? 2 + (htab->params->plt_static_chain
11769                                      && PPC_HA (off + 16) == PPC_HA (off))
11770                               : 1)));
11771           if (r == NULL)
11772             return FALSE;
11773           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11774           if (bfd_big_endian (info->output_bfd))
11775             r[0].r_offset += 2;
11776           r[0].r_addend = targ;
11777         }
11778       if (stub_entry->h != NULL
11779           && (stub_entry->h == htab->tls_get_addr_fd
11780               || stub_entry->h == htab->tls_get_addr)
11781           && htab->params->tls_get_addr_opt)
11782         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11783       else
11784         p = build_plt_stub (htab, stub_entry, loc, off, r);
11785       break;
11786
11787     case ppc_stub_save_res:
11788       return TRUE;
11789
11790     default:
11791       BFD_FAIL ();
11792       return FALSE;
11793     }
11794
11795   stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11796
11797   if (htab->params->emit_stub_syms)
11798     {
11799       struct elf_link_hash_entry *h;
11800       size_t len1, len2;
11801       char *name;
11802       const char *const stub_str[] = { "long_branch",
11803                                        "long_branch",
11804                                        "long_branch",
11805                                        "long_branch",
11806                                        "plt_branch",
11807                                        "plt_branch",
11808                                        "plt_branch",
11809                                        "plt_branch",
11810                                        "plt_call",
11811                                        "plt_call",
11812                                        "plt_call",
11813                                        "plt_call" };
11814
11815       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11816       len2 = strlen (stub_entry->root.string);
11817       name = bfd_malloc (len1 + len2 + 2);
11818       if (name == NULL)
11819         return FALSE;
11820       memcpy (name, stub_entry->root.string, 9);
11821       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11822       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11823       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11824       if (h == NULL)
11825         return FALSE;
11826       if (h->root.type == bfd_link_hash_new)
11827         {
11828           h->root.type = bfd_link_hash_defined;
11829           h->root.u.def.section = stub_entry->group->stub_sec;
11830           h->root.u.def.value = stub_entry->stub_offset;
11831           h->ref_regular = 1;
11832           h->def_regular = 1;
11833           h->ref_regular_nonweak = 1;
11834           h->forced_local = 1;
11835           h->non_elf = 0;
11836           h->root.linker_def = 1;
11837         }
11838     }
11839
11840   return TRUE;
11841 }
11842
11843 /* As above, but don't actually build the stub.  Just bump offset so
11844    we know stub section sizes, and select plt_branch stubs where
11845    long_branch stubs won't do.  */
11846
11847 static bfd_boolean
11848 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11849 {
11850   struct ppc_stub_hash_entry *stub_entry;
11851   struct bfd_link_info *info;
11852   struct ppc_link_hash_table *htab;
11853   bfd_vma targ, off;
11854   int size;
11855
11856   /* Massage our args to the form they really have.  */
11857   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11858   info = in_arg;
11859
11860   htab = ppc_hash_table (info);
11861   if (htab == NULL)
11862     return FALSE;
11863
11864   /* Make a note of the offset within the stubs for this entry.  */
11865   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11866
11867   if (stub_entry->h != NULL
11868       && stub_entry->h->save_res
11869       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11870       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11871     {
11872       /* Don't make stubs to out-of-line register save/restore
11873          functions.  Instead, emit copies of the functions.  */
11874       stub_entry->group->needs_save_res = 1;
11875       stub_entry->stub_type = ppc_stub_save_res;
11876       return TRUE;
11877     }
11878
11879   if (stub_entry->stub_type >= ppc_stub_plt_call
11880       && stub_entry->stub_type <= ppc_stub_plt_call_both)
11881     {
11882       asection *plt;
11883       targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11884       if (targ >= (bfd_vma) -2)
11885         abort ();
11886       plt = htab->elf.splt;
11887       if (!htab->elf.dynamic_sections_created
11888           || stub_entry->h == NULL
11889           || stub_entry->h->elf.dynindx == -1)
11890         {
11891           if (stub_entry->symtype == STT_GNU_IFUNC)
11892             plt = htab->elf.iplt;
11893           else
11894             plt = htab->pltlocal;
11895         }
11896       targ += plt->output_offset + plt->output_section->vma;
11897
11898       if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11899         {
11900           off = (8 + stub_entry->stub_offset
11901                  + stub_entry->group->stub_sec->output_offset
11902                  + stub_entry->group->stub_sec->output_section->vma);
11903           if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11904             off += 4;
11905         }
11906       else
11907         off = (elf_gp (info->output_bfd)
11908                + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11909
11910       if (htab->params->plt_stub_align != 0)
11911         {
11912           unsigned pad = plt_stub_pad (htab, stub_entry, targ - off);
11913
11914           stub_entry->group->stub_sec->size += pad;
11915           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11916           if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11917             off += pad;
11918         }
11919
11920       off = targ - off;
11921       size = plt_stub_size (htab, stub_entry, off);
11922
11923       if (stub_entry->stub_type < ppc_stub_plt_call_notoc)
11924         {
11925           if (stub_entry->h != NULL
11926               && (stub_entry->h == htab->tls_get_addr_fd
11927                   || stub_entry->h == htab->tls_get_addr)
11928               && htab->params->tls_get_addr_opt
11929               && stub_entry->stub_type == ppc_stub_plt_call_r2save)
11930             stub_entry->group->tls_get_addr_opt_bctrl
11931               = stub_entry->stub_offset + size - 5 * 4;
11932
11933           if (info->emitrelocations)
11934             {
11935               stub_entry->group->stub_sec->reloc_count
11936                 += ((PPC_HA (off) != 0)
11937                     + (htab->opd_abi
11938                        ? 2 + (htab->params->plt_static_chain
11939                               && PPC_HA (off + 16) == PPC_HA (off))
11940                        : 1));
11941               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11942             }
11943         }
11944     }
11945   else
11946     {
11947       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11948          variants.  */
11949       bfd_vma r2off = 0;
11950       bfd_vma local_off = 0;
11951
11952       targ = (stub_entry->target_value
11953               + stub_entry->target_section->output_offset
11954               + stub_entry->target_section->output_section->vma);
11955       off = (stub_entry->stub_offset
11956              + stub_entry->group->stub_sec->output_offset
11957              + stub_entry->group->stub_sec->output_section->vma);
11958
11959       /* Reset the stub type from the plt variant in case we now
11960          can reach with a shorter stub.  */
11961       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11962         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11963
11964       size = 4;
11965       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11966         {
11967           r2off = get_r2off (info, stub_entry);
11968           if (r2off == (bfd_vma) -1)
11969             {
11970               htab->stub_error = TRUE;
11971               return FALSE;
11972             }
11973           size = 8;
11974           if (PPC_HA (r2off) != 0)
11975             size += 4;
11976           if (PPC_LO (r2off) != 0)
11977             size += 4;
11978           off += size - 4;
11979         }
11980       else if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
11981         {
11982           size = 20 + size_offset (targ - (off + 8));
11983           if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
11984             size += 4;
11985           off += size - 4;
11986         }
11987       off = targ - off;
11988
11989       if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
11990         {
11991           if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11992             {
11993               stub_entry->stub_type += (ppc_stub_plt_branch_notoc
11994                                         - ppc_stub_long_branch_notoc);
11995               size += 4;
11996             }
11997         }
11998       else
11999         {
12000           local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12001
12002           /* If the branch offset is too big, use a ppc_stub_plt_branch.
12003              Do the same for -R objects without function descriptors.  */
12004           if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
12005                && r2off == 0
12006                && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12007               || off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off)
12008             {
12009               struct ppc_branch_hash_entry *br_entry;
12010
12011               br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12012                                                  stub_entry->root.string + 9,
12013                                                  TRUE, FALSE);
12014               if (br_entry == NULL)
12015                 {
12016                   _bfd_error_handler (_("can't build branch stub `%s'"),
12017                                       stub_entry->root.string);
12018                   htab->stub_error = TRUE;
12019                   return FALSE;
12020                 }
12021
12022               if (br_entry->iter != htab->stub_iteration)
12023                 {
12024                   br_entry->iter = htab->stub_iteration;
12025                   br_entry->offset = htab->brlt->size;
12026                   htab->brlt->size += 8;
12027
12028                   if (htab->relbrlt != NULL)
12029                     htab->relbrlt->size += sizeof (Elf64_External_Rela);
12030                   else if (info->emitrelocations)
12031                     {
12032                       htab->brlt->reloc_count += 1;
12033                       htab->brlt->flags |= SEC_RELOC;
12034                     }
12035                 }
12036
12037               targ = (br_entry->offset
12038                       + htab->brlt->output_offset
12039                       + htab->brlt->output_section->vma);
12040               off = (elf_gp (info->output_bfd)
12041                      + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12042               off = targ - off;
12043
12044               if (info->emitrelocations)
12045                 {
12046                   stub_entry->group->stub_sec->reloc_count
12047                     += 1 + (PPC_HA (off) != 0);
12048                   stub_entry->group->stub_sec->flags |= SEC_RELOC;
12049                 }
12050
12051               stub_entry->stub_type
12052                 += ppc_stub_plt_branch - ppc_stub_long_branch;
12053               if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
12054                 {
12055                   size = 12;
12056                   if (PPC_HA (off) != 0)
12057                     size = 16;
12058                 }
12059               else
12060                 {
12061                   size = 16;
12062                   if (PPC_HA (off) != 0)
12063                     size += 4;
12064
12065                   if (PPC_HA (r2off) != 0)
12066                     size += 4;
12067                   if (PPC_LO (r2off) != 0)
12068                     size += 4;
12069                 }
12070             }
12071           else if (info->emitrelocations)
12072             {
12073               stub_entry->group->stub_sec->reloc_count += 1;
12074               stub_entry->group->stub_sec->flags |= SEC_RELOC;
12075             }
12076         }
12077     }
12078
12079   stub_entry->group->stub_sec->size += size;
12080   return TRUE;
12081 }
12082
12083 /* Set up various things so that we can make a list of input sections
12084    for each output section included in the link.  Returns -1 on error,
12085    0 when no stubs will be needed, and 1 on success.  */
12086
12087 int
12088 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12089 {
12090   unsigned int id;
12091   bfd_size_type amt;
12092   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12093
12094   if (htab == NULL)
12095     return -1;
12096
12097   htab->sec_info_arr_size = _bfd_section_id;
12098   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12099   htab->sec_info = bfd_zmalloc (amt);
12100   if (htab->sec_info == NULL)
12101     return -1;
12102
12103   /* Set toc_off for com, und, abs and ind sections.  */
12104   for (id = 0; id < 3; id++)
12105     htab->sec_info[id].toc_off = TOC_BASE_OFF;
12106
12107   return 1;
12108 }
12109
12110 /* Set up for first pass at multitoc partitioning.  */
12111
12112 void
12113 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12114 {
12115   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12116
12117   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12118   htab->toc_bfd = NULL;
12119   htab->toc_first_sec = NULL;
12120 }
12121
12122 /* The linker repeatedly calls this function for each TOC input section
12123    and linker generated GOT section.  Group input bfds such that the toc
12124    within a group is less than 64k in size.  */
12125
12126 bfd_boolean
12127 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12128 {
12129   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12130   bfd_vma addr, off, limit;
12131
12132   if (htab == NULL)
12133     return FALSE;
12134
12135   if (!htab->second_toc_pass)
12136     {
12137       /* Keep track of the first .toc or .got section for this input bfd.  */
12138       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
12139
12140       if (new_bfd)
12141         {
12142           htab->toc_bfd = isec->owner;
12143           htab->toc_first_sec = isec;
12144         }
12145
12146       addr = isec->output_offset + isec->output_section->vma;
12147       off = addr - htab->toc_curr;
12148       limit = 0x80008000;
12149       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12150         limit = 0x10000;
12151       if (off + isec->size > limit)
12152         {
12153           addr = (htab->toc_first_sec->output_offset
12154                   + htab->toc_first_sec->output_section->vma);
12155           htab->toc_curr = addr;
12156           htab->toc_curr &= -TOC_BASE_ALIGN;
12157         }
12158
12159       /* toc_curr is the base address of this toc group.  Set elf_gp
12160          for the input section to be the offset relative to the
12161          output toc base plus 0x8000.  Making the input elf_gp an
12162          offset allows us to move the toc as a whole without
12163          recalculating input elf_gp.  */
12164       off = htab->toc_curr - elf_gp (info->output_bfd);
12165       off += TOC_BASE_OFF;
12166
12167       /* Die if someone uses a linker script that doesn't keep input
12168          file .toc and .got together.  */
12169       if (new_bfd
12170           && elf_gp (isec->owner) != 0
12171           && elf_gp (isec->owner) != off)
12172         return FALSE;
12173
12174       elf_gp (isec->owner) = off;
12175       return TRUE;
12176     }
12177
12178   /* During the second pass toc_first_sec points to the start of
12179      a toc group, and toc_curr is used to track the old elf_gp.
12180      We use toc_bfd to ensure we only look at each bfd once.  */
12181   if (htab->toc_bfd == isec->owner)
12182     return TRUE;
12183   htab->toc_bfd = isec->owner;
12184
12185   if (htab->toc_first_sec == NULL
12186       || htab->toc_curr != elf_gp (isec->owner))
12187     {
12188       htab->toc_curr = elf_gp (isec->owner);
12189       htab->toc_first_sec = isec;
12190     }
12191   addr = (htab->toc_first_sec->output_offset
12192           + htab->toc_first_sec->output_section->vma);
12193   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12194   elf_gp (isec->owner) = off;
12195
12196   return TRUE;
12197 }
12198
12199 /* Called via elf_link_hash_traverse to merge GOT entries for global
12200    symbol H.  */
12201
12202 static bfd_boolean
12203 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12204 {
12205   if (h->root.type == bfd_link_hash_indirect)
12206     return TRUE;
12207
12208   merge_got_entries (&h->got.glist);
12209
12210   return TRUE;
12211 }
12212
12213 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12214    symbol H.  */
12215
12216 static bfd_boolean
12217 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12218 {
12219   struct got_entry *gent;
12220
12221   if (h->root.type == bfd_link_hash_indirect)
12222     return TRUE;
12223
12224   for (gent = h->got.glist; gent != NULL; gent = gent->next)
12225     if (!gent->is_indirect)
12226       allocate_got (h, (struct bfd_link_info *) inf, gent);
12227   return TRUE;
12228 }
12229
12230 /* Called on the first multitoc pass after the last call to
12231    ppc64_elf_next_toc_section.  This function removes duplicate GOT
12232    entries.  */
12233
12234 bfd_boolean
12235 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12236 {
12237   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12238   struct bfd *ibfd, *ibfd2;
12239   bfd_boolean done_something;
12240
12241   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12242
12243   if (!htab->do_multi_toc)
12244     return FALSE;
12245
12246   /* Merge global sym got entries within a toc group.  */
12247   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12248
12249   /* And tlsld_got.  */
12250   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12251     {
12252       struct got_entry *ent, *ent2;
12253
12254       if (!is_ppc64_elf (ibfd))
12255         continue;
12256
12257       ent = ppc64_tlsld_got (ibfd);
12258       if (!ent->is_indirect
12259           && ent->got.offset != (bfd_vma) -1)
12260         {
12261           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12262             {
12263               if (!is_ppc64_elf (ibfd2))
12264                 continue;
12265
12266               ent2 = ppc64_tlsld_got (ibfd2);
12267               if (!ent2->is_indirect
12268                   && ent2->got.offset != (bfd_vma) -1
12269                   && elf_gp (ibfd2) == elf_gp (ibfd))
12270                 {
12271                   ent2->is_indirect = TRUE;
12272                   ent2->got.ent = ent;
12273                 }
12274             }
12275         }
12276     }
12277
12278   /* Zap sizes of got sections.  */
12279   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12280   htab->elf.irelplt->size -= htab->got_reli_size;
12281   htab->got_reli_size = 0;
12282
12283   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12284     {
12285       asection *got, *relgot;
12286
12287       if (!is_ppc64_elf (ibfd))
12288         continue;
12289
12290       got = ppc64_elf_tdata (ibfd)->got;
12291       if (got != NULL)
12292         {
12293           got->rawsize = got->size;
12294           got->size = 0;
12295           relgot = ppc64_elf_tdata (ibfd)->relgot;
12296           relgot->rawsize = relgot->size;
12297           relgot->size = 0;
12298         }
12299     }
12300
12301   /* Now reallocate the got, local syms first.  We don't need to
12302      allocate section contents again since we never increase size.  */
12303   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12304     {
12305       struct got_entry **lgot_ents;
12306       struct got_entry **end_lgot_ents;
12307       struct plt_entry **local_plt;
12308       struct plt_entry **end_local_plt;
12309       unsigned char *lgot_masks;
12310       bfd_size_type locsymcount;
12311       Elf_Internal_Shdr *symtab_hdr;
12312       asection *s;
12313
12314       if (!is_ppc64_elf (ibfd))
12315         continue;
12316
12317       lgot_ents = elf_local_got_ents (ibfd);
12318       if (!lgot_ents)
12319         continue;
12320
12321       symtab_hdr = &elf_symtab_hdr (ibfd);
12322       locsymcount = symtab_hdr->sh_info;
12323       end_lgot_ents = lgot_ents + locsymcount;
12324       local_plt = (struct plt_entry **) end_lgot_ents;
12325       end_local_plt = local_plt + locsymcount;
12326       lgot_masks = (unsigned char *) end_local_plt;
12327       s = ppc64_elf_tdata (ibfd)->got;
12328       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12329         {
12330           struct got_entry *ent;
12331
12332           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12333             {
12334               unsigned int ent_size = 8;
12335               unsigned int rel_size = sizeof (Elf64_External_Rela);
12336
12337               ent->got.offset = s->size;
12338               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12339                 {
12340                   ent_size *= 2;
12341                   rel_size *= 2;
12342                 }
12343               s->size += ent_size;
12344               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12345                 {
12346                   htab->elf.irelplt->size += rel_size;
12347                   htab->got_reli_size += rel_size;
12348                 }
12349               else if (bfd_link_pic (info)
12350                        && !((ent->tls_type & TLS_TPREL) != 0
12351                             && bfd_link_executable (info)))
12352                 {
12353                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12354                   srel->size += rel_size;
12355                 }
12356             }
12357         }
12358     }
12359
12360   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12361
12362   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12363     {
12364       struct got_entry *ent;
12365
12366       if (!is_ppc64_elf (ibfd))
12367         continue;
12368
12369       ent = ppc64_tlsld_got (ibfd);
12370       if (!ent->is_indirect
12371           && ent->got.offset != (bfd_vma) -1)
12372         {
12373           asection *s = ppc64_elf_tdata (ibfd)->got;
12374           ent->got.offset = s->size;
12375           s->size += 16;
12376           if (bfd_link_pic (info))
12377             {
12378               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12379               srel->size += sizeof (Elf64_External_Rela);
12380             }
12381         }
12382     }
12383
12384   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12385   if (!done_something)
12386     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12387       {
12388         asection *got;
12389
12390         if (!is_ppc64_elf (ibfd))
12391           continue;
12392
12393         got = ppc64_elf_tdata (ibfd)->got;
12394         if (got != NULL)
12395           {
12396             done_something = got->rawsize != got->size;
12397             if (done_something)
12398               break;
12399           }
12400       }
12401
12402   if (done_something)
12403     (*htab->params->layout_sections_again) ();
12404
12405   /* Set up for second pass over toc sections to recalculate elf_gp
12406      on input sections.  */
12407   htab->toc_bfd = NULL;
12408   htab->toc_first_sec = NULL;
12409   htab->second_toc_pass = TRUE;
12410   return done_something;
12411 }
12412
12413 /* Called after second pass of multitoc partitioning.  */
12414
12415 void
12416 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12417 {
12418   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12419
12420   /* After the second pass, toc_curr tracks the TOC offset used
12421      for code sections below in ppc64_elf_next_input_section.  */
12422   htab->toc_curr = TOC_BASE_OFF;
12423 }
12424
12425 /* No toc references were found in ISEC.  If the code in ISEC makes no
12426    calls, then there's no need to use toc adjusting stubs when branching
12427    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12428    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12429    needed, and 2 if a cyclical call-graph was found but no other reason
12430    for a stub was detected.  If called from the top level, a return of
12431    2 means the same as a return of 0.  */
12432
12433 static int
12434 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12435 {
12436   int ret;
12437
12438   /* Mark this section as checked.  */
12439   isec->call_check_done = 1;
12440
12441   /* We know none of our code bearing sections will need toc stubs.  */
12442   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12443     return 0;
12444
12445   if (isec->size == 0)
12446     return 0;
12447
12448   if (isec->output_section == NULL)
12449     return 0;
12450
12451   ret = 0;
12452   if (isec->reloc_count != 0)
12453     {
12454       Elf_Internal_Rela *relstart, *rel;
12455       Elf_Internal_Sym *local_syms;
12456       struct ppc_link_hash_table *htab;
12457
12458       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12459                                             info->keep_memory);
12460       if (relstart == NULL)
12461         return -1;
12462
12463       /* Look for branches to outside of this section.  */
12464       local_syms = NULL;
12465       htab = ppc_hash_table (info);
12466       if (htab == NULL)
12467         return -1;
12468
12469       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12470         {
12471           enum elf_ppc64_reloc_type r_type;
12472           unsigned long r_symndx;
12473           struct elf_link_hash_entry *h;
12474           struct ppc_link_hash_entry *eh;
12475           Elf_Internal_Sym *sym;
12476           asection *sym_sec;
12477           struct _opd_sec_data *opd;
12478           bfd_vma sym_value;
12479           bfd_vma dest;
12480
12481           r_type = ELF64_R_TYPE (rel->r_info);
12482           if (r_type != R_PPC64_REL24
12483               && r_type != R_PPC64_REL24_NOTOC
12484               && r_type != R_PPC64_REL14
12485               && r_type != R_PPC64_REL14_BRTAKEN
12486               && r_type != R_PPC64_REL14_BRNTAKEN
12487               && r_type != R_PPC64_PLTCALL)
12488             continue;
12489
12490           r_symndx = ELF64_R_SYM (rel->r_info);
12491           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12492                           isec->owner))
12493             {
12494               ret = -1;
12495               break;
12496             }
12497
12498           /* Calls to dynamic lib functions go through a plt call stub
12499              that uses r2.  */
12500           eh = (struct ppc_link_hash_entry *) h;
12501           if (eh != NULL
12502               && (eh->elf.plt.plist != NULL
12503                   || (eh->oh != NULL
12504                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12505             {
12506               ret = 1;
12507               break;
12508             }
12509
12510           if (sym_sec == NULL)
12511             /* Ignore other undefined symbols.  */
12512             continue;
12513
12514           /* Assume branches to other sections not included in the
12515              link need stubs too, to cover -R and absolute syms.  */
12516           if (sym_sec->output_section == NULL)
12517             {
12518               ret = 1;
12519               break;
12520             }
12521
12522           if (h == NULL)
12523             sym_value = sym->st_value;
12524           else
12525             {
12526               if (h->root.type != bfd_link_hash_defined
12527                   && h->root.type != bfd_link_hash_defweak)
12528                 abort ();
12529               sym_value = h->root.u.def.value;
12530             }
12531           sym_value += rel->r_addend;
12532
12533           /* If this branch reloc uses an opd sym, find the code section.  */
12534           opd = get_opd_info (sym_sec);
12535           if (opd != NULL)
12536             {
12537               if (h == NULL && opd->adjust != NULL)
12538                 {
12539                   long adjust;
12540
12541                   adjust = opd->adjust[OPD_NDX (sym_value)];
12542                   if (adjust == -1)
12543                     /* Assume deleted functions won't ever be called.  */
12544                     continue;
12545                   sym_value += adjust;
12546                 }
12547
12548               dest = opd_entry_value (sym_sec, sym_value,
12549                                       &sym_sec, NULL, FALSE);
12550               if (dest == (bfd_vma) -1)
12551                 continue;
12552             }
12553           else
12554             dest = (sym_value
12555                     + sym_sec->output_offset
12556                     + sym_sec->output_section->vma);
12557
12558           /* Ignore branch to self.  */
12559           if (sym_sec == isec)
12560             continue;
12561
12562           /* If the called function uses the toc, we need a stub.  */
12563           if (sym_sec->has_toc_reloc
12564               || sym_sec->makes_toc_func_call)
12565             {
12566               ret = 1;
12567               break;
12568             }
12569
12570           /* Assume any branch that needs a long branch stub might in fact
12571              need a plt_branch stub.  A plt_branch stub uses r2.  */
12572           else if (dest - (isec->output_offset
12573                            + isec->output_section->vma
12574                            + rel->r_offset) + (1 << 25)
12575                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12576                                                              ? h->other
12577                                                              : sym->st_other))
12578             {
12579               ret = 1;
12580               break;
12581             }
12582
12583           /* If calling back to a section in the process of being
12584              tested, we can't say for sure that no toc adjusting stubs
12585              are needed, so don't return zero.  */
12586           else if (sym_sec->call_check_in_progress)
12587             ret = 2;
12588
12589           /* Branches to another section that itself doesn't have any TOC
12590              references are OK.  Recursively call ourselves to check.  */
12591           else if (!sym_sec->call_check_done)
12592             {
12593               int recur;
12594
12595               /* Mark current section as indeterminate, so that other
12596                  sections that call back to current won't be marked as
12597                  known.  */
12598               isec->call_check_in_progress = 1;
12599               recur = toc_adjusting_stub_needed (info, sym_sec);
12600               isec->call_check_in_progress = 0;
12601
12602               if (recur != 0)
12603                 {
12604                   ret = recur;
12605                   if (recur != 2)
12606                     break;
12607                 }
12608             }
12609         }
12610
12611       if (local_syms != NULL
12612           && (elf_symtab_hdr (isec->owner).contents
12613               != (unsigned char *) local_syms))
12614         free (local_syms);
12615       if (elf_section_data (isec)->relocs != relstart)
12616         free (relstart);
12617     }
12618
12619   if ((ret & 1) == 0
12620       && isec->map_head.s != NULL
12621       && (strcmp (isec->output_section->name, ".init") == 0
12622           || strcmp (isec->output_section->name, ".fini") == 0))
12623     {
12624       if (isec->map_head.s->has_toc_reloc
12625           || isec->map_head.s->makes_toc_func_call)
12626         ret = 1;
12627       else if (!isec->map_head.s->call_check_done)
12628         {
12629           int recur;
12630           isec->call_check_in_progress = 1;
12631           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12632           isec->call_check_in_progress = 0;
12633           if (recur != 0)
12634             ret = recur;
12635         }
12636     }
12637
12638   if (ret == 1)
12639     isec->makes_toc_func_call = 1;
12640
12641   return ret;
12642 }
12643
12644 /* The linker repeatedly calls this function for each input section,
12645    in the order that input sections are linked into output sections.
12646    Build lists of input sections to determine groupings between which
12647    we may insert linker stubs.  */
12648
12649 bfd_boolean
12650 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12651 {
12652   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12653
12654   if (htab == NULL)
12655     return FALSE;
12656
12657   if ((isec->output_section->flags & SEC_CODE) != 0
12658       && isec->output_section->id < htab->sec_info_arr_size)
12659     {
12660       /* This happens to make the list in reverse order,
12661          which is what we want.  */
12662       htab->sec_info[isec->id].u.list
12663         = htab->sec_info[isec->output_section->id].u.list;
12664       htab->sec_info[isec->output_section->id].u.list = isec;
12665     }
12666
12667   if (htab->multi_toc_needed)
12668     {
12669       /* Analyse sections that aren't already flagged as needing a
12670          valid toc pointer.  Exclude .fixup for the linux kernel.
12671          .fixup contains branches, but only back to the function that
12672          hit an exception.  */
12673       if (!(isec->has_toc_reloc
12674             || (isec->flags & SEC_CODE) == 0
12675             || strcmp (isec->name, ".fixup") == 0
12676             || isec->call_check_done))
12677         {
12678           if (toc_adjusting_stub_needed (info, isec) < 0)
12679             return FALSE;
12680         }
12681       /* Make all sections use the TOC assigned for this object file.
12682          This will be wrong for pasted sections;  We fix that in
12683          check_pasted_section().  */
12684       if (elf_gp (isec->owner) != 0)
12685         htab->toc_curr = elf_gp (isec->owner);
12686     }
12687
12688   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12689   return TRUE;
12690 }
12691
12692 /* Check that all .init and .fini sections use the same toc, if they
12693    have toc relocs.  */
12694
12695 static bfd_boolean
12696 check_pasted_section (struct bfd_link_info *info, const char *name)
12697 {
12698   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12699
12700   if (o != NULL)
12701     {
12702       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12703       bfd_vma toc_off = 0;
12704       asection *i;
12705
12706       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12707         if (i->has_toc_reloc)
12708           {
12709             if (toc_off == 0)
12710               toc_off = htab->sec_info[i->id].toc_off;
12711             else if (toc_off != htab->sec_info[i->id].toc_off)
12712               return FALSE;
12713           }
12714
12715       if (toc_off == 0)
12716         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12717           if (i->makes_toc_func_call)
12718             {
12719               toc_off = htab->sec_info[i->id].toc_off;
12720               break;
12721             }
12722
12723       /* Make sure the whole pasted function uses the same toc offset.  */
12724       if (toc_off != 0)
12725         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12726           htab->sec_info[i->id].toc_off = toc_off;
12727     }
12728   return TRUE;
12729 }
12730
12731 bfd_boolean
12732 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12733 {
12734   return (check_pasted_section (info, ".init")
12735           & check_pasted_section (info, ".fini"));
12736 }
12737
12738 /* See whether we can group stub sections together.  Grouping stub
12739    sections may result in fewer stubs.  More importantly, we need to
12740    put all .init* and .fini* stubs at the beginning of the .init or
12741    .fini output sections respectively, because glibc splits the
12742    _init and _fini functions into multiple parts.  Putting a stub in
12743    the middle of a function is not a good idea.  */
12744
12745 static bfd_boolean
12746 group_sections (struct bfd_link_info *info,
12747                 bfd_size_type stub_group_size,
12748                 bfd_boolean stubs_always_before_branch)
12749 {
12750   struct ppc_link_hash_table *htab;
12751   asection *osec;
12752   bfd_boolean suppress_size_errors;
12753
12754   htab = ppc_hash_table (info);
12755   if (htab == NULL)
12756     return FALSE;
12757
12758   suppress_size_errors = FALSE;
12759   if (stub_group_size == 1)
12760     {
12761       /* Default values.  */
12762       if (stubs_always_before_branch)
12763         stub_group_size = 0x1e00000;
12764       else
12765         stub_group_size = 0x1c00000;
12766       suppress_size_errors = TRUE;
12767     }
12768
12769   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12770     {
12771       asection *tail;
12772
12773       if (osec->id >= htab->sec_info_arr_size)
12774         continue;
12775
12776       tail = htab->sec_info[osec->id].u.list;
12777       while (tail != NULL)
12778         {
12779           asection *curr;
12780           asection *prev;
12781           bfd_size_type total;
12782           bfd_boolean big_sec;
12783           bfd_vma curr_toc;
12784           struct map_stub *group;
12785           bfd_size_type group_size;
12786
12787           curr = tail;
12788           total = tail->size;
12789           group_size = (ppc64_elf_section_data (tail) != NULL
12790                         && ppc64_elf_section_data (tail)->has_14bit_branch
12791                         ? stub_group_size >> 10 : stub_group_size);
12792
12793           big_sec = total > group_size;
12794           if (big_sec && !suppress_size_errors)
12795             /* xgettext:c-format */
12796             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12797                                 tail->owner, tail);
12798           curr_toc = htab->sec_info[tail->id].toc_off;
12799
12800           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12801                  && ((total += curr->output_offset - prev->output_offset)
12802                      < (ppc64_elf_section_data (prev) != NULL
12803                         && ppc64_elf_section_data (prev)->has_14bit_branch
12804                         ? (group_size = stub_group_size >> 10) : group_size))
12805                  && htab->sec_info[prev->id].toc_off == curr_toc)
12806             curr = prev;
12807
12808           /* OK, the size from the start of CURR to the end is less
12809              than group_size and thus can be handled by one stub
12810              section.  (or the tail section is itself larger than
12811              group_size, in which case we may be toast.)  We should
12812              really be keeping track of the total size of stubs added
12813              here, as stubs contribute to the final output section
12814              size.  That's a little tricky, and this way will only
12815              break if stubs added make the total size more than 2^25,
12816              ie. for the default stub_group_size, if stubs total more
12817              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12818           group = bfd_alloc (curr->owner, sizeof (*group));
12819           if (group == NULL)
12820             return FALSE;
12821           group->link_sec = curr;
12822           group->stub_sec = NULL;
12823           group->needs_save_res = 0;
12824           group->tls_get_addr_opt_bctrl = -1u;
12825           group->next = htab->group;
12826           htab->group = group;
12827           do
12828             {
12829               prev = htab->sec_info[tail->id].u.list;
12830               /* Set up this stub group.  */
12831               htab->sec_info[tail->id].u.group = group;
12832             }
12833           while (tail != curr && (tail = prev) != NULL);
12834
12835           /* But wait, there's more!  Input sections up to group_size
12836              bytes before the stub section can be handled by it too.
12837              Don't do this if we have a really large section after the
12838              stubs, as adding more stubs increases the chance that
12839              branches may not reach into the stub section.  */
12840           if (!stubs_always_before_branch && !big_sec)
12841             {
12842               total = 0;
12843               while (prev != NULL
12844                      && ((total += tail->output_offset - prev->output_offset)
12845                          < (ppc64_elf_section_data (prev) != NULL
12846                             && ppc64_elf_section_data (prev)->has_14bit_branch
12847                             ? (group_size = stub_group_size >> 10) : group_size))
12848                      && htab->sec_info[prev->id].toc_off == curr_toc)
12849                 {
12850                   tail = prev;
12851                   prev = htab->sec_info[tail->id].u.list;
12852                   htab->sec_info[tail->id].u.group = group;
12853                 }
12854             }
12855           tail = prev;
12856         }
12857     }
12858   return TRUE;
12859 }
12860
12861 static const unsigned char glink_eh_frame_cie[] =
12862 {
12863   0, 0, 0, 16,                          /* length.  */
12864   0, 0, 0, 0,                           /* id.  */
12865   1,                                    /* CIE version.  */
12866   'z', 'R', 0,                          /* Augmentation string.  */
12867   4,                                    /* Code alignment.  */
12868   0x78,                                 /* Data alignment.  */
12869   65,                                   /* RA reg.  */
12870   1,                                    /* Augmentation size.  */
12871   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12872   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12873 };
12874
12875 static size_t
12876 stub_eh_frame_size (struct map_stub *group, size_t align)
12877 {
12878   size_t this_size = 17;
12879   if (group->tls_get_addr_opt_bctrl != -1u)
12880     {
12881       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12882       if (to_bctrl < 64)
12883         this_size += 1;
12884       else if (to_bctrl < 256)
12885         this_size += 2;
12886       else if (to_bctrl < 65536)
12887         this_size += 3;
12888       else
12889         this_size += 5;
12890       this_size += 6;
12891     }
12892   this_size = (this_size + align - 1) & -align;
12893   return this_size;
12894 }
12895
12896 /* Stripping output sections is normally done before dynamic section
12897    symbols have been allocated.  This function is called later, and
12898    handles cases like htab->brlt which is mapped to its own output
12899    section.  */
12900
12901 static void
12902 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12903 {
12904   if (isec->size == 0
12905       && isec->output_section->size == 0
12906       && !(isec->output_section->flags & SEC_KEEP)
12907       && !bfd_section_removed_from_list (info->output_bfd,
12908                                          isec->output_section)
12909       && elf_section_data (isec->output_section)->dynindx == 0)
12910     {
12911       isec->output_section->flags |= SEC_EXCLUDE;
12912       bfd_section_list_remove (info->output_bfd, isec->output_section);
12913       info->output_bfd->section_count--;
12914     }
12915 }
12916
12917 /* Determine and set the size of the stub section for a final link.
12918
12919    The basic idea here is to examine all the relocations looking for
12920    PC-relative calls to a target that is unreachable with a "bl"
12921    instruction.  */
12922
12923 bfd_boolean
12924 ppc64_elf_size_stubs (struct bfd_link_info *info)
12925 {
12926   bfd_size_type stub_group_size;
12927   bfd_boolean stubs_always_before_branch;
12928   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12929
12930   if (htab == NULL)
12931     return FALSE;
12932
12933   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12934     htab->params->plt_thread_safe = 1;
12935   if (!htab->opd_abi)
12936     htab->params->plt_thread_safe = 0;
12937   else if (htab->params->plt_thread_safe == -1)
12938     {
12939       static const char *const thread_starter[] =
12940         {
12941           "pthread_create",
12942           /* libstdc++ */
12943           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12944           /* librt */
12945           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12946           "mq_notify", "create_timer",
12947           /* libanl */
12948           "getaddrinfo_a",
12949           /* libgomp */
12950           "GOMP_parallel",
12951           "GOMP_parallel_start",
12952           "GOMP_parallel_loop_static",
12953           "GOMP_parallel_loop_static_start",
12954           "GOMP_parallel_loop_dynamic",
12955           "GOMP_parallel_loop_dynamic_start",
12956           "GOMP_parallel_loop_guided",
12957           "GOMP_parallel_loop_guided_start",
12958           "GOMP_parallel_loop_runtime",
12959           "GOMP_parallel_loop_runtime_start",
12960           "GOMP_parallel_sections",
12961           "GOMP_parallel_sections_start",
12962           /* libgo */
12963           "__go_go",
12964         };
12965       unsigned i;
12966
12967       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12968         {
12969           struct elf_link_hash_entry *h;
12970           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12971                                     FALSE, FALSE, TRUE);
12972           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12973           if (htab->params->plt_thread_safe)
12974             break;
12975         }
12976     }
12977   stubs_always_before_branch = htab->params->group_size < 0;
12978   if (htab->params->group_size < 0)
12979     stub_group_size = -htab->params->group_size;
12980   else
12981     stub_group_size = htab->params->group_size;
12982
12983   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12984     return FALSE;
12985
12986 #define STUB_SHRINK_ITER 20
12987   /* Loop until no stubs added.  After iteration 20 of this loop we may
12988      exit on a stub section shrinking.  This is to break out of a
12989      pathological case where adding stubs on one iteration decreases
12990      section gaps (perhaps due to alignment), which then requires
12991      fewer or smaller stubs on the next iteration.  */
12992
12993   while (1)
12994     {
12995       bfd *input_bfd;
12996       unsigned int bfd_indx;
12997       struct map_stub *group;
12998
12999       htab->stub_iteration += 1;
13000
13001       for (input_bfd = info->input_bfds, bfd_indx = 0;
13002            input_bfd != NULL;
13003            input_bfd = input_bfd->link.next, bfd_indx++)
13004         {
13005           Elf_Internal_Shdr *symtab_hdr;
13006           asection *section;
13007           Elf_Internal_Sym *local_syms = NULL;
13008
13009           if (!is_ppc64_elf (input_bfd))
13010             continue;
13011
13012           /* We'll need the symbol table in a second.  */
13013           symtab_hdr = &elf_symtab_hdr (input_bfd);
13014           if (symtab_hdr->sh_info == 0)
13015             continue;
13016
13017           /* Walk over each section attached to the input bfd.  */
13018           for (section = input_bfd->sections;
13019                section != NULL;
13020                section = section->next)
13021             {
13022               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13023
13024               /* If there aren't any relocs, then there's nothing more
13025                  to do.  */
13026               if ((section->flags & SEC_RELOC) == 0
13027                   || (section->flags & SEC_ALLOC) == 0
13028                   || (section->flags & SEC_LOAD) == 0
13029                   || (section->flags & SEC_CODE) == 0
13030                   || section->reloc_count == 0)
13031                 continue;
13032
13033               /* If this section is a link-once section that will be
13034                  discarded, then don't create any stubs.  */
13035               if (section->output_section == NULL
13036                   || section->output_section->owner != info->output_bfd)
13037                 continue;
13038
13039               /* Get the relocs.  */
13040               internal_relocs
13041                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13042                                              info->keep_memory);
13043               if (internal_relocs == NULL)
13044                 goto error_ret_free_local;
13045
13046               /* Now examine each relocation.  */
13047               irela = internal_relocs;
13048               irelaend = irela + section->reloc_count;
13049               for (; irela < irelaend; irela++)
13050                 {
13051                   enum elf_ppc64_reloc_type r_type;
13052                   unsigned int r_indx;
13053                   enum ppc_stub_type stub_type;
13054                   struct ppc_stub_hash_entry *stub_entry;
13055                   asection *sym_sec, *code_sec;
13056                   bfd_vma sym_value, code_value;
13057                   bfd_vma destination;
13058                   unsigned long local_off;
13059                   bfd_boolean ok_dest;
13060                   struct ppc_link_hash_entry *hash;
13061                   struct ppc_link_hash_entry *fdh;
13062                   struct elf_link_hash_entry *h;
13063                   Elf_Internal_Sym *sym;
13064                   char *stub_name;
13065                   const asection *id_sec;
13066                   struct _opd_sec_data *opd;
13067                   struct plt_entry *plt_ent;
13068
13069                   r_type = ELF64_R_TYPE (irela->r_info);
13070                   r_indx = ELF64_R_SYM (irela->r_info);
13071
13072                   if (r_type >= R_PPC64_max)
13073                     {
13074                       bfd_set_error (bfd_error_bad_value);
13075                       goto error_ret_free_internal;
13076                     }
13077
13078                   /* Only look for stubs on branch instructions.  */
13079                   if (r_type != R_PPC64_REL24
13080                       && r_type != R_PPC64_REL24_NOTOC
13081                       && r_type != R_PPC64_REL14
13082                       && r_type != R_PPC64_REL14_BRTAKEN
13083                       && r_type != R_PPC64_REL14_BRNTAKEN)
13084                     continue;
13085
13086                   /* Now determine the call target, its name, value,
13087                      section.  */
13088                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13089                                   r_indx, input_bfd))
13090                     goto error_ret_free_internal;
13091                   hash = (struct ppc_link_hash_entry *) h;
13092
13093                   ok_dest = FALSE;
13094                   fdh = NULL;
13095                   sym_value = 0;
13096                   if (hash == NULL)
13097                     {
13098                       sym_value = sym->st_value;
13099                       if (sym_sec != NULL
13100                           && sym_sec->output_section != NULL)
13101                         ok_dest = TRUE;
13102                     }
13103                   else if (hash->elf.root.type == bfd_link_hash_defined
13104                            || hash->elf.root.type == bfd_link_hash_defweak)
13105                     {
13106                       sym_value = hash->elf.root.u.def.value;
13107                       if (sym_sec->output_section != NULL)
13108                         ok_dest = TRUE;
13109                     }
13110                   else if (hash->elf.root.type == bfd_link_hash_undefweak
13111                            || hash->elf.root.type == bfd_link_hash_undefined)
13112                     {
13113                       /* Recognise an old ABI func code entry sym, and
13114                          use the func descriptor sym instead if it is
13115                          defined.  */
13116                       if (hash->elf.root.root.string[0] == '.'
13117                           && hash->oh != NULL)
13118                         {
13119                           fdh = ppc_follow_link (hash->oh);
13120                           if (fdh->elf.root.type == bfd_link_hash_defined
13121                               || fdh->elf.root.type == bfd_link_hash_defweak)
13122                             {
13123                               sym_sec = fdh->elf.root.u.def.section;
13124                               sym_value = fdh->elf.root.u.def.value;
13125                               if (sym_sec->output_section != NULL)
13126                                 ok_dest = TRUE;
13127                             }
13128                           else
13129                             fdh = NULL;
13130                         }
13131                     }
13132                   else
13133                     {
13134                       bfd_set_error (bfd_error_bad_value);
13135                       goto error_ret_free_internal;
13136                     }
13137
13138                   destination = 0;
13139                   local_off = 0;
13140                   if (ok_dest)
13141                     {
13142                       sym_value += irela->r_addend;
13143                       destination = (sym_value
13144                                      + sym_sec->output_offset
13145                                      + sym_sec->output_section->vma);
13146                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
13147                                                             ? hash->elf.other
13148                                                             : sym->st_other);
13149                     }
13150
13151                   code_sec = sym_sec;
13152                   code_value = sym_value;
13153                   opd = get_opd_info (sym_sec);
13154                   if (opd != NULL)
13155                     {
13156                       bfd_vma dest;
13157
13158                       if (hash == NULL && opd->adjust != NULL)
13159                         {
13160                           long adjust = opd->adjust[OPD_NDX (sym_value)];
13161                           if (adjust == -1)
13162                             continue;
13163                           code_value += adjust;
13164                           sym_value += adjust;
13165                         }
13166                       dest = opd_entry_value (sym_sec, sym_value,
13167                                               &code_sec, &code_value, FALSE);
13168                       if (dest != (bfd_vma) -1)
13169                         {
13170                           destination = dest;
13171                           if (fdh != NULL)
13172                             {
13173                               /* Fixup old ABI sym to point at code
13174                                  entry.  */
13175                               hash->elf.root.type = bfd_link_hash_defweak;
13176                               hash->elf.root.u.def.section = code_sec;
13177                               hash->elf.root.u.def.value = code_value;
13178                             }
13179                         }
13180                     }
13181
13182                   /* Determine what (if any) linker stub is needed.  */
13183                   plt_ent = NULL;
13184                   stub_type = ppc_type_of_stub (section, irela, &hash,
13185                                                 &plt_ent, destination,
13186                                                 local_off);
13187
13188                   if (r_type == R_PPC64_REL24_NOTOC)
13189                     {
13190                       if (stub_type == ppc_stub_plt_call)
13191                         stub_type = ppc_stub_plt_call_notoc;
13192                       else if (stub_type == ppc_stub_long_branch
13193                                || (code_sec != NULL
13194                                    && code_sec->output_section != NULL
13195                                    && (((hash ? hash->elf.other : sym->st_other)
13196                                         & STO_PPC64_LOCAL_MASK)
13197                                        != 1 << STO_PPC64_LOCAL_BIT)))
13198                         stub_type = ppc_stub_long_branch_notoc;
13199                     }
13200                   else if (stub_type != ppc_stub_plt_call)
13201                     {
13202                       /* Check whether we need a TOC adjusting stub.
13203                          Since the linker pastes together pieces from
13204                          different object files when creating the
13205                          _init and _fini functions, it may be that a
13206                          call to what looks like a local sym is in
13207                          fact a call needing a TOC adjustment.  */
13208                       if ((code_sec != NULL
13209                            && code_sec->output_section != NULL
13210                            && (htab->sec_info[code_sec->id].toc_off
13211                                != htab->sec_info[section->id].toc_off)
13212                            && (code_sec->has_toc_reloc
13213                                || code_sec->makes_toc_func_call))
13214                           || (((hash ? hash->elf.other : sym->st_other)
13215                                & STO_PPC64_LOCAL_MASK)
13216                               == 1 << STO_PPC64_LOCAL_BIT))
13217                         stub_type = ppc_stub_long_branch_r2off;
13218                     }
13219
13220                   if (stub_type == ppc_stub_none)
13221                     continue;
13222
13223                   /* __tls_get_addr calls might be eliminated.  */
13224                   if (stub_type != ppc_stub_plt_call
13225                       && stub_type != ppc_stub_plt_call_notoc
13226                       && hash != NULL
13227                       && (hash == htab->tls_get_addr
13228                           || hash == htab->tls_get_addr_fd)
13229                       && section->has_tls_reloc
13230                       && irela != internal_relocs)
13231                     {
13232                       /* Get tls info.  */
13233                       unsigned char *tls_mask;
13234
13235                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13236                                          irela - 1, input_bfd))
13237                         goto error_ret_free_internal;
13238                       if ((*tls_mask & TLS_TLS) != 0)
13239                         continue;
13240                     }
13241
13242                   if (stub_type == ppc_stub_plt_call)
13243                     {
13244                       if (!htab->opd_abi
13245                           && htab->params->plt_localentry0 != 0
13246                           && is_elfv2_localentry0 (&hash->elf))
13247                         htab->has_plt_localentry0 = 1;
13248                       else if (irela + 1 < irelaend
13249                                && irela[1].r_offset == irela->r_offset + 4
13250                                && (ELF64_R_TYPE (irela[1].r_info)
13251                                    == R_PPC64_TOCSAVE))
13252                         {
13253                           if (!tocsave_find (htab, INSERT,
13254                                              &local_syms, irela + 1, input_bfd))
13255                             goto error_ret_free_internal;
13256                         }
13257                       else
13258                         stub_type = ppc_stub_plt_call_r2save;
13259                     }
13260
13261                   /* Support for grouping stub sections.  */
13262                   id_sec = htab->sec_info[section->id].u.group->link_sec;
13263
13264                   /* Get the name of this stub.  */
13265                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13266                   if (!stub_name)
13267                     goto error_ret_free_internal;
13268
13269                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13270                                                      stub_name, FALSE, FALSE);
13271                   if (stub_entry != NULL)
13272                     {
13273                       enum ppc_stub_type old_type;
13274                       /* A stub has already been created, but it may
13275                          not be the required type.  We shouldn't be
13276                          transitioning from plt_call to long_branch
13277                          stubs or vice versa, but we might be
13278                          upgrading from plt_call to plt_call_r2save or
13279                          from long_branch to long_branch_r2off.  */
13280                       free (stub_name);
13281                       old_type = stub_entry->stub_type;
13282                       switch (old_type)
13283                         {
13284                         default:
13285                           abort ();
13286
13287                         case ppc_stub_save_res:
13288                           continue;
13289
13290                         case ppc_stub_plt_call:
13291                         case ppc_stub_plt_call_r2save:
13292                         case ppc_stub_plt_call_notoc:
13293                         case ppc_stub_plt_call_both:
13294                           if (stub_type == ppc_stub_plt_call)
13295                             continue;
13296                           else if (stub_type == ppc_stub_plt_call_r2save)
13297                             {
13298                               if (old_type == ppc_stub_plt_call_notoc)
13299                                 stub_type = ppc_stub_plt_call_both;
13300                             }
13301                           else if (stub_type == ppc_stub_plt_call_notoc)
13302                             {
13303                               if (old_type == ppc_stub_plt_call_r2save)
13304                                 stub_type = ppc_stub_plt_call_both;
13305                             }
13306                           else
13307                             abort ();
13308                           break;
13309
13310                         case ppc_stub_plt_branch:
13311                         case ppc_stub_plt_branch_r2off:
13312                         case ppc_stub_plt_branch_notoc:
13313                         case ppc_stub_plt_branch_both:
13314                           old_type += (ppc_stub_long_branch
13315                                        - ppc_stub_plt_branch);
13316                           /* Fall through.  */
13317                         case ppc_stub_long_branch:
13318                         case ppc_stub_long_branch_r2off:
13319                         case ppc_stub_long_branch_notoc:
13320                         case ppc_stub_long_branch_both:
13321                           if (stub_type == ppc_stub_long_branch)
13322                             continue;
13323                           else if (stub_type == ppc_stub_long_branch_r2off)
13324                             {
13325                               if (old_type == ppc_stub_long_branch_notoc)
13326                                 stub_type = ppc_stub_long_branch_both;
13327                             }
13328                           else if (stub_type == ppc_stub_long_branch_notoc)
13329                             {
13330                               if (old_type == ppc_stub_long_branch_r2off)
13331                                 stub_type = ppc_stub_long_branch_both;
13332                             }
13333                           else
13334                             abort ();
13335                           break;
13336                         }
13337                       if (old_type < stub_type)
13338                         stub_entry->stub_type = stub_type;
13339                       continue;
13340                     }
13341
13342                   stub_entry = ppc_add_stub (stub_name, section, info);
13343                   if (stub_entry == NULL)
13344                     {
13345                       free (stub_name);
13346                     error_ret_free_internal:
13347                       if (elf_section_data (section)->relocs == NULL)
13348                         free (internal_relocs);
13349                     error_ret_free_local:
13350                       if (local_syms != NULL
13351                           && (symtab_hdr->contents
13352                               != (unsigned char *) local_syms))
13353                         free (local_syms);
13354                       return FALSE;
13355                     }
13356
13357                   stub_entry->stub_type = stub_type;
13358                   if (stub_type >= ppc_stub_plt_call
13359                       && stub_type <= ppc_stub_plt_call_both)
13360                     {
13361                       stub_entry->target_value = sym_value;
13362                       stub_entry->target_section = sym_sec;
13363                     }
13364                   else
13365                     {
13366                       stub_entry->target_value = code_value;
13367                       stub_entry->target_section = code_sec;
13368                     }
13369                   stub_entry->h = hash;
13370                   stub_entry->plt_ent = plt_ent;
13371                   stub_entry->symtype
13372                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13373                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
13374
13375                   if (stub_entry->h != NULL)
13376                     htab->stub_globals += 1;
13377                 }
13378
13379               /* We're done with the internal relocs, free them.  */
13380               if (elf_section_data (section)->relocs != internal_relocs)
13381                 free (internal_relocs);
13382             }
13383
13384           if (local_syms != NULL
13385               && symtab_hdr->contents != (unsigned char *) local_syms)
13386             {
13387               if (!info->keep_memory)
13388                 free (local_syms);
13389               else
13390                 symtab_hdr->contents = (unsigned char *) local_syms;
13391             }
13392         }
13393
13394       /* We may have added some stubs.  Find out the new size of the
13395          stub sections.  */
13396       for (group = htab->group; group != NULL; group = group->next)
13397         if (group->stub_sec != NULL)
13398           {
13399             asection *stub_sec = group->stub_sec;
13400
13401             if (htab->stub_iteration <= STUB_SHRINK_ITER
13402                 || stub_sec->rawsize < stub_sec->size)
13403               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
13404               stub_sec->rawsize = stub_sec->size;
13405             stub_sec->size = 0;
13406             stub_sec->reloc_count = 0;
13407             stub_sec->flags &= ~SEC_RELOC;
13408           }
13409
13410       if (htab->stub_iteration <= STUB_SHRINK_ITER
13411           || htab->brlt->rawsize < htab->brlt->size)
13412         htab->brlt->rawsize = htab->brlt->size;
13413       htab->brlt->size = 0;
13414       htab->brlt->reloc_count = 0;
13415       htab->brlt->flags &= ~SEC_RELOC;
13416       if (htab->relbrlt != NULL)
13417         htab->relbrlt->size = 0;
13418
13419       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13420
13421       for (group = htab->group; group != NULL; group = group->next)
13422         if (group->needs_save_res)
13423           group->stub_sec->size += htab->sfpr->size;
13424
13425       if (info->emitrelocations
13426           && htab->glink != NULL && htab->glink->size != 0)
13427         {
13428           htab->glink->reloc_count = 1;
13429           htab->glink->flags |= SEC_RELOC;
13430         }
13431
13432       if (htab->glink_eh_frame != NULL
13433           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13434           && htab->glink_eh_frame->output_section->size > 8)
13435         {
13436           size_t size = 0, align = 4;
13437
13438           for (group = htab->group; group != NULL; group = group->next)
13439             if (group->stub_sec != NULL)
13440               size += stub_eh_frame_size (group, align);
13441           if (htab->glink != NULL && htab->glink->size != 0)
13442             size += (24 + align - 1) & -align;
13443           if (size != 0)
13444             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13445           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13446           size = (size + align - 1) & -align;
13447           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13448           htab->glink_eh_frame->size = size;
13449         }
13450
13451       if (htab->params->plt_stub_align != 0)
13452         for (group = htab->group; group != NULL; group = group->next)
13453           if (group->stub_sec != NULL)
13454             {
13455               int align = abs (htab->params->plt_stub_align);
13456               group->stub_sec->size
13457                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13458             }
13459
13460       for (group = htab->group; group != NULL; group = group->next)
13461         if (group->stub_sec != NULL
13462             && group->stub_sec->rawsize != group->stub_sec->size
13463             && (htab->stub_iteration <= STUB_SHRINK_ITER
13464                 || group->stub_sec->rawsize < group->stub_sec->size))
13465           break;
13466
13467       if (group == NULL
13468           && (htab->brlt->rawsize == htab->brlt->size
13469               || (htab->stub_iteration > STUB_SHRINK_ITER
13470                   && htab->brlt->rawsize > htab->brlt->size))
13471           && (htab->glink_eh_frame == NULL
13472               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13473         break;
13474
13475       /* Ask the linker to do its stuff.  */
13476       (*htab->params->layout_sections_again) ();
13477     }
13478
13479   if (htab->glink_eh_frame != NULL
13480       && htab->glink_eh_frame->size != 0)
13481     {
13482       bfd_vma val;
13483       bfd_byte *p, *last_fde;
13484       size_t last_fde_len, size, align, pad;
13485       struct map_stub *group;
13486
13487       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13488       if (p == NULL)
13489         return FALSE;
13490       htab->glink_eh_frame->contents = p;
13491       last_fde = p;
13492       align = 4;
13493
13494       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13495       /* CIE length (rewrite in case little-endian).  */
13496       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13497       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13498       p += last_fde_len + 4;
13499
13500       for (group = htab->group; group != NULL; group = group->next)
13501         if (group->stub_sec != NULL)
13502           {
13503             last_fde = p;
13504             last_fde_len = stub_eh_frame_size (group, align) - 4;
13505             /* FDE length.  */
13506             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13507             p += 4;
13508             /* CIE pointer.  */
13509             val = p - htab->glink_eh_frame->contents;
13510             bfd_put_32 (htab->elf.dynobj, val, p);
13511             p += 4;
13512             /* Offset to stub section, written later.  */
13513             p += 4;
13514             /* stub section size.  */
13515             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13516             p += 4;
13517             /* Augmentation.  */
13518             p += 1;
13519             if (group->tls_get_addr_opt_bctrl != -1u)
13520               {
13521                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13522
13523                 /* This FDE needs more than just the default.
13524                    Describe __tls_get_addr_opt stub LR.  */
13525                 if (to_bctrl < 64)
13526                   *p++ = DW_CFA_advance_loc + to_bctrl;
13527                 else if (to_bctrl < 256)
13528                   {
13529                     *p++ = DW_CFA_advance_loc1;
13530                     *p++ = to_bctrl;
13531                   }
13532                 else if (to_bctrl < 65536)
13533                   {
13534                     *p++ = DW_CFA_advance_loc2;
13535                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13536                     p += 2;
13537                   }
13538                 else
13539                   {
13540                     *p++ = DW_CFA_advance_loc4;
13541                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13542                     p += 4;
13543                   }
13544                 *p++ = DW_CFA_offset_extended_sf;
13545                 *p++ = 65;
13546                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13547                 *p++ = DW_CFA_advance_loc + 4;
13548                 *p++ = DW_CFA_restore_extended;
13549                 *p++ = 65;
13550               }
13551             /* Pad.  */
13552             p = last_fde + last_fde_len + 4;
13553           }
13554       if (htab->glink != NULL && htab->glink->size != 0)
13555         {
13556           last_fde = p;
13557           last_fde_len = ((24 + align - 1) & -align) - 4;
13558           /* FDE length.  */
13559           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13560           p += 4;
13561           /* CIE pointer.  */
13562           val = p - htab->glink_eh_frame->contents;
13563           bfd_put_32 (htab->elf.dynobj, val, p);
13564           p += 4;
13565           /* Offset to .glink, written later.  */
13566           p += 4;
13567           /* .glink size.  */
13568           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13569           p += 4;
13570           /* Augmentation.  */
13571           p += 1;
13572
13573           *p++ = DW_CFA_advance_loc + 1;
13574           *p++ = DW_CFA_register;
13575           *p++ = 65;
13576           *p++ = htab->opd_abi ? 12 : 0;
13577           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13578           *p++ = DW_CFA_restore_extended;
13579           *p++ = 65;
13580           p += ((24 + align - 1) & -align) - 24;
13581         }
13582       /* Subsume any padding into the last FDE if user .eh_frame
13583          sections are aligned more than glink_eh_frame.  Otherwise any
13584          zero padding will be seen as a terminator.  */
13585       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13586       size = p - htab->glink_eh_frame->contents;
13587       pad = ((size + align - 1) & -align) - size;
13588       htab->glink_eh_frame->size = size + pad;
13589       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13590     }
13591
13592   maybe_strip_output (info, htab->brlt);
13593   if (htab->glink_eh_frame != NULL)
13594     maybe_strip_output (info, htab->glink_eh_frame);
13595
13596   return TRUE;
13597 }
13598
13599 /* Called after we have determined section placement.  If sections
13600    move, we'll be called again.  Provide a value for TOCstart.  */
13601
13602 bfd_vma
13603 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13604 {
13605   asection *s;
13606   bfd_vma TOCstart, adjust;
13607
13608   if (info != NULL)
13609     {
13610       struct elf_link_hash_entry *h;
13611       struct elf_link_hash_table *htab = elf_hash_table (info);
13612
13613       if (is_elf_hash_table (htab)
13614           && htab->hgot != NULL)
13615         h = htab->hgot;
13616       else
13617         {
13618           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13619           if (is_elf_hash_table (htab))
13620             htab->hgot = h;
13621         }
13622       if (h != NULL
13623           && h->root.type == bfd_link_hash_defined
13624           && !h->root.linker_def
13625           && (!is_elf_hash_table (htab)
13626               || h->def_regular))
13627         {
13628           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13629                       + h->root.u.def.section->output_offset
13630                       + h->root.u.def.section->output_section->vma);
13631           _bfd_set_gp_value (obfd, TOCstart);
13632           return TOCstart;
13633         }
13634     }
13635
13636   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13637      order.  The TOC starts where the first of these sections starts.  */
13638   s = bfd_get_section_by_name (obfd, ".got");
13639   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13640     s = bfd_get_section_by_name (obfd, ".toc");
13641   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13642     s = bfd_get_section_by_name (obfd, ".tocbss");
13643   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13644     s = bfd_get_section_by_name (obfd, ".plt");
13645   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13646     {
13647       /* This may happen for
13648          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13649          .toc directive
13650          o  bad linker script
13651          o --gc-sections and empty TOC sections
13652
13653          FIXME: Warn user?  */
13654
13655       /* Look for a likely section.  We probably won't even be
13656          using TOCstart.  */
13657       for (s = obfd->sections; s != NULL; s = s->next)
13658         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13659                          | SEC_EXCLUDE))
13660             == (SEC_ALLOC | SEC_SMALL_DATA))
13661           break;
13662       if (s == NULL)
13663         for (s = obfd->sections; s != NULL; s = s->next)
13664           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13665               == (SEC_ALLOC | SEC_SMALL_DATA))
13666             break;
13667       if (s == NULL)
13668         for (s = obfd->sections; s != NULL; s = s->next)
13669           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13670               == SEC_ALLOC)
13671             break;
13672       if (s == NULL)
13673         for (s = obfd->sections; s != NULL; s = s->next)
13674           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13675             break;
13676     }
13677
13678   TOCstart = 0;
13679   if (s != NULL)
13680     TOCstart = s->output_section->vma + s->output_offset;
13681
13682   /* Force alignment.  */
13683   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13684   TOCstart -= adjust;
13685   _bfd_set_gp_value (obfd, TOCstart);
13686
13687   if (info != NULL && s != NULL)
13688     {
13689       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13690
13691       if (htab != NULL)
13692         {
13693           if (htab->elf.hgot != NULL)
13694             {
13695               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13696               htab->elf.hgot->root.u.def.section = s;
13697             }
13698         }
13699       else
13700         {
13701           struct bfd_link_hash_entry *bh = NULL;
13702           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13703                                             s, TOC_BASE_OFF - adjust,
13704                                             NULL, FALSE, FALSE, &bh);
13705         }
13706     }
13707   return TOCstart;
13708 }
13709
13710 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13711    write out any global entry stubs, and PLT relocations.  */
13712
13713 static bfd_boolean
13714 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13715 {
13716   struct bfd_link_info *info;
13717   struct ppc_link_hash_table *htab;
13718   struct plt_entry *ent;
13719   asection *s;
13720
13721   if (h->root.type == bfd_link_hash_indirect)
13722     return TRUE;
13723
13724   info = inf;
13725   htab = ppc_hash_table (info);
13726   if (htab == NULL)
13727     return FALSE;
13728
13729   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13730     if (ent->plt.offset != (bfd_vma) -1)
13731       {
13732         /* This symbol has an entry in the procedure linkage
13733            table.  Set it up.  */
13734         Elf_Internal_Rela rela;
13735         asection *plt, *relplt;
13736         bfd_byte *loc;
13737
13738         if (!htab->elf.dynamic_sections_created
13739             || h->dynindx == -1)
13740           {
13741             if (!(h->def_regular
13742                   && (h->root.type == bfd_link_hash_defined
13743                       || h->root.type == bfd_link_hash_defweak)))
13744               continue;
13745             if (h->type == STT_GNU_IFUNC)
13746               {
13747                 plt = htab->elf.iplt;
13748                 relplt = htab->elf.irelplt;
13749                 htab->local_ifunc_resolver = 1;
13750                 if (htab->opd_abi)
13751                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13752                 else
13753                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13754               }
13755             else
13756               {
13757                 plt = htab->pltlocal;
13758                 if (bfd_link_pic (info))
13759                   {
13760                     relplt = htab->relpltlocal;
13761                     if (htab->opd_abi)
13762                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13763                     else
13764                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13765                   }
13766                 else
13767                   relplt = NULL;
13768               }
13769             rela.r_addend = (h->root.u.def.value
13770                              + h->root.u.def.section->output_offset
13771                              + h->root.u.def.section->output_section->vma
13772                              + ent->addend);
13773
13774             if (relplt == NULL)
13775               {
13776                 loc = plt->contents + ent->plt.offset;
13777                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13778                 if (htab->opd_abi)
13779                   {
13780                     bfd_vma toc = elf_gp (info->output_bfd);
13781                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13782                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13783                   }
13784               }
13785             else
13786               {
13787                 rela.r_offset = (plt->output_section->vma
13788                                  + plt->output_offset
13789                                  + ent->plt.offset);
13790                 loc = relplt->contents + (relplt->reloc_count++
13791                                           * sizeof (Elf64_External_Rela));
13792                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13793               }
13794           }
13795         else
13796           {
13797             rela.r_offset = (htab->elf.splt->output_section->vma
13798                              + htab->elf.splt->output_offset
13799                              + ent->plt.offset);
13800             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13801             rela.r_addend = ent->addend;
13802             loc = (htab->elf.srelplt->contents
13803                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13804                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13805             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13806               htab->maybe_local_ifunc_resolver = 1;
13807             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13808           }
13809       }
13810
13811   if (!h->pointer_equality_needed)
13812     return TRUE;
13813
13814   if (h->def_regular)
13815     return TRUE;
13816
13817   s = htab->global_entry;
13818   if (s == NULL || s->size == 0)
13819     return TRUE;
13820
13821   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13822     if (ent->plt.offset != (bfd_vma) -1
13823         && ent->addend == 0)
13824       {
13825         bfd_byte *p;
13826         asection *plt;
13827         bfd_vma off;
13828
13829         p = s->contents + h->root.u.def.value;
13830         plt = htab->elf.splt;
13831         if (!htab->elf.dynamic_sections_created
13832             || h->dynindx == -1)
13833           {
13834             if (h->type == STT_GNU_IFUNC)
13835               plt = htab->elf.iplt;
13836             else
13837               plt = htab->pltlocal;
13838           }
13839         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13840         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13841
13842         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13843           {
13844             info->callbacks->einfo
13845               (_("%P: linkage table error against `%pT'\n"),
13846                h->root.root.string);
13847             bfd_set_error (bfd_error_bad_value);
13848             htab->stub_error = TRUE;
13849           }
13850
13851         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13852         if (htab->params->emit_stub_syms)
13853           {
13854             size_t len = strlen (h->root.root.string);
13855             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13856
13857             if (name == NULL)
13858               return FALSE;
13859
13860             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13861             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13862             if (h == NULL)
13863               return FALSE;
13864             if (h->root.type == bfd_link_hash_new)
13865               {
13866                 h->root.type = bfd_link_hash_defined;
13867                 h->root.u.def.section = s;
13868                 h->root.u.def.value = p - s->contents;
13869                 h->ref_regular = 1;
13870                 h->def_regular = 1;
13871                 h->ref_regular_nonweak = 1;
13872                 h->forced_local = 1;
13873                 h->non_elf = 0;
13874                 h->root.linker_def = 1;
13875               }
13876           }
13877
13878         if (PPC_HA (off) != 0)
13879           {
13880             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13881             p += 4;
13882           }
13883         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13884         p += 4;
13885         bfd_put_32 (s->owner, MTCTR_R12, p);
13886         p += 4;
13887         bfd_put_32 (s->owner, BCTR, p);
13888         break;
13889       }
13890   return TRUE;
13891 }
13892
13893 /* Write PLT relocs for locals.  */
13894
13895 static bfd_boolean
13896 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13897 {
13898   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13899   bfd *ibfd;
13900
13901   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13902     {
13903       struct got_entry **lgot_ents, **end_lgot_ents;
13904       struct plt_entry **local_plt, **lplt, **end_local_plt;
13905       Elf_Internal_Shdr *symtab_hdr;
13906       bfd_size_type locsymcount;
13907       Elf_Internal_Sym *local_syms = NULL;
13908       struct plt_entry *ent;
13909
13910       if (!is_ppc64_elf (ibfd))
13911         continue;
13912
13913       lgot_ents = elf_local_got_ents (ibfd);
13914       if (!lgot_ents)
13915         continue;
13916
13917       symtab_hdr = &elf_symtab_hdr (ibfd);
13918       locsymcount = symtab_hdr->sh_info;
13919       end_lgot_ents = lgot_ents + locsymcount;
13920       local_plt = (struct plt_entry **) end_lgot_ents;
13921       end_local_plt = local_plt + locsymcount;
13922       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13923         for (ent = *lplt; ent != NULL; ent = ent->next)
13924           if (ent->plt.offset != (bfd_vma) -1)
13925             {
13926               Elf_Internal_Sym *sym;
13927               asection *sym_sec;
13928               asection *plt, *relplt;
13929               bfd_byte *loc;
13930               bfd_vma val;
13931
13932               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13933                               lplt - local_plt, ibfd))
13934                 {
13935                   if (local_syms != NULL
13936                       && symtab_hdr->contents != (unsigned char *) local_syms)
13937                     free (local_syms);
13938                   return FALSE;
13939                 }
13940
13941               val = sym->st_value + ent->addend;
13942               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13943               if (sym_sec != NULL && sym_sec->output_section != NULL)
13944                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13945
13946               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13947                 {
13948                   htab->local_ifunc_resolver = 1;
13949                   plt = htab->elf.iplt;
13950                   relplt = htab->elf.irelplt;
13951                 }
13952               else
13953                 {
13954                   plt = htab->pltlocal;
13955                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13956                 }
13957
13958               if (relplt == NULL)
13959                 {
13960                   loc = plt->contents + ent->plt.offset;
13961                   bfd_put_64 (info->output_bfd, val, loc);
13962                   if (htab->opd_abi)
13963                     {
13964                       bfd_vma toc = elf_gp (ibfd);
13965                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13966                     }
13967                 }
13968               else
13969                 {
13970                   Elf_Internal_Rela rela;
13971                   rela.r_offset = (ent->plt.offset
13972                                    + plt->output_offset
13973                                    + plt->output_section->vma);
13974                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13975                     {
13976                       if (htab->opd_abi)
13977                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13978                       else
13979                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13980                     }
13981                   else
13982                     {
13983                       if (htab->opd_abi)
13984                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13985                       else
13986                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13987                     }
13988                   rela.r_addend = val;
13989                   loc = relplt->contents + (relplt->reloc_count++
13990                                             * sizeof (Elf64_External_Rela));
13991                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13992                 }
13993             }
13994
13995       if (local_syms != NULL
13996           && symtab_hdr->contents != (unsigned char *) local_syms)
13997         {
13998           if (!info->keep_memory)
13999             free (local_syms);
14000           else
14001             symtab_hdr->contents = (unsigned char *) local_syms;
14002         }
14003     }
14004   return TRUE;
14005 }
14006
14007 /* Build all the stubs associated with the current output file.
14008    The stubs are kept in a hash table attached to the main linker
14009    hash table.  This function is called via gldelf64ppc_finish.  */
14010
14011 bfd_boolean
14012 ppc64_elf_build_stubs (struct bfd_link_info *info,
14013                        char **stats)
14014 {
14015   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14016   struct map_stub *group;
14017   asection *stub_sec;
14018   bfd_byte *p;
14019   int stub_sec_count = 0;
14020
14021   if (htab == NULL)
14022     return FALSE;
14023
14024   /* Allocate memory to hold the linker stubs.  */
14025   for (group = htab->group; group != NULL; group = group->next)
14026     if ((stub_sec = group->stub_sec) != NULL
14027         && stub_sec->size != 0)
14028       {
14029         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
14030         if (stub_sec->contents == NULL)
14031           return FALSE;
14032         stub_sec->size = 0;
14033       }
14034
14035   if (htab->glink != NULL && htab->glink->size != 0)
14036     {
14037       unsigned int indx;
14038       bfd_vma plt0;
14039
14040       /* Build the .glink plt call stub.  */
14041       if (htab->params->emit_stub_syms)
14042         {
14043           struct elf_link_hash_entry *h;
14044           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
14045                                     TRUE, FALSE, FALSE);
14046           if (h == NULL)
14047             return FALSE;
14048           if (h->root.type == bfd_link_hash_new)
14049             {
14050               h->root.type = bfd_link_hash_defined;
14051               h->root.u.def.section = htab->glink;
14052               h->root.u.def.value = 8;
14053               h->ref_regular = 1;
14054               h->def_regular = 1;
14055               h->ref_regular_nonweak = 1;
14056               h->forced_local = 1;
14057               h->non_elf = 0;
14058               h->root.linker_def = 1;
14059             }
14060         }
14061       plt0 = (htab->elf.splt->output_section->vma
14062               + htab->elf.splt->output_offset
14063               - 16);
14064       if (info->emitrelocations)
14065         {
14066           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
14067           if (r == NULL)
14068             return FALSE;
14069           r->r_offset = (htab->glink->output_offset
14070                          + htab->glink->output_section->vma);
14071           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
14072           r->r_addend = plt0;
14073         }
14074       p = htab->glink->contents;
14075       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
14076       bfd_put_64 (htab->glink->owner, plt0, p);
14077       p += 8;
14078       if (htab->opd_abi)
14079         {
14080           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
14081           p += 4;
14082           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14083           p += 4;
14084           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14085           p += 4;
14086           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14087           p += 4;
14088           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
14089           p += 4;
14090           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14091           p += 4;
14092           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14093           p += 4;
14094           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
14095           p += 4;
14096           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14097           p += 4;
14098           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
14099           p += 4;
14100         }
14101       else
14102         {
14103           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
14104           p += 4;
14105           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14106           p += 4;
14107           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14108           p += 4;
14109           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
14110           p += 4;
14111           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14112           p += 4;
14113           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
14114           p += 4;
14115           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
14116           p += 4;
14117           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14118           p += 4;
14119           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
14120           p += 4;
14121           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14122           p += 4;
14123           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
14124           p += 4;
14125           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14126           p += 4;
14127           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
14128           p += 4;
14129         }
14130       bfd_put_32 (htab->glink->owner, BCTR, p);
14131       p += 4;
14132       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
14133
14134       /* Build the .glink lazy link call stubs.  */
14135       indx = 0;
14136       while (p < htab->glink->contents + htab->glink->size)
14137         {
14138           if (htab->opd_abi)
14139             {
14140               if (indx < 0x8000)
14141                 {
14142                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
14143                   p += 4;
14144                 }
14145               else
14146                 {
14147                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
14148                   p += 4;
14149                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
14150                               p);
14151                   p += 4;
14152                 }
14153             }
14154           bfd_put_32 (htab->glink->owner,
14155                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
14156           indx++;
14157           p += 4;
14158         }
14159     }
14160
14161   /* Build .glink global entry stubs, and PLT relocs for globals.  */
14162   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
14163
14164   if (!write_plt_relocs_for_local_syms (info))
14165     return FALSE;
14166
14167   if (htab->brlt != NULL && htab->brlt->size != 0)
14168     {
14169       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
14170                                          htab->brlt->size);
14171       if (htab->brlt->contents == NULL)
14172         return FALSE;
14173     }
14174   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
14175     {
14176       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
14177                                             htab->relbrlt->size);
14178       if (htab->relbrlt->contents == NULL)
14179         return FALSE;
14180     }
14181
14182   /* Build the stubs as directed by the stub hash table.  */
14183   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
14184
14185   for (group = htab->group; group != NULL; group = group->next)
14186     if (group->needs_save_res)
14187       group->stub_sec->size += htab->sfpr->size;
14188
14189   if (htab->relbrlt != NULL)
14190     htab->relbrlt->reloc_count = 0;
14191
14192   if (htab->params->plt_stub_align != 0)
14193     for (group = htab->group; group != NULL; group = group->next)
14194       if ((stub_sec = group->stub_sec) != NULL)
14195         {
14196           int align = abs (htab->params->plt_stub_align);
14197           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
14198         }
14199
14200   for (group = htab->group; group != NULL; group = group->next)
14201     if (group->needs_save_res)
14202       {
14203         stub_sec = group->stub_sec;
14204         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
14205                 htab->sfpr->contents, htab->sfpr->size);
14206         if (htab->params->emit_stub_syms)
14207           {
14208             unsigned int i;
14209
14210             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
14211               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
14212                 return FALSE;
14213           }
14214       }
14215
14216   for (group = htab->group; group != NULL; group = group->next)
14217     if ((stub_sec = group->stub_sec) != NULL)
14218       {
14219         stub_sec_count += 1;
14220         if (stub_sec->rawsize != stub_sec->size
14221             && (htab->stub_iteration <= STUB_SHRINK_ITER
14222                 || stub_sec->rawsize < stub_sec->size))
14223           break;
14224       }
14225
14226   if (group != NULL)
14227     {
14228       htab->stub_error = TRUE;
14229       _bfd_error_handler (_("stubs don't match calculated size"));
14230     }
14231
14232   if (htab->stub_error)
14233     return FALSE;
14234
14235   if (stats != NULL)
14236     {
14237       size_t len;
14238       *stats = bfd_malloc (500);
14239       if (*stats == NULL)
14240         return FALSE;
14241
14242       len = sprintf (*stats,
14243                      ngettext ("linker stubs in %u group\n",
14244                                "linker stubs in %u groups\n",
14245                                stub_sec_count),
14246                      stub_sec_count);
14247       sprintf (*stats + len, _("  branch         %lu\n"
14248                                "  branch toc adj %lu\n"
14249                                "  branch notoc   %lu\n"
14250                                "  branch both    %lu\n"
14251                                "  long branch    %lu\n"
14252                                "  long toc adj   %lu\n"
14253                                "  long notoc     %lu\n"
14254                                "  long both      %lu\n"
14255                                "  plt call       %lu\n"
14256                                "  plt call save  %lu\n"
14257                                "  plt call notoc %lu\n"
14258                                "  plt call both  %lu\n"
14259                                "  global entry   %lu"),
14260                htab->stub_count[ppc_stub_long_branch - 1],
14261                htab->stub_count[ppc_stub_long_branch_r2off - 1],
14262                htab->stub_count[ppc_stub_long_branch_notoc - 1],
14263                htab->stub_count[ppc_stub_long_branch_both - 1],
14264                htab->stub_count[ppc_stub_plt_branch - 1],
14265                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14266                htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14267                htab->stub_count[ppc_stub_plt_branch_both - 1],
14268                htab->stub_count[ppc_stub_plt_call - 1],
14269                htab->stub_count[ppc_stub_plt_call_r2save - 1],
14270                htab->stub_count[ppc_stub_plt_call_notoc - 1],
14271                htab->stub_count[ppc_stub_plt_call_both - 1],
14272                htab->stub_count[ppc_stub_global_entry - 1]);
14273     }
14274   return TRUE;
14275 }
14276
14277 /* What to do when ld finds relocations against symbols defined in
14278    discarded sections.  */
14279
14280 static unsigned int
14281 ppc64_elf_action_discarded (asection *sec)
14282 {
14283   if (strcmp (".opd", sec->name) == 0)
14284     return 0;
14285
14286   if (strcmp (".toc", sec->name) == 0)
14287     return 0;
14288
14289   if (strcmp (".toc1", sec->name) == 0)
14290     return 0;
14291
14292   return _bfd_elf_default_action_discarded (sec);
14293 }
14294
14295 /* The RELOCATE_SECTION function is called by the ELF backend linker
14296    to handle the relocations for a section.
14297
14298    The relocs are always passed as Rela structures; if the section
14299    actually uses Rel structures, the r_addend field will always be
14300    zero.
14301
14302    This function is responsible for adjust the section contents as
14303    necessary, and (if using Rela relocs and generating a
14304    relocatable output file) adjusting the reloc addend as
14305    necessary.
14306
14307    This function does not have to worry about setting the reloc
14308    address or the reloc symbol index.
14309
14310    LOCAL_SYMS is a pointer to the swapped in local symbols.
14311
14312    LOCAL_SECTIONS is an array giving the section in the input file
14313    corresponding to the st_shndx field of each local symbol.
14314
14315    The global hash table entry for the global symbols can be found
14316    via elf_sym_hashes (input_bfd).
14317
14318    When generating relocatable output, this function must handle
14319    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
14320    going to be the section symbol corresponding to the output
14321    section, which means that the addend must be adjusted
14322    accordingly.  */
14323
14324 static bfd_boolean
14325 ppc64_elf_relocate_section (bfd *output_bfd,
14326                             struct bfd_link_info *info,
14327                             bfd *input_bfd,
14328                             asection *input_section,
14329                             bfd_byte *contents,
14330                             Elf_Internal_Rela *relocs,
14331                             Elf_Internal_Sym *local_syms,
14332                             asection **local_sections)
14333 {
14334   struct ppc_link_hash_table *htab;
14335   Elf_Internal_Shdr *symtab_hdr;
14336   struct elf_link_hash_entry **sym_hashes;
14337   Elf_Internal_Rela *rel;
14338   Elf_Internal_Rela *wrel;
14339   Elf_Internal_Rela *relend;
14340   Elf_Internal_Rela outrel;
14341   bfd_byte *loc;
14342   struct got_entry **local_got_ents;
14343   bfd_vma TOCstart;
14344   bfd_boolean ret = TRUE;
14345   bfd_boolean is_opd;
14346   /* Assume 'at' branch hints.  */
14347   bfd_boolean is_isa_v2 = TRUE;
14348   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14349
14350   /* Initialize howto table if needed.  */
14351   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14352     ppc_howto_init ();
14353
14354   htab = ppc_hash_table (info);
14355   if (htab == NULL)
14356     return FALSE;
14357
14358   /* Don't relocate stub sections.  */
14359   if (input_section->owner == htab->params->stub_bfd)
14360     return TRUE;
14361
14362   BFD_ASSERT (is_ppc64_elf (input_bfd));
14363
14364   local_got_ents = elf_local_got_ents (input_bfd);
14365   TOCstart = elf_gp (output_bfd);
14366   symtab_hdr = &elf_symtab_hdr (input_bfd);
14367   sym_hashes = elf_sym_hashes (input_bfd);
14368   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14369
14370   rel = wrel = relocs;
14371   relend = relocs + input_section->reloc_count;
14372   for (; rel < relend; wrel++, rel++)
14373     {
14374       enum elf_ppc64_reloc_type r_type;
14375       bfd_vma addend;
14376       bfd_reloc_status_type r;
14377       Elf_Internal_Sym *sym;
14378       asection *sec;
14379       struct elf_link_hash_entry *h_elf;
14380       struct ppc_link_hash_entry *h;
14381       struct ppc_link_hash_entry *fdh;
14382       const char *sym_name;
14383       unsigned long r_symndx, toc_symndx;
14384       bfd_vma toc_addend;
14385       unsigned char tls_mask, tls_gd, tls_type;
14386       unsigned char sym_type;
14387       bfd_vma relocation;
14388       bfd_boolean unresolved_reloc, save_unresolved_reloc;
14389       bfd_boolean warned;
14390       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14391       unsigned int insn;
14392       unsigned int mask;
14393       struct ppc_stub_hash_entry *stub_entry;
14394       bfd_vma max_br_offset;
14395       bfd_vma from;
14396       Elf_Internal_Rela orig_rel;
14397       reloc_howto_type *howto;
14398       struct reloc_howto_struct alt_howto;
14399
14400     again:
14401       orig_rel = *rel;
14402
14403       r_type = ELF64_R_TYPE (rel->r_info);
14404       r_symndx = ELF64_R_SYM (rel->r_info);
14405
14406       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14407          symbol of the previous ADDR64 reloc.  The symbol gives us the
14408          proper TOC base to use.  */
14409       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14410           && wrel != relocs
14411           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14412           && is_opd)
14413         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14414
14415       sym = NULL;
14416       sec = NULL;
14417       h_elf = NULL;
14418       sym_name = NULL;
14419       unresolved_reloc = FALSE;
14420       warned = FALSE;
14421
14422       if (r_symndx < symtab_hdr->sh_info)
14423         {
14424           /* It's a local symbol.  */
14425           struct _opd_sec_data *opd;
14426
14427           sym = local_syms + r_symndx;
14428           sec = local_sections[r_symndx];
14429           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14430           sym_type = ELF64_ST_TYPE (sym->st_info);
14431           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14432           opd = get_opd_info (sec);
14433           if (opd != NULL && opd->adjust != NULL)
14434             {
14435               long adjust = opd->adjust[OPD_NDX (sym->st_value
14436                                                  + rel->r_addend)];
14437               if (adjust == -1)
14438                 relocation = 0;
14439               else
14440                 {
14441                   /* If this is a relocation against the opd section sym
14442                      and we have edited .opd, adjust the reloc addend so
14443                      that ld -r and ld --emit-relocs output is correct.
14444                      If it is a reloc against some other .opd symbol,
14445                      then the symbol value will be adjusted later.  */
14446                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14447                     rel->r_addend += adjust;
14448                   else
14449                     relocation += adjust;
14450                 }
14451             }
14452         }
14453       else
14454         {
14455           bfd_boolean ignored;
14456
14457           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14458                                    r_symndx, symtab_hdr, sym_hashes,
14459                                    h_elf, sec, relocation,
14460                                    unresolved_reloc, warned, ignored);
14461           sym_name = h_elf->root.root.string;
14462           sym_type = h_elf->type;
14463           if (sec != NULL
14464               && sec->owner == output_bfd
14465               && strcmp (sec->name, ".opd") == 0)
14466             {
14467               /* This is a symbol defined in a linker script.  All
14468                  such are defined in output sections, even those
14469                  defined by simple assignment from a symbol defined in
14470                  an input section.  Transfer the symbol to an
14471                  appropriate input .opd section, so that a branch to
14472                  this symbol will be mapped to the location specified
14473                  by the opd entry.  */
14474               struct bfd_link_order *lo;
14475               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14476                 if (lo->type == bfd_indirect_link_order)
14477                   {
14478                     asection *isec = lo->u.indirect.section;
14479                     if (h_elf->root.u.def.value >= isec->output_offset
14480                         && h_elf->root.u.def.value < (isec->output_offset
14481                                                       + isec->size))
14482                       {
14483                         h_elf->root.u.def.value -= isec->output_offset;
14484                         h_elf->root.u.def.section = isec;
14485                         sec = isec;
14486                         break;
14487                       }
14488                   }
14489             }
14490         }
14491       h = (struct ppc_link_hash_entry *) h_elf;
14492
14493       if (sec != NULL && discarded_section (sec))
14494         {
14495           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14496                                input_bfd, input_section,
14497                                contents + rel->r_offset);
14498           wrel->r_offset = rel->r_offset;
14499           wrel->r_info = 0;
14500           wrel->r_addend = 0;
14501
14502           /* For ld -r, remove relocations in debug sections against
14503              symbols defined in discarded sections.  Not done for
14504              non-debug to preserve relocs in .eh_frame which the
14505              eh_frame editing code expects to be present.  */
14506           if (bfd_link_relocatable (info)
14507               && (input_section->flags & SEC_DEBUGGING))
14508             wrel--;
14509
14510           continue;
14511         }
14512
14513       if (bfd_link_relocatable (info))
14514         goto copy_reloc;
14515
14516       if (h != NULL && &h->elf == htab->elf.hgot)
14517         {
14518           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14519           sec = bfd_abs_section_ptr;
14520           unresolved_reloc = FALSE;
14521         }
14522
14523       /* TLS optimizations.  Replace instruction sequences and relocs
14524          based on information we collected in tls_optimize.  We edit
14525          RELOCS so that --emit-relocs will output something sensible
14526          for the final instruction stream.  */
14527       tls_mask = 0;
14528       tls_gd = 0;
14529       toc_symndx = 0;
14530       if (h != NULL)
14531         tls_mask = h->tls_mask;
14532       else if (local_got_ents != NULL)
14533         {
14534           struct plt_entry **local_plt = (struct plt_entry **)
14535             (local_got_ents + symtab_hdr->sh_info);
14536           unsigned char *lgot_masks = (unsigned char *)
14537             (local_plt + symtab_hdr->sh_info);
14538           tls_mask = lgot_masks[r_symndx];
14539         }
14540       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14541           && (r_type == R_PPC64_TLS
14542               || r_type == R_PPC64_TLSGD
14543               || r_type == R_PPC64_TLSLD))
14544         {
14545           /* Check for toc tls entries.  */
14546           unsigned char *toc_tls;
14547
14548           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14549                              &local_syms, rel, input_bfd))
14550             return FALSE;
14551
14552           if (toc_tls)
14553             tls_mask = *toc_tls;
14554         }
14555
14556       /* Check that tls relocs are used with tls syms, and non-tls
14557          relocs are used with non-tls syms.  */
14558       if (r_symndx != STN_UNDEF
14559           && r_type != R_PPC64_NONE
14560           && (h == NULL
14561               || h->elf.root.type == bfd_link_hash_defined
14562               || h->elf.root.type == bfd_link_hash_defweak)
14563           && (IS_PPC64_TLS_RELOC (r_type)
14564               != (sym_type == STT_TLS
14565                   || (sym_type == STT_SECTION
14566                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14567         {
14568           if ((tls_mask & TLS_TLS) != 0
14569               && (r_type == R_PPC64_TLS
14570                   || r_type == R_PPC64_TLSGD
14571                   || r_type == R_PPC64_TLSLD))
14572             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14573             ;
14574           else
14575             info->callbacks->einfo
14576               (!IS_PPC64_TLS_RELOC (r_type)
14577                /* xgettext:c-format */
14578                ? _("%H: %s used with TLS symbol `%pT'\n")
14579                /* xgettext:c-format */
14580                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14581                input_bfd, input_section, rel->r_offset,
14582                ppc64_elf_howto_table[r_type]->name,
14583                sym_name);
14584         }
14585
14586       /* Ensure reloc mapping code below stays sane.  */
14587       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14588           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14589           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14590           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14591           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14592           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14593           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14594           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14595           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14596           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14597         abort ();
14598
14599       switch (r_type)
14600         {
14601         default:
14602           break;
14603
14604         case R_PPC64_LO_DS_OPT:
14605           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14606           if ((insn & (0x3f << 26)) != 58u << 26)
14607             abort ();
14608           insn += (14u << 26) - (58u << 26);
14609           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14610           r_type = R_PPC64_TOC16_LO;
14611           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14612           break;
14613
14614         case R_PPC64_TOC16:
14615         case R_PPC64_TOC16_LO:
14616         case R_PPC64_TOC16_DS:
14617         case R_PPC64_TOC16_LO_DS:
14618           {
14619             /* Check for toc tls entries.  */
14620             unsigned char *toc_tls;
14621             int retval;
14622
14623             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14624                                    &local_syms, rel, input_bfd);
14625             if (retval == 0)
14626               return FALSE;
14627
14628             if (toc_tls)
14629               {
14630                 tls_mask = *toc_tls;
14631                 if (r_type == R_PPC64_TOC16_DS
14632                     || r_type == R_PPC64_TOC16_LO_DS)
14633                   {
14634                     if ((tls_mask & TLS_TLS) != 0
14635                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14636                       goto toctprel;
14637                   }
14638                 else
14639                   {
14640                     /* If we found a GD reloc pair, then we might be
14641                        doing a GD->IE transition.  */
14642                     if (retval == 2)
14643                       {
14644                         tls_gd = TLS_TPRELGD;
14645                         if ((tls_mask & TLS_TLS) != 0
14646                             && (tls_mask & TLS_GD) == 0)
14647                           goto tls_ldgd_opt;
14648                       }
14649                     else if (retval == 3)
14650                       {
14651                         if ((tls_mask & TLS_TLS) != 0
14652                             && (tls_mask & TLS_LD) == 0)
14653                           goto tls_ldgd_opt;
14654                       }
14655                   }
14656               }
14657           }
14658           break;
14659
14660         case R_PPC64_GOT_TPREL16_HI:
14661         case R_PPC64_GOT_TPREL16_HA:
14662           if ((tls_mask & TLS_TLS) != 0
14663               && (tls_mask & TLS_TPREL) == 0)
14664             {
14665               rel->r_offset -= d_offset;
14666               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14667               r_type = R_PPC64_NONE;
14668               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14669             }
14670           break;
14671
14672         case R_PPC64_GOT_TPREL16_DS:
14673         case R_PPC64_GOT_TPREL16_LO_DS:
14674           if ((tls_mask & TLS_TLS) != 0
14675               && (tls_mask & TLS_TPREL) == 0)
14676             {
14677             toctprel:
14678               insn = bfd_get_32 (input_bfd,
14679                                  contents + rel->r_offset - d_offset);
14680               insn &= 31 << 21;
14681               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14682               bfd_put_32 (input_bfd, insn,
14683                           contents + rel->r_offset - d_offset);
14684               r_type = R_PPC64_TPREL16_HA;
14685               if (toc_symndx != 0)
14686                 {
14687                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14688                   rel->r_addend = toc_addend;
14689                   /* We changed the symbol.  Start over in order to
14690                      get h, sym, sec etc. right.  */
14691                   goto again;
14692                 }
14693               else
14694                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14695             }
14696           break;
14697
14698         case R_PPC64_TLS:
14699           if ((tls_mask & TLS_TLS) != 0
14700               && (tls_mask & TLS_TPREL) == 0)
14701             {
14702               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14703               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14704               if (insn == 0)
14705                 abort ();
14706               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14707               /* Was PPC64_TLS which sits on insn boundary, now
14708                  PPC64_TPREL16_LO which is at low-order half-word.  */
14709               rel->r_offset += d_offset;
14710               r_type = R_PPC64_TPREL16_LO;
14711               if (toc_symndx != 0)
14712                 {
14713                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14714                   rel->r_addend = toc_addend;
14715                   /* We changed the symbol.  Start over in order to
14716                      get h, sym, sec etc. right.  */
14717                   goto again;
14718                 }
14719               else
14720                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14721             }
14722           break;
14723
14724         case R_PPC64_GOT_TLSGD16_HI:
14725         case R_PPC64_GOT_TLSGD16_HA:
14726           tls_gd = TLS_TPRELGD;
14727           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14728             goto tls_gdld_hi;
14729           break;
14730
14731         case R_PPC64_GOT_TLSLD16_HI:
14732         case R_PPC64_GOT_TLSLD16_HA:
14733           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14734             {
14735             tls_gdld_hi:
14736               if ((tls_mask & tls_gd) != 0)
14737                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14738                           + R_PPC64_GOT_TPREL16_DS);
14739               else
14740                 {
14741                   rel->r_offset -= d_offset;
14742                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14743                   r_type = R_PPC64_NONE;
14744                 }
14745               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14746             }
14747           break;
14748
14749         case R_PPC64_GOT_TLSGD16:
14750         case R_PPC64_GOT_TLSGD16_LO:
14751           tls_gd = TLS_TPRELGD;
14752           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14753             goto tls_ldgd_opt;
14754           break;
14755
14756         case R_PPC64_GOT_TLSLD16:
14757         case R_PPC64_GOT_TLSLD16_LO:
14758           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14759             {
14760               unsigned int insn1, insn2;
14761               bfd_vma offset;
14762
14763             tls_ldgd_opt:
14764               offset = (bfd_vma) -1;
14765               /* If not using the newer R_PPC64_TLSGD/LD to mark
14766                  __tls_get_addr calls, we must trust that the call
14767                  stays with its arg setup insns, ie. that the next
14768                  reloc is the __tls_get_addr call associated with
14769                  the current reloc.  Edit both insns.  */
14770               if (input_section->has_tls_get_addr_call
14771                   && rel + 1 < relend
14772                   && branch_reloc_hash_match (input_bfd, rel + 1,
14773                                               htab->tls_get_addr,
14774                                               htab->tls_get_addr_fd))
14775                 offset = rel[1].r_offset;
14776               /* We read the low GOT_TLS (or TOC16) insn because we
14777                  need to keep the destination reg.  It may be
14778                  something other than the usual r3, and moved to r3
14779                  before the call by intervening code.  */
14780               insn1 = bfd_get_32 (input_bfd,
14781                                   contents + rel->r_offset - d_offset);
14782               if ((tls_mask & tls_gd) != 0)
14783                 {
14784                   /* IE */
14785                   insn1 &= (0x1f << 21) | (0x1f << 16);
14786                   insn1 |= 58 << 26;    /* ld */
14787                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14788                   if (offset != (bfd_vma) -1)
14789                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14790                   if ((tls_mask & TLS_EXPLICIT) == 0)
14791                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14792                               + R_PPC64_GOT_TPREL16_DS);
14793                   else
14794                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14795                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14796                 }
14797               else
14798                 {
14799                   /* LE */
14800                   insn1 &= 0x1f << 21;
14801                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14802                   insn2 = 0x38630000;   /* addi 3,3,0 */
14803                   if (tls_gd == 0)
14804                     {
14805                       /* Was an LD reloc.  */
14806                       if (toc_symndx)
14807                         sec = local_sections[toc_symndx];
14808                       for (r_symndx = 0;
14809                            r_symndx < symtab_hdr->sh_info;
14810                            r_symndx++)
14811                         if (local_sections[r_symndx] == sec)
14812                           break;
14813                       if (r_symndx >= symtab_hdr->sh_info)
14814                         r_symndx = STN_UNDEF;
14815                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14816                       if (r_symndx != STN_UNDEF)
14817                         rel->r_addend -= (local_syms[r_symndx].st_value
14818                                           + sec->output_offset
14819                                           + sec->output_section->vma);
14820                     }
14821                   else if (toc_symndx != 0)
14822                     {
14823                       r_symndx = toc_symndx;
14824                       rel->r_addend = toc_addend;
14825                     }
14826                   r_type = R_PPC64_TPREL16_HA;
14827                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14828                   if (offset != (bfd_vma) -1)
14829                     {
14830                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14831                                                     R_PPC64_TPREL16_LO);
14832                       rel[1].r_offset = offset + d_offset;
14833                       rel[1].r_addend = rel->r_addend;
14834                     }
14835                 }
14836               bfd_put_32 (input_bfd, insn1,
14837                           contents + rel->r_offset - d_offset);
14838               if (offset != (bfd_vma) -1)
14839                 bfd_put_32 (input_bfd, insn2, contents + offset);
14840               if ((tls_mask & tls_gd) == 0
14841                   && (tls_gd == 0 || toc_symndx != 0))
14842                 {
14843                   /* We changed the symbol.  Start over in order
14844                      to get h, sym, sec etc. right.  */
14845                   goto again;
14846                 }
14847             }
14848           break;
14849
14850         case R_PPC64_TLSGD:
14851           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14852               && rel + 1 < relend)
14853             {
14854               unsigned int insn2;
14855               bfd_vma offset = rel->r_offset;
14856
14857               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14858                 {
14859                   bfd_put_32 (output_bfd, NOP, contents + offset);
14860                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14861                   break;
14862                 }
14863
14864               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14865                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14866
14867               if ((tls_mask & TLS_TPRELGD) != 0)
14868                 {
14869                   /* IE */
14870                   r_type = R_PPC64_NONE;
14871                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14872                 }
14873               else
14874                 {
14875                   /* LE */
14876                   if (toc_symndx != 0)
14877                     {
14878                       r_symndx = toc_symndx;
14879                       rel->r_addend = toc_addend;
14880                     }
14881                   r_type = R_PPC64_TPREL16_LO;
14882                   rel->r_offset = offset + d_offset;
14883                   insn2 = 0x38630000;   /* addi 3,3,0 */
14884                 }
14885               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14886               /* Zap the reloc on the _tls_get_addr call too.  */
14887               BFD_ASSERT (offset == rel[1].r_offset);
14888               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14889               bfd_put_32 (input_bfd, insn2, contents + offset);
14890               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14891                 goto again;
14892             }
14893           break;
14894
14895         case R_PPC64_TLSLD:
14896           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14897               && rel + 1 < relend)
14898             {
14899               unsigned int insn2;
14900               bfd_vma offset = rel->r_offset;
14901
14902               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14903                 {
14904                   bfd_put_32 (output_bfd, NOP, contents + offset);
14905                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14906                   break;
14907                 }
14908
14909               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14910                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14911
14912               if (toc_symndx)
14913                 sec = local_sections[toc_symndx];
14914               for (r_symndx = 0;
14915                    r_symndx < symtab_hdr->sh_info;
14916                    r_symndx++)
14917                 if (local_sections[r_symndx] == sec)
14918                   break;
14919               if (r_symndx >= symtab_hdr->sh_info)
14920                 r_symndx = STN_UNDEF;
14921               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14922               if (r_symndx != STN_UNDEF)
14923                 rel->r_addend -= (local_syms[r_symndx].st_value
14924                                   + sec->output_offset
14925                                   + sec->output_section->vma);
14926
14927               r_type = R_PPC64_TPREL16_LO;
14928               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14929               rel->r_offset = offset + d_offset;
14930               /* Zap the reloc on the _tls_get_addr call too.  */
14931               BFD_ASSERT (offset == rel[1].r_offset);
14932               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14933               insn2 = 0x38630000;       /* addi 3,3,0 */
14934               bfd_put_32 (input_bfd, insn2, contents + offset);
14935               goto again;
14936             }
14937           break;
14938
14939         case R_PPC64_DTPMOD64:
14940           if (rel + 1 < relend
14941               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14942               && rel[1].r_offset == rel->r_offset + 8)
14943             {
14944               if ((tls_mask & TLS_GD) == 0)
14945                 {
14946                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14947                   if ((tls_mask & TLS_TPRELGD) != 0)
14948                     r_type = R_PPC64_TPREL64;
14949                   else
14950                     {
14951                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14952                       r_type = R_PPC64_NONE;
14953                     }
14954                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14955                 }
14956             }
14957           else
14958             {
14959               if ((tls_mask & TLS_LD) == 0)
14960                 {
14961                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14962                   r_type = R_PPC64_NONE;
14963                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14964                 }
14965             }
14966           break;
14967
14968         case R_PPC64_TPREL64:
14969           if ((tls_mask & TLS_TPREL) == 0)
14970             {
14971               r_type = R_PPC64_NONE;
14972               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14973             }
14974           break;
14975
14976         case R_PPC64_ENTRY:
14977           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14978           if (!bfd_link_pic (info)
14979               && !info->traditional_format
14980               && relocation + 0x80008000 <= 0xffffffff)
14981             {
14982               unsigned int insn1, insn2;
14983
14984               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14985               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14986               if ((insn1 & ~0xfffc) == LD_R2_0R12
14987                   && insn2 == ADD_R2_R2_R12)
14988                 {
14989                   bfd_put_32 (input_bfd,
14990                               LIS_R2 + PPC_HA (relocation),
14991                               contents + rel->r_offset);
14992                   bfd_put_32 (input_bfd,
14993                               ADDI_R2_R2 + PPC_LO (relocation),
14994                               contents + rel->r_offset + 4);
14995                 }
14996             }
14997           else
14998             {
14999               relocation -= (rel->r_offset
15000                              + input_section->output_offset
15001                              + input_section->output_section->vma);
15002               if (relocation + 0x80008000 <= 0xffffffff)
15003                 {
15004                   unsigned int insn1, insn2;
15005
15006                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15007                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15008                   if ((insn1 & ~0xfffc) == LD_R2_0R12
15009                       && insn2 == ADD_R2_R2_R12)
15010                     {
15011                       bfd_put_32 (input_bfd,
15012                                   ADDIS_R2_R12 + PPC_HA (relocation),
15013                                   contents + rel->r_offset);
15014                       bfd_put_32 (input_bfd,
15015                                   ADDI_R2_R2 + PPC_LO (relocation),
15016                                   contents + rel->r_offset + 4);
15017                     }
15018                 }
15019             }
15020           break;
15021
15022         case R_PPC64_REL16_HA:
15023           /* If we are generating a non-PIC executable, edit
15024              .  0:      addis 2,12,.TOC.-0b@ha
15025              .          addi 2,2,.TOC.-0b@l
15026              used by ELFv2 global entry points to set up r2, to
15027              .          lis 2,.TOC.@ha
15028              .          addi 2,2,.TOC.@l
15029              if .TOC. is in range.  */
15030           if (!bfd_link_pic (info)
15031               && !info->traditional_format
15032               && !htab->opd_abi
15033               && rel->r_addend == d_offset
15034               && h != NULL && &h->elf == htab->elf.hgot
15035               && rel + 1 < relend
15036               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
15037               && rel[1].r_offset == rel->r_offset + 4
15038               && rel[1].r_addend == rel->r_addend + 4
15039               && relocation + 0x80008000 <= 0xffffffff)
15040             {
15041               unsigned int insn1, insn2;
15042               bfd_vma offset = rel->r_offset - d_offset;
15043               insn1 = bfd_get_32 (input_bfd, contents + offset);
15044               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
15045               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
15046                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
15047                 {
15048                   r_type = R_PPC64_ADDR16_HA;
15049                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15050                   rel->r_addend -= d_offset;
15051                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
15052                   rel[1].r_addend -= d_offset + 4;
15053                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
15054                 }
15055             }
15056           break;
15057         }
15058
15059       /* Handle other relocations that tweak non-addend part of insn.  */
15060       insn = 0;
15061       max_br_offset = 1 << 25;
15062       addend = rel->r_addend;
15063       reloc_dest = DEST_NORMAL;
15064       switch (r_type)
15065         {
15066         default:
15067           break;
15068
15069         case R_PPC64_TOCSAVE:
15070           if (relocation + addend == (rel->r_offset
15071                                       + input_section->output_offset
15072                                       + input_section->output_section->vma)
15073               && tocsave_find (htab, NO_INSERT,
15074                                &local_syms, rel, input_bfd))
15075             {
15076               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15077               if (insn == NOP
15078                   || insn == CROR_151515 || insn == CROR_313131)
15079                 bfd_put_32 (input_bfd,
15080                             STD_R2_0R1 + STK_TOC (htab),
15081                             contents + rel->r_offset);
15082             }
15083           break;
15084
15085           /* Branch taken prediction relocations.  */
15086         case R_PPC64_ADDR14_BRTAKEN:
15087         case R_PPC64_REL14_BRTAKEN:
15088           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
15089           /* Fall through.  */
15090
15091           /* Branch not taken prediction relocations.  */
15092         case R_PPC64_ADDR14_BRNTAKEN:
15093         case R_PPC64_REL14_BRNTAKEN:
15094           insn |= bfd_get_32 (input_bfd,
15095                               contents + rel->r_offset) & ~(0x01 << 21);
15096           /* Fall through.  */
15097
15098         case R_PPC64_REL14:
15099           max_br_offset = 1 << 15;
15100           /* Fall through.  */
15101
15102         case R_PPC64_REL24:
15103         case R_PPC64_REL24_NOTOC:
15104         case R_PPC64_PLTCALL:
15105           /* Calls to functions with a different TOC, such as calls to
15106              shared objects, need to alter the TOC pointer.  This is
15107              done using a linkage stub.  A REL24 branching to these
15108              linkage stubs needs to be followed by a nop, as the nop
15109              will be replaced with an instruction to restore the TOC
15110              base pointer.  */
15111           fdh = h;
15112           if (h != NULL
15113               && h->oh != NULL
15114               && h->oh->is_func_descriptor)
15115             fdh = ppc_follow_link (h->oh);
15116           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15117                                            htab);
15118           if (r_type == R_PPC64_PLTCALL
15119               && stub_entry != NULL
15120               && stub_entry->stub_type >= ppc_stub_plt_call
15121               && stub_entry->stub_type <= ppc_stub_plt_call_both)
15122             stub_entry = NULL;
15123
15124           if (stub_entry != NULL
15125               && (stub_entry->stub_type == ppc_stub_plt_call
15126                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
15127                   || stub_entry->stub_type == ppc_stub_plt_call_both
15128                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15129                   || stub_entry->stub_type == ppc_stub_plt_branch_both
15130                   || stub_entry->stub_type == ppc_stub_long_branch_r2off
15131                   || stub_entry->stub_type == ppc_stub_long_branch_both))
15132             {
15133               bfd_boolean can_plt_call = FALSE;
15134
15135               if (stub_entry->stub_type == ppc_stub_plt_call
15136                   && !htab->opd_abi
15137                   && htab->params->plt_localentry0 != 0
15138                   && is_elfv2_localentry0 (&h->elf))
15139                 {
15140                   /* The function doesn't use or change r2.  */
15141                   can_plt_call = TRUE;
15142                 }
15143               else if (r_type == R_PPC64_REL24_NOTOC)
15144                 {
15145                   /* NOTOC calls don't need to restore r2.  */
15146                   can_plt_call = TRUE;
15147                 }
15148
15149               /* All of these stubs may modify r2, so there must be a
15150                  branch and link followed by a nop.  The nop is
15151                  replaced by an insn to restore r2.  */
15152               else if (rel->r_offset + 8 <= input_section->size)
15153                 {
15154                   unsigned long br;
15155
15156                   br = bfd_get_32 (input_bfd,
15157                                    contents + rel->r_offset);
15158                   if ((br & 1) != 0)
15159                     {
15160                       unsigned long nop;
15161
15162                       nop = bfd_get_32 (input_bfd,
15163                                         contents + rel->r_offset + 4);
15164                       if (nop == LD_R2_0R1 + STK_TOC (htab))
15165                         can_plt_call = TRUE;
15166                       else if (nop == NOP
15167                                || nop == CROR_151515
15168                                || nop == CROR_313131)
15169                         {
15170                           if (h != NULL
15171                               && (h == htab->tls_get_addr_fd
15172                                   || h == htab->tls_get_addr)
15173                               && htab->params->tls_get_addr_opt)
15174                             {
15175                               /* Special stub used, leave nop alone.  */
15176                             }
15177                           else
15178                             bfd_put_32 (input_bfd,
15179                                         LD_R2_0R1 + STK_TOC (htab),
15180                                         contents + rel->r_offset + 4);
15181                           can_plt_call = TRUE;
15182                         }
15183                     }
15184                 }
15185
15186               if (!can_plt_call && h != NULL)
15187                 {
15188                   const char *name = h->elf.root.root.string;
15189
15190                   if (*name == '.')
15191                     ++name;
15192
15193                   if (strncmp (name, "__libc_start_main", 17) == 0
15194                       && (name[17] == 0 || name[17] == '@'))
15195                     {
15196                       /* Allow crt1 branch to go via a toc adjusting
15197                          stub.  Other calls that never return could do
15198                          the same, if we could detect such.  */
15199                       can_plt_call = TRUE;
15200                     }
15201                 }
15202
15203               if (!can_plt_call)
15204                 {
15205                   /* g++ as of 20130507 emits self-calls without a
15206                      following nop.  This is arguably wrong since we
15207                      have conflicting information.  On the one hand a
15208                      global symbol and on the other a local call
15209                      sequence, but don't error for this special case.
15210                      It isn't possible to cheaply verify we have
15211                      exactly such a call.  Allow all calls to the same
15212                      section.  */
15213                   asection *code_sec = sec;
15214
15215                   if (get_opd_info (sec) != NULL)
15216                     {
15217                       bfd_vma off = (relocation + addend
15218                                      - sec->output_section->vma
15219                                      - sec->output_offset);
15220
15221                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15222                     }
15223                   if (code_sec == input_section)
15224                     can_plt_call = TRUE;
15225                 }
15226
15227               if (!can_plt_call)
15228                 {
15229                   if (stub_entry->stub_type >= ppc_stub_plt_call
15230                       && stub_entry->stub_type <= ppc_stub_plt_call_both)
15231                     info->callbacks->einfo
15232                       /* xgettext:c-format */
15233                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
15234                          "recompile with -fPIC\n"),
15235                        input_bfd, input_section, rel->r_offset, sym_name);
15236                   else
15237                     info->callbacks->einfo
15238                       /* xgettext:c-format */
15239                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
15240                          "(-mcmodel=small toc adjust stub)\n"),
15241                        input_bfd, input_section, rel->r_offset, sym_name);
15242
15243                   bfd_set_error (bfd_error_bad_value);
15244                   ret = FALSE;
15245                 }
15246
15247               if (can_plt_call
15248                   && stub_entry->stub_type >= ppc_stub_plt_call
15249                   && stub_entry->stub_type <= ppc_stub_plt_call_both)
15250                 unresolved_reloc = FALSE;
15251             }
15252
15253           if ((stub_entry == NULL
15254                || stub_entry->stub_type == ppc_stub_long_branch
15255                || stub_entry->stub_type == ppc_stub_plt_branch)
15256               && get_opd_info (sec) != NULL)
15257             {
15258               /* The branch destination is the value of the opd entry. */
15259               bfd_vma off = (relocation + addend
15260                              - sec->output_section->vma
15261                              - sec->output_offset);
15262               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15263               if (dest != (bfd_vma) -1)
15264                 {
15265                   relocation = dest;
15266                   addend = 0;
15267                   reloc_dest = DEST_OPD;
15268                 }
15269             }
15270
15271           /* If the branch is out of reach we ought to have a long
15272              branch stub.  */
15273           from = (rel->r_offset
15274                   + input_section->output_offset
15275                   + input_section->output_section->vma);
15276
15277           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15278                                                   ? fdh->elf.other
15279                                                   : sym->st_other);
15280
15281           if (stub_entry != NULL
15282               && (stub_entry->stub_type == ppc_stub_long_branch
15283                   || stub_entry->stub_type == ppc_stub_plt_branch)
15284               && (r_type == R_PPC64_ADDR14_BRTAKEN
15285                   || r_type == R_PPC64_ADDR14_BRNTAKEN
15286                   || (relocation + addend - from + max_br_offset
15287                       < 2 * max_br_offset)))
15288             /* Don't use the stub if this branch is in range.  */
15289             stub_entry = NULL;
15290
15291           if (stub_entry != NULL
15292               && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15293                   || stub_entry->stub_type == ppc_stub_long_branch_both
15294                   || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15295                   || stub_entry->stub_type == ppc_stub_plt_branch_both)
15296               && (r_type != R_PPC64_REL24_NOTOC
15297                   || ((fdh ? fdh->elf.other : sym->st_other)
15298                       & STO_PPC64_LOCAL_MASK) == 1 << STO_PPC64_LOCAL_BIT)
15299               && (relocation + addend - from + max_br_offset
15300                   < 2 * max_br_offset))
15301             stub_entry = NULL;
15302
15303           if (stub_entry != NULL
15304               && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15305                   || stub_entry->stub_type == ppc_stub_long_branch_both
15306                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15307                   || stub_entry->stub_type == ppc_stub_plt_branch_both)
15308               && r_type == R_PPC64_REL24_NOTOC
15309               && (relocation + addend - from + max_br_offset
15310                   < 2 * max_br_offset))
15311             stub_entry = NULL;
15312
15313           if (stub_entry != NULL)
15314             {
15315               /* Munge up the value and addend so that we call the stub
15316                  rather than the procedure directly.  */
15317               asection *stub_sec = stub_entry->group->stub_sec;
15318
15319               if (stub_entry->stub_type == ppc_stub_save_res)
15320                 relocation += (stub_sec->output_offset
15321                                + stub_sec->output_section->vma
15322                                + stub_sec->size - htab->sfpr->size
15323                                - htab->sfpr->output_offset
15324                                - htab->sfpr->output_section->vma);
15325               else
15326                 relocation = (stub_entry->stub_offset
15327                               + stub_sec->output_offset
15328                               + stub_sec->output_section->vma);
15329               addend = 0;
15330               reloc_dest = DEST_STUB;
15331
15332               if (((stub_entry->stub_type == ppc_stub_plt_call
15333                     && ALWAYS_EMIT_R2SAVE)
15334                    || stub_entry->stub_type == ppc_stub_plt_call_r2save
15335                    || stub_entry->stub_type == ppc_stub_plt_call_both)
15336                   && !(h != NULL
15337                        && (h == htab->tls_get_addr_fd
15338                            || h == htab->tls_get_addr)
15339                        && htab->params->tls_get_addr_opt)
15340                   && rel + 1 < relend
15341                   && rel[1].r_offset == rel->r_offset + 4
15342                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15343                 relocation += 4;
15344               else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15345                         || stub_entry->stub_type == ppc_stub_plt_branch_both
15346                         || stub_entry->stub_type == ppc_stub_plt_call_both)
15347                        && r_type == R_PPC64_REL24_NOTOC)
15348                 relocation += 4;
15349             }
15350
15351           if (insn != 0)
15352             {
15353               if (is_isa_v2)
15354                 {
15355                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
15356                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
15357                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
15358                   if ((insn & (0x14 << 21)) == (0x04 << 21))
15359                     insn |= 0x02 << 21;
15360                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
15361                     insn |= 0x08 << 21;
15362                   else
15363                     break;
15364                 }
15365               else
15366                 {
15367                   /* Invert 'y' bit if not the default.  */
15368                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
15369                     insn ^= 0x01 << 21;
15370                 }
15371
15372               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15373             }
15374
15375           /* NOP out calls to undefined weak functions.
15376              We can thus call a weak function without first
15377              checking whether the function is defined.  */
15378           else if (h != NULL
15379                    && h->elf.root.type == bfd_link_hash_undefweak
15380                    && h->elf.dynindx == -1
15381                    && (r_type == R_PPC64_REL24
15382                        || r_type == R_PPC64_REL24_NOTOC)
15383                    && relocation == 0
15384                    && addend == 0)
15385             {
15386               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15387               goto copy_reloc;
15388             }
15389           break;
15390         }
15391
15392       /* Set `addend'.  */
15393       tls_type = 0;
15394       save_unresolved_reloc = unresolved_reloc;
15395       switch (r_type)
15396         {
15397         default:
15398           /* xgettext:c-format */
15399           _bfd_error_handler (_("%pB: %s unsupported"),
15400                               input_bfd, ppc64_elf_howto_table[r_type]->name);
15401
15402           bfd_set_error (bfd_error_bad_value);
15403           ret = FALSE;
15404           goto copy_reloc;
15405
15406         case R_PPC64_NONE:
15407         case R_PPC64_TLS:
15408         case R_PPC64_TLSGD:
15409         case R_PPC64_TLSLD:
15410         case R_PPC64_TOCSAVE:
15411         case R_PPC64_GNU_VTINHERIT:
15412         case R_PPC64_GNU_VTENTRY:
15413         case R_PPC64_ENTRY:
15414           goto copy_reloc;
15415
15416           /* GOT16 relocations.  Like an ADDR16 using the symbol's
15417              address in the GOT as relocation value instead of the
15418              symbol's value itself.  Also, create a GOT entry for the
15419              symbol and put the symbol value there.  */
15420         case R_PPC64_GOT_TLSGD16:
15421         case R_PPC64_GOT_TLSGD16_LO:
15422         case R_PPC64_GOT_TLSGD16_HI:
15423         case R_PPC64_GOT_TLSGD16_HA:
15424           tls_type = TLS_TLS | TLS_GD;
15425           goto dogot;
15426
15427         case R_PPC64_GOT_TLSLD16:
15428         case R_PPC64_GOT_TLSLD16_LO:
15429         case R_PPC64_GOT_TLSLD16_HI:
15430         case R_PPC64_GOT_TLSLD16_HA:
15431           tls_type = TLS_TLS | TLS_LD;
15432           goto dogot;
15433
15434         case R_PPC64_GOT_TPREL16_DS:
15435         case R_PPC64_GOT_TPREL16_LO_DS:
15436         case R_PPC64_GOT_TPREL16_HI:
15437         case R_PPC64_GOT_TPREL16_HA:
15438           tls_type = TLS_TLS | TLS_TPREL;
15439           goto dogot;
15440
15441         case R_PPC64_GOT_DTPREL16_DS:
15442         case R_PPC64_GOT_DTPREL16_LO_DS:
15443         case R_PPC64_GOT_DTPREL16_HI:
15444         case R_PPC64_GOT_DTPREL16_HA:
15445           tls_type = TLS_TLS | TLS_DTPREL;
15446           goto dogot;
15447
15448         case R_PPC64_GOT16:
15449         case R_PPC64_GOT16_LO:
15450         case R_PPC64_GOT16_HI:
15451         case R_PPC64_GOT16_HA:
15452         case R_PPC64_GOT16_DS:
15453         case R_PPC64_GOT16_LO_DS:
15454         dogot:
15455           {
15456             /* Relocation is to the entry for this symbol in the global
15457                offset table.  */
15458             asection *got;
15459             bfd_vma *offp;
15460             bfd_vma off;
15461             unsigned long indx = 0;
15462             struct got_entry *ent;
15463
15464             if (tls_type == (TLS_TLS | TLS_LD)
15465                 && (h == NULL
15466                     || !h->elf.def_dynamic))
15467               ent = ppc64_tlsld_got (input_bfd);
15468             else
15469               {
15470                 if (h != NULL)
15471                   {
15472                     if (!htab->elf.dynamic_sections_created
15473                         || h->elf.dynindx == -1
15474                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15475                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15476                       /* This is actually a static link, or it is a
15477                          -Bsymbolic link and the symbol is defined
15478                          locally, or the symbol was forced to be local
15479                          because of a version file.  */
15480                       ;
15481                     else
15482                       {
15483                         indx = h->elf.dynindx;
15484                         unresolved_reloc = FALSE;
15485                       }
15486                     ent = h->elf.got.glist;
15487                   }
15488                 else
15489                   {
15490                     if (local_got_ents == NULL)
15491                       abort ();
15492                     ent = local_got_ents[r_symndx];
15493                   }
15494
15495                 for (; ent != NULL; ent = ent->next)
15496                   if (ent->addend == orig_rel.r_addend
15497                       && ent->owner == input_bfd
15498                       && ent->tls_type == tls_type)
15499                     break;
15500               }
15501
15502             if (ent == NULL)
15503               abort ();
15504             if (ent->is_indirect)
15505               ent = ent->got.ent;
15506             offp = &ent->got.offset;
15507             got = ppc64_elf_tdata (ent->owner)->got;
15508             if (got == NULL)
15509               abort ();
15510
15511             /* The offset must always be a multiple of 8.  We use the
15512                least significant bit to record whether we have already
15513                processed this entry.  */
15514             off = *offp;
15515             if ((off & 1) != 0)
15516               off &= ~1;
15517             else
15518               {
15519                 /* Generate relocs for the dynamic linker, except in
15520                    the case of TLSLD where we'll use one entry per
15521                    module.  */
15522                 asection *relgot;
15523                 bfd_boolean ifunc;
15524
15525                 *offp = off | 1;
15526                 relgot = NULL;
15527                 ifunc = (h != NULL
15528                          ? h->elf.type == STT_GNU_IFUNC
15529                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15530                 if (ifunc)
15531                   {
15532                     relgot = htab->elf.irelplt;
15533                     if (indx == 0)
15534                       htab->local_ifunc_resolver = 1;
15535                     else if (is_static_defined (&h->elf))
15536                       htab->maybe_local_ifunc_resolver = 1;
15537                   }
15538                 else if (indx != 0
15539                          || (bfd_link_pic (info)
15540                              && (h == NULL
15541                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15542                                  || (tls_type == (TLS_TLS | TLS_LD)
15543                                      && !h->elf.def_dynamic))
15544                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15545                                   && bfd_link_executable (info)
15546                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15547                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15548                 if (relgot != NULL)
15549                   {
15550                     outrel.r_offset = (got->output_section->vma
15551                                        + got->output_offset
15552                                        + off);
15553                     outrel.r_addend = addend;
15554                     if (tls_type & (TLS_LD | TLS_GD))
15555                       {
15556                         outrel.r_addend = 0;
15557                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15558                         if (tls_type == (TLS_TLS | TLS_GD))
15559                           {
15560                             loc = relgot->contents;
15561                             loc += (relgot->reloc_count++
15562                                     * sizeof (Elf64_External_Rela));
15563                             bfd_elf64_swap_reloca_out (output_bfd,
15564                                                        &outrel, loc);
15565                             outrel.r_offset += 8;
15566                             outrel.r_addend = addend;
15567                             outrel.r_info
15568                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15569                           }
15570                       }
15571                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15572                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15573                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15574                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15575                     else if (indx != 0)
15576                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15577                     else
15578                       {
15579                         if (ifunc)
15580                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15581                         else
15582                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15583
15584                         /* Write the .got section contents for the sake
15585                            of prelink.  */
15586                         loc = got->contents + off;
15587                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15588                                     loc);
15589                       }
15590
15591                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15592                       {
15593                         outrel.r_addend += relocation;
15594                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15595                           {
15596                             if (htab->elf.tls_sec == NULL)
15597                               outrel.r_addend = 0;
15598                             else
15599                               outrel.r_addend -= htab->elf.tls_sec->vma;
15600                           }
15601                       }
15602                     loc = relgot->contents;
15603                     loc += (relgot->reloc_count++
15604                             * sizeof (Elf64_External_Rela));
15605                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15606                   }
15607
15608                 /* Init the .got section contents here if we're not
15609                    emitting a reloc.  */
15610                 else
15611                   {
15612                     relocation += addend;
15613                     if (tls_type != 0)
15614                       {
15615                         if (htab->elf.tls_sec == NULL)
15616                           relocation = 0;
15617                         else
15618                           {
15619                             if (tls_type & TLS_LD)
15620                               relocation = 0;
15621                             else
15622                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15623                             if (tls_type & TLS_TPREL)
15624                               relocation += DTP_OFFSET - TP_OFFSET;
15625                           }
15626
15627                         if (tls_type & (TLS_GD | TLS_LD))
15628                           {
15629                             bfd_put_64 (output_bfd, relocation,
15630                                         got->contents + off + 8);
15631                             relocation = 1;
15632                           }
15633                       }
15634                     bfd_put_64 (output_bfd, relocation,
15635                                 got->contents + off);
15636                   }
15637               }
15638
15639             if (off >= (bfd_vma) -2)
15640               abort ();
15641
15642             relocation = got->output_section->vma + got->output_offset + off;
15643             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15644           }
15645           break;
15646
15647         case R_PPC64_PLT16_HA:
15648         case R_PPC64_PLT16_HI:
15649         case R_PPC64_PLT16_LO:
15650         case R_PPC64_PLT16_LO_DS:
15651         case R_PPC64_PLT32:
15652         case R_PPC64_PLT64:
15653         case R_PPC64_PLTSEQ:
15654         case R_PPC64_PLTCALL:
15655           /* Relocation is to the entry for this symbol in the
15656              procedure linkage table.  */
15657           unresolved_reloc = TRUE;
15658           {
15659             struct plt_entry **plt_list = NULL;
15660             if (h != NULL)
15661               plt_list = &h->elf.plt.plist;
15662             else if (local_got_ents != NULL)
15663               {
15664                 struct plt_entry **local_plt = (struct plt_entry **)
15665                   (local_got_ents + symtab_hdr->sh_info);
15666                 plt_list = local_plt + r_symndx;
15667               }
15668             if (plt_list)
15669               {
15670                 struct plt_entry *ent;
15671
15672                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15673                   if (ent->plt.offset != (bfd_vma) -1
15674                       && ent->addend == orig_rel.r_addend)
15675                     {
15676                       asection *plt;
15677                       bfd_vma got;
15678
15679                       plt = htab->elf.splt;
15680                       if (!htab->elf.dynamic_sections_created
15681                           || h == NULL
15682                           || h->elf.dynindx == -1)
15683                         {
15684                           if (h != NULL
15685                               ? h->elf.type == STT_GNU_IFUNC
15686                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15687                             plt = htab->elf.iplt;
15688                           else
15689                             plt = htab->pltlocal;
15690                         }
15691                       relocation = (plt->output_section->vma
15692                                     + plt->output_offset
15693                                     + ent->plt.offset);
15694                       if (r_type == R_PPC64_PLT16_HA
15695                           || r_type ==R_PPC64_PLT16_HI
15696                           || r_type ==R_PPC64_PLT16_LO
15697                           || r_type ==R_PPC64_PLT16_LO_DS)
15698                         {
15699                           got = (elf_gp (output_bfd)
15700                                  + htab->sec_info[input_section->id].toc_off);
15701                           relocation -= got;
15702                         }
15703                       addend = 0;
15704                       unresolved_reloc = FALSE;
15705                       break;
15706                     }
15707               }
15708           }
15709           break;
15710
15711         case R_PPC64_TOC:
15712           /* Relocation value is TOC base.  */
15713           relocation = TOCstart;
15714           if (r_symndx == STN_UNDEF)
15715             relocation += htab->sec_info[input_section->id].toc_off;
15716           else if (unresolved_reloc)
15717             ;
15718           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15719             relocation += htab->sec_info[sec->id].toc_off;
15720           else
15721             unresolved_reloc = TRUE;
15722           goto dodyn;
15723
15724           /* TOC16 relocs.  We want the offset relative to the TOC base,
15725              which is the address of the start of the TOC plus 0x8000.
15726              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15727              in this order.  */
15728         case R_PPC64_TOC16:
15729         case R_PPC64_TOC16_LO:
15730         case R_PPC64_TOC16_HI:
15731         case R_PPC64_TOC16_DS:
15732         case R_PPC64_TOC16_LO_DS:
15733         case R_PPC64_TOC16_HA:
15734           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15735           break;
15736
15737           /* Relocate against the beginning of the section.  */
15738         case R_PPC64_SECTOFF:
15739         case R_PPC64_SECTOFF_LO:
15740         case R_PPC64_SECTOFF_HI:
15741         case R_PPC64_SECTOFF_DS:
15742         case R_PPC64_SECTOFF_LO_DS:
15743         case R_PPC64_SECTOFF_HA:
15744           if (sec != NULL)
15745             addend -= sec->output_section->vma;
15746           break;
15747
15748         case R_PPC64_REL16:
15749         case R_PPC64_REL16_LO:
15750         case R_PPC64_REL16_HI:
15751         case R_PPC64_REL16_HA:
15752         case R_PPC64_REL16DX_HA:
15753           break;
15754
15755         case R_PPC64_REL14:
15756         case R_PPC64_REL14_BRNTAKEN:
15757         case R_PPC64_REL14_BRTAKEN:
15758         case R_PPC64_REL24:
15759         case R_PPC64_REL24_NOTOC:
15760           break;
15761
15762         case R_PPC64_TPREL16:
15763         case R_PPC64_TPREL16_LO:
15764         case R_PPC64_TPREL16_HI:
15765         case R_PPC64_TPREL16_HA:
15766         case R_PPC64_TPREL16_DS:
15767         case R_PPC64_TPREL16_LO_DS:
15768         case R_PPC64_TPREL16_HIGH:
15769         case R_PPC64_TPREL16_HIGHA:
15770         case R_PPC64_TPREL16_HIGHER:
15771         case R_PPC64_TPREL16_HIGHERA:
15772         case R_PPC64_TPREL16_HIGHEST:
15773         case R_PPC64_TPREL16_HIGHESTA:
15774           if (h != NULL
15775               && h->elf.root.type == bfd_link_hash_undefweak
15776               && h->elf.dynindx == -1)
15777             {
15778               /* Make this relocation against an undefined weak symbol
15779                  resolve to zero.  This is really just a tweak, since
15780                  code using weak externs ought to check that they are
15781                  defined before using them.  */
15782               bfd_byte *p = contents + rel->r_offset - d_offset;
15783
15784               insn = bfd_get_32 (input_bfd, p);
15785               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15786               if (insn != 0)
15787                 bfd_put_32 (input_bfd, insn, p);
15788               break;
15789             }
15790           if (htab->elf.tls_sec != NULL)
15791             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15792           /* The TPREL16 relocs shouldn't really be used in shared
15793              libs or with non-local symbols as that will result in
15794              DT_TEXTREL being set, but support them anyway.  */
15795           goto dodyn;
15796
15797         case R_PPC64_DTPREL16:
15798         case R_PPC64_DTPREL16_LO:
15799         case R_PPC64_DTPREL16_HI:
15800         case R_PPC64_DTPREL16_HA:
15801         case R_PPC64_DTPREL16_DS:
15802         case R_PPC64_DTPREL16_LO_DS:
15803         case R_PPC64_DTPREL16_HIGH:
15804         case R_PPC64_DTPREL16_HIGHA:
15805         case R_PPC64_DTPREL16_HIGHER:
15806         case R_PPC64_DTPREL16_HIGHERA:
15807         case R_PPC64_DTPREL16_HIGHEST:
15808         case R_PPC64_DTPREL16_HIGHESTA:
15809           if (htab->elf.tls_sec != NULL)
15810             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15811           break;
15812
15813         case R_PPC64_ADDR64_LOCAL:
15814           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15815                                               ? h->elf.other
15816                                               : sym->st_other);
15817           break;
15818
15819         case R_PPC64_DTPMOD64:
15820           relocation = 1;
15821           addend = 0;
15822           goto dodyn;
15823
15824         case R_PPC64_TPREL64:
15825           if (htab->elf.tls_sec != NULL)
15826             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15827           goto dodyn;
15828
15829         case R_PPC64_DTPREL64:
15830           if (htab->elf.tls_sec != NULL)
15831             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15832           /* Fall through.  */
15833
15834           /* Relocations that may need to be propagated if this is a
15835              dynamic object.  */
15836         case R_PPC64_REL30:
15837         case R_PPC64_REL32:
15838         case R_PPC64_REL64:
15839         case R_PPC64_ADDR14:
15840         case R_PPC64_ADDR14_BRNTAKEN:
15841         case R_PPC64_ADDR14_BRTAKEN:
15842         case R_PPC64_ADDR16:
15843         case R_PPC64_ADDR16_DS:
15844         case R_PPC64_ADDR16_HA:
15845         case R_PPC64_ADDR16_HI:
15846         case R_PPC64_ADDR16_HIGH:
15847         case R_PPC64_ADDR16_HIGHA:
15848         case R_PPC64_ADDR16_HIGHER:
15849         case R_PPC64_ADDR16_HIGHERA:
15850         case R_PPC64_ADDR16_HIGHEST:
15851         case R_PPC64_ADDR16_HIGHESTA:
15852         case R_PPC64_ADDR16_LO:
15853         case R_PPC64_ADDR16_LO_DS:
15854         case R_PPC64_ADDR24:
15855         case R_PPC64_ADDR32:
15856         case R_PPC64_ADDR64:
15857         case R_PPC64_UADDR16:
15858         case R_PPC64_UADDR32:
15859         case R_PPC64_UADDR64:
15860         dodyn:
15861           if ((input_section->flags & SEC_ALLOC) == 0)
15862             break;
15863
15864           if (NO_OPD_RELOCS && is_opd)
15865             break;
15866
15867           if (bfd_link_pic (info)
15868               ? ((h == NULL
15869                   || h->dyn_relocs != NULL)
15870                  && ((h != NULL && pc_dynrelocs (h))
15871                      || must_be_dyn_reloc (info, r_type)))
15872               : (h != NULL
15873                  ? h->dyn_relocs != NULL
15874                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15875             {
15876               bfd_boolean skip, relocate;
15877               asection *sreloc;
15878               bfd_vma out_off;
15879               long indx = 0;
15880
15881               /* When generating a dynamic object, these relocations
15882                  are copied into the output file to be resolved at run
15883                  time.  */
15884
15885               skip = FALSE;
15886               relocate = FALSE;
15887
15888               out_off = _bfd_elf_section_offset (output_bfd, info,
15889                                                  input_section, rel->r_offset);
15890               if (out_off == (bfd_vma) -1)
15891                 skip = TRUE;
15892               else if (out_off == (bfd_vma) -2)
15893                 skip = TRUE, relocate = TRUE;
15894               out_off += (input_section->output_section->vma
15895                           + input_section->output_offset);
15896               outrel.r_offset = out_off;
15897               outrel.r_addend = rel->r_addend;
15898
15899               /* Optimize unaligned reloc use.  */
15900               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15901                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15902                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15903               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15904                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15905                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15906               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15907                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15908                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15909
15910               if (skip)
15911                 memset (&outrel, 0, sizeof outrel);
15912               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15913                        && !is_opd
15914                        && r_type != R_PPC64_TOC)
15915                 {
15916                   indx = h->elf.dynindx;
15917                   BFD_ASSERT (indx != -1);
15918                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15919                 }
15920               else
15921                 {
15922                   /* This symbol is local, or marked to become local,
15923                      or this is an opd section reloc which must point
15924                      at a local function.  */
15925                   outrel.r_addend += relocation;
15926                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15927                     {
15928                       if (is_opd && h != NULL)
15929                         {
15930                           /* Lie about opd entries.  This case occurs
15931                              when building shared libraries and we
15932                              reference a function in another shared
15933                              lib.  The same thing happens for a weak
15934                              definition in an application that's
15935                              overridden by a strong definition in a
15936                              shared lib.  (I believe this is a generic
15937                              bug in binutils handling of weak syms.)
15938                              In these cases we won't use the opd
15939                              entry in this lib.  */
15940                           unresolved_reloc = FALSE;
15941                         }
15942                       if (!is_opd
15943                           && r_type == R_PPC64_ADDR64
15944                           && (h != NULL
15945                               ? h->elf.type == STT_GNU_IFUNC
15946                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15947                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15948                       else
15949                         {
15950                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15951
15952                           /* We need to relocate .opd contents for ld.so.
15953                              Prelink also wants simple and consistent rules
15954                              for relocs.  This make all RELATIVE relocs have
15955                              *r_offset equal to r_addend.  */
15956                           relocate = TRUE;
15957                         }
15958                     }
15959                   else
15960                     {
15961                       if (h != NULL
15962                           ? h->elf.type == STT_GNU_IFUNC
15963                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15964                         {
15965                           info->callbacks->einfo
15966                             /* xgettext:c-format */
15967                             (_("%H: %s for indirect "
15968                                "function `%pT' unsupported\n"),
15969                              input_bfd, input_section, rel->r_offset,
15970                              ppc64_elf_howto_table[r_type]->name,
15971                              sym_name);
15972                           ret = FALSE;
15973                         }
15974                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15975                         ;
15976                       else if (sec == NULL || sec->owner == NULL)
15977                         {
15978                           bfd_set_error (bfd_error_bad_value);
15979                           return FALSE;
15980                         }
15981                       else
15982                         {
15983                           asection *osec;
15984
15985                           osec = sec->output_section;
15986                           indx = elf_section_data (osec)->dynindx;
15987
15988                           if (indx == 0)
15989                             {
15990                               if ((osec->flags & SEC_READONLY) == 0
15991                                   && htab->elf.data_index_section != NULL)
15992                                 osec = htab->elf.data_index_section;
15993                               else
15994                                 osec = htab->elf.text_index_section;
15995                               indx = elf_section_data (osec)->dynindx;
15996                             }
15997                           BFD_ASSERT (indx != 0);
15998
15999                           /* We are turning this relocation into one
16000                              against a section symbol, so subtract out
16001                              the output section's address but not the
16002                              offset of the input section in the output
16003                              section.  */
16004                           outrel.r_addend -= osec->vma;
16005                         }
16006
16007                       outrel.r_info = ELF64_R_INFO (indx, r_type);
16008                     }
16009                 }
16010
16011               sreloc = elf_section_data (input_section)->sreloc;
16012               if (h != NULL
16013                   ? h->elf.type == STT_GNU_IFUNC
16014                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16015                 {
16016                   sreloc = htab->elf.irelplt;
16017                   if (indx == 0)
16018                     htab->local_ifunc_resolver = 1;
16019                   else if (is_static_defined (&h->elf))
16020                     htab->maybe_local_ifunc_resolver = 1;
16021                 }
16022               if (sreloc == NULL)
16023                 abort ();
16024
16025               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16026                   >= sreloc->size)
16027                 abort ();
16028               loc = sreloc->contents;
16029               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16030               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16031
16032               /* If this reloc is against an external symbol, it will
16033                  be computed at runtime, so there's no need to do
16034                  anything now.  However, for the sake of prelink ensure
16035                  that the section contents are a known value.  */
16036               if (! relocate)
16037                 {
16038                   unresolved_reloc = FALSE;
16039                   /* The value chosen here is quite arbitrary as ld.so
16040                      ignores section contents except for the special
16041                      case of .opd where the contents might be accessed
16042                      before relocation.  Choose zero, as that won't
16043                      cause reloc overflow.  */
16044                   relocation = 0;
16045                   addend = 0;
16046                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16047                      to improve backward compatibility with older
16048                      versions of ld.  */
16049                   if (r_type == R_PPC64_ADDR64)
16050                     addend = outrel.r_addend;
16051                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
16052                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
16053                     addend = outrel.r_offset;
16054                 }
16055             }
16056           break;
16057
16058         case R_PPC64_COPY:
16059         case R_PPC64_GLOB_DAT:
16060         case R_PPC64_JMP_SLOT:
16061         case R_PPC64_JMP_IREL:
16062         case R_PPC64_RELATIVE:
16063           /* We shouldn't ever see these dynamic relocs in relocatable
16064              files.  */
16065           /* Fall through.  */
16066
16067         case R_PPC64_PLTGOT16:
16068         case R_PPC64_PLTGOT16_DS:
16069         case R_PPC64_PLTGOT16_HA:
16070         case R_PPC64_PLTGOT16_HI:
16071         case R_PPC64_PLTGOT16_LO:
16072         case R_PPC64_PLTGOT16_LO_DS:
16073         case R_PPC64_PLTREL32:
16074         case R_PPC64_PLTREL64:
16075           /* These ones haven't been implemented yet.  */
16076
16077           info->callbacks->einfo
16078             /* xgettext:c-format */
16079             (_("%P: %pB: %s is not supported for `%pT'\n"),
16080              input_bfd,
16081              ppc64_elf_howto_table[r_type]->name, sym_name);
16082
16083           bfd_set_error (bfd_error_invalid_operation);
16084           ret = FALSE;
16085           goto copy_reloc;
16086         }
16087
16088       /* Multi-instruction sequences that access the TOC can be
16089          optimized, eg. addis ra,r2,0; addi rb,ra,x;
16090          to             nop;           addi rb,r2,x;  */
16091       switch (r_type)
16092         {
16093         default:
16094           break;
16095
16096         case R_PPC64_GOT_TLSLD16_HI:
16097         case R_PPC64_GOT_TLSGD16_HI:
16098         case R_PPC64_GOT_TPREL16_HI:
16099         case R_PPC64_GOT_DTPREL16_HI:
16100         case R_PPC64_GOT16_HI:
16101         case R_PPC64_TOC16_HI:
16102           /* These relocs would only be useful if building up an
16103              offset to later add to r2, perhaps in an indexed
16104              addressing mode instruction.  Don't try to optimize.
16105              Unfortunately, the possibility of someone building up an
16106              offset like this or even with the HA relocs, means that
16107              we need to check the high insn when optimizing the low
16108              insn.  */
16109           break;
16110
16111         case R_PPC64_PLTCALL:
16112           if (unresolved_reloc)
16113             {
16114               /* No plt entry.  Make this into a direct call.  */
16115               bfd_byte *p = contents + rel->r_offset;
16116               insn = bfd_get_32 (input_bfd, p);
16117               insn &= 1;
16118               bfd_put_32 (input_bfd, B_DOT | insn, p);
16119               bfd_put_32 (input_bfd, NOP, p + 4);
16120               unresolved_reloc = save_unresolved_reloc;
16121               r_type = R_PPC64_REL24;
16122             }
16123           break;
16124
16125         case R_PPC64_PLTSEQ:
16126           if (unresolved_reloc)
16127             {
16128               unresolved_reloc = FALSE;
16129               goto nop_it;
16130             }
16131           break;
16132
16133         case R_PPC64_PLT16_HA:
16134           if (unresolved_reloc)
16135             {
16136               unresolved_reloc = FALSE;
16137               goto nop_it;
16138             }
16139           /* Fall through.  */
16140         case R_PPC64_GOT_TLSLD16_HA:
16141         case R_PPC64_GOT_TLSGD16_HA:
16142         case R_PPC64_GOT_TPREL16_HA:
16143         case R_PPC64_GOT_DTPREL16_HA:
16144         case R_PPC64_GOT16_HA:
16145         case R_PPC64_TOC16_HA:
16146           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16147               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16148             {
16149               bfd_byte *p;
16150             nop_it:
16151               p = contents + (rel->r_offset & ~3);
16152               bfd_put_32 (input_bfd, NOP, p);
16153               goto copy_reloc;
16154             }
16155           break;
16156
16157         case R_PPC64_PLT16_LO:
16158         case R_PPC64_PLT16_LO_DS:
16159           if (unresolved_reloc)
16160             {
16161               unresolved_reloc = FALSE;
16162               goto nop_it;
16163             }
16164           /* Fall through.  */
16165         case R_PPC64_GOT_TLSLD16_LO:
16166         case R_PPC64_GOT_TLSGD16_LO:
16167         case R_PPC64_GOT_TPREL16_LO_DS:
16168         case R_PPC64_GOT_DTPREL16_LO_DS:
16169         case R_PPC64_GOT16_LO:
16170         case R_PPC64_GOT16_LO_DS:
16171         case R_PPC64_TOC16_LO:
16172         case R_PPC64_TOC16_LO_DS:
16173           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16174               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16175             {
16176               bfd_byte *p = contents + (rel->r_offset & ~3);
16177               insn = bfd_get_32 (input_bfd, p);
16178               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16179                 {
16180                   /* Transform addic to addi when we change reg.  */
16181                   insn &= ~((0x3f << 26) | (0x1f << 16));
16182                   insn |= (14u << 26) | (2 << 16);
16183                 }
16184               else
16185                 {
16186                   insn &= ~(0x1f << 16);
16187                   insn |= 2 << 16;
16188                 }
16189               bfd_put_32 (input_bfd, insn, p);
16190             }
16191           break;
16192
16193         case R_PPC64_TPREL16_HA:
16194           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16195             {
16196               bfd_byte *p = contents + (rel->r_offset & ~3);
16197               insn = bfd_get_32 (input_bfd, p);
16198               if ((insn & ((0x3f << 26) | 0x1f << 16))
16199                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16200                 /* xgettext:c-format */
16201                 info->callbacks->minfo
16202                   (_("%H: warning: %s unexpected insn %#x.\n"),
16203                    input_bfd, input_section, rel->r_offset,
16204                    ppc64_elf_howto_table[r_type]->name, insn);
16205               else
16206                 {
16207                   bfd_put_32 (input_bfd, NOP, p);
16208                   goto copy_reloc;
16209                 }
16210             }
16211           break;
16212
16213         case R_PPC64_TPREL16_LO:
16214         case R_PPC64_TPREL16_LO_DS:
16215           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16216             {
16217               bfd_byte *p = contents + (rel->r_offset & ~3);
16218               insn = bfd_get_32 (input_bfd, p);
16219               insn &= ~(0x1f << 16);
16220               insn |= 13 << 16;
16221               bfd_put_32 (input_bfd, insn, p);
16222             }
16223           break;
16224         }
16225
16226       /* Do any further special processing.  */
16227       switch (r_type)
16228         {
16229         default:
16230           break;
16231
16232         case R_PPC64_REL16_HA:
16233         case R_PPC64_REL16DX_HA:
16234         case R_PPC64_ADDR16_HA:
16235         case R_PPC64_ADDR16_HIGHA:
16236         case R_PPC64_ADDR16_HIGHERA:
16237         case R_PPC64_ADDR16_HIGHESTA:
16238         case R_PPC64_TOC16_HA:
16239         case R_PPC64_SECTOFF_HA:
16240         case R_PPC64_TPREL16_HA:
16241         case R_PPC64_TPREL16_HIGHA:
16242         case R_PPC64_TPREL16_HIGHERA:
16243         case R_PPC64_TPREL16_HIGHESTA:
16244         case R_PPC64_DTPREL16_HA:
16245         case R_PPC64_DTPREL16_HIGHA:
16246         case R_PPC64_DTPREL16_HIGHERA:
16247         case R_PPC64_DTPREL16_HIGHESTA:
16248           /* It's just possible that this symbol is a weak symbol
16249              that's not actually defined anywhere. In that case,
16250              'sec' would be NULL, and we should leave the symbol
16251              alone (it will be set to zero elsewhere in the link).  */
16252           if (sec == NULL)
16253             break;
16254           /* Fall through.  */
16255
16256         case R_PPC64_GOT16_HA:
16257         case R_PPC64_PLTGOT16_HA:
16258         case R_PPC64_PLT16_HA:
16259         case R_PPC64_GOT_TLSGD16_HA:
16260         case R_PPC64_GOT_TLSLD16_HA:
16261         case R_PPC64_GOT_TPREL16_HA:
16262         case R_PPC64_GOT_DTPREL16_HA:
16263           /* Add 0x10000 if sign bit in 0:15 is set.
16264              Bits 0:15 are not used.  */
16265           addend += 0x8000;
16266           break;
16267
16268         case R_PPC64_ADDR16_DS:
16269         case R_PPC64_ADDR16_LO_DS:
16270         case R_PPC64_GOT16_DS:
16271         case R_PPC64_GOT16_LO_DS:
16272         case R_PPC64_PLT16_LO_DS:
16273         case R_PPC64_SECTOFF_DS:
16274         case R_PPC64_SECTOFF_LO_DS:
16275         case R_PPC64_TOC16_DS:
16276         case R_PPC64_TOC16_LO_DS:
16277         case R_PPC64_PLTGOT16_DS:
16278         case R_PPC64_PLTGOT16_LO_DS:
16279         case R_PPC64_GOT_TPREL16_DS:
16280         case R_PPC64_GOT_TPREL16_LO_DS:
16281         case R_PPC64_GOT_DTPREL16_DS:
16282         case R_PPC64_GOT_DTPREL16_LO_DS:
16283         case R_PPC64_TPREL16_DS:
16284         case R_PPC64_TPREL16_LO_DS:
16285         case R_PPC64_DTPREL16_DS:
16286         case R_PPC64_DTPREL16_LO_DS:
16287           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16288           mask = 3;
16289           /* If this reloc is against an lq, lxv, or stxv insn, then
16290              the value must be a multiple of 16.  This is somewhat of
16291              a hack, but the "correct" way to do this by defining _DQ
16292              forms of all the _DS relocs bloats all reloc switches in
16293              this file.  It doesn't make much sense to use these
16294              relocs in data, so testing the insn should be safe.  */
16295           if ((insn & (0x3f << 26)) == (56u << 26)
16296               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16297             mask = 15;
16298           relocation += addend;
16299           addend = insn & (mask ^ 3);
16300           if ((relocation & mask) != 0)
16301             {
16302               relocation ^= relocation & mask;
16303               info->callbacks->einfo
16304                 /* xgettext:c-format */
16305                 (_("%H: error: %s not a multiple of %u\n"),
16306                  input_bfd, input_section, rel->r_offset,
16307                  ppc64_elf_howto_table[r_type]->name,
16308                  mask + 1);
16309               bfd_set_error (bfd_error_bad_value);
16310               ret = FALSE;
16311               goto copy_reloc;
16312             }
16313           break;
16314         }
16315
16316       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16317          because such sections are not SEC_ALLOC and thus ld.so will
16318          not process them.  */
16319       howto = ppc64_elf_howto_table[(int) r_type];
16320       if (unresolved_reloc
16321           && !((input_section->flags & SEC_DEBUGGING) != 0
16322                && h->elf.def_dynamic)
16323           && _bfd_elf_section_offset (output_bfd, info, input_section,
16324                                       rel->r_offset) != (bfd_vma) -1)
16325         {
16326           info->callbacks->einfo
16327             /* xgettext:c-format */
16328             (_("%H: unresolvable %s against `%pT'\n"),
16329              input_bfd, input_section, rel->r_offset,
16330              howto->name,
16331              h->elf.root.root.string);
16332           ret = FALSE;
16333         }
16334
16335       /* 16-bit fields in insns mostly have signed values, but a
16336          few insns have 16-bit unsigned values.  Really, we should
16337          have different reloc types.  */
16338       if (howto->complain_on_overflow != complain_overflow_dont
16339           && howto->dst_mask == 0xffff
16340           && (input_section->flags & SEC_CODE) != 0)
16341         {
16342           enum complain_overflow complain = complain_overflow_signed;
16343
16344           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16345           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16346             complain = complain_overflow_bitfield;
16347           else if (howto->rightshift == 0
16348                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16349                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16350                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16351                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16352                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16353                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16354             complain = complain_overflow_unsigned;
16355           if (howto->complain_on_overflow != complain)
16356             {
16357               alt_howto = *howto;
16358               alt_howto.complain_on_overflow = complain;
16359               howto = &alt_howto;
16360             }
16361         }
16362
16363       if (r_type == R_PPC64_REL16DX_HA)
16364         {
16365           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
16366           if (rel->r_offset + 4 > input_section->size)
16367             r = bfd_reloc_outofrange;
16368           else
16369             {
16370               relocation += addend;
16371               relocation -= (rel->r_offset
16372                              + input_section->output_offset
16373                              + input_section->output_section->vma);
16374               relocation = (bfd_signed_vma) relocation >> 16;
16375               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16376               insn &= ~0x1fffc1;
16377               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16378               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16379               r = bfd_reloc_ok;
16380               if (relocation + 0x8000 > 0xffff)
16381                 r = bfd_reloc_overflow;
16382             }
16383         }
16384       else
16385         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
16386                                       rel->r_offset, relocation, addend);
16387
16388       if (r != bfd_reloc_ok)
16389         {
16390           char *more_info = NULL;
16391           const char *reloc_name = howto->name;
16392
16393           if (reloc_dest != DEST_NORMAL)
16394             {
16395               more_info = bfd_malloc (strlen (reloc_name) + 8);
16396               if (more_info != NULL)
16397                 {
16398                   strcpy (more_info, reloc_name);
16399                   strcat (more_info, (reloc_dest == DEST_OPD
16400                                       ? " (OPD)" : " (stub)"));
16401                   reloc_name = more_info;
16402                 }
16403             }
16404
16405           if (r == bfd_reloc_overflow)
16406             {
16407               /* On code like "if (foo) foo();" don't report overflow
16408                  on a branch to zero when foo is undefined.  */
16409               if (!warned
16410                   && (reloc_dest == DEST_STUB
16411                       || !(h != NULL
16412                            && (h->elf.root.type == bfd_link_hash_undefweak
16413                                || h->elf.root.type == bfd_link_hash_undefined)
16414                            && is_branch_reloc (r_type))))
16415                 info->callbacks->reloc_overflow (info, &h->elf.root,
16416                                                  sym_name, reloc_name,
16417                                                  orig_rel.r_addend,
16418                                                  input_bfd, input_section,
16419                                                  rel->r_offset);
16420             }
16421           else
16422             {
16423               info->callbacks->einfo
16424                 /* xgettext:c-format */
16425                 (_("%H: %s against `%pT': error %d\n"),
16426                  input_bfd, input_section, rel->r_offset,
16427                  reloc_name, sym_name, (int) r);
16428               ret = FALSE;
16429             }
16430           if (more_info != NULL)
16431             free (more_info);
16432         }
16433     copy_reloc:
16434       if (wrel != rel)
16435         *wrel = *rel;
16436     }
16437
16438   if (wrel != rel)
16439     {
16440       Elf_Internal_Shdr *rel_hdr;
16441       size_t deleted = rel - wrel;
16442
16443       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16444       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16445       if (rel_hdr->sh_size == 0)
16446         {
16447           /* It is too late to remove an empty reloc section.  Leave
16448              one NONE reloc.
16449              ??? What is wrong with an empty section???  */
16450           rel_hdr->sh_size = rel_hdr->sh_entsize;
16451           deleted -= 1;
16452         }
16453       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16454       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16455       input_section->reloc_count -= deleted;
16456     }
16457
16458   /* If we're emitting relocations, then shortly after this function
16459      returns, reloc offsets and addends for this section will be
16460      adjusted.  Worse, reloc symbol indices will be for the output
16461      file rather than the input.  Save a copy of the relocs for
16462      opd_entry_value.  */
16463   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16464     {
16465       bfd_size_type amt;
16466       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16467       rel = bfd_alloc (input_bfd, amt);
16468       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16469       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16470       if (rel == NULL)
16471         return FALSE;
16472       memcpy (rel, relocs, amt);
16473     }
16474   return ret;
16475 }
16476
16477 /* Adjust the value of any local symbols in opd sections.  */
16478
16479 static int
16480 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16481                               const char *name ATTRIBUTE_UNUSED,
16482                               Elf_Internal_Sym *elfsym,
16483                               asection *input_sec,
16484                               struct elf_link_hash_entry *h)
16485 {
16486   struct _opd_sec_data *opd;
16487   long adjust;
16488   bfd_vma value;
16489
16490   if (h != NULL)
16491     return 1;
16492
16493   opd = get_opd_info (input_sec);
16494   if (opd == NULL || opd->adjust == NULL)
16495     return 1;
16496
16497   value = elfsym->st_value - input_sec->output_offset;
16498   if (!bfd_link_relocatable (info))
16499     value -= input_sec->output_section->vma;
16500
16501   adjust = opd->adjust[OPD_NDX (value)];
16502   if (adjust == -1)
16503     return 2;
16504
16505   elfsym->st_value += adjust;
16506   return 1;
16507 }
16508
16509 /* Finish up dynamic symbol handling.  We set the contents of various
16510    dynamic sections here.  */
16511
16512 static bfd_boolean
16513 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16514                                  struct bfd_link_info *info,
16515                                  struct elf_link_hash_entry *h,
16516                                  Elf_Internal_Sym *sym)
16517 {
16518   struct ppc_link_hash_table *htab;
16519   struct plt_entry *ent;
16520
16521   htab = ppc_hash_table (info);
16522   if (htab == NULL)
16523     return FALSE;
16524
16525   if (!htab->opd_abi && !h->def_regular)
16526     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16527       if (ent->plt.offset != (bfd_vma) -1)
16528         {
16529           /* Mark the symbol as undefined, rather than as
16530              defined in glink.  Leave the value if there were
16531              any relocations where pointer equality matters
16532              (this is a clue for the dynamic linker, to make
16533              function pointer comparisons work between an
16534              application and shared library), otherwise set it
16535              to zero.  */
16536           sym->st_shndx = SHN_UNDEF;
16537           if (!h->pointer_equality_needed)
16538             sym->st_value = 0;
16539           else if (!h->ref_regular_nonweak)
16540             {
16541               /* This breaks function pointer comparisons, but
16542                  that is better than breaking tests for a NULL
16543                  function pointer.  */
16544               sym->st_value = 0;
16545             }
16546           break;
16547         }
16548
16549   if (h->needs_copy)
16550     {
16551       /* This symbol needs a copy reloc.  Set it up.  */
16552       Elf_Internal_Rela rela;
16553       asection *srel;
16554       bfd_byte *loc;
16555
16556       if (h->dynindx == -1
16557           || (h->root.type != bfd_link_hash_defined
16558               && h->root.type != bfd_link_hash_defweak)
16559           || htab->elf.srelbss == NULL
16560           || htab->elf.sreldynrelro == NULL)
16561         abort ();
16562
16563       rela.r_offset = (h->root.u.def.value
16564                        + h->root.u.def.section->output_section->vma
16565                        + h->root.u.def.section->output_offset);
16566       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16567       rela.r_addend = 0;
16568       if (h->root.u.def.section == htab->elf.sdynrelro)
16569         srel = htab->elf.sreldynrelro;
16570       else
16571         srel = htab->elf.srelbss;
16572       loc = srel->contents;
16573       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16574       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16575     }
16576
16577   return TRUE;
16578 }
16579
16580 /* Used to decide how to sort relocs in an optimal manner for the
16581    dynamic linker, before writing them out.  */
16582
16583 static enum elf_reloc_type_class
16584 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16585                             const asection *rel_sec,
16586                             const Elf_Internal_Rela *rela)
16587 {
16588   enum elf_ppc64_reloc_type r_type;
16589   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16590
16591   if (rel_sec == htab->elf.irelplt)
16592     return reloc_class_ifunc;
16593
16594   r_type = ELF64_R_TYPE (rela->r_info);
16595   switch (r_type)
16596     {
16597     case R_PPC64_RELATIVE:
16598       return reloc_class_relative;
16599     case R_PPC64_JMP_SLOT:
16600       return reloc_class_plt;
16601     case R_PPC64_COPY:
16602       return reloc_class_copy;
16603     default:
16604       return reloc_class_normal;
16605     }
16606 }
16607
16608 /* Finish up the dynamic sections.  */
16609
16610 static bfd_boolean
16611 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16612                                    struct bfd_link_info *info)
16613 {
16614   struct ppc_link_hash_table *htab;
16615   bfd *dynobj;
16616   asection *sdyn;
16617
16618   htab = ppc_hash_table (info);
16619   if (htab == NULL)
16620     return FALSE;
16621
16622   dynobj = htab->elf.dynobj;
16623   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16624
16625   if (htab->elf.dynamic_sections_created)
16626     {
16627       Elf64_External_Dyn *dyncon, *dynconend;
16628
16629       if (sdyn == NULL || htab->elf.sgot == NULL)
16630         abort ();
16631
16632       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16633       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16634       for (; dyncon < dynconend; dyncon++)
16635         {
16636           Elf_Internal_Dyn dyn;
16637           asection *s;
16638
16639           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16640
16641           switch (dyn.d_tag)
16642             {
16643             default:
16644               continue;
16645
16646             case DT_PPC64_GLINK:
16647               s = htab->glink;
16648               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16649               /* We stupidly defined DT_PPC64_GLINK to be the start
16650                  of glink rather than the first entry point, which is
16651                  what ld.so needs, and now have a bigger stub to
16652                  support automatic multiple TOCs.  */
16653               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16654               break;
16655
16656             case DT_PPC64_OPD:
16657               s = bfd_get_section_by_name (output_bfd, ".opd");
16658               if (s == NULL)
16659                 continue;
16660               dyn.d_un.d_ptr = s->vma;
16661               break;
16662
16663             case DT_PPC64_OPT:
16664               if (htab->do_multi_toc && htab->multi_toc_needed)
16665                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16666               if (htab->has_plt_localentry0)
16667                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16668               break;
16669
16670             case DT_PPC64_OPDSZ:
16671               s = bfd_get_section_by_name (output_bfd, ".opd");
16672               if (s == NULL)
16673                 continue;
16674               dyn.d_un.d_val = s->size;
16675               break;
16676
16677             case DT_PLTGOT:
16678               s = htab->elf.splt;
16679               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16680               break;
16681
16682             case DT_JMPREL:
16683               s = htab->elf.srelplt;
16684               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16685               break;
16686
16687             case DT_PLTRELSZ:
16688               dyn.d_un.d_val = htab->elf.srelplt->size;
16689               break;
16690
16691             case DT_TEXTREL:
16692               if (htab->local_ifunc_resolver)
16693                 info->callbacks->einfo
16694                   (_("%X%P: text relocations and GNU indirect "
16695                      "functions will result in a segfault at runtime\n"));
16696               else if (htab->maybe_local_ifunc_resolver)
16697                 info->callbacks->einfo
16698                   (_("%P: warning: text relocations and GNU indirect "
16699                      "functions may result in a segfault at runtime\n"));
16700               continue;
16701             }
16702
16703           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16704         }
16705     }
16706
16707   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16708       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16709     {
16710       /* Fill in the first entry in the global offset table.
16711          We use it to hold the link-time TOCbase.  */
16712       bfd_put_64 (output_bfd,
16713                   elf_gp (output_bfd) + TOC_BASE_OFF,
16714                   htab->elf.sgot->contents);
16715
16716       /* Set .got entry size.  */
16717       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16718     }
16719
16720   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16721       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16722     {
16723       /* Set .plt entry size.  */
16724       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16725         = PLT_ENTRY_SIZE (htab);
16726     }
16727
16728   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16729      brlt ourselves if emitrelocations.  */
16730   if (htab->brlt != NULL
16731       && htab->brlt->reloc_count != 0
16732       && !_bfd_elf_link_output_relocs (output_bfd,
16733                                        htab->brlt,
16734                                        elf_section_data (htab->brlt)->rela.hdr,
16735                                        elf_section_data (htab->brlt)->relocs,
16736                                        NULL))
16737     return FALSE;
16738
16739   if (htab->glink != NULL
16740       && htab->glink->reloc_count != 0
16741       && !_bfd_elf_link_output_relocs (output_bfd,
16742                                        htab->glink,
16743                                        elf_section_data (htab->glink)->rela.hdr,
16744                                        elf_section_data (htab->glink)->relocs,
16745                                        NULL))
16746     return FALSE;
16747
16748   if (htab->glink_eh_frame != NULL
16749       && htab->glink_eh_frame->size != 0)
16750     {
16751       bfd_vma val;
16752       bfd_byte *p;
16753       struct map_stub *group;
16754       size_t align = 4;
16755
16756       p = htab->glink_eh_frame->contents;
16757       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16758
16759       for (group = htab->group; group != NULL; group = group->next)
16760         if (group->stub_sec != NULL)
16761           {
16762             /* Offset to stub section.  */
16763             val = (group->stub_sec->output_section->vma
16764                    + group->stub_sec->output_offset);
16765             val -= (htab->glink_eh_frame->output_section->vma
16766                     + htab->glink_eh_frame->output_offset
16767                     + (p + 8 - htab->glink_eh_frame->contents));
16768             if (val + 0x80000000 > 0xffffffff)
16769               {
16770                 _bfd_error_handler
16771                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16772                    group->stub_sec->name);
16773                 return FALSE;
16774               }
16775             bfd_put_32 (dynobj, val, p + 8);
16776             p += stub_eh_frame_size (group, align);
16777           }
16778       if (htab->glink != NULL && htab->glink->size != 0)
16779         {
16780           /* Offset to .glink.  */
16781           val = (htab->glink->output_section->vma
16782                  + htab->glink->output_offset
16783                  + 8);
16784           val -= (htab->glink_eh_frame->output_section->vma
16785                   + htab->glink_eh_frame->output_offset
16786                   + (p + 8 - htab->glink_eh_frame->contents));
16787           if (val + 0x80000000 > 0xffffffff)
16788             {
16789               _bfd_error_handler
16790                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16791                  htab->glink->name);
16792               return FALSE;
16793             }
16794           bfd_put_32 (dynobj, val, p + 8);
16795           p += (24 + align - 1) & -align;
16796         }
16797
16798       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16799           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16800                                                htab->glink_eh_frame,
16801                                                htab->glink_eh_frame->contents))
16802         return FALSE;
16803     }
16804
16805   /* We need to handle writing out multiple GOT sections ourselves,
16806      since we didn't add them to DYNOBJ.  We know dynobj is the first
16807      bfd.  */
16808   while ((dynobj = dynobj->link.next) != NULL)
16809     {
16810       asection *s;
16811
16812       if (!is_ppc64_elf (dynobj))
16813         continue;
16814
16815       s = ppc64_elf_tdata (dynobj)->got;
16816       if (s != NULL
16817           && s->size != 0
16818           && s->output_section != bfd_abs_section_ptr
16819           && !bfd_set_section_contents (output_bfd, s->output_section,
16820                                         s->contents, s->output_offset,
16821                                         s->size))
16822         return FALSE;
16823       s = ppc64_elf_tdata (dynobj)->relgot;
16824       if (s != NULL
16825           && s->size != 0
16826           && s->output_section != bfd_abs_section_ptr
16827           && !bfd_set_section_contents (output_bfd, s->output_section,
16828                                         s->contents, s->output_offset,
16829                                         s->size))
16830         return FALSE;
16831     }
16832
16833   return TRUE;
16834 }
16835
16836 #include "elf64-target.h"
16837
16838 /* FreeBSD support */
16839
16840 #undef  TARGET_LITTLE_SYM
16841 #undef  TARGET_LITTLE_NAME
16842
16843 #undef  TARGET_BIG_SYM
16844 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16845 #undef  TARGET_BIG_NAME
16846 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16847
16848 #undef  ELF_OSABI
16849 #define ELF_OSABI       ELFOSABI_FREEBSD
16850
16851 #undef  elf64_bed
16852 #define elf64_bed       elf64_powerpc_fbsd_bed
16853
16854 #include "elf64-target.h"