bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2018 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define ELF_RELROPAGESIZE       ELF_MAXPAGESIZE
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_want_dynrelro 1
  77 #define elf_backend_can_gc_sections 1
  78 #define elf_backend_can_refcount 1
  79 #define elf_backend_rela_normal 1
  80 #define elf_backend_dtrel_excludes_plt 1
  81 #define elf_backend_default_execstack 0
  82
  83 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  84 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  85 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  86 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  87 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  88 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  89 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  90 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  91 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  92 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  93
  94 #define elf_backend_object_p                  ppc64_elf_object_p
  95 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  96 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  97 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  98 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  99 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
 100 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 101 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 102 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 103 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 104 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 105 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
 106 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 107 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 108 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 109 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 110 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 111 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 112 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 113 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 114 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 115 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 116 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 117 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 118 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 119 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 120 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 121 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 122 #define elf_backend_special_sections          ppc64_elf_special_sections
 123 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 124 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 125 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 126
 127 /* The name of the dynamic interpreter.  This is put in the .interp
 128    section.  */
 129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 130
 131 /* The size in bytes of an entry in the procedure linkage table.  */
 132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
 134
 135 /* The initial size of the plt reserved for the dynamic linker.  */
 136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 137
 138 /* Offsets to some stack save slots.  */
 139 #define STK_LR 16
 140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 141 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 142    CR save slot.  Used only by optimised __tls_get_addr call stub,
 143    relying on __tls_get_addr_opt not saving CR..  */
 144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 145
 146 /* TOC base pointers offset from start of TOC.  */
 147 #define TOC_BASE_OFF    0x8000
 148 /* TOC base alignment.  */
 149 #define TOC_BASE_ALIGN  256
 150
 151 /* Offset of tp and dtp pointers from start of TLS block.  */
 152 #define TP_OFFSET       0x7000
 153 #define DTP_OFFSET      0x8000
 154
 155 /* .plt call stub instructions.  The normal stub is like this, but
 156    sometimes the .plt entry crosses a 64k boundary and we need to
 157    insert an addi to adjust r11.  */
 158 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 159 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 160 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 161 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 162 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 163 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 164 #define BCTR            0x4e800420      /* bctr                      */
 165
 166 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 167 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 168 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 169
 170 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 171 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 172 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 173 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 174 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 175 #define BNECTR          0x4ca20420      /* bnectr+               */
 176 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 177
 178 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 179 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 180 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 181
 182 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 183 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 184 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 185
 186 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 187 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 188 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 189 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 190 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 191
 192 /* __glink_PLTresolve stub instructions.  We enter with the index in R0.  */
 193 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 194   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 195                                         /* 0:                           */
 196                                         /*  .quad plt0-1f               */
 197                                         /* __glink:                     */
 198 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 199 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 200                                         /* 1:                           */
 201 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 202                                         /*  ld %2,(0b-1b)(%11)          */
 203 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 204 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 205                                         /*  ld %12,0(%11)               */
 206                                         /*  ld %2,8(%11)                */
 207                                         /*  mtctr %12                   */
 208                                         /*  ld %11,16(%11)              */
 209                                         /*  bctr                        */
 210 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 211 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 212 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 213 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 214 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 215
 216 /* Pad with this.  */
 217 #define NOP             0x60000000
 218
 219 /* Some other nops.  */
 220 #define CROR_151515     0x4def7b82
 221 #define CROR_313131     0x4ffffb82
 222
 223 /* .glink entries for the first 32k functions are two instructions.  */
 224 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 225 #define B_DOT           0x48000000      /* b     .              */
 226
 227 /* After that, we need two instructions to load the index, followed by
 228    a branch.  */
 229 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 230 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 231
 232 /* Instructions used by the save and restore reg functions.  */
 233 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 234 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 235 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 236 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 237 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 238 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 239 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 240 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 241 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 242 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 243 #define BLR             0x4e800020      /* blr                  */
 244
 245 /* Since .opd is an array of descriptors and each entry will end up
 246    with identical R_PPC64_RELATIVE relocs, there is really no need to
 247    propagate .opd relocs;  The dynamic linker should be taught to
 248    relocate .opd without reloc entries.  */
 249 #ifndef NO_OPD_RELOCS
 250 #define NO_OPD_RELOCS 0
 251 #endif
 252
 253 #ifndef ARRAY_SIZE
 254 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 255 #endif
 256
 257 static inline int
 258 abiversion (bfd *abfd)
 259 {
 260   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 261 }
 262
 263 static inline void
 264 set_abiversion (bfd *abfd, int ver)
 265 {
 266   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 267   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 268 }
 269 \f
 270 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 271
 272 /* Relocation HOWTO's.  */
 273 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 274
 275 static reloc_howto_type ppc64_elf_howto_raw[] =
 276 {
 277   /* This reloc does nothing.  */
 278   HOWTO (R_PPC64_NONE,          /* type */
 279          0,                     /* rightshift */
 280          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          0,                     /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_dont, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_NONE",        /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0,                     /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 32 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR32,        /* type */
 294          0,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          32,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR32",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffffffff,            /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* An absolute 26 bit branch; the lower two bits must be zero.
 308      FIXME: we don't check that, we just clear them.  */
 309   HOWTO (R_PPC64_ADDR24,        /* type */
 310          0,                     /* rightshift */
 311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 312          26,                    /* bitsize */
 313          FALSE,                 /* pc_relative */
 314          0,                     /* bitpos */
 315          complain_overflow_bitfield, /* complain_on_overflow */
 316          bfd_elf_generic_reloc, /* special_function */
 317          "R_PPC64_ADDR24",      /* name */
 318          FALSE,                 /* partial_inplace */
 319          0,                     /* src_mask */
 320          0x03fffffc,            /* dst_mask */
 321          FALSE),                /* pcrel_offset */
 322
 323   /* A standard 16 bit relocation.  */
 324   HOWTO (R_PPC64_ADDR16,        /* type */
 325          0,                     /* rightshift */
 326          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          16,                    /* bitsize */
 328          FALSE,                 /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield, /* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* special_function */
 332          "R_PPC64_ADDR16",      /* name */
 333          FALSE,                 /* partial_inplace */
 334          0,                     /* src_mask */
 335          0xffff,                /* dst_mask */
 336          FALSE),                /* pcrel_offset */
 337
 338   /* A 16 bit relocation without overflow.  */
 339   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 340          0,                     /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_dont,/* complain_on_overflow */
 346          bfd_elf_generic_reloc, /* special_function */
 347          "R_PPC64_ADDR16_LO",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* Bits 16-31 of an address.  */
 354   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 355          16,                    /* rightshift */
 356          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_signed, /* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_PPC64_ADDR16_HI",   /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0xffff,                /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 369      bits, treated as a signed number, is negative.  */
 370   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 371          16,                    /* rightshift */
 372          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 373          16,                    /* bitsize */
 374          FALSE,                 /* pc_relative */
 375          0,                     /* bitpos */
 376          complain_overflow_signed, /* complain_on_overflow */
 377          ppc64_elf_ha_reloc,    /* special_function */
 378          "R_PPC64_ADDR16_HA",   /* name */
 379          FALSE,                 /* partial_inplace */
 380          0,                     /* src_mask */
 381          0xffff,                /* dst_mask */
 382          FALSE),                /* pcrel_offset */
 383
 384   /* An absolute 16 bit branch; the lower two bits must be zero.
 385      FIXME: we don't check that, we just clear them.  */
 386   HOWTO (R_PPC64_ADDR14,        /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          16,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_signed, /* complain_on_overflow */
 393          ppc64_elf_branch_reloc, /* special_function */
 394          "R_PPC64_ADDR14",      /* name */
 395          FALSE,                 /* partial_inplace */
 396          0,                     /* src_mask */
 397          0x0000fffc,            /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   /* An absolute 16 bit branch, for which bit 10 should be set to
 401      indicate that the branch is expected to be taken.  The lower two
 402      bits must be zero.  */
 403   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          FALSE,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_brtaken_reloc, /* special_function */
 411          "R_PPC64_ADDR14_BRTAKEN",/* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000fffc,            /* dst_mask */
 415          FALSE),                /* pcrel_offset */
 416
 417   /* An absolute 16 bit branch, for which bit 10 should be set to
 418      indicate that the branch is not expected to be taken.  The lower
 419      two bits must be zero.  */
 420   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 421          0,                     /* rightshift */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          FALSE,                 /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed, /* complain_on_overflow */
 427          ppc64_elf_brtaken_reloc, /* special_function */
 428          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 429          FALSE,                 /* partial_inplace */
 430          0,                     /* src_mask */
 431          0x0000fffc,            /* dst_mask */
 432          FALSE),                /* pcrel_offset */
 433
 434   /* A relative 26 bit branch; the lower two bits must be zero.  */
 435   HOWTO (R_PPC64_REL24,         /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          26,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_branch_reloc, /* special_function */
 443          "R_PPC64_REL24",       /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x03fffffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch; the lower two bits must be zero.  */
 450   HOWTO (R_PPC64_REL14,         /* type */
 451          0,                     /* rightshift */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          TRUE,                  /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_signed, /* complain_on_overflow */
 457          ppc64_elf_branch_reloc, /* special_function */
 458          "R_PPC64_REL14",       /* name */
 459          FALSE,                 /* partial_inplace */
 460          0,                     /* src_mask */
 461          0x0000fffc,            /* dst_mask */
 462          TRUE),                 /* pcrel_offset */
 463
 464   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 465      the branch is expected to be taken.  The lower two bits must be
 466      zero.  */
 467   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 468          0,                     /* rightshift */
 469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          16,                    /* bitsize */
 471          TRUE,                  /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_signed, /* complain_on_overflow */
 474          ppc64_elf_brtaken_reloc, /* special_function */
 475          "R_PPC64_REL14_BRTAKEN", /* name */
 476          FALSE,                 /* partial_inplace */
 477          0,                     /* src_mask */
 478          0x0000fffc,            /* dst_mask */
 479          TRUE),                 /* pcrel_offset */
 480
 481   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 482      the branch is not expected to be taken.  The lower two bits must
 483      be zero.  */
 484   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          TRUE,                  /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_signed, /* complain_on_overflow */
 491          ppc64_elf_brtaken_reloc, /* special_function */
 492          "R_PPC64_REL14_BRNTAKEN",/* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0x0000fffc,            /* dst_mask */
 496          TRUE),                 /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 499      symbol.  */
 500   HOWTO (R_PPC64_GOT16,         /* type */
 501          0,                     /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed, /* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16",       /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_LO,      /* type */
 517          0,                     /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_dont, /* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_LO",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 531      the symbol.  */
 532   HOWTO (R_PPC64_GOT16_HI,      /* type */
 533          16,                    /* rightshift */
 534          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 535          16,                    /* bitsize */
 536          FALSE,                 /* pc_relative */
 537          0,                     /* bitpos */
 538          complain_overflow_signed,/* complain_on_overflow */
 539          ppc64_elf_unhandled_reloc, /* special_function */
 540          "R_PPC64_GOT16_HI",    /* name */
 541          FALSE,                 /* partial_inplace */
 542          0,                     /* src_mask */
 543          0xffff,                /* dst_mask */
 544          FALSE),                /* pcrel_offset */
 545
 546   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 547      the symbol.  */
 548   HOWTO (R_PPC64_GOT16_HA,      /* type */
 549          16,                    /* rightshift */
 550          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 551          16,                    /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_signed,/* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_GOT16_HA",    /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0xffff,                /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* This is used only by the dynamic linker.  The symbol should exist
 563      both in the object being run and in some shared library.  The
 564      dynamic linker copies the data addressed by the symbol from the
 565      shared library into the object, because the object being
 566      run has to have the data at some particular address.  */
 567   HOWTO (R_PPC64_COPY,          /* type */
 568          0,                     /* rightshift */
 569          0,                     /* this one is variable size */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_COPY",        /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Like R_PPC64_ADDR64, but used when setting global offset table
 582      entries.  */
 583   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 584          0,                     /* rightshift */
 585          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 586          64,                    /* bitsize */
 587          FALSE,                 /* pc_relative */
 588          0,                     /* bitpos */
 589          complain_overflow_dont, /* complain_on_overflow */
 590          ppc64_elf_unhandled_reloc,  /* special_function */
 591          "R_PPC64_GLOB_DAT",    /* name */
 592          FALSE,                 /* partial_inplace */
 593          0,                     /* src_mask */
 594          ONES (64),             /* dst_mask */
 595          FALSE),                /* pcrel_offset */
 596
 597   /* Created by the link editor.  Marks a procedure linkage table
 598      entry for a symbol.  */
 599   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 600          0,                     /* rightshift */
 601          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          0,                     /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_dont, /* complain_on_overflow */
 606          ppc64_elf_unhandled_reloc, /* special_function */
 607          "R_PPC64_JMP_SLOT",    /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0,                     /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Used only by the dynamic linker.  When the object is run, this
 614      doubleword64 is set to the load address of the object, plus the
 615      addend.  */
 616   HOWTO (R_PPC64_RELATIVE,      /* type */
 617          0,                     /* rightshift */
 618          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 619          64,                    /* bitsize */
 620          FALSE,                 /* pc_relative */
 621          0,                     /* bitpos */
 622          complain_overflow_dont, /* complain_on_overflow */
 623          bfd_elf_generic_reloc, /* special_function */
 624          "R_PPC64_RELATIVE",    /* name */
 625          FALSE,                 /* partial_inplace */
 626          0,                     /* src_mask */
 627          ONES (64),             /* dst_mask */
 628          FALSE),                /* pcrel_offset */
 629
 630   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 631   HOWTO (R_PPC64_UADDR32,       /* type */
 632          0,                     /* rightshift */
 633          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 634          32,                    /* bitsize */
 635          FALSE,                 /* pc_relative */
 636          0,                     /* bitpos */
 637          complain_overflow_bitfield, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_UADDR32",     /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          FALSE),                /* pcrel_offset */
 644
 645   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 646   HOWTO (R_PPC64_UADDR16,       /* type */
 647          0,                     /* rightshift */
 648          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          16,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          bfd_elf_generic_reloc, /* special_function */
 654          "R_PPC64_UADDR16",     /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffff,                /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative.  */
 661   HOWTO (R_PPC64_REL32,         /* type */
 662          0,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          32,                    /* bitsize */
 665          TRUE,                  /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_signed, /* complain_on_overflow */
 668          bfd_elf_generic_reloc, /* special_function */
 669          "R_PPC64_REL32",       /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffffffff,            /* dst_mask */
 673          TRUE),                 /* pcrel_offset */
 674
 675   /* 32-bit relocation to the symbol's procedure linkage table.  */
 676   HOWTO (R_PPC64_PLT32,         /* type */
 677          0,                     /* rightshift */
 678          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          32,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_bitfield, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT32",       /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffffffff,            /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 691      FIXME: R_PPC64_PLTREL32 not supported.  */
 692   HOWTO (R_PPC64_PLTREL32,      /* type */
 693          0,                     /* rightshift */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          32,                    /* bitsize */
 696          TRUE,                  /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLTREL32",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffffffff,            /* dst_mask */
 704          TRUE),                 /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_LO,      /* type */
 709          0,                     /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_dont, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_LO",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 723      the symbol.  */
 724   HOWTO (R_PPC64_PLT16_HI,      /* type */
 725          16,                    /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_signed, /* complain_on_overflow */
 731          ppc64_elf_unhandled_reloc, /* special_function */
 732          "R_PPC64_PLT16_HI",    /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 739      the symbol.  */
 740   HOWTO (R_PPC64_PLT16_HA,      /* type */
 741          16,                    /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_signed, /* complain_on_overflow */
 747          ppc64_elf_unhandled_reloc, /* special_function */
 748          "R_PPC64_PLT16_HA",    /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF,       /* type */
 756          0,                     /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF",     /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 770   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 771          0,                     /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_dont, /* complain_on_overflow */
 777          ppc64_elf_sectoff_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_LO",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* 16-bit upper half section relative relocation.  */
 785   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 786          16,                    /* rightshift */
 787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          16,                    /* bitsize */
 789          FALSE,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_signed, /* complain_on_overflow */
 792          ppc64_elf_sectoff_reloc, /* special_function */
 793          "R_PPC64_SECTOFF_HI",  /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xffff,                /* dst_mask */
 797          FALSE),                /* pcrel_offset */
 798
 799   /* 16-bit upper half adjusted section relative relocation.  */
 800   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 801          16,                    /* rightshift */
 802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_signed, /* complain_on_overflow */
 807          ppc64_elf_sectoff_ha_reloc, /* special_function */
 808          "R_PPC64_SECTOFF_HA",  /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 815   HOWTO (R_PPC64_REL30,         /* type */
 816          2,                     /* rightshift */
 817          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          30,                    /* bitsize */
 819          TRUE,                  /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_REL30",       /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xfffffffc,            /* dst_mask */
 827          TRUE),                 /* pcrel_offset */
 828
 829   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 830
 831   /* A standard 64-bit relocation.  */
 832   HOWTO (R_PPC64_ADDR64,        /* type */
 833          0,                     /* rightshift */
 834          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 835          64,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          bfd_elf_generic_reloc, /* special_function */
 840          "R_PPC64_ADDR64",      /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          ONES (64),             /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 32-47 of an address.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 848          32,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_PPC64_ADDR16_HIGHER", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* The bits 32-47 of an address, plus 1 if the contents of the low
 862      16 bits, treated as a signed number, is negative.  */
 863   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 864          32,                    /* rightshift */
 865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          16,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          ppc64_elf_ha_reloc,    /* special_function */
 871          "R_PPC64_ADDR16_HIGHERA", /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          0xffff,                /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* The bits 48-63 of an address.  */
 878   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 879          48,                    /* rightshift */
 880          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 881          16,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_ADDR16_HIGHEST", /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          0xffff,                /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   /* The bits 48-63 of an address, plus 1 if the contents of the low
 893      16 bits, treated as a signed number, is negative.  */
 894   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 895          48,                    /* rightshift */
 896          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          16,                    /* bitsize */
 898          FALSE,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          ppc64_elf_ha_reloc,    /* special_function */
 902          "R_PPC64_ADDR16_HIGHESTA", /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          0xffff,                /* dst_mask */
 906          FALSE),                /* pcrel_offset */
 907
 908   /* Like ADDR64, but may be unaligned.  */
 909   HOWTO (R_PPC64_UADDR64,       /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          bfd_elf_generic_reloc, /* special_function */
 917          "R_PPC64_UADDR64",     /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit relative relocation.  */
 924   HOWTO (R_PPC64_REL64,         /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          bfd_elf_generic_reloc, /* special_function */
 932          "R_PPC64_REL64",       /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 64-bit relocation to the symbol's procedure linkage table.  */
 939   HOWTO (R_PPC64_PLT64,         /* type */
 940          0,                     /* rightshift */
 941          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 942          64,                    /* bitsize */
 943          FALSE,                 /* pc_relative */
 944          0,                     /* bitpos */
 945          complain_overflow_dont, /* complain_on_overflow */
 946          ppc64_elf_unhandled_reloc, /* special_function */
 947          "R_PPC64_PLT64",       /* name */
 948          FALSE,                 /* partial_inplace */
 949          0,                     /* src_mask */
 950          ONES (64),             /* dst_mask */
 951          FALSE),                /* pcrel_offset */
 952
 953   /* 64-bit PC relative relocation to the symbol's procedure linkage
 954      table.  */
 955   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 956   HOWTO (R_PPC64_PLTREL64,      /* type */
 957          0,                     /* rightshift */
 958          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 959          64,                    /* bitsize */
 960          TRUE,                  /* pc_relative */
 961          0,                     /* bitpos */
 962          complain_overflow_dont, /* complain_on_overflow */
 963          ppc64_elf_unhandled_reloc, /* special_function */
 964          "R_PPC64_PLTREL64",    /* name */
 965          FALSE,                 /* partial_inplace */
 966          0,                     /* src_mask */
 967          ONES (64),             /* dst_mask */
 968          TRUE),                 /* pcrel_offset */
 969
 970   /* 16 bit TOC-relative relocation.  */
 971
 972   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 973   HOWTO (R_PPC64_TOC16,         /* type */
 974          0,                     /* rightshift */
 975          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 976          16,                    /* bitsize */
 977          FALSE,                 /* pc_relative */
 978          0,                     /* bitpos */
 979          complain_overflow_signed, /* complain_on_overflow */
 980          ppc64_elf_toc_reloc,   /* special_function */
 981          "R_PPC64_TOC16",       /* name */
 982          FALSE,                 /* partial_inplace */
 983          0,                     /* src_mask */
 984          0xffff,                /* dst_mask */
 985          FALSE),                /* pcrel_offset */
 986
 987   /* 16 bit TOC-relative relocation without overflow.  */
 988
 989   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 990   HOWTO (R_PPC64_TOC16_LO,      /* type */
 991          0,                     /* rightshift */
 992          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 993          16,                    /* bitsize */
 994          FALSE,                 /* pc_relative */
 995          0,                     /* bitpos */
 996          complain_overflow_dont, /* complain_on_overflow */
 997          ppc64_elf_toc_reloc,   /* special_function */
 998          "R_PPC64_TOC16_LO",    /* name */
 999          FALSE,                 /* partial_inplace */
1000          0,                     /* src_mask */
1001          0xffff,                /* dst_mask */
1002          FALSE),                /* pcrel_offset */
1003
1004   /* 16 bit TOC-relative relocation, high 16 bits.  */
1005
1006   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HI,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_reloc,   /* special_function */
1015          "R_PPC64_TOC16_HI",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1022      contents of the low 16 bits, treated as a signed number, is
1023      negative.  */
1024
1025   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1026   HOWTO (R_PPC64_TOC16_HA,      /* type */
1027          16,                    /* rightshift */
1028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          16,                    /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_signed, /* complain_on_overflow */
1033          ppc64_elf_toc_ha_reloc, /* special_function */
1034          "R_PPC64_TOC16_HA",    /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0xffff,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1041
1042   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1043   HOWTO (R_PPC64_TOC,           /* type */
1044          0,                     /* rightshift */
1045          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1046          64,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_toc64_reloc, /* special_function */
1051          "R_PPC64_TOC",         /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          ONES (64),             /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_GOT16, but also informs the link editor that the
1058      value to relocate may (!) refer to a PLT entry which the link
1059      editor (a) may replace with the symbol value.  If the link editor
1060      is unable to fully resolve the symbol, it may (b) create a PLT
1061      entry and store the address to the new PLT entry in the GOT.
1062      This permits lazy resolution of function symbols at run time.
1063      The link editor may also skip all of this and just (c) emit a
1064      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1065   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1066     HOWTO (R_PPC64_PLTGOT16,    /* type */
1067          0,                     /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16",    /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1081   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1082   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1083          0,                     /* rightshift */
1084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1085          16,                    /* bitsize */
1086          FALSE,                 /* pc_relative */
1087          0,                     /* bitpos */
1088          complain_overflow_dont, /* complain_on_overflow */
1089          ppc64_elf_unhandled_reloc, /* special_function */
1090          "R_PPC64_PLTGOT16_LO", /* name */
1091          FALSE,                 /* partial_inplace */
1092          0,                     /* src_mask */
1093          0xffff,                /* dst_mask */
1094          FALSE),                /* pcrel_offset */
1095
1096   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1097   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1098   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1099          16,                    /* rightshift */
1100          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1101          16,                    /* bitsize */
1102          FALSE,                 /* pc_relative */
1103          0,                     /* bitpos */
1104          complain_overflow_signed, /* complain_on_overflow */
1105          ppc64_elf_unhandled_reloc, /* special_function */
1106          "R_PPC64_PLTGOT16_HI", /* name */
1107          FALSE,                 /* partial_inplace */
1108          0,                     /* src_mask */
1109          0xffff,                /* dst_mask */
1110          FALSE),                /* pcrel_offset */
1111
1112   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1113      1 if the contents of the low 16 bits, treated as a signed number,
1114      is negative.  */
1115   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1116   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1117          16,                    /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_signed, /* complain_on_overflow */
1123          ppc64_elf_unhandled_reloc, /* special_function */
1124          "R_PPC64_PLTGOT16_HA", /* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xffff,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          bfd_elf_generic_reloc, /* special_function */
1139          "R_PPC64_ADDR16_DS",   /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont,/* complain_on_overflow */
1153          bfd_elf_generic_reloc, /* special_function */
1154          "R_PPC64_ADDR16_LO_DS",/* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_GOT16_DS,      /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_signed, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_GOT16_DS",    /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_dont, /* complain_on_overflow */
1183          ppc64_elf_unhandled_reloc, /* special_function */
1184          "R_PPC64_GOT16_LO_DS", /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_unhandled_reloc, /* special_function */
1199          "R_PPC64_PLT16_LO_DS", /* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_sectoff_reloc, /* special_function */
1214          "R_PPC64_SECTOFF_DS",  /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_sectoff_reloc, /* special_function */
1229          "R_PPC64_SECTOFF_LO_DS",/* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1236   HOWTO (R_PPC64_TOC16_DS,      /* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_signed, /* complain_on_overflow */
1243          ppc64_elf_toc_reloc,   /* special_function */
1244          "R_PPC64_TOC16_DS",    /* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1251   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_toc_reloc,   /* special_function */
1259          "R_PPC64_TOC16_LO_DS", /* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1266   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1267   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1268          0,                     /* rightshift */
1269          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1270          16,                    /* bitsize */
1271          FALSE,                 /* pc_relative */
1272          0,                     /* bitpos */
1273          complain_overflow_signed, /* complain_on_overflow */
1274          ppc64_elf_unhandled_reloc, /* special_function */
1275          "R_PPC64_PLTGOT16_DS", /* name */
1276          FALSE,                 /* partial_inplace */
1277          0,                     /* src_mask */
1278          0xfffc,                /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1282   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1283   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1284          0,                     /* rightshift */
1285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1286          16,                    /* bitsize */
1287          FALSE,                 /* pc_relative */
1288          0,                     /* bitpos */
1289          complain_overflow_dont, /* complain_on_overflow */
1290          ppc64_elf_unhandled_reloc, /* special_function */
1291          "R_PPC64_PLTGOT16_LO_DS",/* name */
1292          FALSE,                 /* partial_inplace */
1293          0,                     /* src_mask */
1294          0xfffc,                /* dst_mask */
1295          FALSE),                /* pcrel_offset */
1296
1297   /* Marker relocs for TLS.  */
1298   HOWTO (R_PPC64_TLS,
1299          0,                     /* rightshift */
1300          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1301          32,                    /* bitsize */
1302          FALSE,                 /* pc_relative */
1303          0,                     /* bitpos */
1304          complain_overflow_dont, /* complain_on_overflow */
1305          bfd_elf_generic_reloc, /* special_function */
1306          "R_PPC64_TLS",         /* name */
1307          FALSE,                 /* partial_inplace */
1308          0,                     /* src_mask */
1309          0,                     /* dst_mask */
1310          FALSE),                /* pcrel_offset */
1311
1312   HOWTO (R_PPC64_TLSGD,
1313          0,                     /* rightshift */
1314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1315          32,                    /* bitsize */
1316          FALSE,                 /* pc_relative */
1317          0,                     /* bitpos */
1318          complain_overflow_dont, /* complain_on_overflow */
1319          bfd_elf_generic_reloc, /* special_function */
1320          "R_PPC64_TLSGD",       /* name */
1321          FALSE,                 /* partial_inplace */
1322          0,                     /* src_mask */
1323          0,                     /* dst_mask */
1324          FALSE),                /* pcrel_offset */
1325
1326   HOWTO (R_PPC64_TLSLD,
1327          0,                     /* rightshift */
1328          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          32,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          bfd_elf_generic_reloc, /* special_function */
1334          "R_PPC64_TLSLD",       /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          0,                     /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Marker reloc for optimizing r2 save in prologue rather than on
1341      each plt call stub.  */
1342   HOWTO (R_PPC64_TOCSAVE,
1343          0,                     /* rightshift */
1344          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          32,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_dont, /* complain_on_overflow */
1349          bfd_elf_generic_reloc, /* special_function */
1350          "R_PPC64_TOCSAVE",     /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          0,                     /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* Marker relocs on inline plt call instructions.  */
1357   HOWTO (R_PPC64_PLTSEQ,
1358          0,                     /* rightshift */
1359          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          32,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_dont, /* complain_on_overflow */
1364          bfd_elf_generic_reloc, /* special_function */
1365          "R_PPC64_PLTSEQ",      /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0,                     /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   HOWTO (R_PPC64_PLTCALL,
1372          0,                     /* rightshift */
1373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          32,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          bfd_elf_generic_reloc, /* special_function */
1379          "R_PPC64_PLTCALL",     /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0,                     /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Computes the load module index of the load module that contains the
1386      definition of its TLS sym.  */
1387   HOWTO (R_PPC64_DTPMOD64,
1388          0,                     /* rightshift */
1389          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          64,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_dont, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPMOD64",    /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          ONES (64),             /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Computes a dtv-relative displacement, the difference between the value
1402      of sym+add and the base address of the thread-local storage block that
1403      contains the definition of sym, minus 0x8000.  */
1404   HOWTO (R_PPC64_DTPREL64,
1405          0,                     /* rightshift */
1406          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1407          64,                    /* bitsize */
1408          FALSE,                 /* pc_relative */
1409          0,                     /* bitpos */
1410          complain_overflow_dont, /* complain_on_overflow */
1411          ppc64_elf_unhandled_reloc, /* special_function */
1412          "R_PPC64_DTPREL64",    /* name */
1413          FALSE,                 /* partial_inplace */
1414          0,                     /* src_mask */
1415          ONES (64),             /* dst_mask */
1416          FALSE),                /* pcrel_offset */
1417
1418   /* A 16 bit dtprel reloc.  */
1419   HOWTO (R_PPC64_DTPREL16,
1420          0,                     /* rightshift */
1421          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1422          16,                    /* bitsize */
1423          FALSE,                 /* pc_relative */
1424          0,                     /* bitpos */
1425          complain_overflow_signed, /* complain_on_overflow */
1426          ppc64_elf_unhandled_reloc, /* special_function */
1427          "R_PPC64_DTPREL16",    /* name */
1428          FALSE,                 /* partial_inplace */
1429          0,                     /* src_mask */
1430          0xffff,                /* dst_mask */
1431          FALSE),                /* pcrel_offset */
1432
1433   /* Like DTPREL16, but no overflow.  */
1434   HOWTO (R_PPC64_DTPREL16_LO,
1435          0,                     /* rightshift */
1436          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1437          16,                    /* bitsize */
1438          FALSE,                 /* pc_relative */
1439          0,                     /* bitpos */
1440          complain_overflow_dont, /* complain_on_overflow */
1441          ppc64_elf_unhandled_reloc, /* special_function */
1442          "R_PPC64_DTPREL16_LO", /* name */
1443          FALSE,                 /* partial_inplace */
1444          0,                     /* src_mask */
1445          0xffff,                /* dst_mask */
1446          FALSE),                /* pcrel_offset */
1447
1448   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1449   HOWTO (R_PPC64_DTPREL16_HI,
1450          16,                    /* rightshift */
1451          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1452          16,                    /* bitsize */
1453          FALSE,                 /* pc_relative */
1454          0,                     /* bitpos */
1455          complain_overflow_signed, /* complain_on_overflow */
1456          ppc64_elf_unhandled_reloc, /* special_function */
1457          "R_PPC64_DTPREL16_HI", /* name */
1458          FALSE,                 /* partial_inplace */
1459          0,                     /* src_mask */
1460          0xffff,                /* dst_mask */
1461          FALSE),                /* pcrel_offset */
1462
1463   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1464   HOWTO (R_PPC64_DTPREL16_HA,
1465          16,                    /* rightshift */
1466          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1467          16,                    /* bitsize */
1468          FALSE,                 /* pc_relative */
1469          0,                     /* bitpos */
1470          complain_overflow_signed, /* complain_on_overflow */
1471          ppc64_elf_unhandled_reloc, /* special_function */
1472          "R_PPC64_DTPREL16_HA", /* name */
1473          FALSE,                 /* partial_inplace */
1474          0,                     /* src_mask */
1475          0xffff,                /* dst_mask */
1476          FALSE),                /* pcrel_offset */
1477
1478   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1479   HOWTO (R_PPC64_DTPREL16_HIGHER,
1480          32,                    /* rightshift */
1481          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1482          16,                    /* bitsize */
1483          FALSE,                 /* pc_relative */
1484          0,                     /* bitpos */
1485          complain_overflow_dont, /* complain_on_overflow */
1486          ppc64_elf_unhandled_reloc, /* special_function */
1487          "R_PPC64_DTPREL16_HIGHER", /* name */
1488          FALSE,                 /* partial_inplace */
1489          0,                     /* src_mask */
1490          0xffff,                /* dst_mask */
1491          FALSE),                /* pcrel_offset */
1492
1493   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1494   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1495          32,                    /* rightshift */
1496          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1497          16,                    /* bitsize */
1498          FALSE,                 /* pc_relative */
1499          0,                     /* bitpos */
1500          complain_overflow_dont, /* complain_on_overflow */
1501          ppc64_elf_unhandled_reloc, /* special_function */
1502          "R_PPC64_DTPREL16_HIGHERA", /* name */
1503          FALSE,                 /* partial_inplace */
1504          0,                     /* src_mask */
1505          0xffff,                /* dst_mask */
1506          FALSE),                /* pcrel_offset */
1507
1508   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1509   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1510          48,                    /* rightshift */
1511          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          16,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_DTPREL16_HIGHEST", /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          0xffff,                /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1524   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1525          48,                    /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_dont, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like DTPREL16, but for insns with a DS field.  */
1539   HOWTO (R_PPC64_DTPREL16_DS,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_signed, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_DTPREL16_DS", /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xfffc,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like DTPREL16_DS, but no overflow.  */
1554   HOWTO (R_PPC64_DTPREL16_LO_DS,
1555          0,                     /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_dont, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_DTPREL16_LO_DS", /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xfffc,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Computes a tp-relative displacement, the difference between the value of
1569      sym+add and the value of the thread pointer (r13).  */
1570   HOWTO (R_PPC64_TPREL64,
1571          0,                     /* rightshift */
1572          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1573          64,                    /* bitsize */
1574          FALSE,                 /* pc_relative */
1575          0,                     /* bitpos */
1576          complain_overflow_dont, /* complain_on_overflow */
1577          ppc64_elf_unhandled_reloc, /* special_function */
1578          "R_PPC64_TPREL64",     /* name */
1579          FALSE,                 /* partial_inplace */
1580          0,                     /* src_mask */
1581          ONES (64),             /* dst_mask */
1582          FALSE),                /* pcrel_offset */
1583
1584   /* A 16 bit tprel reloc.  */
1585   HOWTO (R_PPC64_TPREL16,
1586          0,                     /* rightshift */
1587          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1588          16,                    /* bitsize */
1589          FALSE,                 /* pc_relative */
1590          0,                     /* bitpos */
1591          complain_overflow_signed, /* complain_on_overflow */
1592          ppc64_elf_unhandled_reloc, /* special_function */
1593          "R_PPC64_TPREL16",     /* name */
1594          FALSE,                 /* partial_inplace */
1595          0,                     /* src_mask */
1596          0xffff,                /* dst_mask */
1597          FALSE),                /* pcrel_offset */
1598
1599   /* Like TPREL16, but no overflow.  */
1600   HOWTO (R_PPC64_TPREL16_LO,
1601          0,                     /* rightshift */
1602          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1603          16,                    /* bitsize */
1604          FALSE,                 /* pc_relative */
1605          0,                     /* bitpos */
1606          complain_overflow_dont, /* complain_on_overflow */
1607          ppc64_elf_unhandled_reloc, /* special_function */
1608          "R_PPC64_TPREL16_LO",  /* name */
1609          FALSE,                 /* partial_inplace */
1610          0,                     /* src_mask */
1611          0xffff,                /* dst_mask */
1612          FALSE),                /* pcrel_offset */
1613
1614   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1615   HOWTO (R_PPC64_TPREL16_HI,
1616          16,                    /* rightshift */
1617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1618          16,                    /* bitsize */
1619          FALSE,                 /* pc_relative */
1620          0,                     /* bitpos */
1621          complain_overflow_signed, /* complain_on_overflow */
1622          ppc64_elf_unhandled_reloc, /* special_function */
1623          "R_PPC64_TPREL16_HI",  /* name */
1624          FALSE,                 /* partial_inplace */
1625          0,                     /* src_mask */
1626          0xffff,                /* dst_mask */
1627          FALSE),                /* pcrel_offset */
1628
1629   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1630   HOWTO (R_PPC64_TPREL16_HA,
1631          16,                    /* rightshift */
1632          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1633          16,                    /* bitsize */
1634          FALSE,                 /* pc_relative */
1635          0,                     /* bitpos */
1636          complain_overflow_signed, /* complain_on_overflow */
1637          ppc64_elf_unhandled_reloc, /* special_function */
1638          "R_PPC64_TPREL16_HA",  /* name */
1639          FALSE,                 /* partial_inplace */
1640          0,                     /* src_mask */
1641          0xffff,                /* dst_mask */
1642          FALSE),                /* pcrel_offset */
1643
1644   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1645   HOWTO (R_PPC64_TPREL16_HIGHER,
1646          32,                    /* rightshift */
1647          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1648          16,                    /* bitsize */
1649          FALSE,                 /* pc_relative */
1650          0,                     /* bitpos */
1651          complain_overflow_dont, /* complain_on_overflow */
1652          ppc64_elf_unhandled_reloc, /* special_function */
1653          "R_PPC64_TPREL16_HIGHER",      /* name */
1654          FALSE,                 /* partial_inplace */
1655          0,                     /* src_mask */
1656          0xffff,                /* dst_mask */
1657          FALSE),                /* pcrel_offset */
1658
1659   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1660   HOWTO (R_PPC64_TPREL16_HIGHERA,
1661          32,                    /* rightshift */
1662          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1663          16,                    /* bitsize */
1664          FALSE,                 /* pc_relative */
1665          0,                     /* bitpos */
1666          complain_overflow_dont, /* complain_on_overflow */
1667          ppc64_elf_unhandled_reloc, /* special_function */
1668          "R_PPC64_TPREL16_HIGHERA", /* name */
1669          FALSE,                 /* partial_inplace */
1670          0,                     /* src_mask */
1671          0xffff,                /* dst_mask */
1672          FALSE),                /* pcrel_offset */
1673
1674   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1675   HOWTO (R_PPC64_TPREL16_HIGHEST,
1676          48,                    /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_dont, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_TPREL16_HIGHEST", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1690   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1691          48,                    /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_dont, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_TPREL16_HIGHESTA", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like TPREL16, but for insns with a DS field.  */
1705   HOWTO (R_PPC64_TPREL16_DS,
1706          0,                     /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_TPREL16_DS",  /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xfffc,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like TPREL16_DS, but no overflow.  */
1720   HOWTO (R_PPC64_TPREL16_LO_DS,
1721          0,                     /* rightshift */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1723          16,                    /* bitsize */
1724          FALSE,                 /* pc_relative */
1725          0,                     /* bitpos */
1726          complain_overflow_dont, /* complain_on_overflow */
1727          ppc64_elf_unhandled_reloc, /* special_function */
1728          "R_PPC64_TPREL16_LO_DS", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xfffc,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1736      to the first entry relative to the TOC base (r2).  */
1737   HOWTO (R_PPC64_GOT_TLSGD16,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_signed, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSGD16", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSGD16, but no overflow.  */
1752   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_dont, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSGD16_LO", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1768          16,                    /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSGD16_HI", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1782   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1783          16,                    /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSGD16_HA", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1797      with values (sym+add)@dtpmod and zero, and computes the offset to the
1798      first entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_TLSLD16,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_TLSLD16", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xffff,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_TLSLD16, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_TLSLD16_LO", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xffff,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_TLSLD16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_TLSLD16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1859      the offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_DTPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_DTPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_DTPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_DTPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1920      offset to the entry relative to the TOC base (r2).  */
1921   HOWTO (R_PPC64_GOT_TPREL16_DS,
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          FALSE,                 /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_signed, /* complain_on_overflow */
1928          ppc64_elf_unhandled_reloc, /* special_function */
1929          "R_PPC64_GOT_TPREL16_DS", /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xfffc,                /* dst_mask */
1933          FALSE),                /* pcrel_offset */
1934
1935   /* Like GOT_TPREL16_DS, but no overflow.  */
1936   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1937          0,                     /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          FALSE,                 /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          ppc64_elf_unhandled_reloc, /* special_function */
1944          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xfffc,                /* dst_mask */
1948          FALSE),                /* pcrel_offset */
1949
1950   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1951   HOWTO (R_PPC64_GOT_TPREL16_HI,
1952          16,                    /* rightshift */
1953          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1954          16,                    /* bitsize */
1955          FALSE,                 /* pc_relative */
1956          0,                     /* bitpos */
1957          complain_overflow_signed, /* complain_on_overflow */
1958          ppc64_elf_unhandled_reloc, /* special_function */
1959          "R_PPC64_GOT_TPREL16_HI", /* name */
1960          FALSE,                 /* partial_inplace */
1961          0,                     /* src_mask */
1962          0xffff,                /* dst_mask */
1963          FALSE),                /* pcrel_offset */
1964
1965   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1966   HOWTO (R_PPC64_GOT_TPREL16_HA,
1967          16,                    /* rightshift */
1968          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1969          16,                    /* bitsize */
1970          FALSE,                 /* pc_relative */
1971          0,                     /* bitpos */
1972          complain_overflow_signed, /* complain_on_overflow */
1973          ppc64_elf_unhandled_reloc, /* special_function */
1974          "R_PPC64_GOT_TPREL16_HA", /* name */
1975          FALSE,                 /* partial_inplace */
1976          0,                     /* src_mask */
1977          0xffff,                /* dst_mask */
1978          FALSE),                /* pcrel_offset */
1979
1980   HOWTO (R_PPC64_JMP_IREL,      /* type */
1981          0,                     /* rightshift */
1982          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1983          0,                     /* bitsize */
1984          FALSE,                 /* pc_relative */
1985          0,                     /* bitpos */
1986          complain_overflow_dont, /* complain_on_overflow */
1987          ppc64_elf_unhandled_reloc, /* special_function */
1988          "R_PPC64_JMP_IREL",    /* name */
1989          FALSE,                 /* partial_inplace */
1990          0,                     /* src_mask */
1991          0,                     /* dst_mask */
1992          FALSE),                /* pcrel_offset */
1993
1994   HOWTO (R_PPC64_IRELATIVE,     /* type */
1995          0,                     /* rightshift */
1996          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1997          64,                    /* bitsize */
1998          FALSE,                 /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_dont, /* complain_on_overflow */
2001          bfd_elf_generic_reloc, /* special_function */
2002          "R_PPC64_IRELATIVE",   /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          ONES (64),             /* dst_mask */
2006          FALSE),                /* pcrel_offset */
2007
2008   /* A 16 bit relative relocation.  */
2009   HOWTO (R_PPC64_REL16,         /* type */
2010          0,                     /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          TRUE,                  /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_signed, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_REL16",       /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          TRUE),                 /* pcrel_offset */
2022
2023   /* A 16 bit relative relocation without overflow.  */
2024   HOWTO (R_PPC64_REL16_LO,      /* type */
2025          0,                     /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          TRUE,                  /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont,/* complain_on_overflow */
2031          bfd_elf_generic_reloc, /* special_function */
2032          "R_PPC64_REL16_LO",    /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          TRUE),                 /* pcrel_offset */
2037
2038   /* The high order 16 bits of a relative address.  */
2039   HOWTO (R_PPC64_REL16_HI,      /* type */
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          TRUE,                  /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_signed, /* complain_on_overflow */
2046          bfd_elf_generic_reloc, /* special_function */
2047          "R_PPC64_REL16_HI",    /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          TRUE),                 /* pcrel_offset */
2052
2053   /* The high order 16 bits of a relative address, plus 1 if the contents of
2054      the low 16 bits, treated as a signed number, is negative.  */
2055   HOWTO (R_PPC64_REL16_HA,      /* type */
2056          16,                    /* rightshift */
2057          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2058          16,                    /* bitsize */
2059          TRUE,                  /* pc_relative */
2060          0,                     /* bitpos */
2061          complain_overflow_signed, /* complain_on_overflow */
2062          ppc64_elf_ha_reloc,    /* special_function */
2063          "R_PPC64_REL16_HA",    /* name */
2064          FALSE,                 /* partial_inplace */
2065          0,                     /* src_mask */
2066          0xffff,                /* dst_mask */
2067          TRUE),                 /* pcrel_offset */
2068
2069   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2070   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2071          16,                    /* rightshift */
2072          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2073          16,                    /* bitsize */
2074          TRUE,                  /* pc_relative */
2075          0,                     /* bitpos */
2076          complain_overflow_signed, /* complain_on_overflow */
2077          ppc64_elf_ha_reloc,    /* special_function */
2078          "R_PPC64_REL16DX_HA",  /* name */
2079          FALSE,                 /* partial_inplace */
2080          0,                     /* src_mask */
2081          0x1fffc1,              /* dst_mask */
2082          TRUE),                 /* pcrel_offset */
2083
2084   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2085   HOWTO (R_PPC64_16DX_HA,       /* type */
2086          16,                    /* rightshift */
2087          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2088          16,                    /* bitsize */
2089          FALSE,                 /* pc_relative */
2090          0,                     /* bitpos */
2091          complain_overflow_signed, /* complain_on_overflow */
2092          ppc64_elf_ha_reloc,    /* special_function */
2093          "R_PPC64_16DX_HA",     /* name */
2094          FALSE,                 /* partial_inplace */
2095          0,                     /* src_mask */
2096          0x1fffc1,              /* dst_mask */
2097          FALSE),                /* pcrel_offset */
2098
2099   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2100   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2101          16,                    /* rightshift */
2102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2103          16,                    /* bitsize */
2104          FALSE,                 /* pc_relative */
2105          0,                     /* bitpos */
2106          complain_overflow_dont, /* complain_on_overflow */
2107          bfd_elf_generic_reloc, /* special_function */
2108          "R_PPC64_ADDR16_HIGH", /* name */
2109          FALSE,                 /* partial_inplace */
2110          0,                     /* src_mask */
2111          0xffff,                /* dst_mask */
2112          FALSE),                /* pcrel_offset */
2113
2114   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2115   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2116          16,                    /* rightshift */
2117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2118          16,                    /* bitsize */
2119          FALSE,                 /* pc_relative */
2120          0,                     /* bitpos */
2121          complain_overflow_dont, /* complain_on_overflow */
2122          ppc64_elf_ha_reloc,    /* special_function */
2123          "R_PPC64_ADDR16_HIGHA",        /* name */
2124          FALSE,                 /* partial_inplace */
2125          0,                     /* src_mask */
2126          0xffff,                /* dst_mask */
2127          FALSE),                /* pcrel_offset */
2128
2129   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2130   HOWTO (R_PPC64_DTPREL16_HIGH,
2131          16,                    /* rightshift */
2132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2133          16,                    /* bitsize */
2134          FALSE,                 /* pc_relative */
2135          0,                     /* bitpos */
2136          complain_overflow_dont, /* complain_on_overflow */
2137          ppc64_elf_unhandled_reloc, /* special_function */
2138          "R_PPC64_DTPREL16_HIGH", /* name */
2139          FALSE,                 /* partial_inplace */
2140          0,                     /* src_mask */
2141          0xffff,                /* dst_mask */
2142          FALSE),                /* pcrel_offset */
2143
2144   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2145   HOWTO (R_PPC64_DTPREL16_HIGHA,
2146          16,                    /* rightshift */
2147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2148          16,                    /* bitsize */
2149          FALSE,                 /* pc_relative */
2150          0,                     /* bitpos */
2151          complain_overflow_dont, /* complain_on_overflow */
2152          ppc64_elf_unhandled_reloc, /* special_function */
2153          "R_PPC64_DTPREL16_HIGHA", /* name */
2154          FALSE,                 /* partial_inplace */
2155          0,                     /* src_mask */
2156          0xffff,                /* dst_mask */
2157          FALSE),                /* pcrel_offset */
2158
2159   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2160   HOWTO (R_PPC64_TPREL16_HIGH,
2161          16,                    /* rightshift */
2162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2163          16,                    /* bitsize */
2164          FALSE,                 /* pc_relative */
2165          0,                     /* bitpos */
2166          complain_overflow_dont, /* complain_on_overflow */
2167          ppc64_elf_unhandled_reloc, /* special_function */
2168          "R_PPC64_TPREL16_HIGH",        /* name */
2169          FALSE,                 /* partial_inplace */
2170          0,                     /* src_mask */
2171          0xffff,                /* dst_mask */
2172          FALSE),                /* pcrel_offset */
2173
2174   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2175   HOWTO (R_PPC64_TPREL16_HIGHA,
2176          16,                    /* rightshift */
2177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2178          16,                    /* bitsize */
2179          FALSE,                 /* pc_relative */
2180          0,                     /* bitpos */
2181          complain_overflow_dont, /* complain_on_overflow */
2182          ppc64_elf_unhandled_reloc, /* special_function */
2183          "R_PPC64_TPREL16_HIGHA",       /* name */
2184          FALSE,                 /* partial_inplace */
2185          0,                     /* src_mask */
2186          0xffff,                /* dst_mask */
2187          FALSE),                /* pcrel_offset */
2188
2189   /* Marker reloc on ELFv2 large-model function entry.  */
2190   HOWTO (R_PPC64_ENTRY,
2191          0,                     /* rightshift */
2192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2193          32,                    /* bitsize */
2194          FALSE,                 /* pc_relative */
2195          0,                     /* bitpos */
2196          complain_overflow_dont, /* complain_on_overflow */
2197          bfd_elf_generic_reloc, /* special_function */
2198          "R_PPC64_ENTRY",       /* name */
2199          FALSE,                 /* partial_inplace */
2200          0,                     /* src_mask */
2201          0,                     /* dst_mask */
2202          FALSE),                /* pcrel_offset */
2203
2204   /* Like ADDR64, but use local entry point of function.  */
2205   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2206          0,                     /* rightshift */
2207          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2208          64,                    /* bitsize */
2209          FALSE,                 /* pc_relative */
2210          0,                     /* bitpos */
2211          complain_overflow_dont, /* complain_on_overflow */
2212          bfd_elf_generic_reloc, /* special_function */
2213          "R_PPC64_ADDR64_LOCAL", /* name */
2214          FALSE,                 /* partial_inplace */
2215          0,                     /* src_mask */
2216          ONES (64),             /* dst_mask */
2217          FALSE),                /* pcrel_offset */
2218
2219   /* GNU extension to record C++ vtable hierarchy.  */
2220   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2221          0,                     /* rightshift */
2222          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2223          0,                     /* bitsize */
2224          FALSE,                 /* pc_relative */
2225          0,                     /* bitpos */
2226          complain_overflow_dont, /* complain_on_overflow */
2227          NULL,                  /* special_function */
2228          "R_PPC64_GNU_VTINHERIT", /* name */
2229          FALSE,                 /* partial_inplace */
2230          0,                     /* src_mask */
2231          0,                     /* dst_mask */
2232          FALSE),                /* pcrel_offset */
2233
2234   /* GNU extension to record C++ vtable member usage.  */
2235   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2236          0,                     /* rightshift */
2237          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2238          0,                     /* bitsize */
2239          FALSE,                 /* pc_relative */
2240          0,                     /* bitpos */
2241          complain_overflow_dont, /* complain_on_overflow */
2242          NULL,                  /* special_function */
2243          "R_PPC64_GNU_VTENTRY", /* name */
2244          FALSE,                 /* partial_inplace */
2245          0,                     /* src_mask */
2246          0,                     /* dst_mask */
2247          FALSE),                /* pcrel_offset */
2248 };
2249
2250 \f
2251 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2252    be done.  */
2253
2254 static void
2255 ppc_howto_init (void)
2256 {
2257   unsigned int i, type;
2258
2259   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2260     {
2261       type = ppc64_elf_howto_raw[i].type;
2262       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2263       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2264     }
2265 }
2266
2267 static reloc_howto_type *
2268 ppc64_elf_reloc_type_lookup (bfd *abfd,
2269                              bfd_reloc_code_real_type code)
2270 {
2271   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2272
2273   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2274     /* Initialize howto table if needed.  */
2275     ppc_howto_init ();
2276
2277   switch (code)
2278     {
2279     default:
2280       /* xgettext:c-format */
2281       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2282       bfd_set_error (bfd_error_bad_value);
2283       return NULL;
2284
2285     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2286       break;
2287     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2288       break;
2289     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2290       break;
2291     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2292       break;
2293     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2294       break;
2295     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2296       break;
2297     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2298       break;
2299     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2300       break;
2301     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2302       break;
2303     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2304       break;
2305     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2306       break;
2307     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2308       break;
2309     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2310       break;
2311     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2312       break;
2313     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2314       break;
2315     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2316       break;
2317     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2318       break;
2319     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2320       break;
2321     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2322       break;
2323     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2324       break;
2325     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2326       break;
2327     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2328       break;
2329     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2330       break;
2331     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2332       break;
2333     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2334       break;
2335     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2336       break;
2337     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2338       break;
2339     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2340       break;
2341     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2342       break;
2343     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2344       break;
2345     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2346       break;
2347     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2348       break;
2349     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2350       break;
2351     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2352       break;
2353     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2354       break;
2355     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2356       break;
2357     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2358       break;
2359     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2360       break;
2361     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2362       break;
2363     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2364       break;
2365     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2366       break;
2367     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2368       break;
2369     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2370       break;
2371     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2372       break;
2373     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2374       break;
2375     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2376       break;
2377     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2378       break;
2379     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2380       break;
2381     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2384       break;
2385     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2386       break;
2387     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2388       break;
2389     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2390       break;
2391     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2392       break;
2393     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2394       break;
2395     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2396       break;
2397     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2398       break;
2399     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2400       break;
2401     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2402       break;
2403     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2404       break;
2405     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2406       break;
2407     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2408       break;
2409     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2410       break;
2411     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2412       break;
2413     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2414       break;
2415     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2416       break;
2417     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2418       break;
2419     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2422       break;
2423     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2426       break;
2427     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2428       break;
2429     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2430       break;
2431     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2432       break;
2433     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2436       break;
2437     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2440       break;
2441     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2442       break;
2443     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2444       break;
2445     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2446       break;
2447     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2448       break;
2449     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2450       break;
2451     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2452       break;
2453     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2454       break;
2455     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2456       break;
2457     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2458       break;
2459     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2460       break;
2461     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2462       break;
2463     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2464       break;
2465     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2466       break;
2467     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2468       break;
2469     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2470       break;
2471     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2472       break;
2473     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2474       break;
2475     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2476       break;
2477     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2478       break;
2479     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2480       break;
2481     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2482       break;
2483     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2484       break;
2485     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2486       break;
2487     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2488       break;
2489     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2490       break;
2491     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2492       break;
2493     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2494       break;
2495     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2496       break;
2497     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2498       break;
2499     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2500       break;
2501     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2502       break;
2503     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2504       break;
2505     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2506       break;
2507     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2508       break;
2509     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2510       break;
2511     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2512       break;
2513     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2514       break;
2515     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2516       break;
2517     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2518       break;
2519     }
2520
2521   return ppc64_elf_howto_table[r];
2522 };
2523
2524 static reloc_howto_type *
2525 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2526                              const char *r_name)
2527 {
2528   unsigned int i;
2529
2530   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2531     if (ppc64_elf_howto_raw[i].name != NULL
2532         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2533       return &ppc64_elf_howto_raw[i];
2534
2535
2536   return NULL;
2537 }
2538
2539 /* Set the howto pointer for a PowerPC ELF reloc.  */
2540
2541 static bfd_boolean
2542 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2543                          Elf_Internal_Rela *dst)
2544 {
2545   unsigned int type;
2546
2547   /* Initialize howto table if needed.  */
2548   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2549     ppc_howto_init ();
2550
2551   type = ELF64_R_TYPE (dst->r_info);
2552   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2553     {
2554       /* xgettext:c-format */
2555       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2556                           abfd, type);
2557       bfd_set_error (bfd_error_bad_value);
2558       return FALSE;
2559     }
2560   cache_ptr->howto = ppc64_elf_howto_table[type];
2561   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2562     {
2563       /* xgettext:c-format */
2564       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2565                           abfd, type);
2566       bfd_set_error (bfd_error_bad_value);
2567       return FALSE;
2568     }
2569
2570   return TRUE;
2571 }
2572
2573 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2574
2575 static bfd_reloc_status_type
2576 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2577                     void *data, asection *input_section,
2578                     bfd *output_bfd, char **error_message)
2579 {
2580   enum elf_ppc64_reloc_type r_type;
2581   long insn;
2582   bfd_size_type octets;
2583   bfd_vma value;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   /* Adjust the addend for sign extension of the low 16 bits.
2593      We won't actually be using the low 16 bits, so trashing them
2594      doesn't matter.  */
2595   reloc_entry->addend += 0x8000;
2596   r_type = reloc_entry->howto->type;
2597   if (r_type != R_PPC64_REL16DX_HA)
2598     return bfd_reloc_continue;
2599
2600   value = 0;
2601   if (!bfd_is_com_section (symbol->section))
2602     value = symbol->value;
2603   value += (reloc_entry->addend
2604             + symbol->section->output_offset
2605             + symbol->section->output_section->vma);
2606   value -= (reloc_entry->address
2607             + input_section->output_offset
2608             + input_section->output_section->vma);
2609   value = (bfd_signed_vma) value >> 16;
2610
2611   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2612   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2613   insn &= ~0x1fffc1;
2614   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2615   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2616   if (value + 0x8000 > 0xffff)
2617     return bfd_reloc_overflow;
2618   return bfd_reloc_ok;
2619 }
2620
2621 static bfd_reloc_status_type
2622 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2623                         void *data, asection *input_section,
2624                         bfd *output_bfd, char **error_message)
2625 {
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   if (strcmp (symbol->section->name, ".opd") == 0
2631       && (symbol->section->owner->flags & DYNAMIC) == 0)
2632     {
2633       bfd_vma dest = opd_entry_value (symbol->section,
2634                                       symbol->value + reloc_entry->addend,
2635                                       NULL, NULL, FALSE);
2636       if (dest != (bfd_vma) -1)
2637         reloc_entry->addend = dest - (symbol->value
2638                                       + symbol->section->output_section->vma
2639                                       + symbol->section->output_offset);
2640     }
2641   else
2642     {
2643       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2644
2645       if (symbol->section->owner != abfd
2646           && symbol->section->owner != NULL
2647           && abiversion (symbol->section->owner) >= 2)
2648         {
2649           unsigned int i;
2650
2651           for (i = 0; i < symbol->section->owner->symcount; ++i)
2652             {
2653               asymbol *symdef = symbol->section->owner->outsymbols[i];
2654
2655               if (strcmp (symdef->name, symbol->name) == 0)
2656                 {
2657                   elfsym = (elf_symbol_type *) symdef;
2658                   break;
2659                 }
2660             }
2661         }
2662       reloc_entry->addend
2663         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2664     }
2665   return bfd_reloc_continue;
2666 }
2667
2668 static bfd_reloc_status_type
2669 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2670                          void *data, asection *input_section,
2671                          bfd *output_bfd, char **error_message)
2672 {
2673   long insn;
2674   enum elf_ppc64_reloc_type r_type;
2675   bfd_size_type octets;
2676   /* Assume 'at' branch hints.  */
2677   bfd_boolean is_isa_v2 = TRUE;
2678
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2687   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2688   insn &= ~(0x01 << 21);
2689   r_type = reloc_entry->howto->type;
2690   if (r_type == R_PPC64_ADDR14_BRTAKEN
2691       || r_type == R_PPC64_REL14_BRTAKEN)
2692     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2693
2694   if (is_isa_v2)
2695     {
2696       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2697          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2698          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2699       if ((insn & (0x14 << 21)) == (0x04 << 21))
2700         insn |= 0x02 << 21;
2701       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2702         insn |= 0x08 << 21;
2703       else
2704         goto out;
2705     }
2706   else
2707     {
2708       bfd_vma target = 0;
2709       bfd_vma from;
2710
2711       if (!bfd_is_com_section (symbol->section))
2712         target = symbol->value;
2713       target += symbol->section->output_section->vma;
2714       target += symbol->section->output_offset;
2715       target += reloc_entry->addend;
2716
2717       from = (reloc_entry->address
2718               + input_section->output_offset
2719               + input_section->output_section->vma);
2720
2721       /* Invert 'y' bit if not the default.  */
2722       if ((bfd_signed_vma) (target - from) < 0)
2723         insn ^= 0x01 << 21;
2724     }
2725   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2726  out:
2727   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2728                                  input_section, output_bfd, error_message);
2729 }
2730
2731 static bfd_reloc_status_type
2732 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2733                          void *data, asection *input_section,
2734                          bfd *output_bfd, char **error_message)
2735 {
2736   /* If this is a relocatable link (output_bfd test tells us), just
2737      call the generic function.  Any adjustment will be done at final
2738      link time.  */
2739   if (output_bfd != NULL)
2740     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2741                                   input_section, output_bfd, error_message);
2742
2743   /* Subtract the symbol section base address.  */
2744   reloc_entry->addend -= symbol->section->output_section->vma;
2745   return bfd_reloc_continue;
2746 }
2747
2748 static bfd_reloc_status_type
2749 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2750                             void *data, asection *input_section,
2751                             bfd *output_bfd, char **error_message)
2752 {
2753   /* If this is a relocatable link (output_bfd test tells us), just
2754      call the generic function.  Any adjustment will be done at final
2755      link time.  */
2756   if (output_bfd != NULL)
2757     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2758                                   input_section, output_bfd, error_message);
2759
2760   /* Subtract the symbol section base address.  */
2761   reloc_entry->addend -= symbol->section->output_section->vma;
2762
2763   /* Adjust the addend for sign extension of the low 16 bits.  */
2764   reloc_entry->addend += 0x8000;
2765   return bfd_reloc_continue;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                      void *data, asection *input_section,
2771                      bfd *output_bfd, char **error_message)
2772 {
2773   bfd_vma TOCstart;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   /* Subtract the TOC base address.  */
2787   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2788   return bfd_reloc_continue;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                         void *data, asection *input_section,
2794                         bfd *output_bfd, char **error_message)
2795 {
2796   bfd_vma TOCstart;
2797
2798   /* If this is a relocatable link (output_bfd test tells us), just
2799      call the generic function.  Any adjustment will be done at final
2800      link time.  */
2801   if (output_bfd != NULL)
2802     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2803                                   input_section, output_bfd, error_message);
2804
2805   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2806   if (TOCstart == 0)
2807     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2808
2809   /* Subtract the TOC base address.  */
2810   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2811
2812   /* Adjust the addend for sign extension of the low 16 bits.  */
2813   reloc_entry->addend += 0x8000;
2814   return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819                        void *data, asection *input_section,
2820                        bfd *output_bfd, char **error_message)
2821 {
2822   bfd_vma TOCstart;
2823   bfd_size_type octets;
2824
2825   /* If this is a relocatable link (output_bfd test tells us), just
2826      call the generic function.  Any adjustment will be done at final
2827      link time.  */
2828   if (output_bfd != NULL)
2829     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2830                                   input_section, output_bfd, error_message);
2831
2832   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2833   if (TOCstart == 0)
2834     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2835
2836   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2837   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2838   return bfd_reloc_ok;
2839 }
2840
2841 static bfd_reloc_status_type
2842 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2843                            void *data, asection *input_section,
2844                            bfd *output_bfd, char **error_message)
2845 {
2846   /* If this is a relocatable link (output_bfd test tells us), just
2847      call the generic function.  Any adjustment will be done at final
2848      link time.  */
2849   if (output_bfd != NULL)
2850     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2851                                   input_section, output_bfd, error_message);
2852
2853   if (error_message != NULL)
2854     {
2855       static char buf[60];
2856       sprintf (buf, "generic linker can't handle %s",
2857                reloc_entry->howto->name);
2858       *error_message = buf;
2859     }
2860   return bfd_reloc_dangerous;
2861 }
2862
2863 /* Track GOT entries needed for a given symbol.  We might need more
2864    than one got entry per symbol.  */
2865 struct got_entry
2866 {
2867   struct got_entry *next;
2868
2869   /* The symbol addend that we'll be placing in the GOT.  */
2870   bfd_vma addend;
2871
2872   /* Unlike other ELF targets, we use separate GOT entries for the same
2873      symbol referenced from different input files.  This is to support
2874      automatic multiple TOC/GOT sections, where the TOC base can vary
2875      from one input file to another.  After partitioning into TOC groups
2876      we merge entries within the group.
2877
2878      Point to the BFD owning this GOT entry.  */
2879   bfd *owner;
2880
2881   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2882      TLS_TPREL or TLS_DTPREL for tls entries.  */
2883   unsigned char tls_type;
2884
2885   /* Non-zero if got.ent points to real entry.  */
2886   unsigned char is_indirect;
2887
2888   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2889   union
2890     {
2891       bfd_signed_vma refcount;
2892       bfd_vma offset;
2893       struct got_entry *ent;
2894     } got;
2895 };
2896
2897 /* The same for PLT.  */
2898 struct plt_entry
2899 {
2900   struct plt_entry *next;
2901
2902   bfd_vma addend;
2903
2904   union
2905     {
2906       bfd_signed_vma refcount;
2907       bfd_vma offset;
2908     } plt;
2909 };
2910
2911 struct ppc64_elf_obj_tdata
2912 {
2913   struct elf_obj_tdata elf;
2914
2915   /* Shortcuts to dynamic linker sections.  */
2916   asection *got;
2917   asection *relgot;
2918
2919   /* Used during garbage collection.  We attach global symbols defined
2920      on removed .opd entries to this section so that the sym is removed.  */
2921   asection *deleted_section;
2922
2923   /* TLS local dynamic got entry handling.  Support for multiple GOT
2924      sections means we potentially need one of these for each input bfd.  */
2925   struct got_entry tlsld_got;
2926
2927   union {
2928     /* A copy of relocs before they are modified for --emit-relocs.  */
2929     Elf_Internal_Rela *relocs;
2930
2931     /* Section contents.  */
2932     bfd_byte *contents;
2933   } opd;
2934
2935   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2936      the reloc to be in the range -32768 to 32767.  */
2937   unsigned int has_small_toc_reloc : 1;
2938
2939   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2940      instruction not one we handle.  */
2941   unsigned int unexpected_toc_insn : 1;
2942 };
2943
2944 #define ppc64_elf_tdata(bfd) \
2945   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2946
2947 #define ppc64_tlsld_got(bfd) \
2948   (&ppc64_elf_tdata (bfd)->tlsld_got)
2949
2950 #define is_ppc64_elf(bfd) \
2951   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2952    && elf_object_id (bfd) == PPC64_ELF_DATA)
2953
2954 /* Override the generic function because we store some extras.  */
2955
2956 static bfd_boolean
2957 ppc64_elf_mkobject (bfd *abfd)
2958 {
2959   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2960                                   PPC64_ELF_DATA);
2961 }
2962
2963 /* Fix bad default arch selected for a 64 bit input bfd when the
2964    default is 32 bit.  Also select arch based on apuinfo.  */
2965
2966 static bfd_boolean
2967 ppc64_elf_object_p (bfd *abfd)
2968 {
2969   if (!abfd->arch_info->the_default)
2970     return TRUE;
2971
2972   if (abfd->arch_info->bits_per_word == 32)
2973     {
2974       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2975
2976       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2977         {
2978           /* Relies on arch after 32 bit default being 64 bit default.  */
2979           abfd->arch_info = abfd->arch_info->next;
2980           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2981         }
2982     }
2983   return _bfd_elf_ppc_set_arch (abfd);
2984 }
2985
2986 /* Support for core dump NOTE sections.  */
2987
2988 static bfd_boolean
2989 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2990 {
2991   size_t offset, size;
2992
2993   if (note->descsz != 504)
2994     return FALSE;
2995
2996   /* pr_cursig */
2997   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2998
2999   /* pr_pid */
3000   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3001
3002   /* pr_reg */
3003   offset = 112;
3004   size = 384;
3005
3006   /* Make a ".reg/999" section.  */
3007   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3008                                           size, note->descpos + offset);
3009 }
3010
3011 static bfd_boolean
3012 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3013 {
3014   if (note->descsz != 136)
3015     return FALSE;
3016
3017   elf_tdata (abfd)->core->pid
3018     = bfd_get_32 (abfd, note->descdata + 24);
3019   elf_tdata (abfd)->core->program
3020     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3021   elf_tdata (abfd)->core->command
3022     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3023
3024   return TRUE;
3025 }
3026
3027 static char *
3028 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3029                            ...)
3030 {
3031   switch (note_type)
3032     {
3033     default:
3034       return NULL;
3035
3036     case NT_PRPSINFO:
3037       {
3038         char data[136];
3039         va_list ap;
3040
3041         va_start (ap, note_type);
3042         memset (data, 0, sizeof (data));
3043         strncpy (data + 40, va_arg (ap, const char *), 16);
3044         strncpy (data + 56, va_arg (ap, const char *), 80);
3045         va_end (ap);
3046         return elfcore_write_note (abfd, buf, bufsiz,
3047                                    "CORE", note_type, data, sizeof (data));
3048       }
3049
3050     case NT_PRSTATUS:
3051       {
3052         char data[504];
3053         va_list ap;
3054         long pid;
3055         int cursig;
3056         const void *greg;
3057
3058         va_start (ap, note_type);
3059         memset (data, 0, 112);
3060         pid = va_arg (ap, long);
3061         bfd_put_32 (abfd, pid, data + 32);
3062         cursig = va_arg (ap, int);
3063         bfd_put_16 (abfd, cursig, data + 12);
3064         greg = va_arg (ap, const void *);
3065         memcpy (data + 112, greg, 384);
3066         memset (data + 496, 0, 8);
3067         va_end (ap);
3068         return elfcore_write_note (abfd, buf, bufsiz,
3069                                    "CORE", note_type, data, sizeof (data));
3070       }
3071     }
3072 }
3073
3074 /* Add extra PPC sections.  */
3075
3076 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3077 {
3078   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3079   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3080   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3081   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3082   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3083   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3084   { NULL,                     0,  0, 0,            0 }
3085 };
3086
3087 enum _ppc64_sec_type {
3088   sec_normal = 0,
3089   sec_opd = 1,
3090   sec_toc = 2
3091 };
3092
3093 struct _ppc64_elf_section_data
3094 {
3095   struct bfd_elf_section_data elf;
3096
3097   union
3098   {
3099     /* An array with one entry for each opd function descriptor,
3100        and some spares since opd entries may be either 16 or 24 bytes.  */
3101 #define OPD_NDX(OFF) ((OFF) >> 4)
3102     struct _opd_sec_data
3103     {
3104       /* Points to the function code section for local opd entries.  */
3105       asection **func_sec;
3106
3107       /* After editing .opd, adjust references to opd local syms.  */
3108       long *adjust;
3109     } opd;
3110
3111     /* An array for toc sections, indexed by offset/8.  */
3112     struct _toc_sec_data
3113     {
3114       /* Specifies the relocation symbol index used at a given toc offset.  */
3115       unsigned *symndx;
3116
3117       /* And the relocation addend.  */
3118       bfd_vma *add;
3119     } toc;
3120   } u;
3121
3122   enum _ppc64_sec_type sec_type:2;
3123
3124   /* Flag set when small branches are detected.  Used to
3125      select suitable defaults for the stub group size.  */
3126   unsigned int has_14bit_branch:1;
3127
3128   /* Flag set when PLTCALL relocs are detected.  */
3129   unsigned int has_pltcall:1;
3130 };
3131
3132 #define ppc64_elf_section_data(sec) \
3133   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3134
3135 static bfd_boolean
3136 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3137 {
3138   if (!sec->used_by_bfd)
3139     {
3140       struct _ppc64_elf_section_data *sdata;
3141       bfd_size_type amt = sizeof (*sdata);
3142
3143       sdata = bfd_zalloc (abfd, amt);
3144       if (sdata == NULL)
3145         return FALSE;
3146       sec->used_by_bfd = sdata;
3147     }
3148
3149   return _bfd_elf_new_section_hook (abfd, sec);
3150 }
3151
3152 static struct _opd_sec_data *
3153 get_opd_info (asection * sec)
3154 {
3155   if (sec != NULL
3156       && ppc64_elf_section_data (sec) != NULL
3157       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3158     return &ppc64_elf_section_data (sec)->u.opd;
3159   return NULL;
3160 }
3161 \f
3162 /* Parameters for the qsort hook.  */
3163 static bfd_boolean synthetic_relocatable;
3164 static asection *synthetic_opd;
3165
3166 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3167
3168 static int
3169 compare_symbols (const void *ap, const void *bp)
3170 {
3171   const asymbol *a = * (const asymbol **) ap;
3172   const asymbol *b = * (const asymbol **) bp;
3173
3174   /* Section symbols first.  */
3175   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3176     return -1;
3177   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3178     return 1;
3179
3180   /* then .opd symbols.  */
3181   if (synthetic_opd != NULL)
3182     {
3183       if (strcmp (a->section->name, ".opd") == 0
3184           && strcmp (b->section->name, ".opd") != 0)
3185         return -1;
3186       if (strcmp (a->section->name, ".opd") != 0
3187           && strcmp (b->section->name, ".opd") == 0)
3188         return 1;
3189     }
3190
3191   /* then other code symbols.  */
3192   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3193       == (SEC_CODE | SEC_ALLOC)
3194       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195          != (SEC_CODE | SEC_ALLOC))
3196     return -1;
3197
3198   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3199       != (SEC_CODE | SEC_ALLOC)
3200       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3201          == (SEC_CODE | SEC_ALLOC))
3202     return 1;
3203
3204   if (synthetic_relocatable)
3205     {
3206       if (a->section->id < b->section->id)
3207         return -1;
3208
3209       if (a->section->id > b->section->id)
3210         return 1;
3211     }
3212
3213   if (a->value + a->section->vma < b->value + b->section->vma)
3214     return -1;
3215
3216   if (a->value + a->section->vma > b->value + b->section->vma)
3217     return 1;
3218
3219   /* For syms with the same value, prefer strong dynamic global function
3220      syms over other syms.  */
3221   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3222     return -1;
3223
3224   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3225     return 1;
3226
3227   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3228     return -1;
3229
3230   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3231     return 1;
3232
3233   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3234     return -1;
3235
3236   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3237     return 1;
3238
3239   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3240     return -1;
3241
3242   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3243     return 1;
3244
3245   return a > b;
3246 }
3247
3248 /* Search SYMS for a symbol of the given VALUE.  */
3249
3250 static asymbol *
3251 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3252 {
3253   long mid;
3254
3255   if (id == (unsigned) -1)
3256     {
3257       while (lo < hi)
3258         {
3259           mid = (lo + hi) >> 1;
3260           if (syms[mid]->value + syms[mid]->section->vma < value)
3261             lo = mid + 1;
3262           else if (syms[mid]->value + syms[mid]->section->vma > value)
3263             hi = mid;
3264           else
3265             return syms[mid];
3266         }
3267     }
3268   else
3269     {
3270       while (lo < hi)
3271         {
3272           mid = (lo + hi) >> 1;
3273           if (syms[mid]->section->id < id)
3274             lo = mid + 1;
3275           else if (syms[mid]->section->id > id)
3276             hi = mid;
3277           else if (syms[mid]->value < value)
3278             lo = mid + 1;
3279           else if (syms[mid]->value > value)
3280             hi = mid;
3281           else
3282             return syms[mid];
3283         }
3284     }
3285   return NULL;
3286 }
3287
3288 static bfd_boolean
3289 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3290 {
3291   bfd_vma vma = *(bfd_vma *) ptr;
3292   return ((section->flags & SEC_ALLOC) != 0
3293           && section->vma <= vma
3294           && vma < section->vma + section->size);
3295 }
3296
3297 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3298    entry syms.  Also generate @plt symbols for the glink branch table.
3299    Returns count of synthetic symbols in RET or -1 on error.  */
3300
3301 static long
3302 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3303                                 long static_count, asymbol **static_syms,
3304                                 long dyn_count, asymbol **dyn_syms,
3305                                 asymbol **ret)
3306 {
3307   asymbol *s;
3308   size_t i, j, count;
3309   char *names;
3310   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3311   asection *opd = NULL;
3312   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3313   asymbol **syms;
3314   int abi = abiversion (abfd);
3315
3316   *ret = NULL;
3317
3318   if (abi < 2)
3319     {
3320       opd = bfd_get_section_by_name (abfd, ".opd");
3321       if (opd == NULL && abi == 1)
3322         return 0;
3323     }
3324
3325   syms = NULL;
3326   codesecsym = 0;
3327   codesecsymend = 0;
3328   secsymend = 0;
3329   opdsymend = 0;
3330   symcount = 0;
3331   if (opd != NULL)
3332     {
3333       symcount = static_count;
3334       if (!relocatable)
3335         symcount += dyn_count;
3336       if (symcount == 0)
3337         return 0;
3338
3339       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3340       if (syms == NULL)
3341         return -1;
3342
3343       if (!relocatable && static_count != 0 && dyn_count != 0)
3344         {
3345           /* Use both symbol tables.  */
3346           memcpy (syms, static_syms, static_count * sizeof (*syms));
3347           memcpy (syms + static_count, dyn_syms,
3348                   (dyn_count + 1) * sizeof (*syms));
3349         }
3350       else if (!relocatable && static_count == 0)
3351         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3352       else
3353         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3354
3355       /* Trim uninteresting symbols.  Interesting symbols are section,
3356          function, and notype symbols.  */
3357       for (i = 0, j = 0; i < symcount; ++i)
3358         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3359                                | BSF_RELC | BSF_SRELC)) == 0)
3360           syms[j++] = syms[i];
3361       symcount = j;
3362
3363       synthetic_relocatable = relocatable;
3364       synthetic_opd = opd;
3365       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3366
3367       if (!relocatable && symcount > 1)
3368         {
3369           /* Trim duplicate syms, since we may have merged the normal and
3370              dynamic symbols.  Actually, we only care about syms that have
3371              different values, so trim any with the same value.  */
3372           for (i = 1, j = 1; i < symcount; ++i)
3373             if (syms[i - 1]->value + syms[i - 1]->section->vma
3374                 != syms[i]->value + syms[i]->section->vma)
3375               syms[j++] = syms[i];
3376           symcount = j;
3377         }
3378
3379       i = 0;
3380       /* Note that here and in compare_symbols we can't compare opd and
3381          sym->section directly.  With separate debug info files, the
3382          symbols will be extracted from the debug file while abfd passed
3383          to this function is the real binary.  */
3384       if (strcmp (syms[i]->section->name, ".opd") == 0)
3385         ++i;
3386       codesecsym = i;
3387
3388       for (; i < symcount; ++i)
3389         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3390                                          | SEC_THREAD_LOCAL))
3391              != (SEC_CODE | SEC_ALLOC))
3392             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3393           break;
3394       codesecsymend = i;
3395
3396       for (; i < symcount; ++i)
3397         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3398           break;
3399       secsymend = i;
3400
3401       for (; i < symcount; ++i)
3402         if (strcmp (syms[i]->section->name, ".opd") != 0)
3403           break;
3404       opdsymend = i;
3405
3406       for (; i < symcount; ++i)
3407         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3408             != (SEC_CODE | SEC_ALLOC))
3409           break;
3410       symcount = i;
3411     }
3412   count = 0;
3413
3414   if (relocatable)
3415     {
3416       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3417       arelent *r;
3418       size_t size;
3419       size_t relcount;
3420
3421       if (opdsymend == secsymend)
3422         goto done;
3423
3424       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3425       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3426       if (relcount == 0)
3427         goto done;
3428
3429       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3430         {
3431           count = -1;
3432           goto done;
3433         }
3434
3435       size = 0;
3436       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3437         {
3438           asymbol *sym;
3439
3440           while (r < opd->relocation + relcount
3441                  && r->address < syms[i]->value + opd->vma)
3442             ++r;
3443
3444           if (r == opd->relocation + relcount)
3445             break;
3446
3447           if (r->address != syms[i]->value + opd->vma)
3448             continue;
3449
3450           if (r->howto->type != R_PPC64_ADDR64)
3451             continue;
3452
3453           sym = *r->sym_ptr_ptr;
3454           if (!sym_exists_at (syms, opdsymend, symcount,
3455                               sym->section->id, sym->value + r->addend))
3456             {
3457               ++count;
3458               size += sizeof (asymbol);
3459               size += strlen (syms[i]->name) + 2;
3460             }
3461         }
3462
3463       if (size == 0)
3464         goto done;
3465       s = *ret = bfd_malloc (size);
3466       if (s == NULL)
3467         {
3468           count = -1;
3469           goto done;
3470         }
3471
3472       names = (char *) (s + count);
3473
3474       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3475         {
3476           asymbol *sym;
3477
3478           while (r < opd->relocation + relcount
3479                  && r->address < syms[i]->value + opd->vma)
3480             ++r;
3481
3482           if (r == opd->relocation + relcount)
3483             break;
3484
3485           if (r->address != syms[i]->value + opd->vma)
3486             continue;
3487
3488           if (r->howto->type != R_PPC64_ADDR64)
3489             continue;
3490
3491           sym = *r->sym_ptr_ptr;
3492           if (!sym_exists_at (syms, opdsymend, symcount,
3493                               sym->section->id, sym->value + r->addend))
3494             {
3495               size_t len;
3496
3497               *s = *syms[i];
3498               s->flags |= BSF_SYNTHETIC;
3499               s->section = sym->section;
3500               s->value = sym->value + r->addend;
3501               s->name = names;
3502               *names++ = '.';
3503               len = strlen (syms[i]->name);
3504               memcpy (names, syms[i]->name, len + 1);
3505               names += len + 1;
3506               /* Have udata.p point back to the original symbol this
3507                  synthetic symbol was derived from.  */
3508               s->udata.p = syms[i];
3509               s++;
3510             }
3511         }
3512     }
3513   else
3514     {
3515       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3516       bfd_byte *contents = NULL;
3517       size_t size;
3518       size_t plt_count = 0;
3519       bfd_vma glink_vma = 0, resolv_vma = 0;
3520       asection *dynamic, *glink = NULL, *relplt = NULL;
3521       arelent *p;
3522
3523       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3524         {
3525         free_contents_and_exit_err:
3526           count = -1;
3527         free_contents_and_exit:
3528           if (contents)
3529             free (contents);
3530           goto done;
3531         }
3532
3533       size = 0;
3534       for (i = secsymend; i < opdsymend; ++i)
3535         {
3536           bfd_vma ent;
3537
3538           /* Ignore bogus symbols.  */
3539           if (syms[i]->value > opd->size - 8)
3540             continue;
3541
3542           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3543           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3544             {
3545               ++count;
3546               size += sizeof (asymbol);
3547               size += strlen (syms[i]->name) + 2;
3548             }
3549         }
3550
3551       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3552       if (dyn_count != 0
3553           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3554         {
3555           bfd_byte *dynbuf, *extdyn, *extdynend;
3556           size_t extdynsize;
3557           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3558
3559           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3560             goto free_contents_and_exit_err;
3561
3562           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3563           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3564
3565           extdyn = dynbuf;
3566           extdynend = extdyn + dynamic->size;
3567           for (; extdyn < extdynend; extdyn += extdynsize)
3568             {
3569               Elf_Internal_Dyn dyn;
3570               (*swap_dyn_in) (abfd, extdyn, &dyn);
3571
3572               if (dyn.d_tag == DT_NULL)
3573                 break;
3574
3575               if (dyn.d_tag == DT_PPC64_GLINK)
3576                 {
3577                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3578                      See comment in ppc64_elf_finish_dynamic_sections. */
3579                   glink_vma = dyn.d_un.d_val + 8 * 4;
3580                   /* The .glink section usually does not survive the final
3581                      link; search for the section (usually .text) where the
3582                      glink stubs now reside.  */
3583                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3584                                                 &glink_vma);
3585                   break;
3586                 }
3587             }
3588
3589           free (dynbuf);
3590         }
3591
3592       if (glink != NULL)
3593         {
3594           /* Determine __glink trampoline by reading the relative branch
3595              from the first glink stub.  */
3596           bfd_byte buf[4];
3597           unsigned int off = 0;
3598
3599           while (bfd_get_section_contents (abfd, glink, buf,
3600                                            glink_vma + off - glink->vma, 4))
3601             {
3602               unsigned int insn = bfd_get_32 (abfd, buf);
3603               insn ^= B_DOT;
3604               if ((insn & ~0x3fffffc) == 0)
3605                 {
3606                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3607                   break;
3608                 }
3609               off += 4;
3610               if (off > 4)
3611                 break;
3612             }
3613
3614           if (resolv_vma)
3615             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3616
3617           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3618           if (relplt != NULL)
3619             {
3620               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3621               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3622                 goto free_contents_and_exit_err;
3623
3624               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3625               size += plt_count * sizeof (asymbol);
3626
3627               p = relplt->relocation;
3628               for (i = 0; i < plt_count; i++, p++)
3629                 {
3630                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3631                   if (p->addend != 0)
3632                     size += sizeof ("+0x") - 1 + 16;
3633                 }
3634             }
3635         }
3636
3637       if (size == 0)
3638         goto free_contents_and_exit;
3639       s = *ret = bfd_malloc (size);
3640       if (s == NULL)
3641         goto free_contents_and_exit_err;
3642
3643       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3644
3645       for (i = secsymend; i < opdsymend; ++i)
3646         {
3647           bfd_vma ent;
3648
3649           if (syms[i]->value > opd->size - 8)
3650             continue;
3651
3652           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3653           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3654             {
3655               size_t lo, hi;
3656               size_t len;
3657               asection *sec = abfd->sections;
3658
3659               *s = *syms[i];
3660               lo = codesecsym;
3661               hi = codesecsymend;
3662               while (lo < hi)
3663                 {
3664                   size_t mid = (lo + hi) >> 1;
3665                   if (syms[mid]->section->vma < ent)
3666                     lo = mid + 1;
3667                   else if (syms[mid]->section->vma > ent)
3668                     hi = mid;
3669                   else
3670                     {
3671                       sec = syms[mid]->section;
3672                       break;
3673                     }
3674                 }
3675
3676               if (lo >= hi && lo > codesecsym)
3677                 sec = syms[lo - 1]->section;
3678
3679               for (; sec != NULL; sec = sec->next)
3680                 {
3681                   if (sec->vma > ent)
3682                     break;
3683                   /* SEC_LOAD may not be set if SEC is from a separate debug
3684                      info file.  */
3685                   if ((sec->flags & SEC_ALLOC) == 0)
3686                     break;
3687                   if ((sec->flags & SEC_CODE) != 0)
3688                     s->section = sec;
3689                 }
3690               s->flags |= BSF_SYNTHETIC;
3691               s->value = ent - s->section->vma;
3692               s->name = names;
3693               *names++ = '.';
3694               len = strlen (syms[i]->name);
3695               memcpy (names, syms[i]->name, len + 1);
3696               names += len + 1;
3697               /* Have udata.p point back to the original symbol this
3698                  synthetic symbol was derived from.  */
3699               s->udata.p = syms[i];
3700               s++;
3701             }
3702         }
3703       free (contents);
3704
3705       if (glink != NULL && relplt != NULL)
3706         {
3707           if (resolv_vma)
3708             {
3709               /* Add a symbol for the main glink trampoline.  */
3710               memset (s, 0, sizeof *s);
3711               s->the_bfd = abfd;
3712               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3713               s->section = glink;
3714               s->value = resolv_vma - glink->vma;
3715               s->name = names;
3716               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3717               names += sizeof ("__glink_PLTresolve");
3718               s++;
3719               count++;
3720             }
3721
3722           /* FIXME: It would be very much nicer to put sym@plt on the
3723              stub rather than on the glink branch table entry.  The
3724              objdump disassembler would then use a sensible symbol
3725              name on plt calls.  The difficulty in doing so is
3726              a) finding the stubs, and,
3727              b) matching stubs against plt entries, and,
3728              c) there can be multiple stubs for a given plt entry.
3729
3730              Solving (a) could be done by code scanning, but older
3731              ppc64 binaries used different stubs to current code.
3732              (b) is the tricky one since you need to known the toc
3733              pointer for at least one function that uses a pic stub to
3734              be able to calculate the plt address referenced.
3735              (c) means gdb would need to set multiple breakpoints (or
3736              find the glink branch itself) when setting breakpoints
3737              for pending shared library loads.  */
3738           p = relplt->relocation;
3739           for (i = 0; i < plt_count; i++, p++)
3740             {
3741               size_t len;
3742
3743               *s = **p->sym_ptr_ptr;
3744               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3745                  we are defining a symbol, ensure one of them is set.  */
3746               if ((s->flags & BSF_LOCAL) == 0)
3747                 s->flags |= BSF_GLOBAL;
3748               s->flags |= BSF_SYNTHETIC;
3749               s->section = glink;
3750               s->value = glink_vma - glink->vma;
3751               s->name = names;
3752               s->udata.p = NULL;
3753               len = strlen ((*p->sym_ptr_ptr)->name);
3754               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3755               names += len;
3756               if (p->addend != 0)
3757                 {
3758                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3759                   names += sizeof ("+0x") - 1;
3760                   bfd_sprintf_vma (abfd, names, p->addend);
3761                   names += strlen (names);
3762                 }
3763               memcpy (names, "@plt", sizeof ("@plt"));
3764               names += sizeof ("@plt");
3765               s++;
3766               if (abi < 2)
3767                 {
3768                   glink_vma += 8;
3769                   if (i >= 0x8000)
3770                     glink_vma += 4;
3771                 }
3772               else
3773                 glink_vma += 4;
3774             }
3775           count += plt_count;
3776         }
3777     }
3778
3779  done:
3780   free (syms);
3781   return count;
3782 }
3783 \f
3784 /* The following functions are specific to the ELF linker, while
3785    functions above are used generally.  Those named ppc64_elf_* are
3786    called by the main ELF linker code.  They appear in this file more
3787    or less in the order in which they are called.  eg.
3788    ppc64_elf_check_relocs is called early in the link process,
3789    ppc64_elf_finish_dynamic_sections is one of the last functions
3790    called.
3791
3792    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3793    functions have both a function code symbol and a function descriptor
3794    symbol.  A call to foo in a relocatable object file looks like:
3795
3796    .            .text
3797    .    x:
3798    .            bl      .foo
3799    .            nop
3800
3801    The function definition in another object file might be:
3802
3803    .            .section .opd
3804    .    foo:    .quad   .foo
3805    .            .quad   .TOC.@tocbase
3806    .            .quad   0
3807    .
3808    .            .text
3809    .    .foo:   blr
3810
3811    When the linker resolves the call during a static link, the branch
3812    unsurprisingly just goes to .foo and the .opd information is unused.
3813    If the function definition is in a shared library, things are a little
3814    different:  The call goes via a plt call stub, the opd information gets
3815    copied to the plt, and the linker patches the nop.
3816
3817    .    x:
3818    .            bl      .foo_stub
3819    .            ld      2,40(1)
3820    .
3821    .
3822    .    .foo_stub:
3823    .            std     2,40(1)                 # in practice, the call stub
3824    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3825    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3826    .            ld      12,0(11)
3827    .            ld      2,8(11)
3828    .            mtctr   12
3829    .            ld      11,16(11)
3830    .            bctr
3831    .
3832    .            .section .plt
3833    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3834
3835    The "reloc ()" notation is supposed to indicate that the linker emits
3836    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3837    copying.
3838
3839    What are the difficulties here?  Well, firstly, the relocations
3840    examined by the linker in check_relocs are against the function code
3841    sym .foo, while the dynamic relocation in the plt is emitted against
3842    the function descriptor symbol, foo.  Somewhere along the line, we need
3843    to carefully copy dynamic link information from one symbol to the other.
3844    Secondly, the generic part of the elf linker will make .foo a dynamic
3845    symbol as is normal for most other backends.  We need foo dynamic
3846    instead, at least for an application final link.  However, when
3847    creating a shared library containing foo, we need to have both symbols
3848    dynamic so that references to .foo are satisfied during the early
3849    stages of linking.  Otherwise the linker might decide to pull in a
3850    definition from some other object, eg. a static library.
3851
3852    Update: As of August 2004, we support a new convention.  Function
3853    calls may use the function descriptor symbol, ie. "bl foo".  This
3854    behaves exactly as "bl .foo".  */
3855
3856 /* Of those relocs that might be copied as dynamic relocs, this
3857    function selects those that must be copied when linking a shared
3858    library or PIE, even when the symbol is local.  */
3859
3860 static int
3861 must_be_dyn_reloc (struct bfd_link_info *info,
3862                    enum elf_ppc64_reloc_type r_type)
3863 {
3864   switch (r_type)
3865     {
3866     default:
3867       /* Only relative relocs can be resolved when the object load
3868          address isn't fixed.  DTPREL64 is excluded because the
3869          dynamic linker needs to differentiate global dynamic from
3870          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3871       return 1;
3872
3873     case R_PPC64_REL32:
3874     case R_PPC64_REL64:
3875     case R_PPC64_REL30:
3876       return 0;
3877
3878     case R_PPC64_TPREL16:
3879     case R_PPC64_TPREL16_LO:
3880     case R_PPC64_TPREL16_HI:
3881     case R_PPC64_TPREL16_HA:
3882     case R_PPC64_TPREL16_DS:
3883     case R_PPC64_TPREL16_LO_DS:
3884     case R_PPC64_TPREL16_HIGH:
3885     case R_PPC64_TPREL16_HIGHA:
3886     case R_PPC64_TPREL16_HIGHER:
3887     case R_PPC64_TPREL16_HIGHERA:
3888     case R_PPC64_TPREL16_HIGHEST:
3889     case R_PPC64_TPREL16_HIGHESTA:
3890     case R_PPC64_TPREL64:
3891       /* These relocations are relative but in a shared library the
3892          linker doesn't know the thread pointer base.  */
3893       return bfd_link_dll (info);
3894     }
3895 }
3896
3897 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3898    copying dynamic variables from a shared lib into an app's dynbss
3899    section, and instead use a dynamic relocation to point into the
3900    shared lib.  With code that gcc generates, it's vital that this be
3901    enabled;  In the PowerPC64 ABI, the address of a function is actually
3902    the address of a function descriptor, which resides in the .opd
3903    section.  gcc uses the descriptor directly rather than going via the
3904    GOT as some other ABI's do, which means that initialized function
3905    pointers must reference the descriptor.  Thus, a function pointer
3906    initialized to the address of a function in a shared library will
3907    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3908    redefines the function descriptor symbol to point to the copy.  This
3909    presents a problem as a plt entry for that function is also
3910    initialized from the function descriptor symbol and the copy reloc
3911    may not be initialized first.  */
3912 #define ELIMINATE_COPY_RELOCS 1
3913
3914 /* Section name for stubs is the associated section name plus this
3915    string.  */
3916 #define STUB_SUFFIX ".stub"
3917
3918 /* Linker stubs.
3919    ppc_stub_long_branch:
3920    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3921    destination, but a 24 bit branch in a stub section will reach.
3922    .    b       dest
3923
3924    ppc_stub_plt_branch:
3925    Similar to the above, but a 24 bit branch in the stub section won't
3926    reach its destination.
3927    .    addis   %r11,%r2,xxx@toc@ha
3928    .    ld      %r12,xxx@toc@l(%r11)
3929    .    mtctr   %r12
3930    .    bctr
3931
3932    ppc_stub_plt_call:
3933    Used to call a function in a shared library.  If it so happens that
3934    the plt entry referenced crosses a 64k boundary, then an extra
3935    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3936    .    std     %r2,40(%r1)
3937    .    addis   %r11,%r2,xxx@toc@ha
3938    .    ld      %r12,xxx+0@toc@l(%r11)
3939    .    mtctr   %r12
3940    .    ld      %r2,xxx+8@toc@l(%r11)
3941    .    ld      %r11,xxx+16@toc@l(%r11)
3942    .    bctr
3943
3944    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3945    code to adjust the value and save r2 to support multiple toc sections.
3946    A ppc_stub_long_branch with an r2 offset looks like:
3947    .    std     %r2,40(%r1)
3948    .    addis   %r2,%r2,off@ha
3949    .    addi    %r2,%r2,off@l
3950    .    b       dest
3951
3952    A ppc_stub_plt_branch with an r2 offset looks like:
3953    .    std     %r2,40(%r1)
3954    .    addis   %r11,%r2,xxx@toc@ha
3955    .    ld      %r12,xxx@toc@l(%r11)
3956    .    addis   %r2,%r2,off@ha
3957    .    addi    %r2,%r2,off@l
3958    .    mtctr   %r12
3959    .    bctr
3960
3961    In cases where the "addis" instruction would add zero, the "addis" is
3962    omitted and following instructions modified slightly in some cases.
3963 */
3964
3965 enum ppc_stub_type {
3966   ppc_stub_none,
3967   ppc_stub_long_branch,
3968   ppc_stub_long_branch_r2off,
3969   ppc_stub_plt_branch,
3970   ppc_stub_plt_branch_r2off,
3971   ppc_stub_plt_call,
3972   ppc_stub_plt_call_r2save,
3973   ppc_stub_global_entry,
3974   ppc_stub_save_res
3975 };
3976
3977 /* Information on stub grouping.  */
3978 struct map_stub
3979 {
3980   /* The stub section.  */
3981   asection *stub_sec;
3982   /* This is the section to which stubs in the group will be attached.  */
3983   asection *link_sec;
3984   /* Next group.  */
3985   struct map_stub *next;
3986   /* Whether to emit a copy of register save/restore functions in this
3987      group.  */
3988   int needs_save_res;
3989   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3990      or -1u if no such stub with bctrl exists.  */
3991   unsigned int tls_get_addr_opt_bctrl;
3992 };
3993
3994 struct ppc_stub_hash_entry {
3995
3996   /* Base hash table entry structure.  */
3997   struct bfd_hash_entry root;
3998
3999   enum ppc_stub_type stub_type;
4000
4001   /* Group information.  */
4002   struct map_stub *group;
4003
4004   /* Offset within stub_sec of the beginning of this stub.  */
4005   bfd_vma stub_offset;
4006
4007   /* Given the symbol's value and its section we can determine its final
4008      value when building the stubs (so the stub knows where to jump.  */
4009   bfd_vma target_value;
4010   asection *target_section;
4011
4012   /* The symbol table entry, if any, that this was derived from.  */
4013   struct ppc_link_hash_entry *h;
4014   struct plt_entry *plt_ent;
4015
4016   /* Symbol type.  */
4017   unsigned char symtype;
4018
4019   /* Symbol st_other.  */
4020   unsigned char other;
4021 };
4022
4023 struct ppc_branch_hash_entry {
4024
4025   /* Base hash table entry structure.  */
4026   struct bfd_hash_entry root;
4027
4028   /* Offset within branch lookup table.  */
4029   unsigned int offset;
4030
4031   /* Generation marker.  */
4032   unsigned int iter;
4033 };
4034
4035 /* Used to track dynamic relocations for local symbols.  */
4036 struct ppc_dyn_relocs
4037 {
4038   struct ppc_dyn_relocs *next;
4039
4040   /* The input section of the reloc.  */
4041   asection *sec;
4042
4043   /* Total number of relocs copied for the input section.  */
4044   unsigned int count : 31;
4045
4046   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4047   unsigned int ifunc : 1;
4048 };
4049
4050 struct ppc_link_hash_entry
4051 {
4052   struct elf_link_hash_entry elf;
4053
4054   union {
4055     /* A pointer to the most recently used stub hash entry against this
4056        symbol.  */
4057     struct ppc_stub_hash_entry *stub_cache;
4058
4059     /* A pointer to the next symbol starting with a '.'  */
4060     struct ppc_link_hash_entry *next_dot_sym;
4061   } u;
4062
4063   /* Track dynamic relocs copied for this symbol.  */
4064   struct elf_dyn_relocs *dyn_relocs;
4065
4066   /* Link between function code and descriptor symbols.  */
4067   struct ppc_link_hash_entry *oh;
4068
4069   /* Flag function code and descriptor symbols.  */
4070   unsigned int is_func:1;
4071   unsigned int is_func_descriptor:1;
4072   unsigned int fake:1;
4073
4074   /* Whether global opd/toc sym has been adjusted or not.
4075      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4076      should be set for all globals defined in any opd/toc section.  */
4077   unsigned int adjust_done:1;
4078
4079   /* Set if this is an out-of-line register save/restore function,
4080      with non-standard calling convention.  */
4081   unsigned int save_res:1;
4082
4083   /* Set if a duplicate symbol with non-zero localentry is detected,
4084      even when the duplicate symbol does not provide a definition.  */
4085   unsigned int non_zero_localentry:1;
4086
4087   /* Contexts in which symbol is used in the GOT (or TOC).
4088      Bits are or'd into the mask as the corresponding relocs are
4089      encountered during check_relocs, with TLS_TLS being set when any
4090      of the other TLS bits are set.  tls_optimize clears bits when
4091      optimizing to indicate the corresponding GOT entry type is not
4092      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4093      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4094      separate flag rather than setting TPREL just for convenience in
4095      distinguishing the two cases.
4096      These flags are also kept for local symbols.  */
4097 #define TLS_TLS          1      /* Any TLS reloc.  */
4098 #define TLS_GD           2      /* GD reloc. */
4099 #define TLS_LD           4      /* LD reloc. */
4100 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4101 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4102 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4103 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4104 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4105   unsigned char tls_mask;
4106
4107   /* The above field is also used to mark function symbols.  In which
4108      case TLS_TLS will be 0.  */
4109 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4110 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4111 #define NON_GOT        256      /* local symbol plt, not stored.  */
4112 };
4113
4114 /* ppc64 ELF linker hash table.  */
4115
4116 struct ppc_link_hash_table
4117 {
4118   struct elf_link_hash_table elf;
4119
4120   /* The stub hash table.  */
4121   struct bfd_hash_table stub_hash_table;
4122
4123   /* Another hash table for plt_branch stubs.  */
4124   struct bfd_hash_table branch_hash_table;
4125
4126   /* Hash table for function prologue tocsave.  */
4127   htab_t tocsave_htab;
4128
4129   /* Various options and other info passed from the linker.  */
4130   struct ppc64_elf_params *params;
4131
4132   /* The size of sec_info below.  */
4133   unsigned int sec_info_arr_size;
4134
4135   /* Per-section array of extra section info.  Done this way rather
4136      than as part of ppc64_elf_section_data so we have the info for
4137      non-ppc64 sections.  */
4138   struct
4139   {
4140     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4141     bfd_vma toc_off;
4142
4143     union
4144     {
4145       /* The section group that this section belongs to.  */
4146       struct map_stub *group;
4147       /* A temp section list pointer.  */
4148       asection *list;
4149     } u;
4150   } *sec_info;
4151
4152   /* Linked list of groups.  */
4153   struct map_stub *group;
4154
4155   /* Temp used when calculating TOC pointers.  */
4156   bfd_vma toc_curr;
4157   bfd *toc_bfd;
4158   asection *toc_first_sec;
4159
4160   /* Used when adding symbols.  */
4161   struct ppc_link_hash_entry *dot_syms;
4162
4163   /* Shortcuts to get to dynamic linker sections.  */
4164   asection *glink;
4165   asection *global_entry;
4166   asection *sfpr;
4167   asection *pltlocal;
4168   asection *relpltlocal;
4169   asection *brlt;
4170   asection *relbrlt;
4171   asection *glink_eh_frame;
4172
4173   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4174   struct ppc_link_hash_entry *tls_get_addr;
4175   struct ppc_link_hash_entry *tls_get_addr_fd;
4176
4177   /* The size of reliplt used by got entry relocs.  */
4178   bfd_size_type got_reli_size;
4179
4180   /* Statistics.  */
4181   unsigned long stub_count[ppc_stub_global_entry];
4182
4183   /* Number of stubs against global syms.  */
4184   unsigned long stub_globals;
4185
4186   /* Set if we're linking code with function descriptors.  */
4187   unsigned int opd_abi:1;
4188
4189   /* Support for multiple toc sections.  */
4190   unsigned int do_multi_toc:1;
4191   unsigned int multi_toc_needed:1;
4192   unsigned int second_toc_pass:1;
4193   unsigned int do_toc_opt:1;
4194
4195   /* Set if tls optimization is enabled.  */
4196   unsigned int do_tls_opt:1;
4197
4198   /* Set if inline plt calls should be converted to direct calls.  */
4199   unsigned int can_convert_all_inline_plt:1;
4200
4201   /* Set on error.  */
4202   unsigned int stub_error:1;
4203
4204   /* Whether func_desc_adjust needs to be run over symbols.  */
4205   unsigned int need_func_desc_adj:1;
4206
4207   /* Whether there exist local gnu indirect function resolvers,
4208      referenced by dynamic relocations.  */
4209   unsigned int local_ifunc_resolver:1;
4210   unsigned int maybe_local_ifunc_resolver:1;
4211
4212   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4213   unsigned int has_plt_localentry0:1;
4214
4215   /* Incremented every time we size stubs.  */
4216   unsigned int stub_iteration;
4217
4218   /* Small local sym cache.  */
4219   struct sym_cache sym_cache;
4220 };
4221
4222 /* Rename some of the generic section flags to better document how they
4223    are used here.  */
4224
4225 /* Nonzero if this section has TLS related relocations.  */
4226 #define has_tls_reloc sec_flg0
4227
4228 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4229 #define has_tls_get_addr_call sec_flg1
4230
4231 /* Nonzero if this section has any toc or got relocs.  */
4232 #define has_toc_reloc sec_flg2
4233
4234 /* Nonzero if this section has a call to another section that uses
4235    the toc or got.  */
4236 #define makes_toc_func_call sec_flg3
4237
4238 /* Recursion protection when determining above flag.  */
4239 #define call_check_in_progress sec_flg4
4240 #define call_check_done sec_flg5
4241
4242 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4243
4244 #define ppc_hash_table(p) \
4245   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4246   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4247
4248 #define ppc_stub_hash_lookup(table, string, create, copy) \
4249   ((struct ppc_stub_hash_entry *) \
4250    bfd_hash_lookup ((table), (string), (create), (copy)))
4251
4252 #define ppc_branch_hash_lookup(table, string, create, copy) \
4253   ((struct ppc_branch_hash_entry *) \
4254    bfd_hash_lookup ((table), (string), (create), (copy)))
4255
4256 /* Create an entry in the stub hash table.  */
4257
4258 static struct bfd_hash_entry *
4259 stub_hash_newfunc (struct bfd_hash_entry *entry,
4260                    struct bfd_hash_table *table,
4261                    const char *string)
4262 {
4263   /* Allocate the structure if it has not already been allocated by a
4264      subclass.  */
4265   if (entry == NULL)
4266     {
4267       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4268       if (entry == NULL)
4269         return entry;
4270     }
4271
4272   /* Call the allocation method of the superclass.  */
4273   entry = bfd_hash_newfunc (entry, table, string);
4274   if (entry != NULL)
4275     {
4276       struct ppc_stub_hash_entry *eh;
4277
4278       /* Initialize the local fields.  */
4279       eh = (struct ppc_stub_hash_entry *) entry;
4280       eh->stub_type = ppc_stub_none;
4281       eh->group = NULL;
4282       eh->stub_offset = 0;
4283       eh->target_value = 0;
4284       eh->target_section = NULL;
4285       eh->h = NULL;
4286       eh->plt_ent = NULL;
4287       eh->other = 0;
4288     }
4289
4290   return entry;
4291 }
4292
4293 /* Create an entry in the branch hash table.  */
4294
4295 static struct bfd_hash_entry *
4296 branch_hash_newfunc (struct bfd_hash_entry *entry,
4297                      struct bfd_hash_table *table,
4298                      const char *string)
4299 {
4300   /* Allocate the structure if it has not already been allocated by a
4301      subclass.  */
4302   if (entry == NULL)
4303     {
4304       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4305       if (entry == NULL)
4306         return entry;
4307     }
4308
4309   /* Call the allocation method of the superclass.  */
4310   entry = bfd_hash_newfunc (entry, table, string);
4311   if (entry != NULL)
4312     {
4313       struct ppc_branch_hash_entry *eh;
4314
4315       /* Initialize the local fields.  */
4316       eh = (struct ppc_branch_hash_entry *) entry;
4317       eh->offset = 0;
4318       eh->iter = 0;
4319     }
4320
4321   return entry;
4322 }
4323
4324 /* Create an entry in a ppc64 ELF linker hash table.  */
4325
4326 static struct bfd_hash_entry *
4327 link_hash_newfunc (struct bfd_hash_entry *entry,
4328                    struct bfd_hash_table *table,
4329                    const char *string)
4330 {
4331   /* Allocate the structure if it has not already been allocated by a
4332      subclass.  */
4333   if (entry == NULL)
4334     {
4335       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4336       if (entry == NULL)
4337         return entry;
4338     }
4339
4340   /* Call the allocation method of the superclass.  */
4341   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4342   if (entry != NULL)
4343     {
4344       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4345
4346       memset (&eh->u.stub_cache, 0,
4347               (sizeof (struct ppc_link_hash_entry)
4348                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4349
4350       /* When making function calls, old ABI code references function entry
4351          points (dot symbols), while new ABI code references the function
4352          descriptor symbol.  We need to make any combination of reference and
4353          definition work together, without breaking archive linking.
4354
4355          For a defined function "foo" and an undefined call to "bar":
4356          An old object defines "foo" and ".foo", references ".bar" (possibly
4357          "bar" too).
4358          A new object defines "foo" and references "bar".
4359
4360          A new object thus has no problem with its undefined symbols being
4361          satisfied by definitions in an old object.  On the other hand, the
4362          old object won't have ".bar" satisfied by a new object.
4363
4364          Keep a list of newly added dot-symbols.  */
4365
4366       if (string[0] == '.')
4367         {
4368           struct ppc_link_hash_table *htab;
4369
4370           htab = (struct ppc_link_hash_table *) table;
4371           eh->u.next_dot_sym = htab->dot_syms;
4372           htab->dot_syms = eh;
4373         }
4374     }
4375
4376   return entry;
4377 }
4378
4379 struct tocsave_entry {
4380   asection *sec;
4381   bfd_vma offset;
4382 };
4383
4384 static hashval_t
4385 tocsave_htab_hash (const void *p)
4386 {
4387   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4388   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4389 }
4390
4391 static int
4392 tocsave_htab_eq (const void *p1, const void *p2)
4393 {
4394   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4395   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4396   return e1->sec == e2->sec && e1->offset == e2->offset;
4397 }
4398
4399 /* Destroy a ppc64 ELF linker hash table.  */
4400
4401 static void
4402 ppc64_elf_link_hash_table_free (bfd *obfd)
4403 {
4404   struct ppc_link_hash_table *htab;
4405
4406   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4407   if (htab->tocsave_htab)
4408     htab_delete (htab->tocsave_htab);
4409   bfd_hash_table_free (&htab->branch_hash_table);
4410   bfd_hash_table_free (&htab->stub_hash_table);
4411   _bfd_elf_link_hash_table_free (obfd);
4412 }
4413
4414 /* Create a ppc64 ELF linker hash table.  */
4415
4416 static struct bfd_link_hash_table *
4417 ppc64_elf_link_hash_table_create (bfd *abfd)
4418 {
4419   struct ppc_link_hash_table *htab;
4420   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4421
4422   htab = bfd_zmalloc (amt);
4423   if (htab == NULL)
4424     return NULL;
4425
4426   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4427                                       sizeof (struct ppc_link_hash_entry),
4428                                       PPC64_ELF_DATA))
4429     {
4430       free (htab);
4431       return NULL;
4432     }
4433
4434   /* Init the stub hash table too.  */
4435   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4436                             sizeof (struct ppc_stub_hash_entry)))
4437     {
4438       _bfd_elf_link_hash_table_free (abfd);
4439       return NULL;
4440     }
4441
4442   /* And the branch hash table.  */
4443   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4444                             sizeof (struct ppc_branch_hash_entry)))
4445     {
4446       bfd_hash_table_free (&htab->stub_hash_table);
4447       _bfd_elf_link_hash_table_free (abfd);
4448       return NULL;
4449     }
4450
4451   htab->tocsave_htab = htab_try_create (1024,
4452                                         tocsave_htab_hash,
4453                                         tocsave_htab_eq,
4454                                         NULL);
4455   if (htab->tocsave_htab == NULL)
4456     {
4457       ppc64_elf_link_hash_table_free (abfd);
4458       return NULL;
4459     }
4460   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4461
4462   /* Initializing two fields of the union is just cosmetic.  We really
4463      only care about glist, but when compiled on a 32-bit host the
4464      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4465      debugger inspection of these fields look nicer.  */
4466   htab->elf.init_got_refcount.refcount = 0;
4467   htab->elf.init_got_refcount.glist = NULL;
4468   htab->elf.init_plt_refcount.refcount = 0;
4469   htab->elf.init_plt_refcount.glist = NULL;
4470   htab->elf.init_got_offset.offset = 0;
4471   htab->elf.init_got_offset.glist = NULL;
4472   htab->elf.init_plt_offset.offset = 0;
4473   htab->elf.init_plt_offset.glist = NULL;
4474
4475   return &htab->elf.root;
4476 }
4477
4478 /* Create sections for linker generated code.  */
4479
4480 static bfd_boolean
4481 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4482 {
4483   struct ppc_link_hash_table *htab;
4484   flagword flags;
4485
4486   htab = ppc_hash_table (info);
4487
4488   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4489            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4490   if (htab->params->save_restore_funcs)
4491     {
4492       /* Create .sfpr for code to save and restore fp regs.  */
4493       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4494                                                        flags);
4495       if (htab->sfpr == NULL
4496           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4497         return FALSE;
4498     }
4499
4500   if (bfd_link_relocatable (info))
4501     return TRUE;
4502
4503   /* Create .glink for lazy dynamic linking support.  */
4504   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4505                                                     flags);
4506   if (htab->glink == NULL
4507       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4508     return FALSE;
4509
4510   /* The part of .glink used by global entry stubs, separate so that
4511      it can be aligned appropriately without affecting htab->glink.  */
4512   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4513                                                            flags);
4514   if (htab->global_entry == NULL
4515       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4516     return FALSE;
4517
4518   if (!info->no_ld_generated_unwind_info)
4519     {
4520       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4521                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4522       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4523                                                                  ".eh_frame",
4524                                                                  flags);
4525       if (htab->glink_eh_frame == NULL
4526           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4527         return FALSE;
4528     }
4529
4530   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4531   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4532   if (htab->elf.iplt == NULL
4533       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4534     return FALSE;
4535
4536   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4537            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4538   htab->elf.irelplt
4539     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4540   if (htab->elf.irelplt == NULL
4541       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4542     return FALSE;
4543
4544   /* Create branch lookup table for plt_branch stubs.  */
4545   flags = (SEC_ALLOC | SEC_LOAD
4546            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4547   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4548                                                    flags);
4549   if (htab->brlt == NULL
4550       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4551     return FALSE;
4552
4553   /* Local plt entries, put in .branch_lt but a separate section for
4554      convenience.  */
4555   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4556                                                        flags);
4557   if (htab->pltlocal == NULL
4558       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4559     return FALSE;
4560
4561   if (!bfd_link_pic (info))
4562     return TRUE;
4563
4564   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4565            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4566   htab->relbrlt
4567     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4568   if (htab->relbrlt == NULL
4569       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4570     return FALSE;
4571
4572   htab->relpltlocal
4573     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4574   if (htab->relpltlocal == NULL
4575       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4576     return FALSE;
4577
4578   return TRUE;
4579 }
4580
4581 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4582
4583 bfd_boolean
4584 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4585                          struct ppc64_elf_params *params)
4586 {
4587   struct ppc_link_hash_table *htab;
4588
4589   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4590
4591 /* Always hook our dynamic sections into the first bfd, which is the
4592    linker created stub bfd.  This ensures that the GOT header is at
4593    the start of the output TOC section.  */
4594   htab = ppc_hash_table (info);
4595   htab->elf.dynobj = params->stub_bfd;
4596   htab->params = params;
4597
4598   return create_linkage_sections (htab->elf.dynobj, info);
4599 }
4600
4601 /* Build a name for an entry in the stub hash table.  */
4602
4603 static char *
4604 ppc_stub_name (const asection *input_section,
4605                const asection *sym_sec,
4606                const struct ppc_link_hash_entry *h,
4607                const Elf_Internal_Rela *rel)
4608 {
4609   char *stub_name;
4610   ssize_t len;
4611
4612   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4613      offsets from a sym as a branch target?  In fact, we could
4614      probably assume the addend is always zero.  */
4615   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4616
4617   if (h)
4618     {
4619       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4620       stub_name = bfd_malloc (len);
4621       if (stub_name == NULL)
4622         return stub_name;
4623
4624       len = sprintf (stub_name, "%08x.%s+%x",
4625                      input_section->id & 0xffffffff,
4626                      h->elf.root.root.string,
4627                      (int) rel->r_addend & 0xffffffff);
4628     }
4629   else
4630     {
4631       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4632       stub_name = bfd_malloc (len);
4633       if (stub_name == NULL)
4634         return stub_name;
4635
4636       len = sprintf (stub_name, "%08x.%x:%x+%x",
4637                      input_section->id & 0xffffffff,
4638                      sym_sec->id & 0xffffffff,
4639                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4640                      (int) rel->r_addend & 0xffffffff);
4641     }
4642   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4643     stub_name[len - 2] = 0;
4644   return stub_name;
4645 }
4646
4647 /* Look up an entry in the stub hash.  Stub entries are cached because
4648    creating the stub name takes a bit of time.  */
4649
4650 static struct ppc_stub_hash_entry *
4651 ppc_get_stub_entry (const asection *input_section,
4652                     const asection *sym_sec,
4653                     struct ppc_link_hash_entry *h,
4654                     const Elf_Internal_Rela *rel,
4655                     struct ppc_link_hash_table *htab)
4656 {
4657   struct ppc_stub_hash_entry *stub_entry;
4658   struct map_stub *group;
4659
4660   /* If this input section is part of a group of sections sharing one
4661      stub section, then use the id of the first section in the group.
4662      Stub names need to include a section id, as there may well be
4663      more than one stub used to reach say, printf, and we need to
4664      distinguish between them.  */
4665   group = htab->sec_info[input_section->id].u.group;
4666   if (group == NULL)
4667     return NULL;
4668
4669   if (h != NULL && h->u.stub_cache != NULL
4670       && h->u.stub_cache->h == h
4671       && h->u.stub_cache->group == group)
4672     {
4673       stub_entry = h->u.stub_cache;
4674     }
4675   else
4676     {
4677       char *stub_name;
4678
4679       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4680       if (stub_name == NULL)
4681         return NULL;
4682
4683       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4684                                          stub_name, FALSE, FALSE);
4685       if (h != NULL)
4686         h->u.stub_cache = stub_entry;
4687
4688       free (stub_name);
4689     }
4690
4691   return stub_entry;
4692 }
4693
4694 /* Add a new stub entry to the stub hash.  Not all fields of the new
4695    stub entry are initialised.  */
4696
4697 static struct ppc_stub_hash_entry *
4698 ppc_add_stub (const char *stub_name,
4699               asection *section,
4700               struct bfd_link_info *info)
4701 {
4702   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4703   struct map_stub *group;
4704   asection *link_sec;
4705   asection *stub_sec;
4706   struct ppc_stub_hash_entry *stub_entry;
4707
4708   group = htab->sec_info[section->id].u.group;
4709   link_sec = group->link_sec;
4710   stub_sec = group->stub_sec;
4711   if (stub_sec == NULL)
4712     {
4713       size_t namelen;
4714       bfd_size_type len;
4715       char *s_name;
4716
4717       namelen = strlen (link_sec->name);
4718       len = namelen + sizeof (STUB_SUFFIX);
4719       s_name = bfd_alloc (htab->params->stub_bfd, len);
4720       if (s_name == NULL)
4721         return NULL;
4722
4723       memcpy (s_name, link_sec->name, namelen);
4724       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4725       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4726       if (stub_sec == NULL)
4727         return NULL;
4728       group->stub_sec = stub_sec;
4729     }
4730
4731   /* Enter this entry into the linker stub hash table.  */
4732   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4733                                      TRUE, FALSE);
4734   if (stub_entry == NULL)
4735     {
4736       /* xgettext:c-format */
4737       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4738                           section->owner, stub_name);
4739       return NULL;
4740     }
4741
4742   stub_entry->group = group;
4743   stub_entry->stub_offset = 0;
4744   return stub_entry;
4745 }
4746
4747 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4748    not already done.  */
4749
4750 static bfd_boolean
4751 create_got_section (bfd *abfd, struct bfd_link_info *info)
4752 {
4753   asection *got, *relgot;
4754   flagword flags;
4755   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4756
4757   if (!is_ppc64_elf (abfd))
4758     return FALSE;
4759   if (htab == NULL)
4760     return FALSE;
4761
4762   if (!htab->elf.sgot
4763       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4764     return FALSE;
4765
4766   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4767            | SEC_LINKER_CREATED);
4768
4769   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4770   if (!got
4771       || !bfd_set_section_alignment (abfd, got, 3))
4772     return FALSE;
4773
4774   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4775                                                flags | SEC_READONLY);
4776   if (!relgot
4777       || ! bfd_set_section_alignment (abfd, relgot, 3))
4778     return FALSE;
4779
4780   ppc64_elf_tdata (abfd)->got = got;
4781   ppc64_elf_tdata (abfd)->relgot = relgot;
4782   return TRUE;
4783 }
4784
4785 /* Follow indirect and warning symbol links.  */
4786
4787 static inline struct bfd_link_hash_entry *
4788 follow_link (struct bfd_link_hash_entry *h)
4789 {
4790   while (h->type == bfd_link_hash_indirect
4791          || h->type == bfd_link_hash_warning)
4792     h = h->u.i.link;
4793   return h;
4794 }
4795
4796 static inline struct elf_link_hash_entry *
4797 elf_follow_link (struct elf_link_hash_entry *h)
4798 {
4799   return (struct elf_link_hash_entry *) follow_link (&h->root);
4800 }
4801
4802 static inline struct ppc_link_hash_entry *
4803 ppc_follow_link (struct ppc_link_hash_entry *h)
4804 {
4805   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4806 }
4807
4808 /* Merge PLT info on FROM with that on TO.  */
4809
4810 static void
4811 move_plt_plist (struct ppc_link_hash_entry *from,
4812                 struct ppc_link_hash_entry *to)
4813 {
4814   if (from->elf.plt.plist != NULL)
4815     {
4816       if (to->elf.plt.plist != NULL)
4817         {
4818           struct plt_entry **entp;
4819           struct plt_entry *ent;
4820
4821           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4822             {
4823               struct plt_entry *dent;
4824
4825               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4826                 if (dent->addend == ent->addend)
4827                   {
4828                     dent->plt.refcount += ent->plt.refcount;
4829                     *entp = ent->next;
4830                     break;
4831                   }
4832               if (dent == NULL)
4833                 entp = &ent->next;
4834             }
4835           *entp = to->elf.plt.plist;
4836         }
4837
4838       to->elf.plt.plist = from->elf.plt.plist;
4839       from->elf.plt.plist = NULL;
4840     }
4841 }
4842
4843 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4844
4845 static void
4846 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4847                                 struct elf_link_hash_entry *dir,
4848                                 struct elf_link_hash_entry *ind)
4849 {
4850   struct ppc_link_hash_entry *edir, *eind;
4851
4852   edir = (struct ppc_link_hash_entry *) dir;
4853   eind = (struct ppc_link_hash_entry *) ind;
4854
4855   edir->is_func |= eind->is_func;
4856   edir->is_func_descriptor |= eind->is_func_descriptor;
4857   edir->tls_mask |= eind->tls_mask;
4858   if (eind->oh != NULL)
4859     edir->oh = ppc_follow_link (eind->oh);
4860
4861   if (edir->elf.versioned != versioned_hidden)
4862     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4863   edir->elf.ref_regular |= eind->elf.ref_regular;
4864   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4865   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4866   edir->elf.needs_plt |= eind->elf.needs_plt;
4867   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4868
4869   /* If we were called to copy over info for a weak sym, don't copy
4870      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4871      in order to simplify readonly_dynrelocs and save a field in the
4872      symbol hash entry, but that means dyn_relocs can't be used in any
4873      tests about a specific symbol, or affect other symbol flags which
4874      are then tested.  */
4875   if (eind->elf.root.type != bfd_link_hash_indirect)
4876     return;
4877
4878   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4879   if (eind->dyn_relocs != NULL)
4880     {
4881       if (edir->dyn_relocs != NULL)
4882         {
4883           struct elf_dyn_relocs **pp;
4884           struct elf_dyn_relocs *p;
4885
4886           /* Add reloc counts against the indirect sym to the direct sym
4887              list.  Merge any entries against the same section.  */
4888           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4889             {
4890               struct elf_dyn_relocs *q;
4891
4892               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4893                 if (q->sec == p->sec)
4894                   {
4895                     q->pc_count += p->pc_count;
4896                     q->count += p->count;
4897                     *pp = p->next;
4898                     break;
4899                   }
4900               if (q == NULL)
4901                 pp = &p->next;
4902             }
4903           *pp = edir->dyn_relocs;
4904         }
4905
4906       edir->dyn_relocs = eind->dyn_relocs;
4907       eind->dyn_relocs = NULL;
4908     }
4909
4910   /* Copy over got entries that we may have already seen to the
4911      symbol which just became indirect.  */
4912   if (eind->elf.got.glist != NULL)
4913     {
4914       if (edir->elf.got.glist != NULL)
4915         {
4916           struct got_entry **entp;
4917           struct got_entry *ent;
4918
4919           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4920             {
4921               struct got_entry *dent;
4922
4923               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4924                 if (dent->addend == ent->addend
4925                     && dent->owner == ent->owner
4926                     && dent->tls_type == ent->tls_type)
4927                   {
4928                     dent->got.refcount += ent->got.refcount;
4929                     *entp = ent->next;
4930                     break;
4931                   }
4932               if (dent == NULL)
4933                 entp = &ent->next;
4934             }
4935           *entp = edir->elf.got.glist;
4936         }
4937
4938       edir->elf.got.glist = eind->elf.got.glist;
4939       eind->elf.got.glist = NULL;
4940     }
4941
4942   /* And plt entries.  */
4943   move_plt_plist (eind, edir);
4944
4945   if (eind->elf.dynindx != -1)
4946     {
4947       if (edir->elf.dynindx != -1)
4948         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4949                                 edir->elf.dynstr_index);
4950       edir->elf.dynindx = eind->elf.dynindx;
4951       edir->elf.dynstr_index = eind->elf.dynstr_index;
4952       eind->elf.dynindx = -1;
4953       eind->elf.dynstr_index = 0;
4954     }
4955 }
4956
4957 /* Find the function descriptor hash entry from the given function code
4958    hash entry FH.  Link the entries via their OH fields.  */
4959
4960 static struct ppc_link_hash_entry *
4961 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4962 {
4963   struct ppc_link_hash_entry *fdh = fh->oh;
4964
4965   if (fdh == NULL)
4966     {
4967       const char *fd_name = fh->elf.root.root.string + 1;
4968
4969       fdh = (struct ppc_link_hash_entry *)
4970         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4971       if (fdh == NULL)
4972         return fdh;
4973
4974       fdh->is_func_descriptor = 1;
4975       fdh->oh = fh;
4976       fh->is_func = 1;
4977       fh->oh = fdh;
4978     }
4979
4980   fdh = ppc_follow_link (fdh);
4981   fdh->is_func_descriptor = 1;
4982   fdh->oh = fh;
4983   return fdh;
4984 }
4985
4986 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4987
4988 static struct ppc_link_hash_entry *
4989 make_fdh (struct bfd_link_info *info,
4990           struct ppc_link_hash_entry *fh)
4991 {
4992   bfd *abfd = fh->elf.root.u.undef.abfd;
4993   struct bfd_link_hash_entry *bh = NULL;
4994   struct ppc_link_hash_entry *fdh;
4995   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4996                     ? BSF_WEAK
4997                     : BSF_GLOBAL);
4998
4999   if (!_bfd_generic_link_add_one_symbol (info, abfd,
5000                                          fh->elf.root.root.string + 1,
5001                                          flags, bfd_und_section_ptr, 0,
5002                                          NULL, FALSE, FALSE, &bh))
5003     return NULL;
5004
5005   fdh = (struct ppc_link_hash_entry *) bh;
5006   fdh->elf.non_elf = 0;
5007   fdh->fake = 1;
5008   fdh->is_func_descriptor = 1;
5009   fdh->oh = fh;
5010   fh->is_func = 1;
5011   fh->oh = fdh;
5012   return fdh;
5013 }
5014
5015 /* Fix function descriptor symbols defined in .opd sections to be
5016    function type.  */
5017
5018 static bfd_boolean
5019 ppc64_elf_add_symbol_hook (bfd *ibfd,
5020                            struct bfd_link_info *info,
5021                            Elf_Internal_Sym *isym,
5022                            const char **name,
5023                            flagword *flags ATTRIBUTE_UNUSED,
5024                            asection **sec,
5025                            bfd_vma *value)
5026 {
5027   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5028       && (ibfd->flags & DYNAMIC) == 0
5029       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5030     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
5031
5032   if (*sec != NULL
5033       && strcmp ((*sec)->name, ".opd") == 0)
5034     {
5035       asection *code_sec;
5036
5037       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5038             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5039         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5040
5041       /* If the symbol is a function defined in .opd, and the function
5042          code is in a discarded group, let it appear to be undefined.  */
5043       if (!bfd_link_relocatable (info)
5044           && (*sec)->reloc_count != 0
5045           && opd_entry_value (*sec, *value, &code_sec, NULL,
5046                               FALSE) != (bfd_vma) -1
5047           && discarded_section (code_sec))
5048         {
5049           *sec = bfd_und_section_ptr;
5050           isym->st_shndx = SHN_UNDEF;
5051         }
5052     }
5053   else if (*sec != NULL
5054            && strcmp ((*sec)->name, ".toc") == 0
5055            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5056     {
5057       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5058       if (htab != NULL)
5059         htab->params->object_in_toc = 1;
5060     }
5061
5062   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5063     {
5064       if (abiversion (ibfd) == 0)
5065         set_abiversion (ibfd, 2);
5066       else if (abiversion (ibfd) == 1)
5067         {
5068           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5069                                 " for ABI version 1"), *name);
5070           bfd_set_error (bfd_error_bad_value);
5071           return FALSE;
5072         }
5073     }
5074
5075   return TRUE;
5076 }
5077
5078 /* Merge non-visibility st_other attributes: local entry point.  */
5079
5080 static void
5081 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5082                                   const Elf_Internal_Sym *isym,
5083                                   bfd_boolean definition,
5084                                   bfd_boolean dynamic)
5085 {
5086   if (definition && (!dynamic || !h->def_regular))
5087     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5088                 | ELF_ST_VISIBILITY (h->other));
5089 }
5090
5091 /* Hook called on merging a symbol.  We use this to clear "fake" since
5092    we now have a real symbol.  */
5093
5094 static bfd_boolean
5095 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5096                         const Elf_Internal_Sym *isym,
5097                         asection **psec ATTRIBUTE_UNUSED,
5098                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5099                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5100                         bfd *oldbfd ATTRIBUTE_UNUSED,
5101                         const asection *oldsec ATTRIBUTE_UNUSED)
5102 {
5103   ((struct ppc_link_hash_entry *) h)->fake = 0;
5104   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5105     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5106   return TRUE;
5107 }
5108
5109 /* This function makes an old ABI object reference to ".bar" cause the
5110    inclusion of a new ABI object archive that defines "bar".
5111    NAME is a symbol defined in an archive.  Return a symbol in the hash
5112    table that might be satisfied by the archive symbols.  */
5113
5114 static struct elf_link_hash_entry *
5115 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5116                                  struct bfd_link_info *info,
5117                                  const char *name)
5118 {
5119   struct elf_link_hash_entry *h;
5120   char *dot_name;
5121   size_t len;
5122
5123   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5124   if (h != NULL
5125       /* Don't return this sym if it is a fake function descriptor
5126          created by add_symbol_adjust.  */
5127       && !((struct ppc_link_hash_entry *) h)->fake)
5128     return h;
5129
5130   if (name[0] == '.')
5131     return h;
5132
5133   len = strlen (name);
5134   dot_name = bfd_alloc (abfd, len + 2);
5135   if (dot_name == NULL)
5136     return (struct elf_link_hash_entry *) -1;
5137   dot_name[0] = '.';
5138   memcpy (dot_name + 1, name, len + 1);
5139   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5140   bfd_release (abfd, dot_name);
5141   return h;
5142 }
5143
5144 /* This function satisfies all old ABI object references to ".bar" if a
5145    new ABI object defines "bar".  Well, at least, undefined dot symbols
5146    are made weak.  This stops later archive searches from including an
5147    object if we already have a function descriptor definition.  It also
5148    prevents the linker complaining about undefined symbols.
5149    We also check and correct mismatched symbol visibility here.  The
5150    most restrictive visibility of the function descriptor and the
5151    function entry symbol is used.  */
5152
5153 static bfd_boolean
5154 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5155 {
5156   struct ppc_link_hash_table *htab;
5157   struct ppc_link_hash_entry *fdh;
5158
5159   if (eh->elf.root.type == bfd_link_hash_warning)
5160     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5161
5162   if (eh->elf.root.type == bfd_link_hash_indirect)
5163     return TRUE;
5164
5165   if (eh->elf.root.root.string[0] != '.')
5166     abort ();
5167
5168   htab = ppc_hash_table (info);
5169   if (htab == NULL)
5170     return FALSE;
5171
5172   fdh = lookup_fdh (eh, htab);
5173   if (fdh == NULL
5174       && !bfd_link_relocatable (info)
5175       && (eh->elf.root.type == bfd_link_hash_undefined
5176           || eh->elf.root.type == bfd_link_hash_undefweak)
5177       && eh->elf.ref_regular)
5178     {
5179       /* Make an undefined function descriptor sym, in order to
5180          pull in an --as-needed shared lib.  Archives are handled
5181          elsewhere.  */
5182       fdh = make_fdh (info, eh);
5183       if (fdh == NULL)
5184         return FALSE;
5185     }
5186
5187   if (fdh != NULL)
5188     {
5189       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5190       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5191
5192       /* Make both descriptor and entry symbol have the most
5193          constraining visibility of either symbol.  */
5194       if (entry_vis < descr_vis)
5195         fdh->elf.other += entry_vis - descr_vis;
5196       else if (entry_vis > descr_vis)
5197         eh->elf.other += descr_vis - entry_vis;
5198
5199       /* Propagate reference flags from entry symbol to function
5200          descriptor symbol.  */
5201       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5202       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5203       fdh->elf.ref_regular |= eh->elf.ref_regular;
5204       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5205
5206       if (!fdh->elf.forced_local
5207           && fdh->elf.dynindx == -1
5208           && fdh->elf.versioned != versioned_hidden
5209           && (bfd_link_dll (info)
5210               || fdh->elf.def_dynamic
5211               || fdh->elf.ref_dynamic)
5212           && (eh->elf.ref_regular
5213               || eh->elf.def_regular))
5214         {
5215           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5216             return FALSE;
5217         }
5218     }
5219
5220   return TRUE;
5221 }
5222
5223 /* Set up opd section info and abiversion for IBFD, and process list
5224    of dot-symbols we made in link_hash_newfunc.  */
5225
5226 static bfd_boolean
5227 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5228 {
5229   struct ppc_link_hash_table *htab;
5230   struct ppc_link_hash_entry **p, *eh;
5231   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5232
5233   if (opd != NULL && opd->size != 0)
5234     {
5235       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5236       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5237
5238       if (abiversion (ibfd) == 0)
5239         set_abiversion (ibfd, 1);
5240       else if (abiversion (ibfd) >= 2)
5241         {
5242           /* xgettext:c-format */
5243           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5244                               ibfd, abiversion (ibfd));
5245           bfd_set_error (bfd_error_bad_value);
5246           return FALSE;
5247         }
5248     }
5249
5250   if (is_ppc64_elf (info->output_bfd))
5251     {
5252       /* For input files without an explicit abiversion in e_flags
5253          we should have flagged any with symbol st_other bits set
5254          as ELFv1 and above flagged those with .opd as ELFv2.
5255          Set the output abiversion if not yet set, and for any input
5256          still ambiguous, take its abiversion from the output.
5257          Differences in ABI are reported later.  */
5258       if (abiversion (info->output_bfd) == 0)
5259         set_abiversion (info->output_bfd, abiversion (ibfd));
5260       else if (abiversion (ibfd) == 0)
5261         set_abiversion (ibfd, abiversion (info->output_bfd));
5262     }
5263
5264   htab = ppc_hash_table (info);
5265   if (htab == NULL)
5266     return TRUE;
5267
5268   if (opd != NULL && opd->size != 0
5269       && (ibfd->flags & DYNAMIC) == 0
5270       && (opd->flags & SEC_RELOC) != 0
5271       && opd->reloc_count != 0
5272       && !bfd_is_abs_section (opd->output_section)
5273       && info->gc_sections)
5274     {
5275       /* Garbage collection needs some extra help with .opd sections.
5276          We don't want to necessarily keep everything referenced by
5277          relocs in .opd, as that would keep all functions.  Instead,
5278          if we reference an .opd symbol (a function descriptor), we
5279          want to keep the function code symbol's section.  This is
5280          easy for global symbols, but for local syms we need to keep
5281          information about the associated function section.  */
5282       bfd_size_type amt;
5283       asection **opd_sym_map;
5284       Elf_Internal_Shdr *symtab_hdr;
5285       Elf_Internal_Rela *relocs, *rel_end, *rel;
5286
5287       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5288       opd_sym_map = bfd_zalloc (ibfd, amt);
5289       if (opd_sym_map == NULL)
5290         return FALSE;
5291       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5292       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5293                                           info->keep_memory);
5294       if (relocs == NULL)
5295         return FALSE;
5296       symtab_hdr = &elf_symtab_hdr (ibfd);
5297       rel_end = relocs + opd->reloc_count - 1;
5298       for (rel = relocs; rel < rel_end; rel++)
5299         {
5300           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5301           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5302
5303           if (r_type == R_PPC64_ADDR64
5304               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5305               && r_symndx < symtab_hdr->sh_info)
5306             {
5307               Elf_Internal_Sym *isym;
5308               asection *s;
5309
5310               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5311               if (isym == NULL)
5312                 {
5313                   if (elf_section_data (opd)->relocs != relocs)
5314                     free (relocs);
5315                   return FALSE;
5316                 }
5317
5318               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5319               if (s != NULL && s != opd)
5320                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5321             }
5322         }
5323       if (elf_section_data (opd)->relocs != relocs)
5324         free (relocs);
5325     }
5326
5327   p = &htab->dot_syms;
5328   while ((eh = *p) != NULL)
5329     {
5330       *p = NULL;
5331       if (&eh->elf == htab->elf.hgot)
5332         ;
5333       else if (htab->elf.hgot == NULL
5334                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5335         htab->elf.hgot = &eh->elf;
5336       else if (abiversion (ibfd) <= 1)
5337         {
5338           htab->need_func_desc_adj = 1;
5339           if (!add_symbol_adjust (eh, info))
5340             return FALSE;
5341         }
5342       p = &eh->u.next_dot_sym;
5343     }
5344   return TRUE;
5345 }
5346
5347 /* Undo hash table changes when an --as-needed input file is determined
5348    not to be needed.  */
5349
5350 static bfd_boolean
5351 ppc64_elf_notice_as_needed (bfd *ibfd,
5352                             struct bfd_link_info *info,
5353                             enum notice_asneeded_action act)
5354 {
5355   if (act == notice_not_needed)
5356     {
5357       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5358
5359       if (htab == NULL)
5360         return FALSE;
5361
5362       htab->dot_syms = NULL;
5363     }
5364   return _bfd_elf_notice_as_needed (ibfd, info, act);
5365 }
5366
5367 /* If --just-symbols against a final linked binary, then assume we need
5368    toc adjusting stubs when calling functions defined there.  */
5369
5370 static void
5371 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5372 {
5373   if ((sec->flags & SEC_CODE) != 0
5374       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5375       && is_ppc64_elf (sec->owner))
5376     {
5377       if (abiversion (sec->owner) >= 2
5378           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5379         sec->has_toc_reloc = 1;
5380     }
5381   _bfd_elf_link_just_syms (sec, info);
5382 }
5383
5384 static struct plt_entry **
5385 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5386                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5387 {
5388   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5389   struct plt_entry **local_plt;
5390   unsigned char *local_got_tls_masks;
5391
5392   if (local_got_ents == NULL)
5393     {
5394       bfd_size_type size = symtab_hdr->sh_info;
5395
5396       size *= (sizeof (*local_got_ents)
5397                + sizeof (*local_plt)
5398                + sizeof (*local_got_tls_masks));
5399       local_got_ents = bfd_zalloc (abfd, size);
5400       if (local_got_ents == NULL)
5401         return NULL;
5402       elf_local_got_ents (abfd) = local_got_ents;
5403     }
5404
5405   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5406     {
5407       struct got_entry *ent;
5408
5409       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5410         if (ent->addend == r_addend
5411             && ent->owner == abfd
5412             && ent->tls_type == tls_type)
5413           break;
5414       if (ent == NULL)
5415         {
5416           bfd_size_type amt = sizeof (*ent);
5417           ent = bfd_alloc (abfd, amt);
5418           if (ent == NULL)
5419             return FALSE;
5420           ent->next = local_got_ents[r_symndx];
5421           ent->addend = r_addend;
5422           ent->owner = abfd;
5423           ent->tls_type = tls_type;
5424           ent->is_indirect = FALSE;
5425           ent->got.refcount = 0;
5426           local_got_ents[r_symndx] = ent;
5427         }
5428       ent->got.refcount += 1;
5429     }
5430
5431   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5432   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5433   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5434
5435   return local_plt + r_symndx;
5436 }
5437
5438 static bfd_boolean
5439 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5440 {
5441   struct plt_entry *ent;
5442
5443   for (ent = *plist; ent != NULL; ent = ent->next)
5444     if (ent->addend == addend)
5445       break;
5446   if (ent == NULL)
5447     {
5448       bfd_size_type amt = sizeof (*ent);
5449       ent = bfd_alloc (abfd, amt);
5450       if (ent == NULL)
5451         return FALSE;
5452       ent->next = *plist;
5453       ent->addend = addend;
5454       ent->plt.refcount = 0;
5455       *plist = ent;
5456     }
5457   ent->plt.refcount += 1;
5458   return TRUE;
5459 }
5460
5461 static bfd_boolean
5462 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5463 {
5464   return (r_type == R_PPC64_REL24
5465           || r_type == R_PPC64_REL14
5466           || r_type == R_PPC64_REL14_BRTAKEN
5467           || r_type == R_PPC64_REL14_BRNTAKEN
5468           || r_type == R_PPC64_ADDR24
5469           || r_type == R_PPC64_ADDR14
5470           || r_type == R_PPC64_ADDR14_BRTAKEN
5471           || r_type == R_PPC64_ADDR14_BRNTAKEN
5472           || r_type == R_PPC64_PLTCALL);
5473 }
5474
5475 /* Relocs on inline plt call sequence insns prior to the call.  */
5476
5477 static bfd_boolean
5478 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5479 {
5480   return (r_type == R_PPC64_PLT16_HA
5481           || r_type == R_PPC64_PLT16_HI
5482           || r_type == R_PPC64_PLT16_LO
5483           || r_type == R_PPC64_PLT16_LO_DS
5484           || r_type == R_PPC64_PLTSEQ);
5485 }
5486
5487 /* Look through the relocs for a section during the first phase, and
5488    calculate needed space in the global offset table, procedure
5489    linkage table, and dynamic reloc sections.  */
5490
5491 static bfd_boolean
5492 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5493                         asection *sec, const Elf_Internal_Rela *relocs)
5494 {
5495   struct ppc_link_hash_table *htab;
5496   Elf_Internal_Shdr *symtab_hdr;
5497   struct elf_link_hash_entry **sym_hashes;
5498   const Elf_Internal_Rela *rel;
5499   const Elf_Internal_Rela *rel_end;
5500   asection *sreloc;
5501   struct elf_link_hash_entry *tga, *dottga;
5502   bfd_boolean is_opd;
5503
5504   if (bfd_link_relocatable (info))
5505     return TRUE;
5506
5507   /* Don't do anything special with non-loaded, non-alloced sections.
5508      In particular, any relocs in such sections should not affect GOT
5509      and PLT reference counting (ie. we don't allow them to create GOT
5510      or PLT entries), there's no possibility or desire to optimize TLS
5511      relocs, and there's not much point in propagating relocs to shared
5512      libs that the dynamic linker won't relocate.  */
5513   if ((sec->flags & SEC_ALLOC) == 0)
5514     return TRUE;
5515
5516   BFD_ASSERT (is_ppc64_elf (abfd));
5517
5518   htab = ppc_hash_table (info);
5519   if (htab == NULL)
5520     return FALSE;
5521
5522   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5523                               FALSE, FALSE, TRUE);
5524   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5525                                  FALSE, FALSE, TRUE);
5526   symtab_hdr = &elf_symtab_hdr (abfd);
5527   sym_hashes = elf_sym_hashes (abfd);
5528   sreloc = NULL;
5529   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5530   rel_end = relocs + sec->reloc_count;
5531   for (rel = relocs; rel < rel_end; rel++)
5532     {
5533       unsigned long r_symndx;
5534       struct elf_link_hash_entry *h;
5535       enum elf_ppc64_reloc_type r_type;
5536       int tls_type;
5537       struct _ppc64_elf_section_data *ppc64_sec;
5538       struct plt_entry **ifunc, **plt_list;
5539
5540       r_symndx = ELF64_R_SYM (rel->r_info);
5541       if (r_symndx < symtab_hdr->sh_info)
5542         h = NULL;
5543       else
5544         {
5545           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5546           h = elf_follow_link (h);
5547
5548           if (h == htab->elf.hgot)
5549             sec->has_toc_reloc = 1;
5550         }
5551
5552       tls_type = 0;
5553       ifunc = NULL;
5554       if (h != NULL)
5555         {
5556           if (h->type == STT_GNU_IFUNC)
5557             {
5558               h->needs_plt = 1;
5559               ifunc = &h->plt.plist;
5560             }
5561         }
5562       else
5563         {
5564           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5565                                                           abfd, r_symndx);
5566           if (isym == NULL)
5567             return FALSE;
5568
5569           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5570             {
5571               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5572                                              rel->r_addend,
5573                                              NON_GOT | PLT_IFUNC);
5574               if (ifunc == NULL)
5575                 return FALSE;
5576             }
5577         }
5578
5579       r_type = ELF64_R_TYPE (rel->r_info);
5580       switch (r_type)
5581         {
5582         case R_PPC64_TLSGD:
5583         case R_PPC64_TLSLD:
5584           /* These special tls relocs tie a call to __tls_get_addr with
5585              its parameter symbol.  */
5586           if (h != NULL)
5587             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5588           else
5589             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5590                                         rel->r_addend,
5591                                         NON_GOT | TLS_TLS | TLS_MARK))
5592               return FALSE;
5593           sec->has_tls_reloc = 1;
5594           break;
5595
5596         case R_PPC64_GOT_TLSLD16:
5597         case R_PPC64_GOT_TLSLD16_LO:
5598         case R_PPC64_GOT_TLSLD16_HI:
5599         case R_PPC64_GOT_TLSLD16_HA:
5600           tls_type = TLS_TLS | TLS_LD;
5601           goto dogottls;
5602
5603         case R_PPC64_GOT_TLSGD16:
5604         case R_PPC64_GOT_TLSGD16_LO:
5605         case R_PPC64_GOT_TLSGD16_HI:
5606         case R_PPC64_GOT_TLSGD16_HA:
5607           tls_type = TLS_TLS | TLS_GD;
5608           goto dogottls;
5609
5610         case R_PPC64_GOT_TPREL16_DS:
5611         case R_PPC64_GOT_TPREL16_LO_DS:
5612         case R_PPC64_GOT_TPREL16_HI:
5613         case R_PPC64_GOT_TPREL16_HA:
5614           if (bfd_link_dll (info))
5615             info->flags |= DF_STATIC_TLS;
5616           tls_type = TLS_TLS | TLS_TPREL;
5617           goto dogottls;
5618
5619         case R_PPC64_GOT_DTPREL16_DS:
5620         case R_PPC64_GOT_DTPREL16_LO_DS:
5621         case R_PPC64_GOT_DTPREL16_HI:
5622         case R_PPC64_GOT_DTPREL16_HA:
5623           tls_type = TLS_TLS | TLS_DTPREL;
5624         dogottls:
5625           sec->has_tls_reloc = 1;
5626           /* Fall through */
5627
5628         case R_PPC64_GOT16:
5629         case R_PPC64_GOT16_DS:
5630         case R_PPC64_GOT16_HA:
5631         case R_PPC64_GOT16_HI:
5632         case R_PPC64_GOT16_LO:
5633         case R_PPC64_GOT16_LO_DS:
5634           /* This symbol requires a global offset table entry.  */
5635           sec->has_toc_reloc = 1;
5636           if (r_type == R_PPC64_GOT_TLSLD16
5637               || r_type == R_PPC64_GOT_TLSGD16
5638               || r_type == R_PPC64_GOT_TPREL16_DS
5639               || r_type == R_PPC64_GOT_DTPREL16_DS
5640               || r_type == R_PPC64_GOT16
5641               || r_type == R_PPC64_GOT16_DS)
5642             {
5643               htab->do_multi_toc = 1;
5644               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5645             }
5646
5647           if (ppc64_elf_tdata (abfd)->got == NULL
5648               && !create_got_section (abfd, info))
5649             return FALSE;
5650
5651           if (h != NULL)
5652             {
5653               struct ppc_link_hash_entry *eh;
5654               struct got_entry *ent;
5655
5656               eh = (struct ppc_link_hash_entry *) h;
5657               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5658                 if (ent->addend == rel->r_addend
5659                     && ent->owner == abfd
5660                     && ent->tls_type == tls_type)
5661                   break;
5662               if (ent == NULL)
5663                 {
5664                   bfd_size_type amt = sizeof (*ent);
5665                   ent = bfd_alloc (abfd, amt);
5666                   if (ent == NULL)
5667                     return FALSE;
5668                   ent->next = eh->elf.got.glist;
5669                   ent->addend = rel->r_addend;
5670                   ent->owner = abfd;
5671                   ent->tls_type = tls_type;
5672                   ent->is_indirect = FALSE;
5673                   ent->got.refcount = 0;
5674                   eh->elf.got.glist = ent;
5675                 }
5676               ent->got.refcount += 1;
5677               eh->tls_mask |= tls_type;
5678             }
5679           else
5680             /* This is a global offset table entry for a local symbol.  */
5681             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5682                                         rel->r_addend, tls_type))
5683               return FALSE;
5684
5685           /* We may also need a plt entry if the symbol turns out to be
5686              an ifunc.  */
5687           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5688             {
5689               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5690                 return FALSE;
5691             }
5692           break;
5693
5694         case R_PPC64_PLT16_HA:
5695         case R_PPC64_PLT16_HI:
5696         case R_PPC64_PLT16_LO:
5697         case R_PPC64_PLT16_LO_DS:
5698         case R_PPC64_PLT32:
5699         case R_PPC64_PLT64:
5700           /* This symbol requires a procedure linkage table entry.  */
5701           plt_list = ifunc;
5702           if (h != NULL)
5703             {
5704               h->needs_plt = 1;
5705               if (h->root.root.string[0] == '.'
5706                   && h->root.root.string[1] != '\0')
5707                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5708               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5709               plt_list = &h->plt.plist;
5710             }
5711           if (plt_list == NULL)
5712             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5713                                               rel->r_addend,
5714                                               NON_GOT | PLT_KEEP);
5715           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5716             return FALSE;
5717           break;
5718
5719           /* The following relocations don't need to propagate the
5720              relocation if linking a shared object since they are
5721              section relative.  */
5722         case R_PPC64_SECTOFF:
5723         case R_PPC64_SECTOFF_LO:
5724         case R_PPC64_SECTOFF_HI:
5725         case R_PPC64_SECTOFF_HA:
5726         case R_PPC64_SECTOFF_DS:
5727         case R_PPC64_SECTOFF_LO_DS:
5728         case R_PPC64_DTPREL16:
5729         case R_PPC64_DTPREL16_LO:
5730         case R_PPC64_DTPREL16_HI:
5731         case R_PPC64_DTPREL16_HA:
5732         case R_PPC64_DTPREL16_DS:
5733         case R_PPC64_DTPREL16_LO_DS:
5734         case R_PPC64_DTPREL16_HIGH:
5735         case R_PPC64_DTPREL16_HIGHA:
5736         case R_PPC64_DTPREL16_HIGHER:
5737         case R_PPC64_DTPREL16_HIGHERA:
5738         case R_PPC64_DTPREL16_HIGHEST:
5739         case R_PPC64_DTPREL16_HIGHESTA:
5740           break;
5741
5742           /* Nor do these.  */
5743         case R_PPC64_REL16:
5744         case R_PPC64_REL16_LO:
5745         case R_PPC64_REL16_HI:
5746         case R_PPC64_REL16_HA:
5747         case R_PPC64_REL16DX_HA:
5748           break;
5749
5750           /* Not supported as a dynamic relocation.  */
5751         case R_PPC64_ADDR64_LOCAL:
5752           if (bfd_link_pic (info))
5753             {
5754               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5755                 ppc_howto_init ();
5756               /* xgettext:c-format */
5757               info->callbacks->einfo (_("%H: %s reloc unsupported "
5758                                         "in shared libraries and PIEs\n"),
5759                                       abfd, sec, rel->r_offset,
5760                                       ppc64_elf_howto_table[r_type]->name);
5761               bfd_set_error (bfd_error_bad_value);
5762               return FALSE;
5763             }
5764           break;
5765
5766         case R_PPC64_TOC16:
5767         case R_PPC64_TOC16_DS:
5768           htab->do_multi_toc = 1;
5769           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5770           /* Fall through.  */
5771         case R_PPC64_TOC16_LO:
5772         case R_PPC64_TOC16_HI:
5773         case R_PPC64_TOC16_HA:
5774         case R_PPC64_TOC16_LO_DS:
5775           sec->has_toc_reloc = 1;
5776           break;
5777
5778           /* Marker reloc.  */
5779         case R_PPC64_ENTRY:
5780           break;
5781
5782           /* This relocation describes the C++ object vtable hierarchy.
5783              Reconstruct it for later use during GC.  */
5784         case R_PPC64_GNU_VTINHERIT:
5785           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5786             return FALSE;
5787           break;
5788
5789           /* This relocation describes which C++ vtable entries are actually
5790              used.  Record for later use during GC.  */
5791         case R_PPC64_GNU_VTENTRY:
5792           BFD_ASSERT (h != NULL);
5793           if (h != NULL
5794               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5795             return FALSE;
5796           break;
5797
5798         case R_PPC64_REL14:
5799         case R_PPC64_REL14_BRTAKEN:
5800         case R_PPC64_REL14_BRNTAKEN:
5801           {
5802             asection *dest = NULL;
5803
5804             /* Heuristic: If jumping outside our section, chances are
5805                we are going to need a stub.  */
5806             if (h != NULL)
5807               {
5808                 /* If the sym is weak it may be overridden later, so
5809                    don't assume we know where a weak sym lives.  */
5810                 if (h->root.type == bfd_link_hash_defined)
5811                   dest = h->root.u.def.section;
5812               }
5813             else
5814               {
5815                 Elf_Internal_Sym *isym;
5816
5817                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5818                                               abfd, r_symndx);
5819                 if (isym == NULL)
5820                   return FALSE;
5821
5822                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5823               }
5824
5825             if (dest != sec)
5826               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5827           }
5828           goto rel24;
5829
5830         case R_PPC64_PLTCALL:
5831           ppc64_elf_section_data (sec)->has_pltcall = 1;
5832           /* Fall through.  */
5833
5834         case R_PPC64_REL24:
5835         rel24:
5836           plt_list = ifunc;
5837           if (h != NULL)
5838             {
5839               h->needs_plt = 1;
5840               if (h->root.root.string[0] == '.'
5841                   && h->root.root.string[1] != '\0')
5842                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5843
5844               if (h == tga || h == dottga)
5845                 {
5846                   sec->has_tls_reloc = 1;
5847                   if (rel != relocs
5848                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5849                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5850                     /* We have a new-style __tls_get_addr call with
5851                        a marker reloc.  */
5852                     ;
5853                   else
5854                     /* Mark this section as having an old-style call.  */
5855                     sec->has_tls_get_addr_call = 1;
5856                 }
5857               plt_list = &h->plt.plist;
5858             }
5859
5860           /* We may need a .plt entry if the function this reloc
5861              refers to is in a shared lib.  */
5862           if (plt_list
5863               && !update_plt_info (abfd, plt_list, rel->r_addend))
5864             return FALSE;
5865           break;
5866
5867         case R_PPC64_ADDR14:
5868         case R_PPC64_ADDR14_BRNTAKEN:
5869         case R_PPC64_ADDR14_BRTAKEN:
5870         case R_PPC64_ADDR24:
5871           goto dodyn;
5872
5873         case R_PPC64_TPREL64:
5874           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5875           if (bfd_link_dll (info))
5876             info->flags |= DF_STATIC_TLS;
5877           goto dotlstoc;
5878
5879         case R_PPC64_DTPMOD64:
5880           if (rel + 1 < rel_end
5881               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5882               && rel[1].r_offset == rel->r_offset + 8)
5883             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5884           else
5885             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5886           goto dotlstoc;
5887
5888         case R_PPC64_DTPREL64:
5889           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5890           if (rel != relocs
5891               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5892               && rel[-1].r_offset == rel->r_offset - 8)
5893             /* This is the second reloc of a dtpmod, dtprel pair.
5894                Don't mark with TLS_DTPREL.  */
5895             goto dodyn;
5896
5897         dotlstoc:
5898           sec->has_tls_reloc = 1;
5899           if (h != NULL)
5900             {
5901               struct ppc_link_hash_entry *eh;
5902               eh = (struct ppc_link_hash_entry *) h;
5903               eh->tls_mask |= tls_type;
5904             }
5905           else
5906             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5907                                         rel->r_addend, tls_type))
5908               return FALSE;
5909
5910           ppc64_sec = ppc64_elf_section_data (sec);
5911           if (ppc64_sec->sec_type != sec_toc)
5912             {
5913               bfd_size_type amt;
5914
5915               /* One extra to simplify get_tls_mask.  */
5916               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5917               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5918               if (ppc64_sec->u.toc.symndx == NULL)
5919                 return FALSE;
5920               amt = sec->size * sizeof (bfd_vma) / 8;
5921               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5922               if (ppc64_sec->u.toc.add == NULL)
5923                 return FALSE;
5924               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5925               ppc64_sec->sec_type = sec_toc;
5926             }
5927           BFD_ASSERT (rel->r_offset % 8 == 0);
5928           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5929           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5930
5931           /* Mark the second slot of a GD or LD entry.
5932              -1 to indicate GD and -2 to indicate LD.  */
5933           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5934             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5935           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5936             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5937           goto dodyn;
5938
5939         case R_PPC64_TPREL16:
5940         case R_PPC64_TPREL16_LO:
5941         case R_PPC64_TPREL16_HI:
5942         case R_PPC64_TPREL16_HA:
5943         case R_PPC64_TPREL16_DS:
5944         case R_PPC64_TPREL16_LO_DS:
5945         case R_PPC64_TPREL16_HIGH:
5946         case R_PPC64_TPREL16_HIGHA:
5947         case R_PPC64_TPREL16_HIGHER:
5948         case R_PPC64_TPREL16_HIGHERA:
5949         case R_PPC64_TPREL16_HIGHEST:
5950         case R_PPC64_TPREL16_HIGHESTA:
5951           if (bfd_link_dll (info))
5952             info->flags |= DF_STATIC_TLS;
5953           goto dodyn;
5954
5955         case R_PPC64_ADDR64:
5956           if (is_opd
5957               && rel + 1 < rel_end
5958               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5959             {
5960               if (h != NULL)
5961                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5962             }
5963           /* Fall through.  */
5964
5965         case R_PPC64_ADDR16:
5966         case R_PPC64_ADDR16_DS:
5967         case R_PPC64_ADDR16_HA:
5968         case R_PPC64_ADDR16_HI:
5969         case R_PPC64_ADDR16_HIGH:
5970         case R_PPC64_ADDR16_HIGHA:
5971         case R_PPC64_ADDR16_HIGHER:
5972         case R_PPC64_ADDR16_HIGHERA:
5973         case R_PPC64_ADDR16_HIGHEST:
5974         case R_PPC64_ADDR16_HIGHESTA:
5975         case R_PPC64_ADDR16_LO:
5976         case R_PPC64_ADDR16_LO_DS:
5977           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5978               && rel->r_addend == 0)
5979             {
5980               /* We may need a .plt entry if this reloc refers to a
5981                  function in a shared lib.  */
5982               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5983                 return FALSE;
5984               h->pointer_equality_needed = 1;
5985             }
5986           /* Fall through.  */
5987
5988         case R_PPC64_REL30:
5989         case R_PPC64_REL32:
5990         case R_PPC64_REL64:
5991         case R_PPC64_ADDR32:
5992         case R_PPC64_UADDR16:
5993         case R_PPC64_UADDR32:
5994         case R_PPC64_UADDR64:
5995         case R_PPC64_TOC:
5996           if (h != NULL && !bfd_link_pic (info))
5997             /* We may need a copy reloc.  */
5998             h->non_got_ref = 1;
5999
6000           /* Don't propagate .opd relocs.  */
6001           if (NO_OPD_RELOCS && is_opd)
6002             break;
6003
6004           /* If we are creating a shared library, and this is a reloc
6005              against a global symbol, or a non PC relative reloc
6006              against a local symbol, then we need to copy the reloc
6007              into the shared library.  However, if we are linking with
6008              -Bsymbolic, we do not need to copy a reloc against a
6009              global symbol which is defined in an object we are
6010              including in the link (i.e., DEF_REGULAR is set).  At
6011              this point we have not seen all the input files, so it is
6012              possible that DEF_REGULAR is not set now but will be set
6013              later (it is never cleared).  In case of a weak definition,
6014              DEF_REGULAR may be cleared later by a strong definition in
6015              a shared library.  We account for that possibility below by
6016              storing information in the dyn_relocs field of the hash
6017              table entry.  A similar situation occurs when creating
6018              shared libraries and symbol visibility changes render the
6019              symbol local.
6020
6021              If on the other hand, we are creating an executable, we
6022              may need to keep relocations for symbols satisfied by a
6023              dynamic library if we manage to avoid copy relocs for the
6024              symbol.  */
6025         dodyn:
6026           if ((bfd_link_pic (info)
6027                && (must_be_dyn_reloc (info, r_type)
6028                    || (h != NULL
6029                        && (!SYMBOLIC_BIND (info, h)
6030                            || h->root.type == bfd_link_hash_defweak
6031                            || !h->def_regular))))
6032               || (ELIMINATE_COPY_RELOCS
6033                   && !bfd_link_pic (info)
6034                   && h != NULL
6035                   && (h->root.type == bfd_link_hash_defweak
6036                       || !h->def_regular))
6037               || (!bfd_link_pic (info)
6038                   && ifunc != NULL))
6039             {
6040               /* We must copy these reloc types into the output file.
6041                  Create a reloc section in dynobj and make room for
6042                  this reloc.  */
6043               if (sreloc == NULL)
6044                 {
6045                   sreloc = _bfd_elf_make_dynamic_reloc_section
6046                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6047
6048                   if (sreloc == NULL)
6049                     return FALSE;
6050                 }
6051
6052               /* If this is a global symbol, we count the number of
6053                  relocations we need for this symbol.  */
6054               if (h != NULL)
6055                 {
6056                   struct elf_dyn_relocs *p;
6057                   struct elf_dyn_relocs **head;
6058
6059                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6060                   p = *head;
6061                   if (p == NULL || p->sec != sec)
6062                     {
6063                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6064                       if (p == NULL)
6065                         return FALSE;
6066                       p->next = *head;
6067                       *head = p;
6068                       p->sec = sec;
6069                       p->count = 0;
6070                       p->pc_count = 0;
6071                     }
6072                   p->count += 1;
6073                   if (!must_be_dyn_reloc (info, r_type))
6074                     p->pc_count += 1;
6075                 }
6076               else
6077                 {
6078                   /* Track dynamic relocs needed for local syms too.
6079                      We really need local syms available to do this
6080                      easily.  Oh well.  */
6081                   struct ppc_dyn_relocs *p;
6082                   struct ppc_dyn_relocs **head;
6083                   bfd_boolean is_ifunc;
6084                   asection *s;
6085                   void *vpp;
6086                   Elf_Internal_Sym *isym;
6087
6088                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6089                                                 abfd, r_symndx);
6090                   if (isym == NULL)
6091                     return FALSE;
6092
6093                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6094                   if (s == NULL)
6095                     s = sec;
6096
6097                   vpp = &elf_section_data (s)->local_dynrel;
6098                   head = (struct ppc_dyn_relocs **) vpp;
6099                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6100                   p = *head;
6101                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6102                     p = p->next;
6103                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6104                     {
6105                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6106                       if (p == NULL)
6107                         return FALSE;
6108                       p->next = *head;
6109                       *head = p;
6110                       p->sec = sec;
6111                       p->ifunc = is_ifunc;
6112                       p->count = 0;
6113                     }
6114                   p->count += 1;
6115                 }
6116             }
6117           break;
6118
6119         default:
6120           break;
6121         }
6122     }
6123
6124   return TRUE;
6125 }
6126
6127 /* Merge backend specific data from an object file to the output
6128    object file when linking.  */
6129
6130 static bfd_boolean
6131 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6132 {
6133   bfd *obfd = info->output_bfd;
6134   unsigned long iflags, oflags;
6135
6136   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6137     return TRUE;
6138
6139   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6140     return TRUE;
6141
6142   if (!_bfd_generic_verify_endian_match (ibfd, info))
6143     return FALSE;
6144
6145   iflags = elf_elfheader (ibfd)->e_flags;
6146   oflags = elf_elfheader (obfd)->e_flags;
6147
6148   if (iflags & ~EF_PPC64_ABI)
6149     {
6150       _bfd_error_handler
6151         /* xgettext:c-format */
6152         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6153       bfd_set_error (bfd_error_bad_value);
6154       return FALSE;
6155     }
6156   else if (iflags != oflags && iflags != 0)
6157     {
6158       _bfd_error_handler
6159         /* xgettext:c-format */
6160         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6161          ibfd, iflags, oflags);
6162       bfd_set_error (bfd_error_bad_value);
6163       return FALSE;
6164     }
6165
6166   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6167
6168   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6169   _bfd_elf_merge_object_attributes (ibfd, info);
6170
6171   return TRUE;
6172 }
6173
6174 static bfd_boolean
6175 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6176 {
6177   /* Print normal ELF private data.  */
6178   _bfd_elf_print_private_bfd_data (abfd, ptr);
6179
6180   if (elf_elfheader (abfd)->e_flags != 0)
6181     {
6182       FILE *file = ptr;
6183
6184       fprintf (file, _("private flags = 0x%lx:"),
6185                elf_elfheader (abfd)->e_flags);
6186
6187       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6188         fprintf (file, _(" [abiv%ld]"),
6189                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6190       fputc ('\n', file);
6191     }
6192
6193   return TRUE;
6194 }
6195
6196 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6197    of the code entry point, and its section, which must be in the same
6198    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6199
6200 static bfd_vma
6201 opd_entry_value (asection *opd_sec,
6202                  bfd_vma offset,
6203                  asection **code_sec,
6204                  bfd_vma *code_off,
6205                  bfd_boolean in_code_sec)
6206 {
6207   bfd *opd_bfd = opd_sec->owner;
6208   Elf_Internal_Rela *relocs;
6209   Elf_Internal_Rela *lo, *hi, *look;
6210   bfd_vma val;
6211
6212   /* No relocs implies we are linking a --just-symbols object, or looking
6213      at a final linked executable with addr2line or somesuch.  */
6214   if (opd_sec->reloc_count == 0)
6215     {
6216       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6217
6218       if (contents == NULL)
6219         {
6220           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6221             return (bfd_vma) -1;
6222           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6223         }
6224
6225       /* PR 17512: file: 64b9dfbb.  */
6226       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6227         return (bfd_vma) -1;
6228
6229       val = bfd_get_64 (opd_bfd, contents + offset);
6230       if (code_sec != NULL)
6231         {
6232           asection *sec, *likely = NULL;
6233
6234           if (in_code_sec)
6235             {
6236               sec = *code_sec;
6237               if (sec->vma <= val
6238                   && val < sec->vma + sec->size)
6239                 likely = sec;
6240               else
6241                 val = -1;
6242             }
6243           else
6244             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6245               if (sec->vma <= val
6246                   && (sec->flags & SEC_LOAD) != 0
6247                   && (sec->flags & SEC_ALLOC) != 0)
6248                 likely = sec;
6249           if (likely != NULL)
6250             {
6251               *code_sec = likely;
6252               if (code_off != NULL)
6253                 *code_off = val - likely->vma;
6254             }
6255         }
6256       return val;
6257     }
6258
6259   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6260
6261   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6262   if (relocs == NULL)
6263     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6264   /* PR 17512: file: df8e1fd6.  */
6265   if (relocs == NULL)
6266     return (bfd_vma) -1;
6267
6268   /* Go find the opd reloc at the sym address.  */
6269   lo = relocs;
6270   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6271   val = (bfd_vma) -1;
6272   while (lo < hi)
6273     {
6274       look = lo + (hi - lo) / 2;
6275       if (look->r_offset < offset)
6276         lo = look + 1;
6277       else if (look->r_offset > offset)
6278         hi = look;
6279       else
6280         {
6281           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6282
6283           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6284               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6285             {
6286               unsigned long symndx = ELF64_R_SYM (look->r_info);
6287               asection *sec = NULL;
6288
6289               if (symndx >= symtab_hdr->sh_info
6290                   && elf_sym_hashes (opd_bfd) != NULL)
6291                 {
6292                   struct elf_link_hash_entry **sym_hashes;
6293                   struct elf_link_hash_entry *rh;
6294
6295                   sym_hashes = elf_sym_hashes (opd_bfd);
6296                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6297                   if (rh != NULL)
6298                     {
6299                       rh = elf_follow_link (rh);
6300                       if (rh->root.type != bfd_link_hash_defined
6301                           && rh->root.type != bfd_link_hash_defweak)
6302                         break;
6303                       if (rh->root.u.def.section->owner == opd_bfd)
6304                         {
6305                           val = rh->root.u.def.value;
6306                           sec = rh->root.u.def.section;
6307                         }
6308                     }
6309                 }
6310
6311               if (sec == NULL)
6312                 {
6313                   Elf_Internal_Sym *sym;
6314
6315                   if (symndx < symtab_hdr->sh_info)
6316                     {
6317                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6318                       if (sym == NULL)
6319                         {
6320                           size_t symcnt = symtab_hdr->sh_info;
6321                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6322                                                       symcnt, 0,
6323                                                       NULL, NULL, NULL);
6324                           if (sym == NULL)
6325                             break;
6326                           symtab_hdr->contents = (bfd_byte *) sym;
6327                         }
6328                       sym += symndx;
6329                     }
6330                   else
6331                     {
6332                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6333                                                   1, symndx,
6334                                                   NULL, NULL, NULL);
6335                       if (sym == NULL)
6336                         break;
6337                     }
6338                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6339                   if (sec == NULL)
6340                     break;
6341                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6342                   val = sym->st_value;
6343                 }
6344
6345               val += look->r_addend;
6346               if (code_off != NULL)
6347                 *code_off = val;
6348               if (code_sec != NULL)
6349                 {
6350                   if (in_code_sec && *code_sec != sec)
6351                     return -1;
6352                   else
6353                     *code_sec = sec;
6354                 }
6355               if (sec->output_section != NULL)
6356                 val += sec->output_section->vma + sec->output_offset;
6357             }
6358           break;
6359         }
6360     }
6361
6362   return val;
6363 }
6364
6365 /* If the ELF symbol SYM might be a function in SEC, return the
6366    function size and set *CODE_OFF to the function's entry point,
6367    otherwise return zero.  */
6368
6369 static bfd_size_type
6370 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6371                               bfd_vma *code_off)
6372 {
6373   bfd_size_type size;
6374
6375   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6376                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6377     return 0;
6378
6379   size = 0;
6380   if (!(sym->flags & BSF_SYNTHETIC))
6381     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6382
6383   if (strcmp (sym->section->name, ".opd") == 0)
6384     {
6385       struct _opd_sec_data *opd = get_opd_info (sym->section);
6386       bfd_vma symval = sym->value;
6387
6388       if (opd != NULL
6389           && opd->adjust != NULL
6390           && elf_section_data (sym->section)->relocs != NULL)
6391         {
6392           /* opd_entry_value will use cached relocs that have been
6393              adjusted, but with raw symbols.  That means both local
6394              and global symbols need adjusting.  */
6395           long adjust = opd->adjust[OPD_NDX (symval)];
6396           if (adjust == -1)
6397             return 0;
6398           symval += adjust;
6399         }
6400
6401       if (opd_entry_value (sym->section, symval,
6402                            &sec, code_off, TRUE) == (bfd_vma) -1)
6403         return 0;
6404       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6405          symbol.  This size has nothing to do with the code size of the
6406          function, which is what we're supposed to return, but the
6407          code size isn't available without looking up the dot-sym.
6408          However, doing that would be a waste of time particularly
6409          since elf_find_function will look at the dot-sym anyway.
6410          Now, elf_find_function will keep the largest size of any
6411          function sym found at the code address of interest, so return
6412          1 here to avoid it incorrectly caching a larger function size
6413          for a small function.  This does mean we return the wrong
6414          size for a new-ABI function of size 24, but all that does is
6415          disable caching for such functions.  */
6416       if (size == 24)
6417         size = 1;
6418     }
6419   else
6420     {
6421       if (sym->section != sec)
6422         return 0;
6423       *code_off = sym->value;
6424     }
6425   if (size == 0)
6426     size = 1;
6427   return size;
6428 }
6429
6430 /* Return true if symbol is a strong function defined in an ELFv2
6431    object with st_other localentry bits of zero, ie. its local entry
6432    point coincides with its global entry point.  */
6433
6434 static bfd_boolean
6435 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6436 {
6437   return (h != NULL
6438           && h->type == STT_FUNC
6439           && h->root.type == bfd_link_hash_defined
6440           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6441           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6442           && is_ppc64_elf (h->root.u.def.section->owner)
6443           && abiversion (h->root.u.def.section->owner) >= 2);
6444 }
6445
6446 /* Return true if symbol is defined in a regular object file.  */
6447
6448 static bfd_boolean
6449 is_static_defined (struct elf_link_hash_entry *h)
6450 {
6451   return ((h->root.type == bfd_link_hash_defined
6452            || h->root.type == bfd_link_hash_defweak)
6453           && h->root.u.def.section != NULL
6454           && h->root.u.def.section->output_section != NULL);
6455 }
6456
6457 /* If FDH is a function descriptor symbol, return the associated code
6458    entry symbol if it is defined.  Return NULL otherwise.  */
6459
6460 static struct ppc_link_hash_entry *
6461 defined_code_entry (struct ppc_link_hash_entry *fdh)
6462 {
6463   if (fdh->is_func_descriptor)
6464     {
6465       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6466       if (fh->elf.root.type == bfd_link_hash_defined
6467           || fh->elf.root.type == bfd_link_hash_defweak)
6468         return fh;
6469     }
6470   return NULL;
6471 }
6472
6473 /* If FH is a function code entry symbol, return the associated
6474    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6475
6476 static struct ppc_link_hash_entry *
6477 defined_func_desc (struct ppc_link_hash_entry *fh)
6478 {
6479   if (fh->oh != NULL
6480       && fh->oh->is_func_descriptor)
6481     {
6482       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6483       if (fdh->elf.root.type == bfd_link_hash_defined
6484           || fdh->elf.root.type == bfd_link_hash_defweak)
6485         return fdh;
6486     }
6487   return NULL;
6488 }
6489
6490 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6491
6492 /* Garbage collect sections, after first dealing with dot-symbols.  */
6493
6494 static bfd_boolean
6495 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6496 {
6497   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6498
6499   if (htab != NULL && htab->need_func_desc_adj)
6500     {
6501       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6502       htab->need_func_desc_adj = 0;
6503     }
6504   return bfd_elf_gc_sections (abfd, info);
6505 }
6506
6507 /* Mark all our entry sym sections, both opd and code section.  */
6508
6509 static void
6510 ppc64_elf_gc_keep (struct bfd_link_info *info)
6511 {
6512   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6513   struct bfd_sym_chain *sym;
6514
6515   if (htab == NULL)
6516     return;
6517
6518   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6519     {
6520       struct ppc_link_hash_entry *eh, *fh;
6521       asection *sec;
6522
6523       eh = (struct ppc_link_hash_entry *)
6524         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6525       if (eh == NULL)
6526         continue;
6527       if (eh->elf.root.type != bfd_link_hash_defined
6528           && eh->elf.root.type != bfd_link_hash_defweak)
6529         continue;
6530
6531       fh = defined_code_entry (eh);
6532       if (fh != NULL)
6533         {
6534           sec = fh->elf.root.u.def.section;
6535           sec->flags |= SEC_KEEP;
6536         }
6537       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6538                && opd_entry_value (eh->elf.root.u.def.section,
6539                                    eh->elf.root.u.def.value,
6540                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6541         sec->flags |= SEC_KEEP;
6542
6543       sec = eh->elf.root.u.def.section;
6544       sec->flags |= SEC_KEEP;
6545     }
6546 }
6547
6548 /* Mark sections containing dynamically referenced symbols.  When
6549    building shared libraries, we must assume that any visible symbol is
6550    referenced.  */
6551
6552 static bfd_boolean
6553 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6554 {
6555   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6556   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6557   struct ppc_link_hash_entry *fdh;
6558   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6559
6560   /* Dynamic linking info is on the func descriptor sym.  */
6561   fdh = defined_func_desc (eh);
6562   if (fdh != NULL)
6563     eh = fdh;
6564
6565   if ((eh->elf.root.type == bfd_link_hash_defined
6566        || eh->elf.root.type == bfd_link_hash_defweak)
6567       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6568           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6569               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6570               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6571               && (!bfd_link_executable (info)
6572                   || info->gc_keep_exported
6573                   || info->export_dynamic
6574                   || (eh->elf.dynamic
6575                       && d != NULL
6576                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6577               && (eh->elf.versioned >= versioned
6578                   || !bfd_hide_sym_by_version (info->version_info,
6579                                                eh->elf.root.root.string)))))
6580     {
6581       asection *code_sec;
6582       struct ppc_link_hash_entry *fh;
6583
6584       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6585
6586       /* Function descriptor syms cause the associated
6587          function code sym section to be marked.  */
6588       fh = defined_code_entry (eh);
6589       if (fh != NULL)
6590         {
6591           code_sec = fh->elf.root.u.def.section;
6592           code_sec->flags |= SEC_KEEP;
6593         }
6594       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6595                && opd_entry_value (eh->elf.root.u.def.section,
6596                                    eh->elf.root.u.def.value,
6597                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6598         code_sec->flags |= SEC_KEEP;
6599     }
6600
6601   return TRUE;
6602 }
6603
6604 /* Return the section that should be marked against GC for a given
6605    relocation.  */
6606
6607 static asection *
6608 ppc64_elf_gc_mark_hook (asection *sec,
6609                         struct bfd_link_info *info,
6610                         Elf_Internal_Rela *rel,
6611                         struct elf_link_hash_entry *h,
6612                         Elf_Internal_Sym *sym)
6613 {
6614   asection *rsec;
6615
6616   /* Syms return NULL if we're marking .opd, so we avoid marking all
6617      function sections, as all functions are referenced in .opd.  */
6618   rsec = NULL;
6619   if (get_opd_info (sec) != NULL)
6620     return rsec;
6621
6622   if (h != NULL)
6623     {
6624       enum elf_ppc64_reloc_type r_type;
6625       struct ppc_link_hash_entry *eh, *fh, *fdh;
6626
6627       r_type = ELF64_R_TYPE (rel->r_info);
6628       switch (r_type)
6629         {
6630         case R_PPC64_GNU_VTINHERIT:
6631         case R_PPC64_GNU_VTENTRY:
6632           break;
6633
6634         default:
6635           switch (h->root.type)
6636             {
6637             case bfd_link_hash_defined:
6638             case bfd_link_hash_defweak:
6639               eh = (struct ppc_link_hash_entry *) h;
6640               fdh = defined_func_desc (eh);
6641               if (fdh != NULL)
6642                 {
6643                   /* -mcall-aixdesc code references the dot-symbol on
6644                      a call reloc.  Mark the function descriptor too
6645                      against garbage collection.  */
6646                   fdh->elf.mark = 1;
6647                   if (fdh->elf.is_weakalias)
6648                     weakdef (&fdh->elf)->mark = 1;
6649                   eh = fdh;
6650                 }
6651
6652               /* Function descriptor syms cause the associated
6653                  function code sym section to be marked.  */
6654               fh = defined_code_entry (eh);
6655               if (fh != NULL)
6656                 {
6657                   /* They also mark their opd section.  */
6658                   eh->elf.root.u.def.section->gc_mark = 1;
6659
6660                   rsec = fh->elf.root.u.def.section;
6661                 }
6662               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6663                        && opd_entry_value (eh->elf.root.u.def.section,
6664                                            eh->elf.root.u.def.value,
6665                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6666                 eh->elf.root.u.def.section->gc_mark = 1;
6667               else
6668                 rsec = h->root.u.def.section;
6669               break;
6670
6671             case bfd_link_hash_common:
6672               rsec = h->root.u.c.p->section;
6673               break;
6674
6675             default:
6676               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6677             }
6678         }
6679     }
6680   else
6681     {
6682       struct _opd_sec_data *opd;
6683
6684       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6685       opd = get_opd_info (rsec);
6686       if (opd != NULL && opd->func_sec != NULL)
6687         {
6688           rsec->gc_mark = 1;
6689
6690           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6691         }
6692     }
6693
6694   return rsec;
6695 }
6696
6697 /* The maximum size of .sfpr.  */
6698 #define SFPR_MAX (218*4)
6699
6700 struct sfpr_def_parms
6701 {
6702   const char name[12];
6703   unsigned char lo, hi;
6704   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6705   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6706 };
6707
6708 /* Auto-generate _save*, _rest* functions in .sfpr.
6709    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6710    instead.  */
6711
6712 static bfd_boolean
6713 sfpr_define (struct bfd_link_info *info,
6714              const struct sfpr_def_parms *parm,
6715              asection *stub_sec)
6716 {
6717   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6718   unsigned int i;
6719   size_t len = strlen (parm->name);
6720   bfd_boolean writing = FALSE;
6721   char sym[16];
6722
6723   if (htab == NULL)
6724     return FALSE;
6725
6726   memcpy (sym, parm->name, len);
6727   sym[len + 2] = 0;
6728
6729   for (i = parm->lo; i <= parm->hi; i++)
6730     {
6731       struct ppc_link_hash_entry *h;
6732
6733       sym[len + 0] = i / 10 + '0';
6734       sym[len + 1] = i % 10 + '0';
6735       h = (struct ppc_link_hash_entry *)
6736         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6737       if (stub_sec != NULL)
6738         {
6739           if (h != NULL
6740               && h->elf.root.type == bfd_link_hash_defined
6741               && h->elf.root.u.def.section == htab->sfpr)
6742             {
6743               struct elf_link_hash_entry *s;
6744               char buf[32];
6745               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6746               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6747               if (s == NULL)
6748                 return FALSE;
6749               if (s->root.type == bfd_link_hash_new
6750                   || (s->root.type = bfd_link_hash_defined
6751                       && s->root.u.def.section == stub_sec))
6752                 {
6753                   s->root.type = bfd_link_hash_defined;
6754                   s->root.u.def.section = stub_sec;
6755                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6756                                          + h->elf.root.u.def.value);
6757                   s->ref_regular = 1;
6758                   s->def_regular = 1;
6759                   s->ref_regular_nonweak = 1;
6760                   s->forced_local = 1;
6761                   s->non_elf = 0;
6762                   s->root.linker_def = 1;
6763                 }
6764             }
6765           continue;
6766         }
6767       if (h != NULL)
6768         {
6769           h->save_res = 1;
6770           if (!h->elf.def_regular)
6771             {
6772               h->elf.root.type = bfd_link_hash_defined;
6773               h->elf.root.u.def.section = htab->sfpr;
6774               h->elf.root.u.def.value = htab->sfpr->size;
6775               h->elf.type = STT_FUNC;
6776               h->elf.def_regular = 1;
6777               h->elf.non_elf = 0;
6778               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6779               writing = TRUE;
6780               if (htab->sfpr->contents == NULL)
6781                 {
6782                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6783                   if (htab->sfpr->contents == NULL)
6784                     return FALSE;
6785                 }
6786             }
6787         }
6788       if (writing)
6789         {
6790           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6791           if (i != parm->hi)
6792             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6793           else
6794             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6795           htab->sfpr->size = p - htab->sfpr->contents;
6796         }
6797     }
6798
6799   return TRUE;
6800 }
6801
6802 static bfd_byte *
6803 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6804 {
6805   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6806   return p + 4;
6807 }
6808
6809 static bfd_byte *
6810 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6811 {
6812   p = savegpr0 (abfd, p, r);
6813   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6814   p = p + 4;
6815   bfd_put_32 (abfd, BLR, p);
6816   return p + 4;
6817 }
6818
6819 static bfd_byte *
6820 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6821 {
6822   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6823   return p + 4;
6824 }
6825
6826 static bfd_byte *
6827 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6828 {
6829   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6830   p = p + 4;
6831   p = restgpr0 (abfd, p, r);
6832   bfd_put_32 (abfd, MTLR_R0, p);
6833   p = p + 4;
6834   if (r == 29)
6835     {
6836       p = restgpr0 (abfd, p, 30);
6837       p = restgpr0 (abfd, p, 31);
6838     }
6839   bfd_put_32 (abfd, BLR, p);
6840   return p + 4;
6841 }
6842
6843 static bfd_byte *
6844 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6845 {
6846   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6847   return p + 4;
6848 }
6849
6850 static bfd_byte *
6851 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6852 {
6853   p = savegpr1 (abfd, p, r);
6854   bfd_put_32 (abfd, BLR, p);
6855   return p + 4;
6856 }
6857
6858 static bfd_byte *
6859 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6860 {
6861   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6862   return p + 4;
6863 }
6864
6865 static bfd_byte *
6866 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6867 {
6868   p = restgpr1 (abfd, p, r);
6869   bfd_put_32 (abfd, BLR, p);
6870   return p + 4;
6871 }
6872
6873 static bfd_byte *
6874 savefpr (bfd *abfd, bfd_byte *p, int r)
6875 {
6876   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6877   return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6882 {
6883   p = savefpr (abfd, p, r);
6884   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6885   p = p + 4;
6886   bfd_put_32 (abfd, BLR, p);
6887   return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 restfpr (bfd *abfd, bfd_byte *p, int r)
6892 {
6893   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6894   return p + 4;
6895 }
6896
6897 static bfd_byte *
6898 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6899 {
6900   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6901   p = p + 4;
6902   p = restfpr (abfd, p, r);
6903   bfd_put_32 (abfd, MTLR_R0, p);
6904   p = p + 4;
6905   if (r == 29)
6906     {
6907       p = restfpr (abfd, p, 30);
6908       p = restfpr (abfd, p, 31);
6909     }
6910   bfd_put_32 (abfd, BLR, p);
6911   return p + 4;
6912 }
6913
6914 static bfd_byte *
6915 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6916 {
6917   p = savefpr (abfd, p, r);
6918   bfd_put_32 (abfd, BLR, p);
6919   return p + 4;
6920 }
6921
6922 static bfd_byte *
6923 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6924 {
6925   p = restfpr (abfd, p, r);
6926   bfd_put_32 (abfd, BLR, p);
6927   return p + 4;
6928 }
6929
6930 static bfd_byte *
6931 savevr (bfd *abfd, bfd_byte *p, int r)
6932 {
6933   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6934   p = p + 4;
6935   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6936   return p + 4;
6937 }
6938
6939 static bfd_byte *
6940 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6941 {
6942   p = savevr (abfd, p, r);
6943   bfd_put_32 (abfd, BLR, p);
6944   return p + 4;
6945 }
6946
6947 static bfd_byte *
6948 restvr (bfd *abfd, bfd_byte *p, int r)
6949 {
6950   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6951   p = p + 4;
6952   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6953   return p + 4;
6954 }
6955
6956 static bfd_byte *
6957 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6958 {
6959   p = restvr (abfd, p, r);
6960   bfd_put_32 (abfd, BLR, p);
6961   return p + 4;
6962 }
6963
6964 /* Called via elf_link_hash_traverse to transfer dynamic linking
6965    information on function code symbol entries to their corresponding
6966    function descriptor symbol entries.  */
6967
6968 static bfd_boolean
6969 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6970 {
6971   struct bfd_link_info *info;
6972   struct ppc_link_hash_table *htab;
6973   struct ppc_link_hash_entry *fh;
6974   struct ppc_link_hash_entry *fdh;
6975   bfd_boolean force_local;
6976
6977   fh = (struct ppc_link_hash_entry *) h;
6978   if (fh->elf.root.type == bfd_link_hash_indirect)
6979     return TRUE;
6980
6981   if (!fh->is_func)
6982     return TRUE;
6983
6984   if (fh->elf.root.root.string[0] != '.'
6985       || fh->elf.root.root.string[1] == '\0')
6986     return TRUE;
6987
6988   info = inf;
6989   htab = ppc_hash_table (info);
6990   if (htab == NULL)
6991     return FALSE;
6992
6993   /* Find the corresponding function descriptor symbol.  */
6994   fdh = lookup_fdh (fh, htab);
6995
6996   /* Resolve undefined references to dot-symbols as the value
6997      in the function descriptor, if we have one in a regular object.
6998      This is to satisfy cases like ".quad .foo".  Calls to functions
6999      in dynamic objects are handled elsewhere.  */
7000   if ((fh->elf.root.type == bfd_link_hash_undefined
7001        || fh->elf.root.type == bfd_link_hash_undefweak)
7002       && (fdh->elf.root.type == bfd_link_hash_defined
7003           || fdh->elf.root.type == bfd_link_hash_defweak)
7004       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7005       && opd_entry_value (fdh->elf.root.u.def.section,
7006                           fdh->elf.root.u.def.value,
7007                           &fh->elf.root.u.def.section,
7008                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7009     {
7010       fh->elf.root.type = fdh->elf.root.type;
7011       fh->elf.forced_local = 1;
7012       fh->elf.def_regular = fdh->elf.def_regular;
7013       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7014     }
7015
7016   if (!fh->elf.dynamic)
7017     {
7018       struct plt_entry *ent;
7019
7020       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7021         if (ent->plt.refcount > 0)
7022           break;
7023       if (ent == NULL)
7024         return TRUE;
7025     }
7026
7027   /* Create a descriptor as undefined if necessary.  */
7028   if (fdh == NULL
7029       && !bfd_link_executable (info)
7030       && (fh->elf.root.type == bfd_link_hash_undefined
7031           || fh->elf.root.type == bfd_link_hash_undefweak))
7032     {
7033       fdh = make_fdh (info, fh);
7034       if (fdh == NULL)
7035         return FALSE;
7036     }
7037
7038   /* We can't support overriding of symbols on a fake descriptor.  */
7039   if (fdh != NULL
7040       && fdh->fake
7041       && (fh->elf.root.type == bfd_link_hash_defined
7042           || fh->elf.root.type == bfd_link_hash_defweak))
7043     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7044
7045   /* Transfer dynamic linking information to the function descriptor.  */
7046   if (fdh != NULL)
7047     {
7048       fdh->elf.ref_regular |= fh->elf.ref_regular;
7049       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7050       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7051       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7052       fdh->elf.dynamic |= fh->elf.dynamic;
7053       fdh->elf.needs_plt |= (fh->elf.needs_plt
7054                              || fh->elf.type == STT_FUNC
7055                              || fh->elf.type == STT_GNU_IFUNC);
7056       move_plt_plist (fh, fdh);
7057
7058       if (!fdh->elf.forced_local
7059           && fh->elf.dynindx != -1)
7060         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7061           return FALSE;
7062     }
7063
7064   /* Now that the info is on the function descriptor, clear the
7065      function code sym info.  Any function code syms for which we
7066      don't have a definition in a regular file, we force local.
7067      This prevents a shared library from exporting syms that have
7068      been imported from another library.  Function code syms that
7069      are really in the library we must leave global to prevent the
7070      linker dragging in a definition from a static library.  */
7071   force_local = (!fh->elf.def_regular
7072                  || fdh == NULL
7073                  || !fdh->elf.def_regular
7074                  || fdh->elf.forced_local);
7075   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7076
7077   return TRUE;
7078 }
7079
7080 static const struct sfpr_def_parms save_res_funcs[] =
7081   {
7082     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7083     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7084     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7085     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7086     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7087     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7088     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7089     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7090     { "._savef", 14, 31, savefpr, savefpr1_tail },
7091     { "._restf", 14, 31, restfpr, restfpr1_tail },
7092     { "_savevr_", 20, 31, savevr, savevr_tail },
7093     { "_restvr_", 20, 31, restvr, restvr_tail }
7094   };
7095
7096 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7097    this hook to a) provide some gcc support functions, and b) transfer
7098    dynamic linking information gathered so far on function code symbol
7099    entries, to their corresponding function descriptor symbol entries.  */
7100
7101 static bfd_boolean
7102 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7103                             struct bfd_link_info *info)
7104 {
7105   struct ppc_link_hash_table *htab;
7106
7107   htab = ppc_hash_table (info);
7108   if (htab == NULL)
7109     return FALSE;
7110
7111   /* Provide any missing _save* and _rest* functions.  */
7112   if (htab->sfpr != NULL)
7113     {
7114       unsigned int i;
7115
7116       htab->sfpr->size = 0;
7117       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7118         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7119           return FALSE;
7120       if (htab->sfpr->size == 0)
7121         htab->sfpr->flags |= SEC_EXCLUDE;
7122     }
7123
7124   if (bfd_link_relocatable (info))
7125     return TRUE;
7126
7127   if (htab->elf.hgot != NULL)
7128     {
7129       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7130       /* Make .TOC. defined so as to prevent it being made dynamic.
7131          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7132       if (!htab->elf.hgot->def_regular
7133           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7134         {
7135           htab->elf.hgot->root.type = bfd_link_hash_defined;
7136           htab->elf.hgot->root.u.def.value = 0;
7137           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7138           htab->elf.hgot->def_regular = 1;
7139           htab->elf.hgot->root.linker_def = 1;
7140         }
7141       htab->elf.hgot->type = STT_OBJECT;
7142       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7143                                | STV_HIDDEN);
7144     }
7145
7146   if (htab->need_func_desc_adj)
7147     {
7148       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7149       htab->need_func_desc_adj = 0;
7150     }
7151
7152   return TRUE;
7153 }
7154
7155 /* Find dynamic relocs for H that apply to read-only sections.  */
7156
7157 static asection *
7158 readonly_dynrelocs (struct elf_link_hash_entry *h)
7159 {
7160   struct ppc_link_hash_entry *eh;
7161   struct elf_dyn_relocs *p;
7162
7163   eh = (struct ppc_link_hash_entry *) h;
7164   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7165     {
7166       asection *s = p->sec->output_section;
7167
7168       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7169         return p->sec;
7170     }
7171   return NULL;
7172 }
7173
7174 /* Return true if we have dynamic relocs against H or any of its weak
7175    aliases, that apply to read-only sections.  Cannot be used after
7176    size_dynamic_sections.  */
7177
7178 static bfd_boolean
7179 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7180 {
7181   struct ppc_link_hash_entry *eh;
7182
7183   eh = (struct ppc_link_hash_entry *) h;
7184   do
7185     {
7186       if (readonly_dynrelocs (&eh->elf))
7187         return TRUE;
7188       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7189     } while (eh != NULL && &eh->elf != h);
7190
7191   return FALSE;
7192 }
7193
7194 /* Return whether EH has pc-relative dynamic relocs.  */
7195
7196 static bfd_boolean
7197 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7198 {
7199   struct elf_dyn_relocs *p;
7200
7201   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7202     if (p->pc_count != 0)
7203       return TRUE;
7204   return FALSE;
7205 }
7206
7207 /* Return true if a global entry stub will be created for H.  Valid
7208    for ELFv2 before plt entries have been allocated.  */
7209
7210 static bfd_boolean
7211 global_entry_stub (struct elf_link_hash_entry *h)
7212 {
7213   struct plt_entry *pent;
7214
7215   if (!h->pointer_equality_needed
7216       || h->def_regular)
7217     return FALSE;
7218
7219   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7220     if (pent->plt.refcount > 0
7221         && pent->addend == 0)
7222       return TRUE;
7223
7224   return FALSE;
7225 }
7226
7227 /* Adjust a symbol defined by a dynamic object and referenced by a
7228    regular object.  The current definition is in some section of the
7229    dynamic object, but we're not including those sections.  We have to
7230    change the definition to something the rest of the link can
7231    understand.  */
7232
7233 static bfd_boolean
7234 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7235                                  struct elf_link_hash_entry *h)
7236 {
7237   struct ppc_link_hash_table *htab;
7238   asection *s, *srel;
7239
7240   htab = ppc_hash_table (info);
7241   if (htab == NULL)
7242     return FALSE;
7243
7244   /* Deal with function syms.  */
7245   if (h->type == STT_FUNC
7246       || h->type == STT_GNU_IFUNC
7247       || h->needs_plt)
7248     {
7249       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7250                            || SYMBOL_CALLS_LOCAL (info, h)
7251                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7252       /* Discard dyn_relocs when non-pic if we've decided that a
7253          function symbol is local and not an ifunc.  We keep dynamic
7254          relocs for ifuncs when local rather than always emitting a
7255          plt call stub for them and defining the symbol on the call
7256          stub.  We can't do that for ELFv1 anyway (a function symbol
7257          is defined on a descriptor, not code) and it can be faster at
7258          run-time due to not needing to bounce through a stub.  The
7259          dyn_relocs for ifuncs will be applied even in a static
7260          executable.  */
7261       if (!bfd_link_pic (info)
7262           && h->type != STT_GNU_IFUNC
7263           && local)
7264         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7265
7266       /* Clear procedure linkage table information for any symbol that
7267          won't need a .plt entry.  */
7268       struct plt_entry *ent;
7269       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7270         if (ent->plt.refcount > 0)
7271           break;
7272       if (ent == NULL
7273           || (h->type != STT_GNU_IFUNC
7274               && local
7275               && (htab->can_convert_all_inline_plt
7276                   || (((struct ppc_link_hash_entry *) h)->tls_mask
7277                       & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7278         {
7279           h->plt.plist = NULL;
7280           h->needs_plt = 0;
7281           h->pointer_equality_needed = 0;
7282         }
7283       else if (abiversion (info->output_bfd) >= 2)
7284         {
7285           /* Taking a function's address in a read/write section
7286              doesn't require us to define the function symbol in the
7287              executable on a global entry stub.  A dynamic reloc can
7288              be used instead.  The reason we prefer a few more dynamic
7289              relocs is that calling via a global entry stub costs a
7290              few more instructions, and pointer_equality_needed causes
7291              extra work in ld.so when resolving these symbols.  */
7292           if (global_entry_stub (h))
7293             {
7294               if (!readonly_dynrelocs (h))
7295                 {
7296                   h->pointer_equality_needed = 0;
7297                   /* If we haven't seen a branch reloc then we don't need
7298                      a plt entry.  */
7299                   if (!h->needs_plt)
7300                     h->plt.plist = NULL;
7301                 }
7302               else if (!bfd_link_pic (info))
7303                 /* We are going to be defining the function symbol on the
7304                    plt stub, so no dyn_relocs needed when non-pic.  */
7305                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7306             }
7307
7308           /* ELFv2 function symbols can't have copy relocs.  */
7309           return TRUE;
7310         }
7311       else if (!h->needs_plt
7312                && !readonly_dynrelocs (h))
7313         {
7314           /* If we haven't seen a branch reloc then we don't need a
7315              plt entry.  */
7316           h->plt.plist = NULL;
7317           h->pointer_equality_needed = 0;
7318           return TRUE;
7319         }
7320     }
7321   else
7322     h->plt.plist = NULL;
7323
7324   /* If this is a weak symbol, and there is a real definition, the
7325      processor independent code will have arranged for us to see the
7326      real definition first, and we can just use the same value.  */
7327   if (h->is_weakalias)
7328     {
7329       struct elf_link_hash_entry *def = weakdef (h);
7330       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7331       h->root.u.def.section = def->root.u.def.section;
7332       h->root.u.def.value = def->root.u.def.value;
7333       if (def->root.u.def.section == htab->elf.sdynbss
7334           || def->root.u.def.section == htab->elf.sdynrelro)
7335         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7336       return TRUE;
7337     }
7338
7339   /* If we are creating a shared library, we must presume that the
7340      only references to the symbol are via the global offset table.
7341      For such cases we need not do anything here; the relocations will
7342      be handled correctly by relocate_section.  */
7343   if (bfd_link_pic (info))
7344     return TRUE;
7345
7346   /* If there are no references to this symbol that do not use the
7347      GOT, we don't need to generate a copy reloc.  */
7348   if (!h->non_got_ref)
7349     return TRUE;
7350
7351   /* Don't generate a copy reloc for symbols defined in the executable.  */
7352   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7353
7354       /* If -z nocopyreloc was given, don't generate them either.  */
7355       || info->nocopyreloc
7356
7357       /* If we don't find any dynamic relocs in read-only sections, then
7358          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7359       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7360
7361       /* Protected variables do not work with .dynbss.  The copy in
7362          .dynbss won't be used by the shared library with the protected
7363          definition for the variable.  Text relocations are preferable
7364          to an incorrect program.  */
7365       || h->protected_def)
7366     return TRUE;
7367
7368   if (h->plt.plist != NULL)
7369     {
7370       /* We should never get here, but unfortunately there are versions
7371          of gcc out there that improperly (for this ABI) put initialized
7372          function pointers, vtable refs and suchlike in read-only
7373          sections.  Allow them to proceed, but warn that this might
7374          break at runtime.  */
7375       info->callbacks->einfo
7376         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7377            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7378          h->root.root.string);
7379     }
7380
7381   /* This is a reference to a symbol defined by a dynamic object which
7382      is not a function.  */
7383
7384   /* We must allocate the symbol in our .dynbss section, which will
7385      become part of the .bss section of the executable.  There will be
7386      an entry for this symbol in the .dynsym section.  The dynamic
7387      object will contain position independent code, so all references
7388      from the dynamic object to this symbol will go through the global
7389      offset table.  The dynamic linker will use the .dynsym entry to
7390      determine the address it must put in the global offset table, so
7391      both the dynamic object and the regular object will refer to the
7392      same memory location for the variable.  */
7393   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7394     {
7395       s = htab->elf.sdynrelro;
7396       srel = htab->elf.sreldynrelro;
7397     }
7398   else
7399     {
7400       s = htab->elf.sdynbss;
7401       srel = htab->elf.srelbss;
7402     }
7403   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7404     {
7405       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7406          linker to copy the initial value out of the dynamic object
7407          and into the runtime process image.  */
7408       srel->size += sizeof (Elf64_External_Rela);
7409       h->needs_copy = 1;
7410     }
7411
7412   /* We no longer want dyn_relocs.  */
7413   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7414   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7415 }
7416
7417 /* If given a function descriptor symbol, hide both the function code
7418    sym and the descriptor.  */
7419 static void
7420 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7421                        struct elf_link_hash_entry *h,
7422                        bfd_boolean force_local)
7423 {
7424   struct ppc_link_hash_entry *eh;
7425   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7426
7427   eh = (struct ppc_link_hash_entry *) h;
7428   if (eh->is_func_descriptor)
7429     {
7430       struct ppc_link_hash_entry *fh = eh->oh;
7431
7432       if (fh == NULL)
7433         {
7434           const char *p, *q;
7435           struct elf_link_hash_table *htab = elf_hash_table (info);
7436           char save;
7437
7438           /* We aren't supposed to use alloca in BFD because on
7439              systems which do not have alloca the version in libiberty
7440              calls xmalloc, which might cause the program to crash
7441              when it runs out of memory.  This function doesn't have a
7442              return status, so there's no way to gracefully return an
7443              error.  So cheat.  We know that string[-1] can be safely
7444              accessed;  It's either a string in an ELF string table,
7445              or allocated in an objalloc structure.  */
7446
7447           p = eh->elf.root.root.string - 1;
7448           save = *p;
7449           *(char *) p = '.';
7450           fh = (struct ppc_link_hash_entry *)
7451             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7452           *(char *) p = save;
7453
7454           /* Unfortunately, if it so happens that the string we were
7455              looking for was allocated immediately before this string,
7456              then we overwrote the string terminator.  That's the only
7457              reason the lookup should fail.  */
7458           if (fh == NULL)
7459             {
7460               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7461               while (q >= eh->elf.root.root.string && *q == *p)
7462                 --q, --p;
7463               if (q < eh->elf.root.root.string && *p == '.')
7464                 fh = (struct ppc_link_hash_entry *)
7465                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7466             }
7467           if (fh != NULL)
7468             {
7469               eh->oh = fh;
7470               fh->oh = eh;
7471             }
7472         }
7473       if (fh != NULL)
7474         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7475     }
7476 }
7477
7478 static bfd_boolean
7479 get_sym_h (struct elf_link_hash_entry **hp,
7480            Elf_Internal_Sym **symp,
7481            asection **symsecp,
7482            unsigned char **tls_maskp,
7483            Elf_Internal_Sym **locsymsp,
7484            unsigned long r_symndx,
7485            bfd *ibfd)
7486 {
7487   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7488
7489   if (r_symndx >= symtab_hdr->sh_info)
7490     {
7491       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7492       struct elf_link_hash_entry *h;
7493
7494       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7495       h = elf_follow_link (h);
7496
7497       if (hp != NULL)
7498         *hp = h;
7499
7500       if (symp != NULL)
7501         *symp = NULL;
7502
7503       if (symsecp != NULL)
7504         {
7505           asection *symsec = NULL;
7506           if (h->root.type == bfd_link_hash_defined
7507               || h->root.type == bfd_link_hash_defweak)
7508             symsec = h->root.u.def.section;
7509           *symsecp = symsec;
7510         }
7511
7512       if (tls_maskp != NULL)
7513         {
7514           struct ppc_link_hash_entry *eh;
7515
7516           eh = (struct ppc_link_hash_entry *) h;
7517           *tls_maskp = &eh->tls_mask;
7518         }
7519     }
7520   else
7521     {
7522       Elf_Internal_Sym *sym;
7523       Elf_Internal_Sym *locsyms = *locsymsp;
7524
7525       if (locsyms == NULL)
7526         {
7527           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7528           if (locsyms == NULL)
7529             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7530                                             symtab_hdr->sh_info,
7531                                             0, NULL, NULL, NULL);
7532           if (locsyms == NULL)
7533             return FALSE;
7534           *locsymsp = locsyms;
7535         }
7536       sym = locsyms + r_symndx;
7537
7538       if (hp != NULL)
7539         *hp = NULL;
7540
7541       if (symp != NULL)
7542         *symp = sym;
7543
7544       if (symsecp != NULL)
7545         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7546
7547       if (tls_maskp != NULL)
7548         {
7549           struct got_entry **lgot_ents;
7550           unsigned char *tls_mask;
7551
7552           tls_mask = NULL;
7553           lgot_ents = elf_local_got_ents (ibfd);
7554           if (lgot_ents != NULL)
7555             {
7556               struct plt_entry **local_plt = (struct plt_entry **)
7557                 (lgot_ents + symtab_hdr->sh_info);
7558               unsigned char *lgot_masks = (unsigned char *)
7559                 (local_plt + symtab_hdr->sh_info);
7560               tls_mask = &lgot_masks[r_symndx];
7561             }
7562           *tls_maskp = tls_mask;
7563         }
7564     }
7565   return TRUE;
7566 }
7567
7568 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7569    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7570    type suitable for optimization, and 1 otherwise.  */
7571
7572 static int
7573 get_tls_mask (unsigned char **tls_maskp,
7574               unsigned long *toc_symndx,
7575               bfd_vma *toc_addend,
7576               Elf_Internal_Sym **locsymsp,
7577               const Elf_Internal_Rela *rel,
7578               bfd *ibfd)
7579 {
7580   unsigned long r_symndx;
7581   int next_r;
7582   struct elf_link_hash_entry *h;
7583   Elf_Internal_Sym *sym;
7584   asection *sec;
7585   bfd_vma off;
7586
7587   r_symndx = ELF64_R_SYM (rel->r_info);
7588   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7589     return 0;
7590
7591   if ((*tls_maskp != NULL
7592        && (**tls_maskp & TLS_TLS) != 0
7593        && **tls_maskp != (TLS_TLS | TLS_MARK))
7594       || sec == NULL
7595       || ppc64_elf_section_data (sec) == NULL
7596       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7597     return 1;
7598
7599   /* Look inside a TOC section too.  */
7600   if (h != NULL)
7601     {
7602       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7603       off = h->root.u.def.value;
7604     }
7605   else
7606     off = sym->st_value;
7607   off += rel->r_addend;
7608   BFD_ASSERT (off % 8 == 0);
7609   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7610   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7611   if (toc_symndx != NULL)
7612     *toc_symndx = r_symndx;
7613   if (toc_addend != NULL)
7614     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7615   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7616     return 0;
7617   if ((h == NULL || is_static_defined (h))
7618       && (next_r == -1 || next_r == -2))
7619     return 1 - next_r;
7620   return 1;
7621 }
7622
7623 /* Find (or create) an entry in the tocsave hash table.  */
7624
7625 static struct tocsave_entry *
7626 tocsave_find (struct ppc_link_hash_table *htab,
7627               enum insert_option insert,
7628               Elf_Internal_Sym **local_syms,
7629               const Elf_Internal_Rela *irela,
7630               bfd *ibfd)
7631 {
7632   unsigned long r_indx;
7633   struct elf_link_hash_entry *h;
7634   Elf_Internal_Sym *sym;
7635   struct tocsave_entry ent, *p;
7636   hashval_t hash;
7637   struct tocsave_entry **slot;
7638
7639   r_indx = ELF64_R_SYM (irela->r_info);
7640   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7641     return NULL;
7642   if (ent.sec == NULL || ent.sec->output_section == NULL)
7643     {
7644       _bfd_error_handler
7645         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7646       return NULL;
7647     }
7648
7649   if (h != NULL)
7650     ent.offset = h->root.u.def.value;
7651   else
7652     ent.offset = sym->st_value;
7653   ent.offset += irela->r_addend;
7654
7655   hash = tocsave_htab_hash (&ent);
7656   slot = ((struct tocsave_entry **)
7657           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7658   if (slot == NULL)
7659     return NULL;
7660
7661   if (*slot == NULL)
7662     {
7663       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7664       if (p == NULL)
7665         return NULL;
7666       *p = ent;
7667       *slot = p;
7668     }
7669   return *slot;
7670 }
7671
7672 /* Adjust all global syms defined in opd sections.  In gcc generated
7673    code for the old ABI, these will already have been done.  */
7674
7675 static bfd_boolean
7676 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7677 {
7678   struct ppc_link_hash_entry *eh;
7679   asection *sym_sec;
7680   struct _opd_sec_data *opd;
7681
7682   if (h->root.type == bfd_link_hash_indirect)
7683     return TRUE;
7684
7685   if (h->root.type != bfd_link_hash_defined
7686       && h->root.type != bfd_link_hash_defweak)
7687     return TRUE;
7688
7689   eh = (struct ppc_link_hash_entry *) h;
7690   if (eh->adjust_done)
7691     return TRUE;
7692
7693   sym_sec = eh->elf.root.u.def.section;
7694   opd = get_opd_info (sym_sec);
7695   if (opd != NULL && opd->adjust != NULL)
7696     {
7697       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7698       if (adjust == -1)
7699         {
7700           /* This entry has been deleted.  */
7701           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7702           if (dsec == NULL)
7703             {
7704               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7705                 if (discarded_section (dsec))
7706                   {
7707                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7708                     break;
7709                   }
7710             }
7711           eh->elf.root.u.def.value = 0;
7712           eh->elf.root.u.def.section = dsec;
7713         }
7714       else
7715         eh->elf.root.u.def.value += adjust;
7716       eh->adjust_done = 1;
7717     }
7718   return TRUE;
7719 }
7720
7721 /* Handles decrementing dynamic reloc counts for the reloc specified by
7722    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7723    have already been determined.  */
7724
7725 static bfd_boolean
7726 dec_dynrel_count (bfd_vma r_info,
7727                   asection *sec,
7728                   struct bfd_link_info *info,
7729                   Elf_Internal_Sym **local_syms,
7730                   struct elf_link_hash_entry *h,
7731                   Elf_Internal_Sym *sym)
7732 {
7733   enum elf_ppc64_reloc_type r_type;
7734   asection *sym_sec = NULL;
7735
7736   /* Can this reloc be dynamic?  This switch, and later tests here
7737      should be kept in sync with the code in check_relocs.  */
7738   r_type = ELF64_R_TYPE (r_info);
7739   switch (r_type)
7740     {
7741     default:
7742       return TRUE;
7743
7744     case R_PPC64_TPREL16:
7745     case R_PPC64_TPREL16_LO:
7746     case R_PPC64_TPREL16_HI:
7747     case R_PPC64_TPREL16_HA:
7748     case R_PPC64_TPREL16_DS:
7749     case R_PPC64_TPREL16_LO_DS:
7750     case R_PPC64_TPREL16_HIGH:
7751     case R_PPC64_TPREL16_HIGHA:
7752     case R_PPC64_TPREL16_HIGHER:
7753     case R_PPC64_TPREL16_HIGHERA:
7754     case R_PPC64_TPREL16_HIGHEST:
7755     case R_PPC64_TPREL16_HIGHESTA:
7756     case R_PPC64_TPREL64:
7757     case R_PPC64_DTPMOD64:
7758     case R_PPC64_DTPREL64:
7759     case R_PPC64_ADDR64:
7760     case R_PPC64_REL30:
7761     case R_PPC64_REL32:
7762     case R_PPC64_REL64:
7763     case R_PPC64_ADDR14:
7764     case R_PPC64_ADDR14_BRNTAKEN:
7765     case R_PPC64_ADDR14_BRTAKEN:
7766     case R_PPC64_ADDR16:
7767     case R_PPC64_ADDR16_DS:
7768     case R_PPC64_ADDR16_HA:
7769     case R_PPC64_ADDR16_HI:
7770     case R_PPC64_ADDR16_HIGH:
7771     case R_PPC64_ADDR16_HIGHA:
7772     case R_PPC64_ADDR16_HIGHER:
7773     case R_PPC64_ADDR16_HIGHERA:
7774     case R_PPC64_ADDR16_HIGHEST:
7775     case R_PPC64_ADDR16_HIGHESTA:
7776     case R_PPC64_ADDR16_LO:
7777     case R_PPC64_ADDR16_LO_DS:
7778     case R_PPC64_ADDR24:
7779     case R_PPC64_ADDR32:
7780     case R_PPC64_UADDR16:
7781     case R_PPC64_UADDR32:
7782     case R_PPC64_UADDR64:
7783     case R_PPC64_TOC:
7784       break;
7785     }
7786
7787   if (local_syms != NULL)
7788     {
7789       unsigned long r_symndx;
7790       bfd *ibfd = sec->owner;
7791
7792       r_symndx = ELF64_R_SYM (r_info);
7793       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7794         return FALSE;
7795     }
7796
7797   if ((bfd_link_pic (info)
7798        && (must_be_dyn_reloc (info, r_type)
7799            || (h != NULL
7800                && (!SYMBOLIC_BIND (info, h)
7801                    || h->root.type == bfd_link_hash_defweak
7802                    || !h->def_regular))))
7803       || (ELIMINATE_COPY_RELOCS
7804           && !bfd_link_pic (info)
7805           && h != NULL
7806           && (h->root.type == bfd_link_hash_defweak
7807               || !h->def_regular)))
7808     ;
7809   else
7810     return TRUE;
7811
7812   if (h != NULL)
7813     {
7814       struct elf_dyn_relocs *p;
7815       struct elf_dyn_relocs **pp;
7816       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7817
7818       /* elf_gc_sweep may have already removed all dyn relocs associated
7819          with local syms for a given section.  Also, symbol flags are
7820          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7821          report a dynreloc miscount.  */
7822       if (*pp == NULL && info->gc_sections)
7823         return TRUE;
7824
7825       while ((p = *pp) != NULL)
7826         {
7827           if (p->sec == sec)
7828             {
7829               if (!must_be_dyn_reloc (info, r_type))
7830                 p->pc_count -= 1;
7831               p->count -= 1;
7832               if (p->count == 0)
7833                 *pp = p->next;
7834               return TRUE;
7835             }
7836           pp = &p->next;
7837         }
7838     }
7839   else
7840     {
7841       struct ppc_dyn_relocs *p;
7842       struct ppc_dyn_relocs **pp;
7843       void *vpp;
7844       bfd_boolean is_ifunc;
7845
7846       if (local_syms == NULL)
7847         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7848       if (sym_sec == NULL)
7849         sym_sec = sec;
7850
7851       vpp = &elf_section_data (sym_sec)->local_dynrel;
7852       pp = (struct ppc_dyn_relocs **) vpp;
7853
7854       if (*pp == NULL && info->gc_sections)
7855         return TRUE;
7856
7857       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7858       while ((p = *pp) != NULL)
7859         {
7860           if (p->sec == sec && p->ifunc == is_ifunc)
7861             {
7862               p->count -= 1;
7863               if (p->count == 0)
7864                 *pp = p->next;
7865               return TRUE;
7866             }
7867           pp = &p->next;
7868         }
7869     }
7870
7871   /* xgettext:c-format */
7872   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7873                       sec->owner, sec);
7874   bfd_set_error (bfd_error_bad_value);
7875   return FALSE;
7876 }
7877
7878 /* Remove unused Official Procedure Descriptor entries.  Currently we
7879    only remove those associated with functions in discarded link-once
7880    sections, or weakly defined functions that have been overridden.  It
7881    would be possible to remove many more entries for statically linked
7882    applications.  */
7883
7884 bfd_boolean
7885 ppc64_elf_edit_opd (struct bfd_link_info *info)
7886 {
7887   bfd *ibfd;
7888   bfd_boolean some_edited = FALSE;
7889   asection *need_pad = NULL;
7890   struct ppc_link_hash_table *htab;
7891
7892   htab = ppc_hash_table (info);
7893   if (htab == NULL)
7894     return FALSE;
7895
7896   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7897     {
7898       asection *sec;
7899       Elf_Internal_Rela *relstart, *rel, *relend;
7900       Elf_Internal_Shdr *symtab_hdr;
7901       Elf_Internal_Sym *local_syms;
7902       struct _opd_sec_data *opd;
7903       bfd_boolean need_edit, add_aux_fields, broken;
7904       bfd_size_type cnt_16b = 0;
7905
7906       if (!is_ppc64_elf (ibfd))
7907         continue;
7908
7909       sec = bfd_get_section_by_name (ibfd, ".opd");
7910       if (sec == NULL || sec->size == 0)
7911         continue;
7912
7913       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7914         continue;
7915
7916       if (sec->output_section == bfd_abs_section_ptr)
7917         continue;
7918
7919       /* Look through the section relocs.  */
7920       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7921         continue;
7922
7923       local_syms = NULL;
7924       symtab_hdr = &elf_symtab_hdr (ibfd);
7925
7926       /* Read the relocations.  */
7927       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7928                                             info->keep_memory);
7929       if (relstart == NULL)
7930         return FALSE;
7931
7932       /* First run through the relocs to check they are sane, and to
7933          determine whether we need to edit this opd section.  */
7934       need_edit = FALSE;
7935       broken = FALSE;
7936       need_pad = sec;
7937       relend = relstart + sec->reloc_count;
7938       for (rel = relstart; rel < relend; )
7939         {
7940           enum elf_ppc64_reloc_type r_type;
7941           unsigned long r_symndx;
7942           asection *sym_sec;
7943           struct elf_link_hash_entry *h;
7944           Elf_Internal_Sym *sym;
7945           bfd_vma offset;
7946
7947           /* .opd contains an array of 16 or 24 byte entries.  We're
7948              only interested in the reloc pointing to a function entry
7949              point.  */
7950           offset = rel->r_offset;
7951           if (rel + 1 == relend
7952               || rel[1].r_offset != offset + 8)
7953             {
7954               /* If someone messes with .opd alignment then after a
7955                  "ld -r" we might have padding in the middle of .opd.
7956                  Also, there's nothing to prevent someone putting
7957                  something silly in .opd with the assembler.  No .opd
7958                  optimization for them!  */
7959             broken_opd:
7960               _bfd_error_handler
7961                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7962               broken = TRUE;
7963               break;
7964             }
7965
7966           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7967               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7968             {
7969               _bfd_error_handler
7970                 /* xgettext:c-format */
7971                 (_("%pB: unexpected reloc type %u in .opd section"),
7972                  ibfd, r_type);
7973               broken = TRUE;
7974               break;
7975             }
7976
7977           r_symndx = ELF64_R_SYM (rel->r_info);
7978           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7979                           r_symndx, ibfd))
7980             goto error_ret;
7981
7982           if (sym_sec == NULL || sym_sec->owner == NULL)
7983             {
7984               const char *sym_name;
7985               if (h != NULL)
7986                 sym_name = h->root.root.string;
7987               else
7988                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7989                                              sym_sec);
7990
7991               _bfd_error_handler
7992                 /* xgettext:c-format */
7993                 (_("%pB: undefined sym `%s' in .opd section"),
7994                  ibfd, sym_name);
7995               broken = TRUE;
7996               break;
7997             }
7998
7999           /* opd entries are always for functions defined in the
8000              current input bfd.  If the symbol isn't defined in the
8001              input bfd, then we won't be using the function in this
8002              bfd;  It must be defined in a linkonce section in another
8003              bfd, or is weak.  It's also possible that we are
8004              discarding the function due to a linker script /DISCARD/,
8005              which we test for via the output_section.  */
8006           if (sym_sec->owner != ibfd
8007               || sym_sec->output_section == bfd_abs_section_ptr)
8008             need_edit = TRUE;
8009
8010           rel += 2;
8011           if (rel + 1 == relend
8012               || (rel + 2 < relend
8013                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8014             ++rel;
8015
8016           if (rel == relend)
8017             {
8018               if (sec->size == offset + 24)
8019                 {
8020                   need_pad = NULL;
8021                   break;
8022                 }
8023               if (sec->size == offset + 16)
8024                 {
8025                   cnt_16b++;
8026                   break;
8027                 }
8028               goto broken_opd;
8029             }
8030           else if (rel + 1 < relend
8031                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8032                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8033             {
8034               if (rel[0].r_offset == offset + 16)
8035                 cnt_16b++;
8036               else if (rel[0].r_offset != offset + 24)
8037                 goto broken_opd;
8038             }
8039           else
8040             goto broken_opd;
8041         }
8042
8043       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8044
8045       if (!broken && (need_edit || add_aux_fields))
8046         {
8047           Elf_Internal_Rela *write_rel;
8048           Elf_Internal_Shdr *rel_hdr;
8049           bfd_byte *rptr, *wptr;
8050           bfd_byte *new_contents;
8051           bfd_size_type amt;
8052
8053           new_contents = NULL;
8054           amt = OPD_NDX (sec->size) * sizeof (long);
8055           opd = &ppc64_elf_section_data (sec)->u.opd;
8056           opd->adjust = bfd_zalloc (sec->owner, amt);
8057           if (opd->adjust == NULL)
8058             return FALSE;
8059
8060           /* This seems a waste of time as input .opd sections are all
8061              zeros as generated by gcc, but I suppose there's no reason
8062              this will always be so.  We might start putting something in
8063              the third word of .opd entries.  */
8064           if ((sec->flags & SEC_IN_MEMORY) == 0)
8065             {
8066               bfd_byte *loc;
8067               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8068                 {
8069                   if (loc != NULL)
8070                     free (loc);
8071                 error_ret:
8072                   if (local_syms != NULL
8073                       && symtab_hdr->contents != (unsigned char *) local_syms)
8074                     free (local_syms);
8075                   if (elf_section_data (sec)->relocs != relstart)
8076                     free (relstart);
8077                   return FALSE;
8078                 }
8079               sec->contents = loc;
8080               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8081             }
8082
8083           elf_section_data (sec)->relocs = relstart;
8084
8085           new_contents = sec->contents;
8086           if (add_aux_fields)
8087             {
8088               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8089               if (new_contents == NULL)
8090                 return FALSE;
8091               need_pad = NULL;
8092             }
8093           wptr = new_contents;
8094           rptr = sec->contents;
8095           write_rel = relstart;
8096           for (rel = relstart; rel < relend; )
8097             {
8098               unsigned long r_symndx;
8099               asection *sym_sec;
8100               struct elf_link_hash_entry *h;
8101               struct ppc_link_hash_entry *fdh = NULL;
8102               Elf_Internal_Sym *sym;
8103               long opd_ent_size;
8104               Elf_Internal_Rela *next_rel;
8105               bfd_boolean skip;
8106
8107               r_symndx = ELF64_R_SYM (rel->r_info);
8108               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8109                               r_symndx, ibfd))
8110                 goto error_ret;
8111
8112               next_rel = rel + 2;
8113               if (next_rel + 1 == relend
8114                   || (next_rel + 2 < relend
8115                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8116                 ++next_rel;
8117
8118               /* See if the .opd entry is full 24 byte or
8119                  16 byte (with fd_aux entry overlapped with next
8120                  fd_func).  */
8121               opd_ent_size = 24;
8122               if (next_rel == relend)
8123                 {
8124                   if (sec->size == rel->r_offset + 16)
8125                     opd_ent_size = 16;
8126                 }
8127               else if (next_rel->r_offset == rel->r_offset + 16)
8128                 opd_ent_size = 16;
8129
8130               if (h != NULL
8131                   && h->root.root.string[0] == '.')
8132                 {
8133                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8134                   if (fdh != NULL)
8135                     {
8136                       fdh = ppc_follow_link (fdh);
8137                       if (fdh->elf.root.type != bfd_link_hash_defined
8138                           && fdh->elf.root.type != bfd_link_hash_defweak)
8139                         fdh = NULL;
8140                     }
8141                 }
8142
8143               skip = (sym_sec->owner != ibfd
8144                       || sym_sec->output_section == bfd_abs_section_ptr);
8145               if (skip)
8146                 {
8147                   if (fdh != NULL && sym_sec->owner == ibfd)
8148                     {
8149                       /* Arrange for the function descriptor sym
8150                          to be dropped.  */
8151                       fdh->elf.root.u.def.value = 0;
8152                       fdh->elf.root.u.def.section = sym_sec;
8153                     }
8154                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8155
8156                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8157                     rel = next_rel;
8158                   else
8159                     while (1)
8160                       {
8161                         if (!dec_dynrel_count (rel->r_info, sec, info,
8162                                                NULL, h, sym))
8163                           goto error_ret;
8164
8165                         if (++rel == next_rel)
8166                           break;
8167
8168                         r_symndx = ELF64_R_SYM (rel->r_info);
8169                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8170                                         r_symndx, ibfd))
8171                           goto error_ret;
8172                       }
8173                 }
8174               else
8175                 {
8176                   /* We'll be keeping this opd entry.  */
8177                   long adjust;
8178
8179                   if (fdh != NULL)
8180                     {
8181                       /* Redefine the function descriptor symbol to
8182                          this location in the opd section.  It is
8183                          necessary to update the value here rather
8184                          than using an array of adjustments as we do
8185                          for local symbols, because various places
8186                          in the generic ELF code use the value
8187                          stored in u.def.value.  */
8188                       fdh->elf.root.u.def.value = wptr - new_contents;
8189                       fdh->adjust_done = 1;
8190                     }
8191
8192                   /* Local syms are a bit tricky.  We could
8193                      tweak them as they can be cached, but
8194                      we'd need to look through the local syms
8195                      for the function descriptor sym which we
8196                      don't have at the moment.  So keep an
8197                      array of adjustments.  */
8198                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8199                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8200
8201                   if (wptr != rptr)
8202                     memcpy (wptr, rptr, opd_ent_size);
8203                   wptr += opd_ent_size;
8204                   if (add_aux_fields && opd_ent_size == 16)
8205                     {
8206                       memset (wptr, '\0', 8);
8207                       wptr += 8;
8208                     }
8209
8210                   /* We need to adjust any reloc offsets to point to the
8211                      new opd entries.  */
8212                   for ( ; rel != next_rel; ++rel)
8213                     {
8214                       rel->r_offset += adjust;
8215                       if (write_rel != rel)
8216                         memcpy (write_rel, rel, sizeof (*rel));
8217                       ++write_rel;
8218                     }
8219                 }
8220
8221               rptr += opd_ent_size;
8222             }
8223
8224           sec->size = wptr - new_contents;
8225           sec->reloc_count = write_rel - relstart;
8226           if (add_aux_fields)
8227             {
8228               free (sec->contents);
8229               sec->contents = new_contents;
8230             }
8231
8232           /* Fudge the header size too, as this is used later in
8233              elf_bfd_final_link if we are emitting relocs.  */
8234           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8235           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8236           some_edited = TRUE;
8237         }
8238       else if (elf_section_data (sec)->relocs != relstart)
8239         free (relstart);
8240
8241       if (local_syms != NULL
8242           && symtab_hdr->contents != (unsigned char *) local_syms)
8243         {
8244           if (!info->keep_memory)
8245             free (local_syms);
8246           else
8247             symtab_hdr->contents = (unsigned char *) local_syms;
8248         }
8249     }
8250
8251   if (some_edited)
8252     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8253
8254   /* If we are doing a final link and the last .opd entry is just 16 byte
8255      long, add a 8 byte padding after it.  */
8256   if (need_pad != NULL && !bfd_link_relocatable (info))
8257     {
8258       bfd_byte *p;
8259
8260       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8261         {
8262           BFD_ASSERT (need_pad->size > 0);
8263
8264           p = bfd_malloc (need_pad->size + 8);
8265           if (p == NULL)
8266             return FALSE;
8267
8268           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8269                                           p, 0, need_pad->size))
8270             return FALSE;
8271
8272           need_pad->contents = p;
8273           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8274         }
8275       else
8276         {
8277           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8278           if (p == NULL)
8279             return FALSE;
8280
8281           need_pad->contents = p;
8282         }
8283
8284       memset (need_pad->contents + need_pad->size, 0, 8);
8285       need_pad->size += 8;
8286     }
8287
8288   return TRUE;
8289 }
8290
8291 /* Analyze inline PLT call relocations to see whether calls to locally
8292    defined functions can be converted to direct calls.  */
8293
8294 bfd_boolean
8295 ppc64_elf_inline_plt (struct bfd_link_info *info)
8296 {
8297   struct ppc_link_hash_table *htab;
8298   bfd *ibfd;
8299   asection *sec;
8300   bfd_vma low_vma, high_vma, limit;
8301
8302   htab = ppc_hash_table (info);
8303   if (htab == NULL)
8304     return FALSE;
8305
8306   /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
8307      reduced somewhat to cater for possible stubs that might be added
8308      between the call and its destination.  */
8309   if (htab->params->group_size < 0)
8310     {
8311       limit = -htab->params->group_size;
8312       if (limit == 1)
8313         limit = 0x1e00000;
8314     }
8315   else
8316     {
8317       limit = htab->params->group_size;
8318       if (limit == 1)
8319         limit = 0x1c00000;
8320     }
8321
8322   low_vma = -1;
8323   high_vma = 0;
8324   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8325     if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8326       {
8327         if (low_vma > sec->vma)
8328           low_vma = sec->vma;
8329         if (high_vma < sec->vma + sec->size)
8330           high_vma = sec->vma + sec->size;
8331       }
8332
8333   /* If a "bl" can reach anywhere in local code sections, then we can
8334      convert all inline PLT sequences to direct calls when the symbol
8335      is local.  */
8336   if (high_vma - low_vma < limit)
8337     {
8338       htab->can_convert_all_inline_plt = 1;
8339       return TRUE;
8340     }
8341
8342   /* Otherwise, go looking through relocs for cases where a direct
8343      call won't reach.  Mark the symbol on any such reloc to disable
8344      the optimization and keep the PLT entry as it seems likely that
8345      this will be better than creating trampolines.  Note that this
8346      will disable the optimization for all inline PLT calls to a
8347      particular symbol, not just those that won't reach.  The
8348      difficulty in doing a more precise optimization is that the
8349      linker needs to make a decision depending on whether a
8350      particular R_PPC64_PLTCALL insn can be turned into a direct
8351      call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8352      the sequence, and there is nothing that ties those relocs
8353      together except their symbol.  */
8354
8355   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8356     {
8357       Elf_Internal_Shdr *symtab_hdr;
8358       Elf_Internal_Sym *local_syms;
8359
8360       if (!is_ppc64_elf (ibfd))
8361         continue;
8362
8363       local_syms = NULL;
8364       symtab_hdr = &elf_symtab_hdr (ibfd);
8365
8366       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8367         if (ppc64_elf_section_data (sec)->has_pltcall
8368             && !bfd_is_abs_section (sec->output_section))
8369           {
8370             Elf_Internal_Rela *relstart, *rel, *relend;
8371
8372             /* Read the relocations.  */
8373             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8374                                                   info->keep_memory);
8375             if (relstart == NULL)
8376               return FALSE;
8377
8378             relend = relstart + sec->reloc_count;
8379             for (rel = relstart; rel < relend; )
8380               {
8381                 enum elf_ppc64_reloc_type r_type;
8382                 unsigned long r_symndx;
8383                 asection *sym_sec;
8384                 struct elf_link_hash_entry *h;
8385                 Elf_Internal_Sym *sym;
8386                 unsigned char *tls_maskp;
8387
8388                 r_type = ELF64_R_TYPE (rel->r_info);
8389                 if (r_type != R_PPC64_PLTCALL)
8390                   continue;
8391
8392                 r_symndx = ELF64_R_SYM (rel->r_info);
8393                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8394                                 r_symndx, ibfd))
8395                   {
8396                     if (elf_section_data (sec)->relocs != relstart)
8397                       free (relstart);
8398                     if (local_syms != NULL
8399                         && symtab_hdr->contents != (unsigned char *) local_syms)
8400                       free (local_syms);
8401                     return FALSE;
8402                   }
8403
8404                 if (sym_sec != NULL && sym_sec->output_section != NULL)
8405                   {
8406                     bfd_vma from, to;
8407                     if (h != NULL)
8408                       to = h->root.u.def.value;
8409                     else
8410                       to = sym->st_value;
8411                     to += (rel->r_addend
8412                            + sym_sec->output_offset
8413                            + sym_sec->output_section->vma);
8414                     from = (rel->r_offset
8415                             + sec->output_offset
8416                             + sec->output_section->vma);
8417                     if (to - from + limit < 2 * limit)
8418                       *tls_maskp &= ~PLT_KEEP;
8419                   }
8420               }
8421             if (elf_section_data (sec)->relocs != relstart)
8422               free (relstart);
8423           }
8424
8425       if (local_syms != NULL
8426           && symtab_hdr->contents != (unsigned char *) local_syms)
8427         {
8428           if (!info->keep_memory)
8429             free (local_syms);
8430           else
8431             symtab_hdr->contents = (unsigned char *) local_syms;
8432         }
8433     }
8434
8435   return TRUE;
8436 }
8437
8438 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8439
8440 asection *
8441 ppc64_elf_tls_setup (struct bfd_link_info *info)
8442 {
8443   struct ppc_link_hash_table *htab;
8444
8445   htab = ppc_hash_table (info);
8446   if (htab == NULL)
8447     return NULL;
8448
8449   if (abiversion (info->output_bfd) == 1)
8450     htab->opd_abi = 1;
8451
8452   if (htab->params->no_multi_toc)
8453     htab->do_multi_toc = 0;
8454   else if (!htab->do_multi_toc)
8455     htab->params->no_multi_toc = 1;
8456
8457   /* Default to --no-plt-localentry, as this option can cause problems
8458      with symbol interposition.  For example, glibc libpthread.so and
8459      libc.so duplicate many pthread symbols, with a fallback
8460      implementation in libc.so.  In some cases the fallback does more
8461      work than the pthread implementation.  __pthread_condattr_destroy
8462      is one such symbol: the libpthread.so implementation is
8463      localentry:0 while the libc.so implementation is localentry:8.
8464      An app that "cleverly" uses dlopen to only load necessary
8465      libraries at runtime may omit loading libpthread.so when not
8466      running multi-threaded, which then results in the libc.so
8467      fallback symbols being used and ld.so complaining.  Now there
8468      are workarounds in ld (see non_zero_localentry) to detect the
8469      pthread situation, but that may not be the only case where
8470      --plt-localentry can cause trouble.  */
8471   if (htab->params->plt_localentry0 < 0)
8472     htab->params->plt_localentry0 = 0;
8473   if (htab->params->plt_localentry0
8474       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8475                                FALSE, FALSE, FALSE) == NULL)
8476     _bfd_error_handler
8477       (_("warning: --plt-localentry is especially dangerous without "
8478          "ld.so support to detect ABI violations"));
8479
8480   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8481                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8482                                               FALSE, FALSE, TRUE));
8483   /* Move dynamic linking info to the function descriptor sym.  */
8484   if (htab->tls_get_addr != NULL)
8485     func_desc_adjust (&htab->tls_get_addr->elf, info);
8486   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8487                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8488                                                  FALSE, FALSE, TRUE));
8489   if (htab->params->tls_get_addr_opt)
8490     {
8491       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8492
8493       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8494                                   FALSE, FALSE, TRUE);
8495       if (opt != NULL)
8496         func_desc_adjust (opt, info);
8497       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8498                                      FALSE, FALSE, TRUE);
8499       if (opt_fd != NULL
8500           && (opt_fd->root.type == bfd_link_hash_defined
8501               || opt_fd->root.type == bfd_link_hash_defweak))
8502         {
8503           /* If glibc supports an optimized __tls_get_addr call stub,
8504              signalled by the presence of __tls_get_addr_opt, and we'll
8505              be calling __tls_get_addr via a plt call stub, then
8506              make __tls_get_addr point to __tls_get_addr_opt.  */
8507           tga_fd = &htab->tls_get_addr_fd->elf;
8508           if (htab->elf.dynamic_sections_created
8509               && tga_fd != NULL
8510               && (tga_fd->type == STT_FUNC
8511                   || tga_fd->needs_plt)
8512               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8513                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8514             {
8515               struct plt_entry *ent;
8516
8517               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8518                 if (ent->plt.refcount > 0)
8519                   break;
8520               if (ent != NULL)
8521                 {
8522                   tga_fd->root.type = bfd_link_hash_indirect;
8523                   tga_fd->root.u.i.link = &opt_fd->root;
8524                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8525                   opt_fd->mark = 1;
8526                   if (opt_fd->dynindx != -1)
8527                     {
8528                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8529                       opt_fd->dynindx = -1;
8530                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8531                                               opt_fd->dynstr_index);
8532                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8533                         return NULL;
8534                     }
8535                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8536                   tga = &htab->tls_get_addr->elf;
8537                   if (opt != NULL && tga != NULL)
8538                     {
8539                       tga->root.type = bfd_link_hash_indirect;
8540                       tga->root.u.i.link = &opt->root;
8541                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8542                       opt->mark = 1;
8543                       _bfd_elf_link_hash_hide_symbol (info, opt,
8544                                                       tga->forced_local);
8545                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8546                     }
8547                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8548                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8549                   if (htab->tls_get_addr != NULL)
8550                     {
8551                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8552                       htab->tls_get_addr->is_func = 1;
8553                     }
8554                 }
8555             }
8556         }
8557       else if (htab->params->tls_get_addr_opt < 0)
8558         htab->params->tls_get_addr_opt = 0;
8559     }
8560   return _bfd_elf_tls_setup (info->output_bfd, info);
8561 }
8562
8563 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8564    HASH1 or HASH2.  */
8565
8566 static bfd_boolean
8567 branch_reloc_hash_match (const bfd *ibfd,
8568                          const Elf_Internal_Rela *rel,
8569                          const struct ppc_link_hash_entry *hash1,
8570                          const struct ppc_link_hash_entry *hash2)
8571 {
8572   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8573   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8574   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8575
8576   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8577     {
8578       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8579       struct elf_link_hash_entry *h;
8580
8581       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8582       h = elf_follow_link (h);
8583       if (h == &hash1->elf || h == &hash2->elf)
8584         return TRUE;
8585     }
8586   return FALSE;
8587 }
8588
8589 /* Run through all the TLS relocs looking for optimization
8590    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8591    a preliminary section layout so that we know the TLS segment
8592    offsets.  We can't optimize earlier because some optimizations need
8593    to know the tp offset, and we need to optimize before allocating
8594    dynamic relocations.  */
8595
8596 bfd_boolean
8597 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8598 {
8599   bfd *ibfd;
8600   asection *sec;
8601   struct ppc_link_hash_table *htab;
8602   unsigned char *toc_ref;
8603   int pass;
8604
8605   if (!bfd_link_executable (info))
8606     return TRUE;
8607
8608   htab = ppc_hash_table (info);
8609   if (htab == NULL)
8610     return FALSE;
8611
8612   /* Make two passes over the relocs.  On the first pass, mark toc
8613      entries involved with tls relocs, and check that tls relocs
8614      involved in setting up a tls_get_addr call are indeed followed by
8615      such a call.  If they are not, we can't do any tls optimization.
8616      On the second pass twiddle tls_mask flags to notify
8617      relocate_section that optimization can be done, and adjust got
8618      and plt refcounts.  */
8619   toc_ref = NULL;
8620   for (pass = 0; pass < 2; ++pass)
8621     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8622       {
8623         Elf_Internal_Sym *locsyms = NULL;
8624         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8625
8626         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8627           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8628             {
8629               Elf_Internal_Rela *relstart, *rel, *relend;
8630               bfd_boolean found_tls_get_addr_arg = 0;
8631
8632               /* Read the relocations.  */
8633               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8634                                                     info->keep_memory);
8635               if (relstart == NULL)
8636                 {
8637                   free (toc_ref);
8638                   return FALSE;
8639                 }
8640
8641               relend = relstart + sec->reloc_count;
8642               for (rel = relstart; rel < relend; rel++)
8643                 {
8644                   enum elf_ppc64_reloc_type r_type;
8645                   unsigned long r_symndx;
8646                   struct elf_link_hash_entry *h;
8647                   Elf_Internal_Sym *sym;
8648                   asection *sym_sec;
8649                   unsigned char *tls_mask;
8650                   unsigned char tls_set, tls_clear, tls_type = 0;
8651                   bfd_vma value;
8652                   bfd_boolean ok_tprel, is_local;
8653                   long toc_ref_index = 0;
8654                   int expecting_tls_get_addr = 0;
8655                   bfd_boolean ret = FALSE;
8656
8657                   r_symndx = ELF64_R_SYM (rel->r_info);
8658                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8659                                   r_symndx, ibfd))
8660                     {
8661                     err_free_rel:
8662                       if (elf_section_data (sec)->relocs != relstart)
8663                         free (relstart);
8664                       if (toc_ref != NULL)
8665                         free (toc_ref);
8666                       if (locsyms != NULL
8667                           && (elf_symtab_hdr (ibfd).contents
8668                               != (unsigned char *) locsyms))
8669                         free (locsyms);
8670                       return ret;
8671                     }
8672
8673                   if (h != NULL)
8674                     {
8675                       if (h->root.type == bfd_link_hash_defined
8676                           || h->root.type == bfd_link_hash_defweak)
8677                         value = h->root.u.def.value;
8678                       else if (h->root.type == bfd_link_hash_undefweak)
8679                         value = 0;
8680                       else
8681                         {
8682                           found_tls_get_addr_arg = 0;
8683                           continue;
8684                         }
8685                     }
8686                   else
8687                     /* Symbols referenced by TLS relocs must be of type
8688                        STT_TLS.  So no need for .opd local sym adjust.  */
8689                     value = sym->st_value;
8690
8691                   ok_tprel = FALSE;
8692                   is_local = FALSE;
8693                   if (h == NULL
8694                       || !h->def_dynamic)
8695                     {
8696                       is_local = TRUE;
8697                       if (h != NULL
8698                           && h->root.type == bfd_link_hash_undefweak)
8699                         ok_tprel = TRUE;
8700                       else if (sym_sec != NULL
8701                                && sym_sec->output_section != NULL)
8702                         {
8703                           value += sym_sec->output_offset;
8704                           value += sym_sec->output_section->vma;
8705                           value -= htab->elf.tls_sec->vma;
8706                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8707                                       < (bfd_vma) 1 << 32);
8708                         }
8709                     }
8710
8711                   r_type = ELF64_R_TYPE (rel->r_info);
8712                   /* If this section has old-style __tls_get_addr calls
8713                      without marker relocs, then check that each
8714                      __tls_get_addr call reloc is preceded by a reloc
8715                      that conceivably belongs to the __tls_get_addr arg
8716                      setup insn.  If we don't find matching arg setup
8717                      relocs, don't do any tls optimization.  */
8718                   if (pass == 0
8719                       && sec->has_tls_get_addr_call
8720                       && h != NULL
8721                       && (h == &htab->tls_get_addr->elf
8722                           || h == &htab->tls_get_addr_fd->elf)
8723                       && !found_tls_get_addr_arg
8724                       && is_branch_reloc (r_type))
8725                     {
8726                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8727                                                 "TLS optimization disabled\n"),
8728                                               ibfd, sec, rel->r_offset);
8729                       ret = TRUE;
8730                       goto err_free_rel;
8731                     }
8732
8733                   found_tls_get_addr_arg = 0;
8734                   switch (r_type)
8735                     {
8736                     case R_PPC64_GOT_TLSLD16:
8737                     case R_PPC64_GOT_TLSLD16_LO:
8738                       expecting_tls_get_addr = 1;
8739                       found_tls_get_addr_arg = 1;
8740                       /* Fall through.  */
8741
8742                     case R_PPC64_GOT_TLSLD16_HI:
8743                     case R_PPC64_GOT_TLSLD16_HA:
8744                       /* These relocs should never be against a symbol
8745                          defined in a shared lib.  Leave them alone if
8746                          that turns out to be the case.  */
8747                       if (!is_local)
8748                         continue;
8749
8750                       /* LD -> LE */
8751                       tls_set = 0;
8752                       tls_clear = TLS_LD;
8753                       tls_type = TLS_TLS | TLS_LD;
8754                       break;
8755
8756                     case R_PPC64_GOT_TLSGD16:
8757                     case R_PPC64_GOT_TLSGD16_LO:
8758                       expecting_tls_get_addr = 1;
8759                       found_tls_get_addr_arg = 1;
8760                       /* Fall through. */
8761
8762                     case R_PPC64_GOT_TLSGD16_HI:
8763                     case R_PPC64_GOT_TLSGD16_HA:
8764                       if (ok_tprel)
8765                         /* GD -> LE */
8766                         tls_set = 0;
8767                       else
8768                         /* GD -> IE */
8769                         tls_set = TLS_TLS | TLS_TPRELGD;
8770                       tls_clear = TLS_GD;
8771                       tls_type = TLS_TLS | TLS_GD;
8772                       break;
8773
8774                     case R_PPC64_GOT_TPREL16_DS:
8775                     case R_PPC64_GOT_TPREL16_LO_DS:
8776                     case R_PPC64_GOT_TPREL16_HI:
8777                     case R_PPC64_GOT_TPREL16_HA:
8778                       if (ok_tprel)
8779                         {
8780                           /* IE -> LE */
8781                           tls_set = 0;
8782                           tls_clear = TLS_TPREL;
8783                           tls_type = TLS_TLS | TLS_TPREL;
8784                           break;
8785                         }
8786                       continue;
8787
8788                     case R_PPC64_TLSGD:
8789                     case R_PPC64_TLSLD:
8790                       if (rel + 1 < relend
8791                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8792                         {
8793                           if (pass != 0
8794                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8795                             {
8796                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8797                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8798                                   r_symndx, ibfd))
8799                                 goto err_free_rel;
8800                               if (h != NULL)
8801                                 {
8802                                   struct plt_entry *ent = NULL;
8803
8804                                   for (ent = h->plt.plist;
8805                                        ent != NULL;
8806                                        ent = ent->next)
8807                                     if (ent->addend == rel[1].r_addend)
8808                                       break;
8809
8810                                   if (ent != NULL
8811                                       && ent->plt.refcount > 0)
8812                                     ent->plt.refcount -= 1;
8813                                 }
8814                             }
8815                           continue;
8816                         }
8817                       found_tls_get_addr_arg = 1;
8818                       /* Fall through.  */
8819
8820                     case R_PPC64_TLS:
8821                     case R_PPC64_TOC16:
8822                     case R_PPC64_TOC16_LO:
8823                       if (sym_sec == NULL || sym_sec != toc)
8824                         continue;
8825
8826                       /* Mark this toc entry as referenced by a TLS
8827                          code sequence.  We can do that now in the
8828                          case of R_PPC64_TLS, and after checking for
8829                          tls_get_addr for the TOC16 relocs.  */
8830                       if (toc_ref == NULL)
8831                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8832                       if (toc_ref == NULL)
8833                         goto err_free_rel;
8834
8835                       if (h != NULL)
8836                         value = h->root.u.def.value;
8837                       else
8838                         value = sym->st_value;
8839                       value += rel->r_addend;
8840                       if (value % 8 != 0)
8841                         continue;
8842                       BFD_ASSERT (value < toc->size
8843                                   && toc->output_offset % 8 == 0);
8844                       toc_ref_index = (value + toc->output_offset) / 8;
8845                       if (r_type == R_PPC64_TLS
8846                           || r_type == R_PPC64_TLSGD
8847                           || r_type == R_PPC64_TLSLD)
8848                         {
8849                           toc_ref[toc_ref_index] = 1;
8850                           continue;
8851                         }
8852
8853                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8854                         continue;
8855
8856                       tls_set = 0;
8857                       tls_clear = 0;
8858                       expecting_tls_get_addr = 2;
8859                       break;
8860
8861                     case R_PPC64_TPREL64:
8862                       if (pass == 0
8863                           || sec != toc
8864                           || toc_ref == NULL
8865                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8866                         continue;
8867                       if (ok_tprel)
8868                         {
8869                           /* IE -> LE */
8870                           tls_set = TLS_EXPLICIT;
8871                           tls_clear = TLS_TPREL;
8872                           break;
8873                         }
8874                       continue;
8875
8876                     case R_PPC64_DTPMOD64:
8877                       if (pass == 0
8878                           || sec != toc
8879                           || toc_ref == NULL
8880                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8881                         continue;
8882                       if (rel + 1 < relend
8883                           && (rel[1].r_info
8884                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8885                           && rel[1].r_offset == rel->r_offset + 8)
8886                         {
8887                           if (ok_tprel)
8888                             /* GD -> LE */
8889                             tls_set = TLS_EXPLICIT | TLS_GD;
8890                           else
8891                             /* GD -> IE */
8892                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8893                           tls_clear = TLS_GD;
8894                         }
8895                       else
8896                         {
8897                           if (!is_local)
8898                             continue;
8899
8900                           /* LD -> LE */
8901                           tls_set = TLS_EXPLICIT;
8902                           tls_clear = TLS_LD;
8903                         }
8904                       break;
8905
8906                     default:
8907                       continue;
8908                     }
8909
8910                   if (pass == 0)
8911                     {
8912                       if (!expecting_tls_get_addr
8913                           || !sec->has_tls_get_addr_call)
8914                         continue;
8915
8916                       if (rel + 1 < relend
8917                           && branch_reloc_hash_match (ibfd, rel + 1,
8918                                                       htab->tls_get_addr,
8919                                                       htab->tls_get_addr_fd))
8920                         {
8921                           if (expecting_tls_get_addr == 2)
8922                             {
8923                               /* Check for toc tls entries.  */
8924                               unsigned char *toc_tls;
8925                               int retval;
8926
8927                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8928                                                      &locsyms,
8929                                                      rel, ibfd);
8930                               if (retval == 0)
8931                                 goto err_free_rel;
8932                               if (toc_tls != NULL)
8933                                 {
8934                                   if ((*toc_tls & TLS_TLS) != 0
8935                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8936                                     found_tls_get_addr_arg = 1;
8937                                   if (retval > 1)
8938                                     toc_ref[toc_ref_index] = 1;
8939                                 }
8940                             }
8941                           continue;
8942                         }
8943
8944                       /* Uh oh, we didn't find the expected call.  We
8945                          could just mark this symbol to exclude it
8946                          from tls optimization but it's safer to skip
8947                          the entire optimization.  */
8948                       /* xgettext:c-format */
8949                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8950                                                 "TLS optimization disabled\n"),
8951                                               ibfd, sec, rel->r_offset);
8952                       ret = TRUE;
8953                       goto err_free_rel;
8954                     }
8955
8956                   /* If we don't have old-style __tls_get_addr calls
8957                      without TLSGD/TLSLD marker relocs, and we haven't
8958                      found a new-style __tls_get_addr call with a
8959                      marker for this symbol, then we either have a
8960                      broken object file or an -mlongcall style
8961                      indirect call to __tls_get_addr without a marker.
8962                      Disable optimization in this case.  */
8963                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8964                       && (tls_set & TLS_EXPLICIT) == 0
8965                       && !sec->has_tls_get_addr_call
8966                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8967                           != (TLS_TLS | TLS_MARK)))
8968                     continue;
8969
8970                   if (expecting_tls_get_addr)
8971                     {
8972                       struct plt_entry *ent = NULL;
8973
8974                       if (htab->tls_get_addr != NULL)
8975                         for (ent = htab->tls_get_addr->elf.plt.plist;
8976                              ent != NULL;
8977                              ent = ent->next)
8978                           if (ent->addend == 0)
8979                             break;
8980
8981                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
8982                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8983                              ent != NULL;
8984                              ent = ent->next)
8985                           if (ent->addend == 0)
8986                             break;
8987
8988                       if (ent != NULL
8989                           && ent->plt.refcount > 0)
8990                         ent->plt.refcount -= 1;
8991                     }
8992
8993                   if (tls_clear == 0)
8994                     continue;
8995
8996                   if ((tls_set & TLS_EXPLICIT) == 0)
8997                     {
8998                       struct got_entry *ent;
8999
9000                       /* Adjust got entry for this reloc.  */
9001                       if (h != NULL)
9002                         ent = h->got.glist;
9003                       else
9004                         ent = elf_local_got_ents (ibfd)[r_symndx];
9005
9006                       for (; ent != NULL; ent = ent->next)
9007                         if (ent->addend == rel->r_addend
9008                             && ent->owner == ibfd
9009                             && ent->tls_type == tls_type)
9010                           break;
9011                       if (ent == NULL)
9012                         abort ();
9013
9014                       if (tls_set == 0)
9015                         {
9016                           /* We managed to get rid of a got entry.  */
9017                           if (ent->got.refcount > 0)
9018                             ent->got.refcount -= 1;
9019                         }
9020                     }
9021                   else
9022                     {
9023                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
9024                          we'll lose one or two dyn relocs.  */
9025                       if (!dec_dynrel_count (rel->r_info, sec, info,
9026                                              NULL, h, sym))
9027                         return FALSE;
9028
9029                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
9030                         {
9031                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9032                                                  NULL, h, sym))
9033                             return FALSE;
9034                         }
9035                     }
9036
9037                   *tls_mask |= tls_set;
9038                   *tls_mask &= ~tls_clear;
9039                 }
9040
9041               if (elf_section_data (sec)->relocs != relstart)
9042                 free (relstart);
9043             }
9044
9045         if (locsyms != NULL
9046             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9047           {
9048             if (!info->keep_memory)
9049               free (locsyms);
9050             else
9051               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9052           }
9053       }
9054
9055   if (toc_ref != NULL)
9056     free (toc_ref);
9057   htab->do_tls_opt = 1;
9058   return TRUE;
9059 }
9060
9061 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9062    the values of any global symbols in a toc section that has been
9063    edited.  Globals in toc sections should be a rarity, so this function
9064    sets a flag if any are found in toc sections other than the one just
9065    edited, so that further hash table traversals can be avoided.  */
9066
9067 struct adjust_toc_info
9068 {
9069   asection *toc;
9070   unsigned long *skip;
9071   bfd_boolean global_toc_syms;
9072 };
9073
9074 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9075
9076 static bfd_boolean
9077 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9078 {
9079   struct ppc_link_hash_entry *eh;
9080   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9081   unsigned long i;
9082
9083   if (h->root.type != bfd_link_hash_defined
9084       && h->root.type != bfd_link_hash_defweak)
9085     return TRUE;
9086
9087   eh = (struct ppc_link_hash_entry *) h;
9088   if (eh->adjust_done)
9089     return TRUE;
9090
9091   if (eh->elf.root.u.def.section == toc_inf->toc)
9092     {
9093       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9094         i = toc_inf->toc->rawsize >> 3;
9095       else
9096         i = eh->elf.root.u.def.value >> 3;
9097
9098       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9099         {
9100           _bfd_error_handler
9101             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9102           do
9103             ++i;
9104           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9105           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9106         }
9107
9108       eh->elf.root.u.def.value -= toc_inf->skip[i];
9109       eh->adjust_done = 1;
9110     }
9111   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9112     toc_inf->global_toc_syms = TRUE;
9113
9114   return TRUE;
9115 }
9116
9117 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9118    on a _LO variety toc/got reloc.  */
9119
9120 static bfd_boolean
9121 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9122 {
9123   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9124           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9125           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9126           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9127           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9128           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9129           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9130           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9131           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9132           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9133           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9134           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9135           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9136           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9137           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9138           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9139           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9140               /* Exclude lfqu by testing reloc.  If relocs are ever
9141                  defined for the reduced D field in psq_lu then those
9142                  will need testing too.  */
9143               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9144           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9145               && (insn & 1) == 0)
9146           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9147           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9148               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9149               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9150           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9151               && (insn & 1) == 0));
9152 }
9153
9154 /* Examine all relocs referencing .toc sections in order to remove
9155    unused .toc entries.  */
9156
9157 bfd_boolean
9158 ppc64_elf_edit_toc (struct bfd_link_info *info)
9159 {
9160   bfd *ibfd;
9161   struct adjust_toc_info toc_inf;
9162   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9163
9164   htab->do_toc_opt = 1;
9165   toc_inf.global_toc_syms = TRUE;
9166   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9167     {
9168       asection *toc, *sec;
9169       Elf_Internal_Shdr *symtab_hdr;
9170       Elf_Internal_Sym *local_syms;
9171       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9172       unsigned long *skip, *drop;
9173       unsigned char *used;
9174       unsigned char *keep, last, some_unused;
9175
9176       if (!is_ppc64_elf (ibfd))
9177         continue;
9178
9179       toc = bfd_get_section_by_name (ibfd, ".toc");
9180       if (toc == NULL
9181           || toc->size == 0
9182           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9183           || discarded_section (toc))
9184         continue;
9185
9186       toc_relocs = NULL;
9187       local_syms = NULL;
9188       symtab_hdr = &elf_symtab_hdr (ibfd);
9189
9190       /* Look at sections dropped from the final link.  */
9191       skip = NULL;
9192       relstart = NULL;
9193       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9194         {
9195           if (sec->reloc_count == 0
9196               || !discarded_section (sec)
9197               || get_opd_info (sec)
9198               || (sec->flags & SEC_ALLOC) == 0
9199               || (sec->flags & SEC_DEBUGGING) != 0)
9200             continue;
9201
9202           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9203           if (relstart == NULL)
9204             goto error_ret;
9205
9206           /* Run through the relocs to see which toc entries might be
9207              unused.  */
9208           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9209             {
9210               enum elf_ppc64_reloc_type r_type;
9211               unsigned long r_symndx;
9212               asection *sym_sec;
9213               struct elf_link_hash_entry *h;
9214               Elf_Internal_Sym *sym;
9215               bfd_vma val;
9216
9217               r_type = ELF64_R_TYPE (rel->r_info);
9218               switch (r_type)
9219                 {
9220                 default:
9221                   continue;
9222
9223                 case R_PPC64_TOC16:
9224                 case R_PPC64_TOC16_LO:
9225                 case R_PPC64_TOC16_HI:
9226                 case R_PPC64_TOC16_HA:
9227                 case R_PPC64_TOC16_DS:
9228                 case R_PPC64_TOC16_LO_DS:
9229                   break;
9230                 }
9231
9232               r_symndx = ELF64_R_SYM (rel->r_info);
9233               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9234                               r_symndx, ibfd))
9235                 goto error_ret;
9236
9237               if (sym_sec != toc)
9238                 continue;
9239
9240               if (h != NULL)
9241                 val = h->root.u.def.value;
9242               else
9243                 val = sym->st_value;
9244               val += rel->r_addend;
9245
9246               if (val >= toc->size)
9247                 continue;
9248
9249               /* Anything in the toc ought to be aligned to 8 bytes.
9250                  If not, don't mark as unused.  */
9251               if (val & 7)
9252                 continue;
9253
9254               if (skip == NULL)
9255                 {
9256                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9257                   if (skip == NULL)
9258                     goto error_ret;
9259                 }
9260
9261               skip[val >> 3] = ref_from_discarded;
9262             }
9263
9264           if (elf_section_data (sec)->relocs != relstart)
9265             free (relstart);
9266         }
9267
9268       /* For largetoc loads of address constants, we can convert
9269          .  addis rx,2,addr@got@ha
9270          .  ld ry,addr@got@l(rx)
9271          to
9272          .  addis rx,2,addr@toc@ha
9273          .  addi ry,rx,addr@toc@l
9274          when addr is within 2G of the toc pointer.  This then means
9275          that the word storing "addr" in the toc is no longer needed.  */
9276
9277       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9278           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9279           && toc->reloc_count != 0)
9280         {
9281           /* Read toc relocs.  */
9282           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9283                                                   info->keep_memory);
9284           if (toc_relocs == NULL)
9285             goto error_ret;
9286
9287           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9288             {
9289               enum elf_ppc64_reloc_type r_type;
9290               unsigned long r_symndx;
9291               asection *sym_sec;
9292               struct elf_link_hash_entry *h;
9293               Elf_Internal_Sym *sym;
9294               bfd_vma val, addr;
9295
9296               r_type = ELF64_R_TYPE (rel->r_info);
9297               if (r_type != R_PPC64_ADDR64)
9298                 continue;
9299
9300               r_symndx = ELF64_R_SYM (rel->r_info);
9301               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9302                               r_symndx, ibfd))
9303                 goto error_ret;
9304
9305               if (sym_sec == NULL
9306                   || sym_sec->output_section == NULL
9307                   || discarded_section (sym_sec))
9308                 continue;
9309
9310               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9311                 continue;
9312
9313               if (h != NULL)
9314                 {
9315                   if (h->type == STT_GNU_IFUNC)
9316                     continue;
9317                   val = h->root.u.def.value;
9318                 }
9319               else
9320                 {
9321                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9322                     continue;
9323                   val = sym->st_value;
9324                 }
9325               val += rel->r_addend;
9326               val += sym_sec->output_section->vma + sym_sec->output_offset;
9327
9328               /* We don't yet know the exact toc pointer value, but we
9329                  know it will be somewhere in the toc section.  Don't
9330                  optimize if the difference from any possible toc
9331                  pointer is outside [ff..f80008000, 7fff7fff].  */
9332               addr = toc->output_section->vma + TOC_BASE_OFF;
9333               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9334                 continue;
9335
9336               addr = toc->output_section->vma + toc->output_section->rawsize;
9337               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9338                 continue;
9339
9340               if (skip == NULL)
9341                 {
9342                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9343                   if (skip == NULL)
9344                     goto error_ret;
9345                 }
9346
9347               skip[rel->r_offset >> 3]
9348                 |= can_optimize | ((rel - toc_relocs) << 2);
9349             }
9350         }
9351
9352       if (skip == NULL)
9353         continue;
9354
9355       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9356       if (used == NULL)
9357         {
9358         error_ret:
9359           if (local_syms != NULL
9360               && symtab_hdr->contents != (unsigned char *) local_syms)
9361             free (local_syms);
9362           if (sec != NULL
9363               && relstart != NULL
9364               && elf_section_data (sec)->relocs != relstart)
9365             free (relstart);
9366           if (toc_relocs != NULL
9367               && elf_section_data (toc)->relocs != toc_relocs)
9368             free (toc_relocs);
9369           if (skip != NULL)
9370             free (skip);
9371           return FALSE;
9372         }
9373
9374       /* Now check all kept sections that might reference the toc.
9375          Check the toc itself last.  */
9376       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9377                   : ibfd->sections);
9378            sec != NULL;
9379            sec = (sec == toc ? NULL
9380                   : sec->next == NULL ? toc
9381                   : sec->next == toc && toc->next ? toc->next
9382                   : sec->next))
9383         {
9384           int repeat;
9385
9386           if (sec->reloc_count == 0
9387               || discarded_section (sec)
9388               || get_opd_info (sec)
9389               || (sec->flags & SEC_ALLOC) == 0
9390               || (sec->flags & SEC_DEBUGGING) != 0)
9391             continue;
9392
9393           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9394                                                 info->keep_memory);
9395           if (relstart == NULL)
9396             {
9397               free (used);
9398               goto error_ret;
9399             }
9400
9401           /* Mark toc entries referenced as used.  */
9402           do
9403             {
9404               repeat = 0;
9405               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9406                 {
9407                   enum elf_ppc64_reloc_type r_type;
9408                   unsigned long r_symndx;
9409                   asection *sym_sec;
9410                   struct elf_link_hash_entry *h;
9411                   Elf_Internal_Sym *sym;
9412                   bfd_vma val;
9413                   enum {no_check, check_lo, check_ha} insn_check;
9414
9415                   r_type = ELF64_R_TYPE (rel->r_info);
9416                   switch (r_type)
9417                     {
9418                     default:
9419                       insn_check = no_check;
9420                       break;
9421
9422                     case R_PPC64_GOT_TLSLD16_HA:
9423                     case R_PPC64_GOT_TLSGD16_HA:
9424                     case R_PPC64_GOT_TPREL16_HA:
9425                     case R_PPC64_GOT_DTPREL16_HA:
9426                     case R_PPC64_GOT16_HA:
9427                     case R_PPC64_TOC16_HA:
9428                       insn_check = check_ha;
9429                       break;
9430
9431                     case R_PPC64_GOT_TLSLD16_LO:
9432                     case R_PPC64_GOT_TLSGD16_LO:
9433                     case R_PPC64_GOT_TPREL16_LO_DS:
9434                     case R_PPC64_GOT_DTPREL16_LO_DS:
9435                     case R_PPC64_GOT16_LO:
9436                     case R_PPC64_GOT16_LO_DS:
9437                     case R_PPC64_TOC16_LO:
9438                     case R_PPC64_TOC16_LO_DS:
9439                       insn_check = check_lo;
9440                       break;
9441                     }
9442
9443                   if (insn_check != no_check)
9444                     {
9445                       bfd_vma off = rel->r_offset & ~3;
9446                       unsigned char buf[4];
9447                       unsigned int insn;
9448
9449                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9450                         {
9451                           free (used);
9452                           goto error_ret;
9453                         }
9454                       insn = bfd_get_32 (ibfd, buf);
9455                       if (insn_check == check_lo
9456                           ? !ok_lo_toc_insn (insn, r_type)
9457                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9458                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9459                         {
9460                           char str[12];
9461
9462                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9463                           sprintf (str, "%#08x", insn);
9464                           info->callbacks->einfo
9465                             /* xgettext:c-format */
9466                             (_("%H: toc optimization is not supported for"
9467                                " %s instruction\n"),
9468                              ibfd, sec, rel->r_offset & ~3, str);
9469                         }
9470                     }
9471
9472                   switch (r_type)
9473                     {
9474                     case R_PPC64_TOC16:
9475                     case R_PPC64_TOC16_LO:
9476                     case R_PPC64_TOC16_HI:
9477                     case R_PPC64_TOC16_HA:
9478                     case R_PPC64_TOC16_DS:
9479                     case R_PPC64_TOC16_LO_DS:
9480                       /* In case we're taking addresses of toc entries.  */
9481                     case R_PPC64_ADDR64:
9482                       break;
9483
9484                     default:
9485                       continue;
9486                     }
9487
9488                   r_symndx = ELF64_R_SYM (rel->r_info);
9489                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9490                                   r_symndx, ibfd))
9491                     {
9492                       free (used);
9493                       goto error_ret;
9494                     }
9495
9496                   if (sym_sec != toc)
9497                     continue;
9498
9499                   if (h != NULL)
9500                     val = h->root.u.def.value;
9501                   else
9502                     val = sym->st_value;
9503                   val += rel->r_addend;
9504
9505                   if (val >= toc->size)
9506                     continue;
9507
9508                   if ((skip[val >> 3] & can_optimize) != 0)
9509                     {
9510                       bfd_vma off;
9511                       unsigned char opc;
9512
9513                       switch (r_type)
9514                         {
9515                         case R_PPC64_TOC16_HA:
9516                           break;
9517
9518                         case R_PPC64_TOC16_LO_DS:
9519                           off = rel->r_offset;
9520                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9521                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9522                                                          off, 1))
9523                             {
9524                               free (used);
9525                               goto error_ret;
9526                             }
9527                           if ((opc & (0x3f << 2)) == (58u << 2))
9528                             break;
9529                           /* Fall through.  */
9530
9531                         default:
9532                           /* Wrong sort of reloc, or not a ld.  We may
9533                              as well clear ref_from_discarded too.  */
9534                           skip[val >> 3] = 0;
9535                         }
9536                     }
9537
9538                   if (sec != toc)
9539                     used[val >> 3] = 1;
9540                   /* For the toc section, we only mark as used if this
9541                      entry itself isn't unused.  */
9542                   else if ((used[rel->r_offset >> 3]
9543                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9544                            && !used[val >> 3])
9545                     {
9546                       /* Do all the relocs again, to catch reference
9547                          chains.  */
9548                       repeat = 1;
9549                       used[val >> 3] = 1;
9550                     }
9551                 }
9552             }
9553           while (repeat);
9554
9555           if (elf_section_data (sec)->relocs != relstart)
9556             free (relstart);
9557         }
9558
9559       /* Merge the used and skip arrays.  Assume that TOC
9560          doublewords not appearing as either used or unused belong
9561          to an entry more than one doubleword in size.  */
9562       for (drop = skip, keep = used, last = 0, some_unused = 0;
9563            drop < skip + (toc->size + 7) / 8;
9564            ++drop, ++keep)
9565         {
9566           if (*keep)
9567             {
9568               *drop &= ~ref_from_discarded;
9569               if ((*drop & can_optimize) != 0)
9570                 some_unused = 1;
9571               last = 0;
9572             }
9573           else if ((*drop & ref_from_discarded) != 0)
9574             {
9575               some_unused = 1;
9576               last = ref_from_discarded;
9577             }
9578           else
9579             *drop = last;
9580         }
9581
9582       free (used);
9583
9584       if (some_unused)
9585         {
9586           bfd_byte *contents, *src;
9587           unsigned long off;
9588           Elf_Internal_Sym *sym;
9589           bfd_boolean local_toc_syms = FALSE;
9590
9591           /* Shuffle the toc contents, and at the same time convert the
9592              skip array from booleans into offsets.  */
9593           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9594             goto error_ret;
9595
9596           elf_section_data (toc)->this_hdr.contents = contents;
9597
9598           for (src = contents, off = 0, drop = skip;
9599                src < contents + toc->size;
9600                src += 8, ++drop)
9601             {
9602               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9603                 off += 8;
9604               else if (off != 0)
9605                 {
9606                   *drop = off;
9607                   memcpy (src - off, src, 8);
9608                 }
9609             }
9610           *drop = off;
9611           toc->rawsize = toc->size;
9612           toc->size = src - contents - off;
9613
9614           /* Adjust addends for relocs against the toc section sym,
9615              and optimize any accesses we can.  */
9616           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9617             {
9618               if (sec->reloc_count == 0
9619                   || discarded_section (sec))
9620                 continue;
9621
9622               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9623                                                     info->keep_memory);
9624               if (relstart == NULL)
9625                 goto error_ret;
9626
9627               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9628                 {
9629                   enum elf_ppc64_reloc_type r_type;
9630                   unsigned long r_symndx;
9631                   asection *sym_sec;
9632                   struct elf_link_hash_entry *h;
9633                   bfd_vma val;
9634
9635                   r_type = ELF64_R_TYPE (rel->r_info);
9636                   switch (r_type)
9637                     {
9638                     default:
9639                       continue;
9640
9641                     case R_PPC64_TOC16:
9642                     case R_PPC64_TOC16_LO:
9643                     case R_PPC64_TOC16_HI:
9644                     case R_PPC64_TOC16_HA:
9645                     case R_PPC64_TOC16_DS:
9646                     case R_PPC64_TOC16_LO_DS:
9647                     case R_PPC64_ADDR64:
9648                       break;
9649                     }
9650
9651                   r_symndx = ELF64_R_SYM (rel->r_info);
9652                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9653                                   r_symndx, ibfd))
9654                     goto error_ret;
9655
9656                   if (sym_sec != toc)
9657                     continue;
9658
9659                   if (h != NULL)
9660                     val = h->root.u.def.value;
9661                   else
9662                     {
9663                       val = sym->st_value;
9664                       if (val != 0)
9665                         local_toc_syms = TRUE;
9666                     }
9667
9668                   val += rel->r_addend;
9669
9670                   if (val > toc->rawsize)
9671                     val = toc->rawsize;
9672                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9673                     continue;
9674                   else if ((skip[val >> 3] & can_optimize) != 0)
9675                     {
9676                       Elf_Internal_Rela *tocrel
9677                         = toc_relocs + (skip[val >> 3] >> 2);
9678                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9679
9680                       switch (r_type)
9681                         {
9682                         case R_PPC64_TOC16_HA:
9683                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9684                           break;
9685
9686                         case R_PPC64_TOC16_LO_DS:
9687                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9688                           break;
9689
9690                         default:
9691                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9692                             ppc_howto_init ();
9693                           info->callbacks->einfo
9694                             /* xgettext:c-format */
9695                             (_("%H: %s references "
9696                                "optimized away TOC entry\n"),
9697                              ibfd, sec, rel->r_offset,
9698                              ppc64_elf_howto_table[r_type]->name);
9699                           bfd_set_error (bfd_error_bad_value);
9700                           goto error_ret;
9701                         }
9702                       rel->r_addend = tocrel->r_addend;
9703                       elf_section_data (sec)->relocs = relstart;
9704                       continue;
9705                     }
9706
9707                   if (h != NULL || sym->st_value != 0)
9708                     continue;
9709
9710                   rel->r_addend -= skip[val >> 3];
9711                   elf_section_data (sec)->relocs = relstart;
9712                 }
9713
9714               if (elf_section_data (sec)->relocs != relstart)
9715                 free (relstart);
9716             }
9717
9718           /* We shouldn't have local or global symbols defined in the TOC,
9719              but handle them anyway.  */
9720           if (local_syms != NULL)
9721             for (sym = local_syms;
9722                  sym < local_syms + symtab_hdr->sh_info;
9723                  ++sym)
9724               if (sym->st_value != 0
9725                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9726                 {
9727                   unsigned long i;
9728
9729                   if (sym->st_value > toc->rawsize)
9730                     i = toc->rawsize >> 3;
9731                   else
9732                     i = sym->st_value >> 3;
9733
9734                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9735                     {
9736                       if (local_toc_syms)
9737                         _bfd_error_handler
9738                           (_("%s defined on removed toc entry"),
9739                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9740                       do
9741                         ++i;
9742                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9743                       sym->st_value = (bfd_vma) i << 3;
9744                     }
9745
9746                   sym->st_value -= skip[i];
9747                   symtab_hdr->contents = (unsigned char *) local_syms;
9748                 }
9749
9750           /* Adjust any global syms defined in this toc input section.  */
9751           if (toc_inf.global_toc_syms)
9752             {
9753               toc_inf.toc = toc;
9754               toc_inf.skip = skip;
9755               toc_inf.global_toc_syms = FALSE;
9756               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9757                                       &toc_inf);
9758             }
9759
9760           if (toc->reloc_count != 0)
9761             {
9762               Elf_Internal_Shdr *rel_hdr;
9763               Elf_Internal_Rela *wrel;
9764               bfd_size_type sz;
9765
9766               /* Remove unused toc relocs, and adjust those we keep.  */
9767               if (toc_relocs == NULL)
9768                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9769                                                         info->keep_memory);
9770               if (toc_relocs == NULL)
9771                 goto error_ret;
9772
9773               wrel = toc_relocs;
9774               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9775                 if ((skip[rel->r_offset >> 3]
9776                      & (ref_from_discarded | can_optimize)) == 0)
9777                   {
9778                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9779                     wrel->r_info = rel->r_info;
9780                     wrel->r_addend = rel->r_addend;
9781                     ++wrel;
9782                   }
9783                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9784                                             &local_syms, NULL, NULL))
9785                   goto error_ret;
9786
9787               elf_section_data (toc)->relocs = toc_relocs;
9788               toc->reloc_count = wrel - toc_relocs;
9789               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9790               sz = rel_hdr->sh_entsize;
9791               rel_hdr->sh_size = toc->reloc_count * sz;
9792             }
9793         }
9794       else if (toc_relocs != NULL
9795                && elf_section_data (toc)->relocs != toc_relocs)
9796         free (toc_relocs);
9797
9798       if (local_syms != NULL
9799           && symtab_hdr->contents != (unsigned char *) local_syms)
9800         {
9801           if (!info->keep_memory)
9802             free (local_syms);
9803           else
9804             symtab_hdr->contents = (unsigned char *) local_syms;
9805         }
9806       free (skip);
9807     }
9808
9809   return TRUE;
9810 }
9811
9812 /* Return true iff input section I references the TOC using
9813    instructions limited to +/-32k offsets.  */
9814
9815 bfd_boolean
9816 ppc64_elf_has_small_toc_reloc (asection *i)
9817 {
9818   return (is_ppc64_elf (i->owner)
9819           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9820 }
9821
9822 /* Allocate space for one GOT entry.  */
9823
9824 static void
9825 allocate_got (struct elf_link_hash_entry *h,
9826               struct bfd_link_info *info,
9827               struct got_entry *gent)
9828 {
9829   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9830   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9831   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9832                  ? 16 : 8);
9833   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9834                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9835   asection *got = ppc64_elf_tdata (gent->owner)->got;
9836
9837   gent->got.offset = got->size;
9838   got->size += entsize;
9839
9840   if (h->type == STT_GNU_IFUNC)
9841     {
9842       htab->elf.irelplt->size += rentsize;
9843       htab->got_reli_size += rentsize;
9844     }
9845   else if (((bfd_link_pic (info)
9846              && !((gent->tls_type & TLS_TPREL) != 0
9847                   && bfd_link_executable (info)
9848                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9849             || (htab->elf.dynamic_sections_created
9850                 && h->dynindx != -1
9851                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9852            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9853     {
9854       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9855       relgot->size += rentsize;
9856     }
9857 }
9858
9859 /* This function merges got entries in the same toc group.  */
9860
9861 static void
9862 merge_got_entries (struct got_entry **pent)
9863 {
9864   struct got_entry *ent, *ent2;
9865
9866   for (ent = *pent; ent != NULL; ent = ent->next)
9867     if (!ent->is_indirect)
9868       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9869         if (!ent2->is_indirect
9870             && ent2->addend == ent->addend
9871             && ent2->tls_type == ent->tls_type
9872             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9873           {
9874             ent2->is_indirect = TRUE;
9875             ent2->got.ent = ent;
9876           }
9877 }
9878
9879 /* If H is undefined, make it dynamic if that makes sense.  */
9880
9881 static bfd_boolean
9882 ensure_undef_dynamic (struct bfd_link_info *info,
9883                       struct elf_link_hash_entry *h)
9884 {
9885   struct elf_link_hash_table *htab = elf_hash_table (info);
9886
9887   if (htab->dynamic_sections_created
9888       && ((info->dynamic_undefined_weak != 0
9889            && h->root.type == bfd_link_hash_undefweak)
9890           || h->root.type == bfd_link_hash_undefined)
9891       && h->dynindx == -1
9892       && !h->forced_local
9893       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9894     return bfd_elf_link_record_dynamic_symbol (info, h);
9895   return TRUE;
9896 }
9897
9898 /* Allocate space in .plt, .got and associated reloc sections for
9899    dynamic relocs.  */
9900
9901 static bfd_boolean
9902 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9903 {
9904   struct bfd_link_info *info;
9905   struct ppc_link_hash_table *htab;
9906   asection *s;
9907   struct ppc_link_hash_entry *eh;
9908   struct got_entry **pgent, *gent;
9909
9910   if (h->root.type == bfd_link_hash_indirect)
9911     return TRUE;
9912
9913   info = (struct bfd_link_info *) inf;
9914   htab = ppc_hash_table (info);
9915   if (htab == NULL)
9916     return FALSE;
9917
9918   eh = (struct ppc_link_hash_entry *) h;
9919   /* Run through the TLS GD got entries first if we're changing them
9920      to TPREL.  */
9921   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9922     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9923       if (gent->got.refcount > 0
9924           && (gent->tls_type & TLS_GD) != 0)
9925         {
9926           /* This was a GD entry that has been converted to TPREL.  If
9927              there happens to be a TPREL entry we can use that one.  */
9928           struct got_entry *ent;
9929           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9930             if (ent->got.refcount > 0
9931                 && (ent->tls_type & TLS_TPREL) != 0
9932                 && ent->addend == gent->addend
9933                 && ent->owner == gent->owner)
9934               {
9935                 gent->got.refcount = 0;
9936                 break;
9937               }
9938
9939           /* If not, then we'll be using our own TPREL entry.  */
9940           if (gent->got.refcount != 0)
9941             gent->tls_type = TLS_TLS | TLS_TPREL;
9942         }
9943
9944   /* Remove any list entry that won't generate a word in the GOT before
9945      we call merge_got_entries.  Otherwise we risk merging to empty
9946      entries.  */
9947   pgent = &h->got.glist;
9948   while ((gent = *pgent) != NULL)
9949     if (gent->got.refcount > 0)
9950       {
9951         if ((gent->tls_type & TLS_LD) != 0
9952             && !h->def_dynamic)
9953           {
9954             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9955             *pgent = gent->next;
9956           }
9957         else
9958           pgent = &gent->next;
9959       }
9960     else
9961       *pgent = gent->next;
9962
9963   if (!htab->do_multi_toc)
9964     merge_got_entries (&h->got.glist);
9965
9966   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9967     if (!gent->is_indirect)
9968       {
9969         /* Make sure this symbol is output as a dynamic symbol.  */
9970         if (!ensure_undef_dynamic (info, h))
9971           return FALSE;
9972
9973         if (!is_ppc64_elf (gent->owner))
9974           abort ();
9975
9976         allocate_got (h, info, gent);
9977       }
9978
9979   /* If no dynamic sections we can't have dynamic relocs, except for
9980      IFUNCs which are handled even in static executables.  */
9981   if (!htab->elf.dynamic_sections_created
9982       && h->type != STT_GNU_IFUNC)
9983     eh->dyn_relocs = NULL;
9984
9985   /* Discard relocs on undefined symbols that must be local.  */
9986   else if (h->root.type == bfd_link_hash_undefined
9987            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9988     eh->dyn_relocs = NULL;
9989
9990   /* Also discard relocs on undefined weak syms with non-default
9991      visibility, or when dynamic_undefined_weak says so.  */
9992   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9993     eh->dyn_relocs = NULL;
9994
9995   if (eh->dyn_relocs != NULL)
9996     {
9997       struct elf_dyn_relocs *p, **pp;
9998
9999       /* In the shared -Bsymbolic case, discard space allocated for
10000          dynamic pc-relative relocs against symbols which turn out to
10001          be defined in regular objects.  For the normal shared case,
10002          discard space for relocs that have become local due to symbol
10003          visibility changes.  */
10004
10005       if (bfd_link_pic (info))
10006         {
10007           /* Relocs that use pc_count are those that appear on a call
10008              insn, or certain REL relocs (see must_be_dyn_reloc) that
10009              can be generated via assembly.  We want calls to
10010              protected symbols to resolve directly to the function
10011              rather than going via the plt.  If people want function
10012              pointer comparisons to work as expected then they should
10013              avoid writing weird assembly.  */
10014           if (SYMBOL_CALLS_LOCAL (info, h))
10015             {
10016               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10017                 {
10018                   p->count -= p->pc_count;
10019                   p->pc_count = 0;
10020                   if (p->count == 0)
10021                     *pp = p->next;
10022                   else
10023                     pp = &p->next;
10024                 }
10025             }
10026
10027           if (eh->dyn_relocs != NULL)
10028             {
10029               /* Make sure this symbol is output as a dynamic symbol.  */
10030               if (!ensure_undef_dynamic (info, h))
10031                 return FALSE;
10032             }
10033         }
10034       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10035         {
10036           /* For the non-pic case, discard space for relocs against
10037              symbols which turn out to need copy relocs or are not
10038              dynamic.  */
10039           if (h->dynamic_adjusted
10040               && !h->def_regular
10041               && !ELF_COMMON_DEF_P (h))
10042             {
10043               /* Make sure this symbol is output as a dynamic symbol.  */
10044               if (!ensure_undef_dynamic (info, h))
10045                 return FALSE;
10046
10047               if (h->dynindx == -1)
10048                 eh->dyn_relocs = NULL;
10049             }
10050           else
10051             eh->dyn_relocs = NULL;
10052         }
10053
10054       /* Finally, allocate space.  */
10055       for (p = eh->dyn_relocs; p != NULL; p = p->next)
10056         {
10057           asection *sreloc = elf_section_data (p->sec)->sreloc;
10058           if (eh->elf.type == STT_GNU_IFUNC)
10059             sreloc = htab->elf.irelplt;
10060           sreloc->size += p->count * sizeof (Elf64_External_Rela);
10061         }
10062     }
10063
10064   /* We might need a PLT entry when the symbol
10065      a) is dynamic, or
10066      b) is an ifunc, or
10067      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10068      d) has plt16 relocs and we are linking statically.  */
10069   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10070       || h->type == STT_GNU_IFUNC
10071       || (h->needs_plt && h->dynamic_adjusted)
10072       || (h->needs_plt
10073           && h->def_regular
10074           && !htab->elf.dynamic_sections_created
10075           && !htab->can_convert_all_inline_plt
10076           && (((struct ppc_link_hash_entry *) h)->tls_mask
10077               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10078     {
10079       struct plt_entry *pent;
10080       bfd_boolean doneone = FALSE;
10081       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10082         if (pent->plt.refcount > 0)
10083           {
10084             if (!htab->elf.dynamic_sections_created
10085                 || h->dynindx == -1)
10086               {
10087                 if (h->type == STT_GNU_IFUNC)
10088                   {
10089                     s = htab->elf.iplt;
10090                     pent->plt.offset = s->size;
10091                     s->size += PLT_ENTRY_SIZE (htab);
10092                     s = htab->elf.irelplt;
10093                   }
10094                 else
10095                   {
10096                     s = htab->pltlocal;
10097                     pent->plt.offset = s->size;
10098                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10099                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10100                   }
10101               }
10102             else
10103               {
10104                 /* If this is the first .plt entry, make room for the special
10105                    first entry.  */
10106                 s = htab->elf.splt;
10107                 if (s->size == 0)
10108                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10109
10110                 pent->plt.offset = s->size;
10111
10112                 /* Make room for this entry.  */
10113                 s->size += PLT_ENTRY_SIZE (htab);
10114
10115                 /* Make room for the .glink code.  */
10116                 s = htab->glink;
10117                 if (s->size == 0)
10118                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
10119                 if (htab->opd_abi)
10120                   {
10121                     /* We need bigger stubs past index 32767.  */
10122                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10123                       s->size += 4;
10124                     s->size += 2*4;
10125                   }
10126                 else
10127                   s->size += 4;
10128
10129                 /* We also need to make an entry in the .rela.plt section.  */
10130                 s = htab->elf.srelplt;
10131               }
10132             if (s != NULL)
10133               s->size += sizeof (Elf64_External_Rela);
10134             doneone = TRUE;
10135           }
10136         else
10137           pent->plt.offset = (bfd_vma) -1;
10138       if (!doneone)
10139         {
10140           h->plt.plist = NULL;
10141           h->needs_plt = 0;
10142         }
10143     }
10144   else
10145     {
10146       h->plt.plist = NULL;
10147       h->needs_plt = 0;
10148     }
10149
10150   return TRUE;
10151 }
10152
10153 #define PPC_LO(v) ((v) & 0xffff)
10154 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10155 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10156
10157 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10158    to set up space for global entry stubs.  These are put in glink,
10159    after the branch table.  */
10160
10161 static bfd_boolean
10162 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10163 {
10164   struct bfd_link_info *info;
10165   struct ppc_link_hash_table *htab;
10166   struct plt_entry *pent;
10167   asection *s, *plt;
10168
10169   if (h->root.type == bfd_link_hash_indirect)
10170     return TRUE;
10171
10172   if (!h->pointer_equality_needed)
10173     return TRUE;
10174
10175   if (h->def_regular)
10176     return TRUE;
10177
10178   info = inf;
10179   htab = ppc_hash_table (info);
10180   if (htab == NULL)
10181     return FALSE;
10182
10183   s = htab->global_entry;
10184   plt = htab->elf.splt;
10185   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10186     if (pent->plt.offset != (bfd_vma) -1
10187         && pent->addend == 0)
10188       {
10189         /* For ELFv2, if this symbol is not defined in a regular file
10190            and we are not generating a shared library or pie, then we
10191            need to define the symbol in the executable on a call stub.
10192            This is to avoid text relocations.  */
10193         bfd_vma off, stub_align, stub_off, stub_size;
10194         unsigned int align_power;
10195
10196         stub_size = 16;
10197         stub_off = s->size;
10198         if (htab->params->plt_stub_align >= 0)
10199           align_power = htab->params->plt_stub_align;
10200         else
10201           align_power = -htab->params->plt_stub_align;
10202         /* Setting section alignment is delayed until we know it is
10203            non-empty.  Otherwise the .text output section will be
10204            aligned at least to plt_stub_align even when no global
10205            entry stubs are needed.  */
10206         if (s->alignment_power < align_power)
10207           s->alignment_power = align_power;
10208         stub_align = (bfd_vma) 1 << align_power;
10209         if (htab->params->plt_stub_align >= 0
10210             || ((((stub_off + stub_size - 1) & -stub_align)
10211                  - (stub_off & -stub_align))
10212                 > ((stub_size - 1) & -stub_align)))
10213           stub_off = (stub_off + stub_align - 1) & -stub_align;
10214         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10215         off -= stub_off + s->output_offset + s->output_section->vma;
10216         /* Note that for --plt-stub-align negative we have a possible
10217            dependency between stub offset and size.  Break that
10218            dependency by assuming the max stub size when calculating
10219            the stub offset.  */
10220         if (PPC_HA (off) == 0)
10221           stub_size -= 4;
10222         h->root.type = bfd_link_hash_defined;
10223         h->root.u.def.section = s;
10224         h->root.u.def.value = stub_off;
10225         s->size = stub_off + stub_size;
10226         break;
10227       }
10228   return TRUE;
10229 }
10230
10231 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10232    read-only sections.  */
10233
10234 static bfd_boolean
10235 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10236 {
10237   asection *sec;
10238
10239   if (h->root.type == bfd_link_hash_indirect)
10240     return TRUE;
10241
10242   sec = readonly_dynrelocs (h);
10243   if (sec != NULL)
10244     {
10245       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10246
10247       info->flags |= DF_TEXTREL;
10248       info->callbacks->minfo
10249         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10250          sec->owner, h->root.root.string, sec);
10251
10252       /* Not an error, just cut short the traversal.  */
10253       return FALSE;
10254     }
10255   return TRUE;
10256 }
10257
10258 /* Set the sizes of the dynamic sections.  */
10259
10260 static bfd_boolean
10261 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10262                                  struct bfd_link_info *info)
10263 {
10264   struct ppc_link_hash_table *htab;
10265   bfd *dynobj;
10266   asection *s;
10267   bfd_boolean relocs;
10268   bfd *ibfd;
10269   struct got_entry *first_tlsld;
10270
10271   htab = ppc_hash_table (info);
10272   if (htab == NULL)
10273     return FALSE;
10274
10275   dynobj = htab->elf.dynobj;
10276   if (dynobj == NULL)
10277     abort ();
10278
10279   if (htab->elf.dynamic_sections_created)
10280     {
10281       /* Set the contents of the .interp section to the interpreter.  */
10282       if (bfd_link_executable (info) && !info->nointerp)
10283         {
10284           s = bfd_get_linker_section (dynobj, ".interp");
10285           if (s == NULL)
10286             abort ();
10287           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10288           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10289         }
10290     }
10291
10292   /* Set up .got offsets for local syms, and space for local dynamic
10293      relocs.  */
10294   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10295     {
10296       struct got_entry **lgot_ents;
10297       struct got_entry **end_lgot_ents;
10298       struct plt_entry **local_plt;
10299       struct plt_entry **end_local_plt;
10300       unsigned char *lgot_masks;
10301       bfd_size_type locsymcount;
10302       Elf_Internal_Shdr *symtab_hdr;
10303
10304       if (!is_ppc64_elf (ibfd))
10305         continue;
10306
10307       for (s = ibfd->sections; s != NULL; s = s->next)
10308         {
10309           struct ppc_dyn_relocs *p;
10310
10311           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10312             {
10313               if (!bfd_is_abs_section (p->sec)
10314                   && bfd_is_abs_section (p->sec->output_section))
10315                 {
10316                   /* Input section has been discarded, either because
10317                      it is a copy of a linkonce section or due to
10318                      linker script /DISCARD/, so we'll be discarding
10319                      the relocs too.  */
10320                 }
10321               else if (p->count != 0)
10322                 {
10323                   asection *srel = elf_section_data (p->sec)->sreloc;
10324                   if (p->ifunc)
10325                     srel = htab->elf.irelplt;
10326                   srel->size += p->count * sizeof (Elf64_External_Rela);
10327                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10328                     info->flags |= DF_TEXTREL;
10329                 }
10330             }
10331         }
10332
10333       lgot_ents = elf_local_got_ents (ibfd);
10334       if (!lgot_ents)
10335         continue;
10336
10337       symtab_hdr = &elf_symtab_hdr (ibfd);
10338       locsymcount = symtab_hdr->sh_info;
10339       end_lgot_ents = lgot_ents + locsymcount;
10340       local_plt = (struct plt_entry **) end_lgot_ents;
10341       end_local_plt = local_plt + locsymcount;
10342       lgot_masks = (unsigned char *) end_local_plt;
10343       s = ppc64_elf_tdata (ibfd)->got;
10344       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10345         {
10346           struct got_entry **pent, *ent;
10347
10348           pent = lgot_ents;
10349           while ((ent = *pent) != NULL)
10350             if (ent->got.refcount > 0)
10351               {
10352                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10353                   {
10354                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10355                     *pent = ent->next;
10356                   }
10357                 else
10358                   {
10359                     unsigned int ent_size = 8;
10360                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10361
10362                     ent->got.offset = s->size;
10363                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10364                       {
10365                         ent_size *= 2;
10366                         rel_size *= 2;
10367                       }
10368                     s->size += ent_size;
10369                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10370                       {
10371                         htab->elf.irelplt->size += rel_size;
10372                         htab->got_reli_size += rel_size;
10373                       }
10374                     else if (bfd_link_pic (info)
10375                              && !((ent->tls_type & TLS_TPREL) != 0
10376                                   && bfd_link_executable (info)))
10377                       {
10378                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10379                         srel->size += rel_size;
10380                       }
10381                     pent = &ent->next;
10382                   }
10383               }
10384             else
10385               *pent = ent->next;
10386         }
10387
10388       /* Allocate space for plt calls to local syms.  */
10389       lgot_masks = (unsigned char *) end_local_plt;
10390       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10391         {
10392           struct plt_entry *ent;
10393
10394           for (ent = *local_plt; ent != NULL; ent = ent->next)
10395             if (ent->plt.refcount > 0)
10396               {
10397                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10398                   {
10399                     s = htab->elf.iplt;
10400                     ent->plt.offset = s->size;
10401                     s->size += PLT_ENTRY_SIZE (htab);
10402                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10403                   }
10404                 else if (htab->can_convert_all_inline_plt
10405                          || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10406                   ent->plt.offset = (bfd_vma) -1;
10407                 else
10408                   {
10409                     s = htab->pltlocal;
10410                     ent->plt.offset = s->size;
10411                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10412                     if (bfd_link_pic (info))
10413                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10414                   }
10415               }
10416             else
10417               ent->plt.offset = (bfd_vma) -1;
10418         }
10419     }
10420
10421   /* Allocate global sym .plt and .got entries, and space for global
10422      sym dynamic relocs.  */
10423   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10424
10425   if (!htab->opd_abi && !bfd_link_pic (info))
10426     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10427
10428   first_tlsld = NULL;
10429   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10430     {
10431       struct got_entry *ent;
10432
10433       if (!is_ppc64_elf (ibfd))
10434         continue;
10435
10436       ent = ppc64_tlsld_got (ibfd);
10437       if (ent->got.refcount > 0)
10438         {
10439           if (!htab->do_multi_toc && first_tlsld != NULL)
10440             {
10441               ent->is_indirect = TRUE;
10442               ent->got.ent = first_tlsld;
10443             }
10444           else
10445             {
10446               if (first_tlsld == NULL)
10447                 first_tlsld = ent;
10448               s = ppc64_elf_tdata (ibfd)->got;
10449               ent->got.offset = s->size;
10450               ent->owner = ibfd;
10451               s->size += 16;
10452               if (bfd_link_pic (info))
10453                 {
10454                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10455                   srel->size += sizeof (Elf64_External_Rela);
10456                 }
10457             }
10458         }
10459       else
10460         ent->got.offset = (bfd_vma) -1;
10461     }
10462
10463   /* We now have determined the sizes of the various dynamic sections.
10464      Allocate memory for them.  */
10465   relocs = FALSE;
10466   for (s = dynobj->sections; s != NULL; s = s->next)
10467     {
10468       if ((s->flags & SEC_LINKER_CREATED) == 0)
10469         continue;
10470
10471       if (s == htab->brlt || s == htab->relbrlt)
10472         /* These haven't been allocated yet;  don't strip.  */
10473         continue;
10474       else if (s == htab->elf.sgot
10475                || s == htab->elf.splt
10476                || s == htab->elf.iplt
10477                || s == htab->pltlocal
10478                || s == htab->glink
10479                || s == htab->global_entry
10480                || s == htab->elf.sdynbss
10481                || s == htab->elf.sdynrelro)
10482         {
10483           /* Strip this section if we don't need it; see the
10484              comment below.  */
10485         }
10486       else if (s == htab->glink_eh_frame)
10487         {
10488           if (!bfd_is_abs_section (s->output_section))
10489             /* Not sized yet.  */
10490             continue;
10491         }
10492       else if (CONST_STRNEQ (s->name, ".rela"))
10493         {
10494           if (s->size != 0)
10495             {
10496               if (s != htab->elf.srelplt)
10497                 relocs = TRUE;
10498
10499               /* We use the reloc_count field as a counter if we need
10500                  to copy relocs into the output file.  */
10501               s->reloc_count = 0;
10502             }
10503         }
10504       else
10505         {
10506           /* It's not one of our sections, so don't allocate space.  */
10507           continue;
10508         }
10509
10510       if (s->size == 0)
10511         {
10512           /* If we don't need this section, strip it from the
10513              output file.  This is mostly to handle .rela.bss and
10514              .rela.plt.  We must create both sections in
10515              create_dynamic_sections, because they must be created
10516              before the linker maps input sections to output
10517              sections.  The linker does that before
10518              adjust_dynamic_symbol is called, and it is that
10519              function which decides whether anything needs to go
10520              into these sections.  */
10521           s->flags |= SEC_EXCLUDE;
10522           continue;
10523         }
10524
10525       if (bfd_is_abs_section (s->output_section))
10526         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10527                             s->name);
10528
10529       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10530         continue;
10531
10532       /* Allocate memory for the section contents.  We use bfd_zalloc
10533          here in case unused entries are not reclaimed before the
10534          section's contents are written out.  This should not happen,
10535          but this way if it does we get a R_PPC64_NONE reloc in .rela
10536          sections instead of garbage.
10537          We also rely on the section contents being zero when writing
10538          the GOT and .dynrelro.  */
10539       s->contents = bfd_zalloc (dynobj, s->size);
10540       if (s->contents == NULL)
10541         return FALSE;
10542     }
10543
10544   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10545     {
10546       if (!is_ppc64_elf (ibfd))
10547         continue;
10548
10549       s = ppc64_elf_tdata (ibfd)->got;
10550       if (s != NULL && s != htab->elf.sgot)
10551         {
10552           if (s->size == 0)
10553             s->flags |= SEC_EXCLUDE;
10554           else
10555             {
10556               s->contents = bfd_zalloc (ibfd, s->size);
10557               if (s->contents == NULL)
10558                 return FALSE;
10559             }
10560         }
10561       s = ppc64_elf_tdata (ibfd)->relgot;
10562       if (s != NULL)
10563         {
10564           if (s->size == 0)
10565             s->flags |= SEC_EXCLUDE;
10566           else
10567             {
10568               s->contents = bfd_zalloc (ibfd, s->size);
10569               if (s->contents == NULL)
10570                 return FALSE;
10571               relocs = TRUE;
10572               s->reloc_count = 0;
10573             }
10574         }
10575     }
10576
10577   if (htab->elf.dynamic_sections_created)
10578     {
10579       bfd_boolean tls_opt;
10580
10581       /* Add some entries to the .dynamic section.  We fill in the
10582          values later, in ppc64_elf_finish_dynamic_sections, but we
10583          must add the entries now so that we get the correct size for
10584          the .dynamic section.  The DT_DEBUG entry is filled in by the
10585          dynamic linker and used by the debugger.  */
10586 #define add_dynamic_entry(TAG, VAL) \
10587   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10588
10589       if (bfd_link_executable (info))
10590         {
10591           if (!add_dynamic_entry (DT_DEBUG, 0))
10592             return FALSE;
10593         }
10594
10595       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10596         {
10597           if (!add_dynamic_entry (DT_PLTGOT, 0)
10598               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10599               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10600               || !add_dynamic_entry (DT_JMPREL, 0)
10601               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10602             return FALSE;
10603         }
10604
10605       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10606         {
10607           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10608               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10609             return FALSE;
10610         }
10611
10612       tls_opt = (htab->params->tls_get_addr_opt
10613                  && htab->tls_get_addr_fd != NULL
10614                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10615       if (tls_opt || !htab->opd_abi)
10616         {
10617           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10618             return FALSE;
10619         }
10620
10621       if (relocs)
10622         {
10623           if (!add_dynamic_entry (DT_RELA, 0)
10624               || !add_dynamic_entry (DT_RELASZ, 0)
10625               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10626             return FALSE;
10627
10628           /* If any dynamic relocs apply to a read-only section,
10629              then we need a DT_TEXTREL entry.  */
10630           if ((info->flags & DF_TEXTREL) == 0)
10631             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10632
10633           if ((info->flags & DF_TEXTREL) != 0)
10634             {
10635               if (!add_dynamic_entry (DT_TEXTREL, 0))
10636                 return FALSE;
10637             }
10638         }
10639     }
10640 #undef add_dynamic_entry
10641
10642   return TRUE;
10643 }
10644
10645 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10646
10647 static bfd_boolean
10648 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10649 {
10650   if (h->plt.plist != NULL
10651       && !h->def_regular
10652       && !h->pointer_equality_needed)
10653     return FALSE;
10654
10655   return _bfd_elf_hash_symbol (h);
10656 }
10657
10658 /* Determine the type of stub needed, if any, for a call.  */
10659
10660 static inline enum ppc_stub_type
10661 ppc_type_of_stub (asection *input_sec,
10662                   const Elf_Internal_Rela *rel,
10663                   struct ppc_link_hash_entry **hash,
10664                   struct plt_entry **plt_ent,
10665                   bfd_vma destination,
10666                   unsigned long local_off)
10667 {
10668   struct ppc_link_hash_entry *h = *hash;
10669   bfd_vma location;
10670   bfd_vma branch_offset;
10671   bfd_vma max_branch_offset;
10672   enum elf_ppc64_reloc_type r_type;
10673
10674   if (h != NULL)
10675     {
10676       struct plt_entry *ent;
10677       struct ppc_link_hash_entry *fdh = h;
10678       if (h->oh != NULL
10679           && h->oh->is_func_descriptor)
10680         {
10681           fdh = ppc_follow_link (h->oh);
10682           *hash = fdh;
10683         }
10684
10685       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10686         if (ent->addend == rel->r_addend
10687             && ent->plt.offset != (bfd_vma) -1)
10688           {
10689             *plt_ent = ent;
10690             return ppc_stub_plt_call;
10691           }
10692
10693       /* Here, we know we don't have a plt entry.  If we don't have a
10694          either a defined function descriptor or a defined entry symbol
10695          in a regular object file, then it is pointless trying to make
10696          any other type of stub.  */
10697       if (!is_static_defined (&fdh->elf)
10698           && !is_static_defined (&h->elf))
10699         return ppc_stub_none;
10700     }
10701   else if (elf_local_got_ents (input_sec->owner) != NULL)
10702     {
10703       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10704       struct plt_entry **local_plt = (struct plt_entry **)
10705         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10706       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10707
10708       if (local_plt[r_symndx] != NULL)
10709         {
10710           struct plt_entry *ent;
10711
10712           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10713             if (ent->addend == rel->r_addend
10714                 && ent->plt.offset != (bfd_vma) -1)
10715               {
10716                 *plt_ent = ent;
10717                 return ppc_stub_plt_call;
10718               }
10719         }
10720     }
10721
10722   /* Determine where the call point is.  */
10723   location = (input_sec->output_offset
10724               + input_sec->output_section->vma
10725               + rel->r_offset);
10726
10727   branch_offset = destination - location;
10728   r_type = ELF64_R_TYPE (rel->r_info);
10729
10730   /* Determine if a long branch stub is needed.  */
10731   max_branch_offset = 1 << 25;
10732   if (r_type == R_PPC64_REL14
10733       || r_type == R_PPC64_REL14_BRTAKEN
10734       || r_type == R_PPC64_REL14_BRNTAKEN)
10735     max_branch_offset = 1 << 15;
10736
10737   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10738     /* We need a stub.  Figure out whether a long_branch or plt_branch
10739        is needed later.  */
10740     return ppc_stub_long_branch;
10741
10742   return ppc_stub_none;
10743 }
10744
10745 /* With power7 weakly ordered memory model, it is possible for ld.so
10746    to update a plt entry in one thread and have another thread see a
10747    stale zero toc entry.  To avoid this we need some sort of acquire
10748    barrier in the call stub.  One solution is to make the load of the
10749    toc word seem to appear to depend on the load of the function entry
10750    word.  Another solution is to test for r2 being zero, and branch to
10751    the appropriate glink entry if so.
10752
10753    .    fake dep barrier        compare
10754    .    ld 12,xxx(2)            ld 12,xxx(2)
10755    .    mtctr 12                mtctr 12
10756    .    xor 11,12,12            ld 2,xxx+8(2)
10757    .    add 2,2,11              cmpldi 2,0
10758    .    ld 2,xxx+8(2)           bnectr+
10759    .    bctr                    b <glink_entry>
10760
10761    The solution involving the compare turns out to be faster, so
10762    that's what we use unless the branch won't reach.  */
10763
10764 #define ALWAYS_USE_FAKE_DEP 0
10765 #define ALWAYS_EMIT_R2SAVE 0
10766
10767 static inline unsigned int
10768 plt_stub_size (struct ppc_link_hash_table *htab,
10769                struct ppc_stub_hash_entry *stub_entry,
10770                bfd_vma off)
10771 {
10772   unsigned size = 12;
10773
10774   if (ALWAYS_EMIT_R2SAVE
10775       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10776     size += 4;
10777   if (PPC_HA (off) != 0)
10778     size += 4;
10779   if (htab->opd_abi)
10780     {
10781       size += 4;
10782       if (htab->params->plt_static_chain)
10783         size += 4;
10784       if (htab->params->plt_thread_safe
10785           && htab->elf.dynamic_sections_created
10786           && stub_entry->h != NULL
10787           && stub_entry->h->elf.dynindx != -1)
10788         size += 8;
10789       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10790         size += 4;
10791     }
10792   if (stub_entry->h != NULL
10793       && (stub_entry->h == htab->tls_get_addr_fd
10794           || stub_entry->h == htab->tls_get_addr)
10795       && htab->params->tls_get_addr_opt)
10796     {
10797       size += 7 * 4;
10798       if (ALWAYS_EMIT_R2SAVE
10799           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10800         size += 6 * 4;
10801     }
10802   return size;
10803 }
10804
10805 /* Depending on the sign of plt_stub_align:
10806    If positive, return the padding to align to a 2**plt_stub_align
10807    boundary.
10808    If negative, if this stub would cross fewer 2**plt_stub_align
10809    boundaries if we align, then return the padding needed to do so.  */
10810
10811 static inline unsigned int
10812 plt_stub_pad (struct ppc_link_hash_table *htab,
10813               struct ppc_stub_hash_entry *stub_entry,
10814               bfd_vma plt_off)
10815 {
10816   int stub_align;
10817   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10818   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10819
10820   if (htab->params->plt_stub_align >= 0)
10821     {
10822       stub_align = 1 << htab->params->plt_stub_align;
10823       if ((stub_off & (stub_align - 1)) != 0)
10824         return stub_align - (stub_off & (stub_align - 1));
10825       return 0;
10826     }
10827
10828   stub_align = 1 << -htab->params->plt_stub_align;
10829   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10830       > ((stub_size - 1) & -stub_align))
10831     return stub_align - (stub_off & (stub_align - 1));
10832   return 0;
10833 }
10834
10835 /* Build a .plt call stub.  */
10836
10837 static inline bfd_byte *
10838 build_plt_stub (struct ppc_link_hash_table *htab,
10839                 struct ppc_stub_hash_entry *stub_entry,
10840                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10841 {
10842   bfd *obfd = htab->params->stub_bfd;
10843   bfd_boolean plt_load_toc = htab->opd_abi;
10844   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10845   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10846                                  && htab->elf.dynamic_sections_created
10847                                  && stub_entry->h != NULL
10848                                  && stub_entry->h->elf.dynindx != -1);
10849   bfd_boolean use_fake_dep = plt_thread_safe;
10850   bfd_vma cmp_branch_off = 0;
10851
10852   if (!ALWAYS_USE_FAKE_DEP
10853       && plt_load_toc
10854       && plt_thread_safe
10855       && !((stub_entry->h == htab->tls_get_addr_fd
10856             || stub_entry->h == htab->tls_get_addr)
10857            && htab->params->tls_get_addr_opt))
10858     {
10859       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10860       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10861                           / PLT_ENTRY_SIZE (htab));
10862       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10863       bfd_vma to, from;
10864
10865       if (pltindex > 32768)
10866         glinkoff += (pltindex - 32768) * 4;
10867       to = (glinkoff
10868             + htab->glink->output_offset
10869             + htab->glink->output_section->vma);
10870       from = (p - stub_entry->group->stub_sec->contents
10871               + 4 * (ALWAYS_EMIT_R2SAVE
10872                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10873               + 4 * (PPC_HA (offset) != 0)
10874               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10875                      != PPC_HA (offset))
10876               + 4 * (plt_static_chain != 0)
10877               + 20
10878               + stub_entry->group->stub_sec->output_offset
10879               + stub_entry->group->stub_sec->output_section->vma);
10880       cmp_branch_off = to - from;
10881       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10882     }
10883
10884   if (PPC_HA (offset) != 0)
10885     {
10886       if (r != NULL)
10887         {
10888           if (ALWAYS_EMIT_R2SAVE
10889               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10890             r[0].r_offset += 4;
10891           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10892           r[1].r_offset = r[0].r_offset + 4;
10893           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10894           r[1].r_addend = r[0].r_addend;
10895           if (plt_load_toc)
10896             {
10897               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10898                 {
10899                   r[2].r_offset = r[1].r_offset + 4;
10900                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10901                   r[2].r_addend = r[0].r_addend;
10902                 }
10903               else
10904                 {
10905                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10906                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10907                   r[2].r_addend = r[0].r_addend + 8;
10908                   if (plt_static_chain)
10909                     {
10910                       r[3].r_offset = r[2].r_offset + 4;
10911                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10912                       r[3].r_addend = r[0].r_addend + 16;
10913                     }
10914                 }
10915             }
10916         }
10917       if (ALWAYS_EMIT_R2SAVE
10918           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10919         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10920       if (plt_load_toc)
10921         {
10922           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10923           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10924         }
10925       else
10926         {
10927           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10928           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10929         }
10930       if (plt_load_toc
10931           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10932         {
10933           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10934           offset = 0;
10935         }
10936       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10937       if (plt_load_toc)
10938         {
10939           if (use_fake_dep)
10940             {
10941               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10942               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10943             }
10944           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10945           if (plt_static_chain)
10946             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10947         }
10948     }
10949   else
10950     {
10951       if (r != NULL)
10952         {
10953           if (ALWAYS_EMIT_R2SAVE
10954               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10955             r[0].r_offset += 4;
10956           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10957           if (plt_load_toc)
10958             {
10959               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10960                 {
10961                   r[1].r_offset = r[0].r_offset + 4;
10962                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10963                   r[1].r_addend = r[0].r_addend;
10964                 }
10965               else
10966                 {
10967                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10968                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10969                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10970                   if (plt_static_chain)
10971                     {
10972                       r[2].r_offset = r[1].r_offset + 4;
10973                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10974                       r[2].r_addend = r[0].r_addend + 8;
10975                     }
10976                 }
10977             }
10978         }
10979       if (ALWAYS_EMIT_R2SAVE
10980           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10981         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10982       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10983       if (plt_load_toc
10984           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10985         {
10986           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10987           offset = 0;
10988         }
10989       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10990       if (plt_load_toc)
10991         {
10992           if (use_fake_dep)
10993             {
10994               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10995               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10996             }
10997           if (plt_static_chain)
10998             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10999           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11000         }
11001     }
11002   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11003     {
11004       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11005       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11006       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11007     }
11008   else
11009     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11010   return p;
11011 }
11012
11013 /* Build a special .plt call stub for __tls_get_addr.  */
11014
11015 #define LD_R11_0R3      0xe9630000
11016 #define LD_R12_0R3      0xe9830000
11017 #define MR_R0_R3        0x7c601b78
11018 #define CMPDI_R11_0     0x2c2b0000
11019 #define ADD_R3_R12_R13  0x7c6c6a14
11020 #define BEQLR           0x4d820020
11021 #define MR_R3_R0        0x7c030378
11022 #define STD_R11_0R1     0xf9610000
11023 #define BCTRL           0x4e800421
11024 #define LD_R11_0R1      0xe9610000
11025 #define MTLR_R11        0x7d6803a6
11026
11027 static inline bfd_byte *
11028 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11029                          struct ppc_stub_hash_entry *stub_entry,
11030                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11031 {
11032   bfd *obfd = htab->params->stub_bfd;
11033
11034   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11035   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11036   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11037   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11038   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11039   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11040   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11041   if (r != NULL)
11042     r[0].r_offset += 7 * 4;
11043   if (!ALWAYS_EMIT_R2SAVE
11044       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
11045     return build_plt_stub (htab, stub_entry, p, offset, r);
11046
11047   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11048   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11049
11050   if (r != NULL)
11051     r[0].r_offset += 2 * 4;
11052   p = build_plt_stub (htab, stub_entry, p, offset, r);
11053   bfd_put_32 (obfd, BCTRL, p - 4);
11054
11055   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11056   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11057   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11058   bfd_put_32 (obfd, BLR, p),                    p += 4;
11059
11060   return p;
11061 }
11062
11063 static Elf_Internal_Rela *
11064 get_relocs (asection *sec, int count)
11065 {
11066   Elf_Internal_Rela *relocs;
11067   struct bfd_elf_section_data *elfsec_data;
11068
11069   elfsec_data = elf_section_data (sec);
11070   relocs = elfsec_data->relocs;
11071   if (relocs == NULL)
11072     {
11073       bfd_size_type relsize;
11074       relsize = sec->reloc_count * sizeof (*relocs);
11075       relocs = bfd_alloc (sec->owner, relsize);
11076       if (relocs == NULL)
11077         return NULL;
11078       elfsec_data->relocs = relocs;
11079       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11080                                           sizeof (Elf_Internal_Shdr));
11081       if (elfsec_data->rela.hdr == NULL)
11082         return NULL;
11083       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11084                                         * sizeof (Elf64_External_Rela));
11085       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11086       sec->reloc_count = 0;
11087     }
11088   relocs += sec->reloc_count;
11089   sec->reloc_count += count;
11090   return relocs;
11091 }
11092
11093 static bfd_vma
11094 get_r2off (struct bfd_link_info *info,
11095            struct ppc_stub_hash_entry *stub_entry)
11096 {
11097   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11098   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11099
11100   if (r2off == 0)
11101     {
11102       /* Support linking -R objects.  Get the toc pointer from the
11103          opd entry.  */
11104       char buf[8];
11105       if (!htab->opd_abi)
11106         return r2off;
11107       asection *opd = stub_entry->h->elf.root.u.def.section;
11108       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11109
11110       if (strcmp (opd->name, ".opd") != 0
11111           || opd->reloc_count != 0)
11112         {
11113           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11114                                   stub_entry->h->elf.root.root.string);
11115           bfd_set_error (bfd_error_bad_value);
11116           return (bfd_vma) -1;
11117         }
11118       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11119         return (bfd_vma) -1;
11120       r2off = bfd_get_64 (opd->owner, buf);
11121       r2off -= elf_gp (info->output_bfd);
11122     }
11123   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11124   return r2off;
11125 }
11126
11127 static bfd_boolean
11128 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11129 {
11130   struct ppc_stub_hash_entry *stub_entry;
11131   struct ppc_branch_hash_entry *br_entry;
11132   struct bfd_link_info *info;
11133   struct ppc_link_hash_table *htab;
11134   bfd_byte *loc;
11135   bfd_byte *p;
11136   bfd_vma dest, off;
11137   Elf_Internal_Rela *r;
11138   asection *plt;
11139
11140   /* Massage our args to the form they really have.  */
11141   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11142   info = in_arg;
11143
11144   htab = ppc_hash_table (info);
11145   if (htab == NULL)
11146     return FALSE;
11147
11148   /* Make a note of the offset within the stubs for this entry.  */
11149   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11150   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11151
11152   htab->stub_count[stub_entry->stub_type - 1] += 1;
11153   switch (stub_entry->stub_type)
11154     {
11155     case ppc_stub_long_branch:
11156     case ppc_stub_long_branch_r2off:
11157       /* Branches are relative.  This is where we are going to.  */
11158       dest = (stub_entry->target_value
11159               + stub_entry->target_section->output_offset
11160               + stub_entry->target_section->output_section->vma);
11161       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11162       off = dest;
11163
11164       /* And this is where we are coming from.  */
11165       off -= (stub_entry->stub_offset
11166               + stub_entry->group->stub_sec->output_offset
11167               + stub_entry->group->stub_sec->output_section->vma);
11168
11169       p = loc;
11170       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11171         {
11172           bfd_vma r2off = get_r2off (info, stub_entry);
11173
11174           if (r2off == (bfd_vma) -1)
11175             {
11176               htab->stub_error = TRUE;
11177               return FALSE;
11178             }
11179           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11180           p += 4;
11181           if (PPC_HA (r2off) != 0)
11182             {
11183               bfd_put_32 (htab->params->stub_bfd,
11184                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11185               p += 4;
11186             }
11187           if (PPC_LO (r2off) != 0)
11188             {
11189               bfd_put_32 (htab->params->stub_bfd,
11190                           ADDI_R2_R2 | PPC_LO (r2off), p);
11191               p += 4;
11192             }
11193           off -= p - loc;
11194         }
11195       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11196       p += 4;
11197
11198       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11199         {
11200           _bfd_error_handler
11201             (_("long branch stub `%s' offset overflow"),
11202              stub_entry->root.string);
11203           htab->stub_error = TRUE;
11204           return FALSE;
11205         }
11206
11207       if (info->emitrelocations)
11208         {
11209           r = get_relocs (stub_entry->group->stub_sec, 1);
11210           if (r == NULL)
11211             return FALSE;
11212           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11213           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11214           r->r_addend = dest;
11215           if (stub_entry->h != NULL)
11216             {
11217               struct elf_link_hash_entry **hashes;
11218               unsigned long symndx;
11219               struct ppc_link_hash_entry *h;
11220
11221               hashes = elf_sym_hashes (htab->params->stub_bfd);
11222               if (hashes == NULL)
11223                 {
11224                   bfd_size_type hsize;
11225
11226                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11227                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11228                   if (hashes == NULL)
11229                     return FALSE;
11230                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11231                   htab->stub_globals = 1;
11232                 }
11233               symndx = htab->stub_globals++;
11234               h = stub_entry->h;
11235               hashes[symndx] = &h->elf;
11236               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11237               if (h->oh != NULL && h->oh->is_func)
11238                 h = ppc_follow_link (h->oh);
11239               if (h->elf.root.u.def.section != stub_entry->target_section)
11240                 /* H is an opd symbol.  The addend must be zero.  */
11241                 r->r_addend = 0;
11242               else
11243                 {
11244                   off = (h->elf.root.u.def.value
11245                          + h->elf.root.u.def.section->output_offset
11246                          + h->elf.root.u.def.section->output_section->vma);
11247                   r->r_addend -= off;
11248                 }
11249             }
11250         }
11251       break;
11252
11253     case ppc_stub_plt_branch:
11254     case ppc_stub_plt_branch_r2off:
11255       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11256                                          stub_entry->root.string + 9,
11257                                          FALSE, FALSE);
11258       if (br_entry == NULL)
11259         {
11260           _bfd_error_handler (_("can't find branch stub `%s'"),
11261                               stub_entry->root.string);
11262           htab->stub_error = TRUE;
11263           return FALSE;
11264         }
11265
11266       dest = (stub_entry->target_value
11267               + stub_entry->target_section->output_offset
11268               + stub_entry->target_section->output_section->vma);
11269       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11270         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11271
11272       bfd_put_64 (htab->brlt->owner, dest,
11273                   htab->brlt->contents + br_entry->offset);
11274
11275       if (br_entry->iter == htab->stub_iteration)
11276         {
11277           br_entry->iter = 0;
11278
11279           if (htab->relbrlt != NULL)
11280             {
11281               /* Create a reloc for the branch lookup table entry.  */
11282               Elf_Internal_Rela rela;
11283               bfd_byte *rl;
11284
11285               rela.r_offset = (br_entry->offset
11286                                + htab->brlt->output_offset
11287                                + htab->brlt->output_section->vma);
11288               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11289               rela.r_addend = dest;
11290
11291               rl = htab->relbrlt->contents;
11292               rl += (htab->relbrlt->reloc_count++
11293                      * sizeof (Elf64_External_Rela));
11294               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11295             }
11296           else if (info->emitrelocations)
11297             {
11298               r = get_relocs (htab->brlt, 1);
11299               if (r == NULL)
11300                 return FALSE;
11301               /* brlt, being SEC_LINKER_CREATED does not go through the
11302                  normal reloc processing.  Symbols and offsets are not
11303                  translated from input file to output file form, so
11304                  set up the offset per the output file.  */
11305               r->r_offset = (br_entry->offset
11306                              + htab->brlt->output_offset
11307                              + htab->brlt->output_section->vma);
11308               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11309               r->r_addend = dest;
11310             }
11311         }
11312
11313       dest = (br_entry->offset
11314               + htab->brlt->output_offset
11315               + htab->brlt->output_section->vma);
11316
11317       off = (dest
11318              - elf_gp (info->output_bfd)
11319              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11320
11321       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11322         {
11323           info->callbacks->einfo
11324             (_("%P: linkage table error against `%pT'\n"),
11325              stub_entry->root.string);
11326           bfd_set_error (bfd_error_bad_value);
11327           htab->stub_error = TRUE;
11328           return FALSE;
11329         }
11330
11331       if (info->emitrelocations)
11332         {
11333           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11334           if (r == NULL)
11335             return FALSE;
11336           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11337           if (bfd_big_endian (info->output_bfd))
11338             r[0].r_offset += 2;
11339           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11340             r[0].r_offset += 4;
11341           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11342           r[0].r_addend = dest;
11343           if (PPC_HA (off) != 0)
11344             {
11345               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11346               r[1].r_offset = r[0].r_offset + 4;
11347               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11348               r[1].r_addend = r[0].r_addend;
11349             }
11350         }
11351
11352       p = loc;
11353       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11354         {
11355           if (PPC_HA (off) != 0)
11356             {
11357               bfd_put_32 (htab->params->stub_bfd,
11358                           ADDIS_R12_R2 | PPC_HA (off), p);
11359               p += 4;
11360               bfd_put_32 (htab->params->stub_bfd,
11361                           LD_R12_0R12 | PPC_LO (off), p);
11362             }
11363           else
11364             bfd_put_32 (htab->params->stub_bfd,
11365                         LD_R12_0R2 | PPC_LO (off), p);
11366         }
11367       else
11368         {
11369           bfd_vma r2off = get_r2off (info, stub_entry);
11370
11371           if (r2off == (bfd_vma) -1)
11372             {
11373               htab->stub_error = TRUE;
11374               return FALSE;
11375             }
11376
11377           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11378           p += 4;
11379           if (PPC_HA (off) != 0)
11380             {
11381               bfd_put_32 (htab->params->stub_bfd,
11382                           ADDIS_R12_R2 | PPC_HA (off), p);
11383               p += 4;
11384               bfd_put_32 (htab->params->stub_bfd,
11385                           LD_R12_0R12 | PPC_LO (off), p);
11386             }
11387           else
11388             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11389
11390           if (PPC_HA (r2off) != 0)
11391             {
11392               p += 4;
11393               bfd_put_32 (htab->params->stub_bfd,
11394                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11395             }
11396           if (PPC_LO (r2off) != 0)
11397             {
11398               p += 4;
11399               bfd_put_32 (htab->params->stub_bfd,
11400                           ADDI_R2_R2 | PPC_LO (r2off), p);
11401             }
11402         }
11403       p += 4;
11404       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11405       p += 4;
11406       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11407       p += 4;
11408       break;
11409
11410     case ppc_stub_plt_call:
11411     case ppc_stub_plt_call_r2save:
11412       if (stub_entry->h != NULL
11413           && stub_entry->h->is_func_descriptor
11414           && stub_entry->h->oh != NULL)
11415         {
11416           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11417
11418           /* If the old-ABI "dot-symbol" is undefined make it weak so
11419              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11420           if (fh->elf.root.type == bfd_link_hash_undefined
11421               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11422                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11423             fh->elf.root.type = bfd_link_hash_undefweak;
11424         }
11425
11426       /* Now build the stub.  */
11427       dest = stub_entry->plt_ent->plt.offset & ~1;
11428       if (dest >= (bfd_vma) -2)
11429         abort ();
11430
11431       plt = htab->elf.splt;
11432       if (!htab->elf.dynamic_sections_created
11433           || stub_entry->h == NULL
11434           || stub_entry->h->elf.dynindx == -1)
11435         {
11436           if (stub_entry->symtype == STT_GNU_IFUNC)
11437             plt = htab->elf.iplt;
11438           else
11439             plt = htab->pltlocal;
11440         }
11441
11442       dest += plt->output_offset + plt->output_section->vma;
11443
11444       off = (dest
11445              - elf_gp (info->output_bfd)
11446              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11447
11448       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11449         {
11450           info->callbacks->einfo
11451             /* xgettext:c-format */
11452             (_("%P: linkage table error against `%pT'\n"),
11453              stub_entry->h != NULL
11454              ? stub_entry->h->elf.root.root.string
11455              : "<local sym>");
11456           bfd_set_error (bfd_error_bad_value);
11457           htab->stub_error = TRUE;
11458           return FALSE;
11459         }
11460
11461       if (htab->params->plt_stub_align != 0)
11462         {
11463           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11464
11465           stub_entry->group->stub_sec->size += pad;
11466           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11467           loc += pad;
11468         }
11469
11470       r = NULL;
11471       if (info->emitrelocations)
11472         {
11473           r = get_relocs (stub_entry->group->stub_sec,
11474                           ((PPC_HA (off) != 0)
11475                            + (htab->opd_abi
11476                               ? 2 + (htab->params->plt_static_chain
11477                                      && PPC_HA (off + 16) == PPC_HA (off))
11478                               : 1)));
11479           if (r == NULL)
11480             return FALSE;
11481           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11482           if (bfd_big_endian (info->output_bfd))
11483             r[0].r_offset += 2;
11484           r[0].r_addend = dest;
11485         }
11486       if (stub_entry->h != NULL
11487           && (stub_entry->h == htab->tls_get_addr_fd
11488               || stub_entry->h == htab->tls_get_addr)
11489           && htab->params->tls_get_addr_opt)
11490         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11491       else
11492         p = build_plt_stub (htab, stub_entry, loc, off, r);
11493       break;
11494
11495     case ppc_stub_save_res:
11496       return TRUE;
11497
11498     default:
11499       BFD_FAIL ();
11500       return FALSE;
11501     }
11502
11503   stub_entry->group->stub_sec->size += p - loc;
11504
11505   if (htab->params->emit_stub_syms)
11506     {
11507       struct elf_link_hash_entry *h;
11508       size_t len1, len2;
11509       char *name;
11510       const char *const stub_str[] = { "long_branch",
11511                                        "long_branch_r2off",
11512                                        "plt_branch",
11513                                        "plt_branch_r2off",
11514                                        "plt_call",
11515                                        "plt_call" };
11516
11517       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11518       len2 = strlen (stub_entry->root.string);
11519       name = bfd_malloc (len1 + len2 + 2);
11520       if (name == NULL)
11521         return FALSE;
11522       memcpy (name, stub_entry->root.string, 9);
11523       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11524       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11525       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11526       if (h == NULL)
11527         return FALSE;
11528       if (h->root.type == bfd_link_hash_new)
11529         {
11530           h->root.type = bfd_link_hash_defined;
11531           h->root.u.def.section = stub_entry->group->stub_sec;
11532           h->root.u.def.value = stub_entry->stub_offset;
11533           h->ref_regular = 1;
11534           h->def_regular = 1;
11535           h->ref_regular_nonweak = 1;
11536           h->forced_local = 1;
11537           h->non_elf = 0;
11538           h->root.linker_def = 1;
11539         }
11540     }
11541
11542   return TRUE;
11543 }
11544
11545 /* As above, but don't actually build the stub.  Just bump offset so
11546    we know stub section sizes, and select plt_branch stubs where
11547    long_branch stubs won't do.  */
11548
11549 static bfd_boolean
11550 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11551 {
11552   struct ppc_stub_hash_entry *stub_entry;
11553   struct bfd_link_info *info;
11554   struct ppc_link_hash_table *htab;
11555   bfd_vma off;
11556   int size;
11557
11558   /* Massage our args to the form they really have.  */
11559   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11560   info = in_arg;
11561
11562   htab = ppc_hash_table (info);
11563   if (htab == NULL)
11564     return FALSE;
11565
11566   if (stub_entry->h != NULL
11567       && stub_entry->h->save_res
11568       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11569       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11570     {
11571       /* Don't make stubs to out-of-line register save/restore
11572          functions.  Instead, emit copies of the functions.  */
11573       stub_entry->group->needs_save_res = 1;
11574       stub_entry->stub_type = ppc_stub_save_res;
11575       return TRUE;
11576     }
11577
11578   if (stub_entry->stub_type == ppc_stub_plt_call
11579       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11580     {
11581       asection *plt;
11582       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11583       if (off >= (bfd_vma) -2)
11584         abort ();
11585       plt = htab->elf.splt;
11586       if (!htab->elf.dynamic_sections_created
11587           || stub_entry->h == NULL
11588           || stub_entry->h->elf.dynindx == -1)
11589         {
11590           if (stub_entry->symtype == STT_GNU_IFUNC)
11591             plt = htab->elf.iplt;
11592           else
11593             plt = htab->pltlocal;
11594         }
11595       off += (plt->output_offset
11596               + plt->output_section->vma
11597               - elf_gp (info->output_bfd)
11598               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11599
11600       size = plt_stub_size (htab, stub_entry, off);
11601       if (stub_entry->h != NULL
11602           && (stub_entry->h == htab->tls_get_addr_fd
11603               || stub_entry->h == htab->tls_get_addr)
11604           && htab->params->tls_get_addr_opt
11605           && (ALWAYS_EMIT_R2SAVE
11606               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11607         stub_entry->group->tls_get_addr_opt_bctrl
11608           = stub_entry->group->stub_sec->size + size - 5 * 4;
11609
11610       if (htab->params->plt_stub_align)
11611         size += plt_stub_pad (htab, stub_entry, off);
11612       if (info->emitrelocations)
11613         {
11614           stub_entry->group->stub_sec->reloc_count
11615             += ((PPC_HA (off) != 0)
11616                 + (htab->opd_abi
11617                    ? 2 + (htab->params->plt_static_chain
11618                           && PPC_HA (off + 16) == PPC_HA (off))
11619                    : 1));
11620           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11621         }
11622     }
11623   else
11624     {
11625       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11626          variants.  */
11627       bfd_vma r2off = 0;
11628       bfd_vma local_off = 0;
11629
11630       off = (stub_entry->target_value
11631              + stub_entry->target_section->output_offset
11632              + stub_entry->target_section->output_section->vma);
11633       off -= (stub_entry->group->stub_sec->size
11634               + stub_entry->group->stub_sec->output_offset
11635               + stub_entry->group->stub_sec->output_section->vma);
11636
11637       /* Reset the stub type from the plt variant in case we now
11638          can reach with a shorter stub.  */
11639       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11640         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11641
11642       size = 4;
11643       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11644         {
11645           r2off = get_r2off (info, stub_entry);
11646           if (r2off == (bfd_vma) -1)
11647             {
11648               htab->stub_error = TRUE;
11649               return FALSE;
11650             }
11651           size = 8;
11652           if (PPC_HA (r2off) != 0)
11653             size += 4;
11654           if (PPC_LO (r2off) != 0)
11655             size += 4;
11656           off -= size - 4;
11657         }
11658
11659       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11660
11661       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11662          Do the same for -R objects without function descriptors.  */
11663       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11664           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11665               && r2off == 0
11666               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11667         {
11668           struct ppc_branch_hash_entry *br_entry;
11669
11670           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11671                                              stub_entry->root.string + 9,
11672                                              TRUE, FALSE);
11673           if (br_entry == NULL)
11674             {
11675               _bfd_error_handler (_("can't build branch stub `%s'"),
11676                                   stub_entry->root.string);
11677               htab->stub_error = TRUE;
11678               return FALSE;
11679             }
11680
11681           if (br_entry->iter != htab->stub_iteration)
11682             {
11683               br_entry->iter = htab->stub_iteration;
11684               br_entry->offset = htab->brlt->size;
11685               htab->brlt->size += 8;
11686
11687               if (htab->relbrlt != NULL)
11688                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11689               else if (info->emitrelocations)
11690                 {
11691                   htab->brlt->reloc_count += 1;
11692                   htab->brlt->flags |= SEC_RELOC;
11693                 }
11694             }
11695
11696           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11697           off = (br_entry->offset
11698                  + htab->brlt->output_offset
11699                  + htab->brlt->output_section->vma
11700                  - elf_gp (info->output_bfd)
11701                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11702
11703           if (info->emitrelocations)
11704             {
11705               stub_entry->group->stub_sec->reloc_count
11706                 += 1 + (PPC_HA (off) != 0);
11707               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11708             }
11709
11710           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11711             {
11712               size = 12;
11713               if (PPC_HA (off) != 0)
11714                 size = 16;
11715             }
11716           else
11717             {
11718               size = 16;
11719               if (PPC_HA (off) != 0)
11720                 size += 4;
11721
11722               if (PPC_HA (r2off) != 0)
11723                 size += 4;
11724               if (PPC_LO (r2off) != 0)
11725                 size += 4;
11726             }
11727         }
11728       else if (info->emitrelocations)
11729         {
11730           stub_entry->group->stub_sec->reloc_count += 1;
11731           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11732         }
11733     }
11734
11735   stub_entry->group->stub_sec->size += size;
11736   return TRUE;
11737 }
11738
11739 /* Set up various things so that we can make a list of input sections
11740    for each output section included in the link.  Returns -1 on error,
11741    0 when no stubs will be needed, and 1 on success.  */
11742
11743 int
11744 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11745 {
11746   unsigned int id;
11747   bfd_size_type amt;
11748   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11749
11750   if (htab == NULL)
11751     return -1;
11752
11753   htab->sec_info_arr_size = bfd_get_next_section_id ();
11754   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11755   htab->sec_info = bfd_zmalloc (amt);
11756   if (htab->sec_info == NULL)
11757     return -1;
11758
11759   /* Set toc_off for com, und, abs and ind sections.  */
11760   for (id = 0; id < 3; id++)
11761     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11762
11763   return 1;
11764 }
11765
11766 /* Set up for first pass at multitoc partitioning.  */
11767
11768 void
11769 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11770 {
11771   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11772
11773   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11774   htab->toc_bfd = NULL;
11775   htab->toc_first_sec = NULL;
11776 }
11777
11778 /* The linker repeatedly calls this function for each TOC input section
11779    and linker generated GOT section.  Group input bfds such that the toc
11780    within a group is less than 64k in size.  */
11781
11782 bfd_boolean
11783 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11784 {
11785   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11786   bfd_vma addr, off, limit;
11787
11788   if (htab == NULL)
11789     return FALSE;
11790
11791   if (!htab->second_toc_pass)
11792     {
11793       /* Keep track of the first .toc or .got section for this input bfd.  */
11794       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11795
11796       if (new_bfd)
11797         {
11798           htab->toc_bfd = isec->owner;
11799           htab->toc_first_sec = isec;
11800         }
11801
11802       addr = isec->output_offset + isec->output_section->vma;
11803       off = addr - htab->toc_curr;
11804       limit = 0x80008000;
11805       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11806         limit = 0x10000;
11807       if (off + isec->size > limit)
11808         {
11809           addr = (htab->toc_first_sec->output_offset
11810                   + htab->toc_first_sec->output_section->vma);
11811           htab->toc_curr = addr;
11812           htab->toc_curr &= -TOC_BASE_ALIGN;
11813         }
11814
11815       /* toc_curr is the base address of this toc group.  Set elf_gp
11816          for the input section to be the offset relative to the
11817          output toc base plus 0x8000.  Making the input elf_gp an
11818          offset allows us to move the toc as a whole without
11819          recalculating input elf_gp.  */
11820       off = htab->toc_curr - elf_gp (info->output_bfd);
11821       off += TOC_BASE_OFF;
11822
11823       /* Die if someone uses a linker script that doesn't keep input
11824          file .toc and .got together.  */
11825       if (new_bfd
11826           && elf_gp (isec->owner) != 0
11827           && elf_gp (isec->owner) != off)
11828         return FALSE;
11829
11830       elf_gp (isec->owner) = off;
11831       return TRUE;
11832     }
11833
11834   /* During the second pass toc_first_sec points to the start of
11835      a toc group, and toc_curr is used to track the old elf_gp.
11836      We use toc_bfd to ensure we only look at each bfd once.  */
11837   if (htab->toc_bfd == isec->owner)
11838     return TRUE;
11839   htab->toc_bfd = isec->owner;
11840
11841   if (htab->toc_first_sec == NULL
11842       || htab->toc_curr != elf_gp (isec->owner))
11843     {
11844       htab->toc_curr = elf_gp (isec->owner);
11845       htab->toc_first_sec = isec;
11846     }
11847   addr = (htab->toc_first_sec->output_offset
11848           + htab->toc_first_sec->output_section->vma);
11849   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11850   elf_gp (isec->owner) = off;
11851
11852   return TRUE;
11853 }
11854
11855 /* Called via elf_link_hash_traverse to merge GOT entries for global
11856    symbol H.  */
11857
11858 static bfd_boolean
11859 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11860 {
11861   if (h->root.type == bfd_link_hash_indirect)
11862     return TRUE;
11863
11864   merge_got_entries (&h->got.glist);
11865
11866   return TRUE;
11867 }
11868
11869 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11870    symbol H.  */
11871
11872 static bfd_boolean
11873 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11874 {
11875   struct got_entry *gent;
11876
11877   if (h->root.type == bfd_link_hash_indirect)
11878     return TRUE;
11879
11880   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11881     if (!gent->is_indirect)
11882       allocate_got (h, (struct bfd_link_info *) inf, gent);
11883   return TRUE;
11884 }
11885
11886 /* Called on the first multitoc pass after the last call to
11887    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11888    entries.  */
11889
11890 bfd_boolean
11891 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11892 {
11893   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11894   struct bfd *ibfd, *ibfd2;
11895   bfd_boolean done_something;
11896
11897   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11898
11899   if (!htab->do_multi_toc)
11900     return FALSE;
11901
11902   /* Merge global sym got entries within a toc group.  */
11903   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11904
11905   /* And tlsld_got.  */
11906   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11907     {
11908       struct got_entry *ent, *ent2;
11909
11910       if (!is_ppc64_elf (ibfd))
11911         continue;
11912
11913       ent = ppc64_tlsld_got (ibfd);
11914       if (!ent->is_indirect
11915           && ent->got.offset != (bfd_vma) -1)
11916         {
11917           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11918             {
11919               if (!is_ppc64_elf (ibfd2))
11920                 continue;
11921
11922               ent2 = ppc64_tlsld_got (ibfd2);
11923               if (!ent2->is_indirect
11924                   && ent2->got.offset != (bfd_vma) -1
11925                   && elf_gp (ibfd2) == elf_gp (ibfd))
11926                 {
11927                   ent2->is_indirect = TRUE;
11928                   ent2->got.ent = ent;
11929                 }
11930             }
11931         }
11932     }
11933
11934   /* Zap sizes of got sections.  */
11935   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11936   htab->elf.irelplt->size -= htab->got_reli_size;
11937   htab->got_reli_size = 0;
11938
11939   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11940     {
11941       asection *got, *relgot;
11942
11943       if (!is_ppc64_elf (ibfd))
11944         continue;
11945
11946       got = ppc64_elf_tdata (ibfd)->got;
11947       if (got != NULL)
11948         {
11949           got->rawsize = got->size;
11950           got->size = 0;
11951           relgot = ppc64_elf_tdata (ibfd)->relgot;
11952           relgot->rawsize = relgot->size;
11953           relgot->size = 0;
11954         }
11955     }
11956
11957   /* Now reallocate the got, local syms first.  We don't need to
11958      allocate section contents again since we never increase size.  */
11959   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11960     {
11961       struct got_entry **lgot_ents;
11962       struct got_entry **end_lgot_ents;
11963       struct plt_entry **local_plt;
11964       struct plt_entry **end_local_plt;
11965       unsigned char *lgot_masks;
11966       bfd_size_type locsymcount;
11967       Elf_Internal_Shdr *symtab_hdr;
11968       asection *s;
11969
11970       if (!is_ppc64_elf (ibfd))
11971         continue;
11972
11973       lgot_ents = elf_local_got_ents (ibfd);
11974       if (!lgot_ents)
11975         continue;
11976
11977       symtab_hdr = &elf_symtab_hdr (ibfd);
11978       locsymcount = symtab_hdr->sh_info;
11979       end_lgot_ents = lgot_ents + locsymcount;
11980       local_plt = (struct plt_entry **) end_lgot_ents;
11981       end_local_plt = local_plt + locsymcount;
11982       lgot_masks = (unsigned char *) end_local_plt;
11983       s = ppc64_elf_tdata (ibfd)->got;
11984       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11985         {
11986           struct got_entry *ent;
11987
11988           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11989             {
11990               unsigned int ent_size = 8;
11991               unsigned int rel_size = sizeof (Elf64_External_Rela);
11992
11993               ent->got.offset = s->size;
11994               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11995                 {
11996                   ent_size *= 2;
11997                   rel_size *= 2;
11998                 }
11999               s->size += ent_size;
12000               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12001                 {
12002                   htab->elf.irelplt->size += rel_size;
12003                   htab->got_reli_size += rel_size;
12004                 }
12005               else if (bfd_link_pic (info)
12006                        && !((ent->tls_type & TLS_TPREL) != 0
12007                             && bfd_link_executable (info)))
12008                 {
12009                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12010                   srel->size += rel_size;
12011                 }
12012             }
12013         }
12014     }
12015
12016   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12017
12018   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12019     {
12020       struct got_entry *ent;
12021
12022       if (!is_ppc64_elf (ibfd))
12023         continue;
12024
12025       ent = ppc64_tlsld_got (ibfd);
12026       if (!ent->is_indirect
12027           && ent->got.offset != (bfd_vma) -1)
12028         {
12029           asection *s = ppc64_elf_tdata (ibfd)->got;
12030           ent->got.offset = s->size;
12031           s->size += 16;
12032           if (bfd_link_pic (info))
12033             {
12034               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12035               srel->size += sizeof (Elf64_External_Rela);
12036             }
12037         }
12038     }
12039
12040   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12041   if (!done_something)
12042     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12043       {
12044         asection *got;
12045
12046         if (!is_ppc64_elf (ibfd))
12047           continue;
12048
12049         got = ppc64_elf_tdata (ibfd)->got;
12050         if (got != NULL)
12051           {
12052             done_something = got->rawsize != got->size;
12053             if (done_something)
12054               break;
12055           }
12056       }
12057
12058   if (done_something)
12059     (*htab->params->layout_sections_again) ();
12060
12061   /* Set up for second pass over toc sections to recalculate elf_gp
12062      on input sections.  */
12063   htab->toc_bfd = NULL;
12064   htab->toc_first_sec = NULL;
12065   htab->second_toc_pass = TRUE;
12066   return done_something;
12067 }
12068
12069 /* Called after second pass of multitoc partitioning.  */
12070
12071 void
12072 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12073 {
12074   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12075
12076   /* After the second pass, toc_curr tracks the TOC offset used
12077      for code sections below in ppc64_elf_next_input_section.  */
12078   htab->toc_curr = TOC_BASE_OFF;
12079 }
12080
12081 /* No toc references were found in ISEC.  If the code in ISEC makes no
12082    calls, then there's no need to use toc adjusting stubs when branching
12083    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12084    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12085    needed, and 2 if a cyclical call-graph was found but no other reason
12086    for a stub was detected.  If called from the top level, a return of
12087    2 means the same as a return of 0.  */
12088
12089 static int
12090 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12091 {
12092   int ret;
12093
12094   /* Mark this section as checked.  */
12095   isec->call_check_done = 1;
12096
12097   /* We know none of our code bearing sections will need toc stubs.  */
12098   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12099     return 0;
12100
12101   if (isec->size == 0)
12102     return 0;
12103
12104   if (isec->output_section == NULL)
12105     return 0;
12106
12107   ret = 0;
12108   if (isec->reloc_count != 0)
12109     {
12110       Elf_Internal_Rela *relstart, *rel;
12111       Elf_Internal_Sym *local_syms;
12112       struct ppc_link_hash_table *htab;
12113
12114       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12115                                             info->keep_memory);
12116       if (relstart == NULL)
12117         return -1;
12118
12119       /* Look for branches to outside of this section.  */
12120       local_syms = NULL;
12121       htab = ppc_hash_table (info);
12122       if (htab == NULL)
12123         return -1;
12124
12125       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12126         {
12127           enum elf_ppc64_reloc_type r_type;
12128           unsigned long r_symndx;
12129           struct elf_link_hash_entry *h;
12130           struct ppc_link_hash_entry *eh;
12131           Elf_Internal_Sym *sym;
12132           asection *sym_sec;
12133           struct _opd_sec_data *opd;
12134           bfd_vma sym_value;
12135           bfd_vma dest;
12136
12137           r_type = ELF64_R_TYPE (rel->r_info);
12138           if (r_type != R_PPC64_REL24
12139               && r_type != R_PPC64_REL14
12140               && r_type != R_PPC64_REL14_BRTAKEN
12141               && r_type != R_PPC64_REL14_BRNTAKEN
12142               && r_type != R_PPC64_PLTCALL)
12143             continue;
12144
12145           r_symndx = ELF64_R_SYM (rel->r_info);
12146           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12147                           isec->owner))
12148             {
12149               ret = -1;
12150               break;
12151             }
12152
12153           /* Calls to dynamic lib functions go through a plt call stub
12154              that uses r2.  */
12155           eh = (struct ppc_link_hash_entry *) h;
12156           if (eh != NULL
12157               && (eh->elf.plt.plist != NULL
12158                   || (eh->oh != NULL
12159                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12160             {
12161               ret = 1;
12162               break;
12163             }
12164
12165           if (sym_sec == NULL)
12166             /* Ignore other undefined symbols.  */
12167             continue;
12168
12169           /* Assume branches to other sections not included in the
12170              link need stubs too, to cover -R and absolute syms.  */
12171           if (sym_sec->output_section == NULL)
12172             {
12173               ret = 1;
12174               break;
12175             }
12176
12177           if (h == NULL)
12178             sym_value = sym->st_value;
12179           else
12180             {
12181               if (h->root.type != bfd_link_hash_defined
12182                   && h->root.type != bfd_link_hash_defweak)
12183                 abort ();
12184               sym_value = h->root.u.def.value;
12185             }
12186           sym_value += rel->r_addend;
12187
12188           /* If this branch reloc uses an opd sym, find the code section.  */
12189           opd = get_opd_info (sym_sec);
12190           if (opd != NULL)
12191             {
12192               if (h == NULL && opd->adjust != NULL)
12193                 {
12194                   long adjust;
12195
12196                   adjust = opd->adjust[OPD_NDX (sym_value)];
12197                   if (adjust == -1)
12198                     /* Assume deleted functions won't ever be called.  */
12199                     continue;
12200                   sym_value += adjust;
12201                 }
12202
12203               dest = opd_entry_value (sym_sec, sym_value,
12204                                       &sym_sec, NULL, FALSE);
12205               if (dest == (bfd_vma) -1)
12206                 continue;
12207             }
12208           else
12209             dest = (sym_value
12210                     + sym_sec->output_offset
12211                     + sym_sec->output_section->vma);
12212
12213           /* Ignore branch to self.  */
12214           if (sym_sec == isec)
12215             continue;
12216
12217           /* If the called function uses the toc, we need a stub.  */
12218           if (sym_sec->has_toc_reloc
12219               || sym_sec->makes_toc_func_call)
12220             {
12221               ret = 1;
12222               break;
12223             }
12224
12225           /* Assume any branch that needs a long branch stub might in fact
12226              need a plt_branch stub.  A plt_branch stub uses r2.  */
12227           else if (dest - (isec->output_offset
12228                            + isec->output_section->vma
12229                            + rel->r_offset) + (1 << 25)
12230                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12231                                                              ? h->other
12232                                                              : sym->st_other))
12233             {
12234               ret = 1;
12235               break;
12236             }
12237
12238           /* If calling back to a section in the process of being
12239              tested, we can't say for sure that no toc adjusting stubs
12240              are needed, so don't return zero.  */
12241           else if (sym_sec->call_check_in_progress)
12242             ret = 2;
12243
12244           /* Branches to another section that itself doesn't have any TOC
12245              references are OK.  Recursively call ourselves to check.  */
12246           else if (!sym_sec->call_check_done)
12247             {
12248               int recur;
12249
12250               /* Mark current section as indeterminate, so that other
12251                  sections that call back to current won't be marked as
12252                  known.  */
12253               isec->call_check_in_progress = 1;
12254               recur = toc_adjusting_stub_needed (info, sym_sec);
12255               isec->call_check_in_progress = 0;
12256
12257               if (recur != 0)
12258                 {
12259                   ret = recur;
12260                   if (recur != 2)
12261                     break;
12262                 }
12263             }
12264         }
12265
12266       if (local_syms != NULL
12267           && (elf_symtab_hdr (isec->owner).contents
12268               != (unsigned char *) local_syms))
12269         free (local_syms);
12270       if (elf_section_data (isec)->relocs != relstart)
12271         free (relstart);
12272     }
12273
12274   if ((ret & 1) == 0
12275       && isec->map_head.s != NULL
12276       && (strcmp (isec->output_section->name, ".init") == 0
12277           || strcmp (isec->output_section->name, ".fini") == 0))
12278     {
12279       if (isec->map_head.s->has_toc_reloc
12280           || isec->map_head.s->makes_toc_func_call)
12281         ret = 1;
12282       else if (!isec->map_head.s->call_check_done)
12283         {
12284           int recur;
12285           isec->call_check_in_progress = 1;
12286           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12287           isec->call_check_in_progress = 0;
12288           if (recur != 0)
12289             ret = recur;
12290         }
12291     }
12292
12293   if (ret == 1)
12294     isec->makes_toc_func_call = 1;
12295
12296   return ret;
12297 }
12298
12299 /* The linker repeatedly calls this function for each input section,
12300    in the order that input sections are linked into output sections.
12301    Build lists of input sections to determine groupings between which
12302    we may insert linker stubs.  */
12303
12304 bfd_boolean
12305 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12306 {
12307   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12308
12309   if (htab == NULL)
12310     return FALSE;
12311
12312   if ((isec->output_section->flags & SEC_CODE) != 0
12313       && isec->output_section->id < htab->sec_info_arr_size)
12314     {
12315       /* This happens to make the list in reverse order,
12316          which is what we want.  */
12317       htab->sec_info[isec->id].u.list
12318         = htab->sec_info[isec->output_section->id].u.list;
12319       htab->sec_info[isec->output_section->id].u.list = isec;
12320     }
12321
12322   if (htab->multi_toc_needed)
12323     {
12324       /* Analyse sections that aren't already flagged as needing a
12325          valid toc pointer.  Exclude .fixup for the linux kernel.
12326          .fixup contains branches, but only back to the function that
12327          hit an exception.  */
12328       if (!(isec->has_toc_reloc
12329             || (isec->flags & SEC_CODE) == 0
12330             || strcmp (isec->name, ".fixup") == 0
12331             || isec->call_check_done))
12332         {
12333           if (toc_adjusting_stub_needed (info, isec) < 0)
12334             return FALSE;
12335         }
12336       /* Make all sections use the TOC assigned for this object file.
12337          This will be wrong for pasted sections;  We fix that in
12338          check_pasted_section().  */
12339       if (elf_gp (isec->owner) != 0)
12340         htab->toc_curr = elf_gp (isec->owner);
12341     }
12342
12343   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12344   return TRUE;
12345 }
12346
12347 /* Check that all .init and .fini sections use the same toc, if they
12348    have toc relocs.  */
12349
12350 static bfd_boolean
12351 check_pasted_section (struct bfd_link_info *info, const char *name)
12352 {
12353   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12354
12355   if (o != NULL)
12356     {
12357       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12358       bfd_vma toc_off = 0;
12359       asection *i;
12360
12361       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12362         if (i->has_toc_reloc)
12363           {
12364             if (toc_off == 0)
12365               toc_off = htab->sec_info[i->id].toc_off;
12366             else if (toc_off != htab->sec_info[i->id].toc_off)
12367               return FALSE;
12368           }
12369
12370       if (toc_off == 0)
12371         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12372           if (i->makes_toc_func_call)
12373             {
12374               toc_off = htab->sec_info[i->id].toc_off;
12375               break;
12376             }
12377
12378       /* Make sure the whole pasted function uses the same toc offset.  */
12379       if (toc_off != 0)
12380         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12381           htab->sec_info[i->id].toc_off = toc_off;
12382     }
12383   return TRUE;
12384 }
12385
12386 bfd_boolean
12387 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12388 {
12389   return (check_pasted_section (info, ".init")
12390           & check_pasted_section (info, ".fini"));
12391 }
12392
12393 /* See whether we can group stub sections together.  Grouping stub
12394    sections may result in fewer stubs.  More importantly, we need to
12395    put all .init* and .fini* stubs at the beginning of the .init or
12396    .fini output sections respectively, because glibc splits the
12397    _init and _fini functions into multiple parts.  Putting a stub in
12398    the middle of a function is not a good idea.  */
12399
12400 static bfd_boolean
12401 group_sections (struct bfd_link_info *info,
12402                 bfd_size_type stub_group_size,
12403                 bfd_boolean stubs_always_before_branch)
12404 {
12405   struct ppc_link_hash_table *htab;
12406   asection *osec;
12407   bfd_boolean suppress_size_errors;
12408
12409   htab = ppc_hash_table (info);
12410   if (htab == NULL)
12411     return FALSE;
12412
12413   suppress_size_errors = FALSE;
12414   if (stub_group_size == 1)
12415     {
12416       /* Default values.  */
12417       if (stubs_always_before_branch)
12418         stub_group_size = 0x1e00000;
12419       else
12420         stub_group_size = 0x1c00000;
12421       suppress_size_errors = TRUE;
12422     }
12423
12424   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12425     {
12426       asection *tail;
12427
12428       if (osec->id >= htab->sec_info_arr_size)
12429         continue;
12430
12431       tail = htab->sec_info[osec->id].u.list;
12432       while (tail != NULL)
12433         {
12434           asection *curr;
12435           asection *prev;
12436           bfd_size_type total;
12437           bfd_boolean big_sec;
12438           bfd_vma curr_toc;
12439           struct map_stub *group;
12440           bfd_size_type group_size;
12441
12442           curr = tail;
12443           total = tail->size;
12444           group_size = (ppc64_elf_section_data (tail) != NULL
12445                         && ppc64_elf_section_data (tail)->has_14bit_branch
12446                         ? stub_group_size >> 10 : stub_group_size);
12447
12448           big_sec = total > group_size;
12449           if (big_sec && !suppress_size_errors)
12450             /* xgettext:c-format */
12451             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12452                                 tail->owner, tail);
12453           curr_toc = htab->sec_info[tail->id].toc_off;
12454
12455           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12456                  && ((total += curr->output_offset - prev->output_offset)
12457                      < (ppc64_elf_section_data (prev) != NULL
12458                         && ppc64_elf_section_data (prev)->has_14bit_branch
12459                         ? (group_size = stub_group_size >> 10) : group_size))
12460                  && htab->sec_info[prev->id].toc_off == curr_toc)
12461             curr = prev;
12462
12463           /* OK, the size from the start of CURR to the end is less
12464              than group_size and thus can be handled by one stub
12465              section.  (or the tail section is itself larger than
12466              group_size, in which case we may be toast.)  We should
12467              really be keeping track of the total size of stubs added
12468              here, as stubs contribute to the final output section
12469              size.  That's a little tricky, and this way will only
12470              break if stubs added make the total size more than 2^25,
12471              ie. for the default stub_group_size, if stubs total more
12472              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12473           group = bfd_alloc (curr->owner, sizeof (*group));
12474           if (group == NULL)
12475             return FALSE;
12476           group->link_sec = curr;
12477           group->stub_sec = NULL;
12478           group->needs_save_res = 0;
12479           group->tls_get_addr_opt_bctrl = -1u;
12480           group->next = htab->group;
12481           htab->group = group;
12482           do
12483             {
12484               prev = htab->sec_info[tail->id].u.list;
12485               /* Set up this stub group.  */
12486               htab->sec_info[tail->id].u.group = group;
12487             }
12488           while (tail != curr && (tail = prev) != NULL);
12489
12490           /* But wait, there's more!  Input sections up to group_size
12491              bytes before the stub section can be handled by it too.
12492              Don't do this if we have a really large section after the
12493              stubs, as adding more stubs increases the chance that
12494              branches may not reach into the stub section.  */
12495           if (!stubs_always_before_branch && !big_sec)
12496             {
12497               total = 0;
12498               while (prev != NULL
12499                      && ((total += tail->output_offset - prev->output_offset)
12500                          < (ppc64_elf_section_data (prev) != NULL
12501                             && ppc64_elf_section_data (prev)->has_14bit_branch
12502                             ? (group_size = stub_group_size >> 10) : group_size))
12503                      && htab->sec_info[prev->id].toc_off == curr_toc)
12504                 {
12505                   tail = prev;
12506                   prev = htab->sec_info[tail->id].u.list;
12507                   htab->sec_info[tail->id].u.group = group;
12508                 }
12509             }
12510           tail = prev;
12511         }
12512     }
12513   return TRUE;
12514 }
12515
12516 static const unsigned char glink_eh_frame_cie[] =
12517 {
12518   0, 0, 0, 16,                          /* length.  */
12519   0, 0, 0, 0,                           /* id.  */
12520   1,                                    /* CIE version.  */
12521   'z', 'R', 0,                          /* Augmentation string.  */
12522   4,                                    /* Code alignment.  */
12523   0x78,                                 /* Data alignment.  */
12524   65,                                   /* RA reg.  */
12525   1,                                    /* Augmentation size.  */
12526   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12527   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12528 };
12529
12530 static size_t
12531 stub_eh_frame_size (struct map_stub *group, size_t align)
12532 {
12533   size_t this_size = 17;
12534   if (group->tls_get_addr_opt_bctrl != -1u)
12535     {
12536       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12537       if (to_bctrl < 64)
12538         this_size += 1;
12539       else if (to_bctrl < 256)
12540         this_size += 2;
12541       else if (to_bctrl < 65536)
12542         this_size += 3;
12543       else
12544         this_size += 5;
12545       this_size += 6;
12546     }
12547   this_size = (this_size + align - 1) & -align;
12548   return this_size;
12549 }
12550
12551 /* Stripping output sections is normally done before dynamic section
12552    symbols have been allocated.  This function is called later, and
12553    handles cases like htab->brlt which is mapped to its own output
12554    section.  */
12555
12556 static void
12557 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12558 {
12559   if (isec->size == 0
12560       && isec->output_section->size == 0
12561       && !(isec->output_section->flags & SEC_KEEP)
12562       && !bfd_section_removed_from_list (info->output_bfd,
12563                                          isec->output_section)
12564       && elf_section_data (isec->output_section)->dynindx == 0)
12565     {
12566       isec->output_section->flags |= SEC_EXCLUDE;
12567       bfd_section_list_remove (info->output_bfd, isec->output_section);
12568       info->output_bfd->section_count--;
12569     }
12570 }
12571
12572 /* Determine and set the size of the stub section for a final link.
12573
12574    The basic idea here is to examine all the relocations looking for
12575    PC-relative calls to a target that is unreachable with a "bl"
12576    instruction.  */
12577
12578 bfd_boolean
12579 ppc64_elf_size_stubs (struct bfd_link_info *info)
12580 {
12581   bfd_size_type stub_group_size;
12582   bfd_boolean stubs_always_before_branch;
12583   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12584
12585   if (htab == NULL)
12586     return FALSE;
12587
12588   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12589     htab->params->plt_thread_safe = 1;
12590   if (!htab->opd_abi)
12591     htab->params->plt_thread_safe = 0;
12592   else if (htab->params->plt_thread_safe == -1)
12593     {
12594       static const char *const thread_starter[] =
12595         {
12596           "pthread_create",
12597           /* libstdc++ */
12598           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12599           /* librt */
12600           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12601           "mq_notify", "create_timer",
12602           /* libanl */
12603           "getaddrinfo_a",
12604           /* libgomp */
12605           "GOMP_parallel",
12606           "GOMP_parallel_start",
12607           "GOMP_parallel_loop_static",
12608           "GOMP_parallel_loop_static_start",
12609           "GOMP_parallel_loop_dynamic",
12610           "GOMP_parallel_loop_dynamic_start",
12611           "GOMP_parallel_loop_guided",
12612           "GOMP_parallel_loop_guided_start",
12613           "GOMP_parallel_loop_runtime",
12614           "GOMP_parallel_loop_runtime_start",
12615           "GOMP_parallel_sections",
12616           "GOMP_parallel_sections_start",
12617           /* libgo */
12618           "__go_go",
12619         };
12620       unsigned i;
12621
12622       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12623         {
12624           struct elf_link_hash_entry *h;
12625           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12626                                     FALSE, FALSE, TRUE);
12627           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12628           if (htab->params->plt_thread_safe)
12629             break;
12630         }
12631     }
12632   stubs_always_before_branch = htab->params->group_size < 0;
12633   if (htab->params->group_size < 0)
12634     stub_group_size = -htab->params->group_size;
12635   else
12636     stub_group_size = htab->params->group_size;
12637
12638   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12639     return FALSE;
12640
12641 #define STUB_SHRINK_ITER 20
12642   /* Loop until no stubs added.  After iteration 20 of this loop we may
12643      exit on a stub section shrinking.  This is to break out of a
12644      pathological case where adding stubs on one iteration decreases
12645      section gaps (perhaps due to alignment), which then requires
12646      fewer or smaller stubs on the next iteration.  */
12647
12648   while (1)
12649     {
12650       bfd *input_bfd;
12651       unsigned int bfd_indx;
12652       struct map_stub *group;
12653
12654       htab->stub_iteration += 1;
12655
12656       for (input_bfd = info->input_bfds, bfd_indx = 0;
12657            input_bfd != NULL;
12658            input_bfd = input_bfd->link.next, bfd_indx++)
12659         {
12660           Elf_Internal_Shdr *symtab_hdr;
12661           asection *section;
12662           Elf_Internal_Sym *local_syms = NULL;
12663
12664           if (!is_ppc64_elf (input_bfd))
12665             continue;
12666
12667           /* We'll need the symbol table in a second.  */
12668           symtab_hdr = &elf_symtab_hdr (input_bfd);
12669           if (symtab_hdr->sh_info == 0)
12670             continue;
12671
12672           /* Walk over each section attached to the input bfd.  */
12673           for (section = input_bfd->sections;
12674                section != NULL;
12675                section = section->next)
12676             {
12677               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12678
12679               /* If there aren't any relocs, then there's nothing more
12680                  to do.  */
12681               if ((section->flags & SEC_RELOC) == 0
12682                   || (section->flags & SEC_ALLOC) == 0
12683                   || (section->flags & SEC_LOAD) == 0
12684                   || (section->flags & SEC_CODE) == 0
12685                   || section->reloc_count == 0)
12686                 continue;
12687
12688               /* If this section is a link-once section that will be
12689                  discarded, then don't create any stubs.  */
12690               if (section->output_section == NULL
12691                   || section->output_section->owner != info->output_bfd)
12692                 continue;
12693
12694               /* Get the relocs.  */
12695               internal_relocs
12696                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12697                                              info->keep_memory);
12698               if (internal_relocs == NULL)
12699                 goto error_ret_free_local;
12700
12701               /* Now examine each relocation.  */
12702               irela = internal_relocs;
12703               irelaend = irela + section->reloc_count;
12704               for (; irela < irelaend; irela++)
12705                 {
12706                   enum elf_ppc64_reloc_type r_type;
12707                   unsigned int r_indx;
12708                   enum ppc_stub_type stub_type;
12709                   struct ppc_stub_hash_entry *stub_entry;
12710                   asection *sym_sec, *code_sec;
12711                   bfd_vma sym_value, code_value;
12712                   bfd_vma destination;
12713                   unsigned long local_off;
12714                   bfd_boolean ok_dest;
12715                   struct ppc_link_hash_entry *hash;
12716                   struct ppc_link_hash_entry *fdh;
12717                   struct elf_link_hash_entry *h;
12718                   Elf_Internal_Sym *sym;
12719                   char *stub_name;
12720                   const asection *id_sec;
12721                   struct _opd_sec_data *opd;
12722                   struct plt_entry *plt_ent;
12723
12724                   r_type = ELF64_R_TYPE (irela->r_info);
12725                   r_indx = ELF64_R_SYM (irela->r_info);
12726
12727                   if (r_type >= R_PPC64_max)
12728                     {
12729                       bfd_set_error (bfd_error_bad_value);
12730                       goto error_ret_free_internal;
12731                     }
12732
12733                   /* Only look for stubs on branch instructions.  */
12734                   if (r_type != R_PPC64_REL24
12735                       && r_type != R_PPC64_REL14
12736                       && r_type != R_PPC64_REL14_BRTAKEN
12737                       && r_type != R_PPC64_REL14_BRNTAKEN)
12738                     continue;
12739
12740                   /* Now determine the call target, its name, value,
12741                      section.  */
12742                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12743                                   r_indx, input_bfd))
12744                     goto error_ret_free_internal;
12745                   hash = (struct ppc_link_hash_entry *) h;
12746
12747                   ok_dest = FALSE;
12748                   fdh = NULL;
12749                   sym_value = 0;
12750                   if (hash == NULL)
12751                     {
12752                       sym_value = sym->st_value;
12753                       if (sym_sec != NULL
12754                           && sym_sec->output_section != NULL)
12755                         ok_dest = TRUE;
12756                     }
12757                   else if (hash->elf.root.type == bfd_link_hash_defined
12758                            || hash->elf.root.type == bfd_link_hash_defweak)
12759                     {
12760                       sym_value = hash->elf.root.u.def.value;
12761                       if (sym_sec->output_section != NULL)
12762                         ok_dest = TRUE;
12763                     }
12764                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12765                            || hash->elf.root.type == bfd_link_hash_undefined)
12766                     {
12767                       /* Recognise an old ABI func code entry sym, and
12768                          use the func descriptor sym instead if it is
12769                          defined.  */
12770                       if (hash->elf.root.root.string[0] == '.'
12771                           && hash->oh != NULL)
12772                         {
12773                           fdh = ppc_follow_link (hash->oh);
12774                           if (fdh->elf.root.type == bfd_link_hash_defined
12775                               || fdh->elf.root.type == bfd_link_hash_defweak)
12776                             {
12777                               sym_sec = fdh->elf.root.u.def.section;
12778                               sym_value = fdh->elf.root.u.def.value;
12779                               if (sym_sec->output_section != NULL)
12780                                 ok_dest = TRUE;
12781                             }
12782                           else
12783                             fdh = NULL;
12784                         }
12785                     }
12786                   else
12787                     {
12788                       bfd_set_error (bfd_error_bad_value);
12789                       goto error_ret_free_internal;
12790                     }
12791
12792                   destination = 0;
12793                   local_off = 0;
12794                   if (ok_dest)
12795                     {
12796                       sym_value += irela->r_addend;
12797                       destination = (sym_value
12798                                      + sym_sec->output_offset
12799                                      + sym_sec->output_section->vma);
12800                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12801                                                             ? hash->elf.other
12802                                                             : sym->st_other);
12803                     }
12804
12805                   code_sec = sym_sec;
12806                   code_value = sym_value;
12807                   opd = get_opd_info (sym_sec);
12808                   if (opd != NULL)
12809                     {
12810                       bfd_vma dest;
12811
12812                       if (hash == NULL && opd->adjust != NULL)
12813                         {
12814                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12815                           if (adjust == -1)
12816                             continue;
12817                           code_value += adjust;
12818                           sym_value += adjust;
12819                         }
12820                       dest = opd_entry_value (sym_sec, sym_value,
12821                                               &code_sec, &code_value, FALSE);
12822                       if (dest != (bfd_vma) -1)
12823                         {
12824                           destination = dest;
12825                           if (fdh != NULL)
12826                             {
12827                               /* Fixup old ABI sym to point at code
12828                                  entry.  */
12829                               hash->elf.root.type = bfd_link_hash_defweak;
12830                               hash->elf.root.u.def.section = code_sec;
12831                               hash->elf.root.u.def.value = code_value;
12832                             }
12833                         }
12834                     }
12835
12836                   /* Determine what (if any) linker stub is needed.  */
12837                   plt_ent = NULL;
12838                   stub_type = ppc_type_of_stub (section, irela, &hash,
12839                                                 &plt_ent, destination,
12840                                                 local_off);
12841
12842                   if (stub_type != ppc_stub_plt_call)
12843                     {
12844                       /* Check whether we need a TOC adjusting stub.
12845                          Since the linker pastes together pieces from
12846                          different object files when creating the
12847                          _init and _fini functions, it may be that a
12848                          call to what looks like a local sym is in
12849                          fact a call needing a TOC adjustment.  */
12850                       if (code_sec != NULL
12851                           && code_sec->output_section != NULL
12852                           && (htab->sec_info[code_sec->id].toc_off
12853                               != htab->sec_info[section->id].toc_off)
12854                           && (code_sec->has_toc_reloc
12855                               || code_sec->makes_toc_func_call))
12856                         stub_type = ppc_stub_long_branch_r2off;
12857                     }
12858
12859                   if (stub_type == ppc_stub_none)
12860                     continue;
12861
12862                   /* __tls_get_addr calls might be eliminated.  */
12863                   if (stub_type != ppc_stub_plt_call
12864                       && hash != NULL
12865                       && (hash == htab->tls_get_addr
12866                           || hash == htab->tls_get_addr_fd)
12867                       && section->has_tls_reloc
12868                       && irela != internal_relocs)
12869                     {
12870                       /* Get tls info.  */
12871                       unsigned char *tls_mask;
12872
12873                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12874                                          irela - 1, input_bfd))
12875                         goto error_ret_free_internal;
12876                       if ((*tls_mask & TLS_TLS) != 0)
12877                         continue;
12878                     }
12879
12880                   if (stub_type == ppc_stub_plt_call)
12881                     {
12882                       if (!htab->opd_abi
12883                           && htab->params->plt_localentry0 != 0
12884                           && is_elfv2_localentry0 (&hash->elf))
12885                         htab->has_plt_localentry0 = 1;
12886                       else if (irela + 1 < irelaend
12887                                && irela[1].r_offset == irela->r_offset + 4
12888                                && (ELF64_R_TYPE (irela[1].r_info)
12889                                    == R_PPC64_TOCSAVE))
12890                         {
12891                           if (!tocsave_find (htab, INSERT,
12892                                              &local_syms, irela + 1, input_bfd))
12893                             goto error_ret_free_internal;
12894                         }
12895                       else
12896                         stub_type = ppc_stub_plt_call_r2save;
12897                     }
12898
12899                   /* Support for grouping stub sections.  */
12900                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12901
12902                   /* Get the name of this stub.  */
12903                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12904                   if (!stub_name)
12905                     goto error_ret_free_internal;
12906
12907                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12908                                                      stub_name, FALSE, FALSE);
12909                   if (stub_entry != NULL)
12910                     {
12911                       /* The proper stub has already been created.  */
12912                       free (stub_name);
12913                       if (stub_type == ppc_stub_plt_call_r2save)
12914                         stub_entry->stub_type = stub_type;
12915                       continue;
12916                     }
12917
12918                   stub_entry = ppc_add_stub (stub_name, section, info);
12919                   if (stub_entry == NULL)
12920                     {
12921                       free (stub_name);
12922                     error_ret_free_internal:
12923                       if (elf_section_data (section)->relocs == NULL)
12924                         free (internal_relocs);
12925                     error_ret_free_local:
12926                       if (local_syms != NULL
12927                           && (symtab_hdr->contents
12928                               != (unsigned char *) local_syms))
12929                         free (local_syms);
12930                       return FALSE;
12931                     }
12932
12933                   stub_entry->stub_type = stub_type;
12934                   if (stub_type != ppc_stub_plt_call
12935                       && stub_type != ppc_stub_plt_call_r2save)
12936                     {
12937                       stub_entry->target_value = code_value;
12938                       stub_entry->target_section = code_sec;
12939                     }
12940                   else
12941                     {
12942                       stub_entry->target_value = sym_value;
12943                       stub_entry->target_section = sym_sec;
12944                     }
12945                   stub_entry->h = hash;
12946                   stub_entry->plt_ent = plt_ent;
12947                   stub_entry->symtype
12948                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12949                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12950
12951                   if (stub_entry->h != NULL)
12952                     htab->stub_globals += 1;
12953                 }
12954
12955               /* We're done with the internal relocs, free them.  */
12956               if (elf_section_data (section)->relocs != internal_relocs)
12957                 free (internal_relocs);
12958             }
12959
12960           if (local_syms != NULL
12961               && symtab_hdr->contents != (unsigned char *) local_syms)
12962             {
12963               if (!info->keep_memory)
12964                 free (local_syms);
12965               else
12966                 symtab_hdr->contents = (unsigned char *) local_syms;
12967             }
12968         }
12969
12970       /* We may have added some stubs.  Find out the new size of the
12971          stub sections.  */
12972       for (group = htab->group; group != NULL; group = group->next)
12973         if (group->stub_sec != NULL)
12974           {
12975             asection *stub_sec = group->stub_sec;
12976
12977             if (htab->stub_iteration <= STUB_SHRINK_ITER
12978                 || stub_sec->rawsize < stub_sec->size)
12979               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12980               stub_sec->rawsize = stub_sec->size;
12981             stub_sec->size = 0;
12982             stub_sec->reloc_count = 0;
12983             stub_sec->flags &= ~SEC_RELOC;
12984           }
12985
12986       if (htab->stub_iteration <= STUB_SHRINK_ITER
12987           || htab->brlt->rawsize < htab->brlt->size)
12988         htab->brlt->rawsize = htab->brlt->size;
12989       htab->brlt->size = 0;
12990       htab->brlt->reloc_count = 0;
12991       htab->brlt->flags &= ~SEC_RELOC;
12992       if (htab->relbrlt != NULL)
12993         htab->relbrlt->size = 0;
12994
12995       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12996
12997       for (group = htab->group; group != NULL; group = group->next)
12998         if (group->needs_save_res)
12999           group->stub_sec->size += htab->sfpr->size;
13000
13001       if (info->emitrelocations
13002           && htab->glink != NULL && htab->glink->size != 0)
13003         {
13004           htab->glink->reloc_count = 1;
13005           htab->glink->flags |= SEC_RELOC;
13006         }
13007
13008       if (htab->glink_eh_frame != NULL
13009           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13010           && htab->glink_eh_frame->output_section->size > 8)
13011         {
13012           size_t size = 0, align = 4;
13013
13014           for (group = htab->group; group != NULL; group = group->next)
13015             if (group->stub_sec != NULL)
13016               size += stub_eh_frame_size (group, align);
13017           if (htab->glink != NULL && htab->glink->size != 0)
13018             size += (24 + align - 1) & -align;
13019           if (size != 0)
13020             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13021           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13022           size = (size + align - 1) & -align;
13023           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13024           htab->glink_eh_frame->size = size;
13025         }
13026
13027       if (htab->params->plt_stub_align != 0)
13028         for (group = htab->group; group != NULL; group = group->next)
13029           if (group->stub_sec != NULL)
13030             {
13031               int align = abs (htab->params->plt_stub_align);
13032               group->stub_sec->size
13033                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13034             }
13035
13036       for (group = htab->group; group != NULL; group = group->next)
13037         if (group->stub_sec != NULL
13038             && group->stub_sec->rawsize != group->stub_sec->size
13039             && (htab->stub_iteration <= STUB_SHRINK_ITER
13040                 || group->stub_sec->rawsize < group->stub_sec->size))
13041           break;
13042
13043       if (group == NULL
13044           && (htab->brlt->rawsize == htab->brlt->size
13045               || (htab->stub_iteration > STUB_SHRINK_ITER
13046                   && htab->brlt->rawsize > htab->brlt->size))
13047           && (htab->glink_eh_frame == NULL
13048               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13049         break;
13050
13051       /* Ask the linker to do its stuff.  */
13052       (*htab->params->layout_sections_again) ();
13053     }
13054
13055   if (htab->glink_eh_frame != NULL
13056       && htab->glink_eh_frame->size != 0)
13057     {
13058       bfd_vma val;
13059       bfd_byte *p, *last_fde;
13060       size_t last_fde_len, size, align, pad;
13061       struct map_stub *group;
13062
13063       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13064       if (p == NULL)
13065         return FALSE;
13066       htab->glink_eh_frame->contents = p;
13067       last_fde = p;
13068       align = 4;
13069
13070       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13071       /* CIE length (rewrite in case little-endian).  */
13072       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13073       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13074       p += last_fde_len + 4;
13075
13076       for (group = htab->group; group != NULL; group = group->next)
13077         if (group->stub_sec != NULL)
13078           {
13079             last_fde = p;
13080             last_fde_len = stub_eh_frame_size (group, align) - 4;
13081             /* FDE length.  */
13082             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13083             p += 4;
13084             /* CIE pointer.  */
13085             val = p - htab->glink_eh_frame->contents;
13086             bfd_put_32 (htab->elf.dynobj, val, p);
13087             p += 4;
13088             /* Offset to stub section, written later.  */
13089             p += 4;
13090             /* stub section size.  */
13091             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13092             p += 4;
13093             /* Augmentation.  */
13094             p += 1;
13095             if (group->tls_get_addr_opt_bctrl != -1u)
13096               {
13097                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13098
13099                 /* This FDE needs more than just the default.
13100                    Describe __tls_get_addr_opt stub LR.  */
13101                 if (to_bctrl < 64)
13102                   *p++ = DW_CFA_advance_loc + to_bctrl;
13103                 else if (to_bctrl < 256)
13104                   {
13105                     *p++ = DW_CFA_advance_loc1;
13106                     *p++ = to_bctrl;
13107                   }
13108                 else if (to_bctrl < 65536)
13109                   {
13110                     *p++ = DW_CFA_advance_loc2;
13111                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13112                     p += 2;
13113                   }
13114                 else
13115                   {
13116                     *p++ = DW_CFA_advance_loc4;
13117                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13118                     p += 4;
13119                   }
13120                 *p++ = DW_CFA_offset_extended_sf;
13121                 *p++ = 65;
13122                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13123                 *p++ = DW_CFA_advance_loc + 4;
13124                 *p++ = DW_CFA_restore_extended;
13125                 *p++ = 65;
13126               }
13127             /* Pad.  */
13128             p = last_fde + last_fde_len + 4;
13129           }
13130       if (htab->glink != NULL && htab->glink->size != 0)
13131         {
13132           last_fde = p;
13133           last_fde_len = ((24 + align - 1) & -align) - 4;
13134           /* FDE length.  */
13135           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13136           p += 4;
13137           /* CIE pointer.  */
13138           val = p - htab->glink_eh_frame->contents;
13139           bfd_put_32 (htab->elf.dynobj, val, p);
13140           p += 4;
13141           /* Offset to .glink, written later.  */
13142           p += 4;
13143           /* .glink size.  */
13144           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13145           p += 4;
13146           /* Augmentation.  */
13147           p += 1;
13148
13149           *p++ = DW_CFA_advance_loc + 1;
13150           *p++ = DW_CFA_register;
13151           *p++ = 65;
13152           *p++ = htab->opd_abi ? 12 : 0;
13153           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13154           *p++ = DW_CFA_restore_extended;
13155           *p++ = 65;
13156           p += ((24 + align - 1) & -align) - 24;
13157         }
13158       /* Subsume any padding into the last FDE if user .eh_frame
13159          sections are aligned more than glink_eh_frame.  Otherwise any
13160          zero padding will be seen as a terminator.  */
13161       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13162       size = p - htab->glink_eh_frame->contents;
13163       pad = ((size + align - 1) & -align) - size;
13164       htab->glink_eh_frame->size = size + pad;
13165       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13166     }
13167
13168   maybe_strip_output (info, htab->brlt);
13169   if (htab->glink_eh_frame != NULL)
13170     maybe_strip_output (info, htab->glink_eh_frame);
13171
13172   return TRUE;
13173 }
13174
13175 /* Called after we have determined section placement.  If sections
13176    move, we'll be called again.  Provide a value for TOCstart.  */
13177
13178 bfd_vma
13179 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13180 {
13181   asection *s;
13182   bfd_vma TOCstart, adjust;
13183
13184   if (info != NULL)
13185     {
13186       struct elf_link_hash_entry *h;
13187       struct elf_link_hash_table *htab = elf_hash_table (info);
13188
13189       if (is_elf_hash_table (htab)
13190           && htab->hgot != NULL)
13191         h = htab->hgot;
13192       else
13193         {
13194           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13195           if (is_elf_hash_table (htab))
13196             htab->hgot = h;
13197         }
13198       if (h != NULL
13199           && h->root.type == bfd_link_hash_defined
13200           && !h->root.linker_def
13201           && (!is_elf_hash_table (htab)
13202               || h->def_regular))
13203         {
13204           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13205                       + h->root.u.def.section->output_offset
13206                       + h->root.u.def.section->output_section->vma);
13207           _bfd_set_gp_value (obfd, TOCstart);
13208           return TOCstart;
13209         }
13210     }
13211
13212   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13213      order.  The TOC starts where the first of these sections starts.  */
13214   s = bfd_get_section_by_name (obfd, ".got");
13215   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13216     s = bfd_get_section_by_name (obfd, ".toc");
13217   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13218     s = bfd_get_section_by_name (obfd, ".tocbss");
13219   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13220     s = bfd_get_section_by_name (obfd, ".plt");
13221   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13222     {
13223       /* This may happen for
13224          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13225          .toc directive
13226          o  bad linker script
13227          o --gc-sections and empty TOC sections
13228
13229          FIXME: Warn user?  */
13230
13231       /* Look for a likely section.  We probably won't even be
13232          using TOCstart.  */
13233       for (s = obfd->sections; s != NULL; s = s->next)
13234         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13235                          | SEC_EXCLUDE))
13236             == (SEC_ALLOC | SEC_SMALL_DATA))
13237           break;
13238       if (s == NULL)
13239         for (s = obfd->sections; s != NULL; s = s->next)
13240           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13241               == (SEC_ALLOC | SEC_SMALL_DATA))
13242             break;
13243       if (s == NULL)
13244         for (s = obfd->sections; s != NULL; s = s->next)
13245           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13246               == SEC_ALLOC)
13247             break;
13248       if (s == NULL)
13249         for (s = obfd->sections; s != NULL; s = s->next)
13250           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13251             break;
13252     }
13253
13254   TOCstart = 0;
13255   if (s != NULL)
13256     TOCstart = s->output_section->vma + s->output_offset;
13257
13258   /* Force alignment.  */
13259   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13260   TOCstart -= adjust;
13261   _bfd_set_gp_value (obfd, TOCstart);
13262
13263   if (info != NULL && s != NULL)
13264     {
13265       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13266
13267       if (htab != NULL)
13268         {
13269           if (htab->elf.hgot != NULL)
13270             {
13271               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13272               htab->elf.hgot->root.u.def.section = s;
13273             }
13274         }
13275       else
13276         {
13277           struct bfd_link_hash_entry *bh = NULL;
13278           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13279                                             s, TOC_BASE_OFF - adjust,
13280                                             NULL, FALSE, FALSE, &bh);
13281         }
13282     }
13283   return TOCstart;
13284 }
13285
13286 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13287    write out any global entry stubs, and PLT relocations.  */
13288
13289 static bfd_boolean
13290 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13291 {
13292   struct bfd_link_info *info;
13293   struct ppc_link_hash_table *htab;
13294   struct plt_entry *ent;
13295   asection *s;
13296
13297   if (h->root.type == bfd_link_hash_indirect)
13298     return TRUE;
13299
13300   info = inf;
13301   htab = ppc_hash_table (info);
13302   if (htab == NULL)
13303     return FALSE;
13304
13305   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13306     if (ent->plt.offset != (bfd_vma) -1)
13307       {
13308         /* This symbol has an entry in the procedure linkage
13309            table.  Set it up.  */
13310         Elf_Internal_Rela rela;
13311         asection *plt, *relplt;
13312         bfd_byte *loc;
13313
13314         if (!htab->elf.dynamic_sections_created
13315             || h->dynindx == -1)
13316           {
13317             if (!(h->def_regular
13318                   && (h->root.type == bfd_link_hash_defined
13319                       || h->root.type == bfd_link_hash_defweak)))
13320               continue;
13321             if (h->type == STT_GNU_IFUNC)
13322               {
13323                 plt = htab->elf.iplt;
13324                 relplt = htab->elf.irelplt;
13325                 htab->local_ifunc_resolver = 1;
13326                 if (htab->opd_abi)
13327                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13328                 else
13329                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13330               }
13331             else
13332               {
13333                 plt = htab->pltlocal;
13334                 if (bfd_link_pic (info))
13335                   {
13336                     relplt = htab->relpltlocal;
13337                     if (htab->opd_abi)
13338                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13339                     else
13340                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13341                   }
13342                 else
13343                   relplt = NULL;
13344               }
13345             rela.r_addend = (h->root.u.def.value
13346                              + h->root.u.def.section->output_offset
13347                              + h->root.u.def.section->output_section->vma
13348                              + ent->addend);
13349
13350             if (relplt == NULL)
13351               {
13352                 loc = plt->contents + ent->plt.offset;
13353                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13354                 if (htab->opd_abi)
13355                   {
13356                     bfd_vma toc = elf_gp (info->output_bfd);
13357                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13358                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13359                   }
13360               }
13361             else
13362               {
13363                 rela.r_offset = (plt->output_section->vma
13364                                  + plt->output_offset
13365                                  + ent->plt.offset);
13366                 loc = relplt->contents + (relplt->reloc_count++
13367                                           * sizeof (Elf64_External_Rela));
13368                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13369               }
13370           }
13371         else
13372           {
13373             rela.r_offset = (htab->elf.splt->output_section->vma
13374                              + htab->elf.splt->output_offset
13375                              + ent->plt.offset);
13376             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13377             rela.r_addend = ent->addend;
13378             loc = (htab->elf.srelplt->contents
13379                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13380                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13381             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13382               htab->maybe_local_ifunc_resolver = 1;
13383             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13384           }
13385       }
13386
13387   if (!h->pointer_equality_needed)
13388     return TRUE;
13389
13390   if (h->def_regular)
13391     return TRUE;
13392
13393   s = htab->global_entry;
13394   if (s == NULL || s->size == 0)
13395     return TRUE;
13396
13397   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13398     if (ent->plt.offset != (bfd_vma) -1
13399         && ent->addend == 0)
13400       {
13401         bfd_byte *p;
13402         asection *plt;
13403         bfd_vma off;
13404
13405         p = s->contents + h->root.u.def.value;
13406         plt = htab->elf.splt;
13407         if (!htab->elf.dynamic_sections_created
13408             || h->dynindx == -1)
13409           {
13410             if (h->type == STT_GNU_IFUNC)
13411               plt = htab->elf.iplt;
13412             else
13413               plt = htab->pltlocal;
13414           }
13415         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13416         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13417
13418         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13419           {
13420             info->callbacks->einfo
13421               (_("%P: linkage table error against `%pT'\n"),
13422                h->root.root.string);
13423             bfd_set_error (bfd_error_bad_value);
13424             htab->stub_error = TRUE;
13425           }
13426
13427         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13428         if (htab->params->emit_stub_syms)
13429           {
13430             size_t len = strlen (h->root.root.string);
13431             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13432
13433             if (name == NULL)
13434               return FALSE;
13435
13436             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13437             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13438             if (h == NULL)
13439               return FALSE;
13440             if (h->root.type == bfd_link_hash_new)
13441               {
13442                 h->root.type = bfd_link_hash_defined;
13443                 h->root.u.def.section = s;
13444                 h->root.u.def.value = p - s->contents;
13445                 h->ref_regular = 1;
13446                 h->def_regular = 1;
13447                 h->ref_regular_nonweak = 1;
13448                 h->forced_local = 1;
13449                 h->non_elf = 0;
13450                 h->root.linker_def = 1;
13451               }
13452           }
13453
13454         if (PPC_HA (off) != 0)
13455           {
13456             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13457             p += 4;
13458           }
13459         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13460         p += 4;
13461         bfd_put_32 (s->owner, MTCTR_R12, p);
13462         p += 4;
13463         bfd_put_32 (s->owner, BCTR, p);
13464         break;
13465       }
13466   return TRUE;
13467 }
13468
13469 /* Write PLT relocs for locals.  */
13470
13471 static bfd_boolean
13472 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13473 {
13474   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13475   bfd *ibfd;
13476
13477   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13478     {
13479       struct got_entry **lgot_ents, **end_lgot_ents;
13480       struct plt_entry **local_plt, **lplt, **end_local_plt;
13481       Elf_Internal_Shdr *symtab_hdr;
13482       bfd_size_type locsymcount;
13483       Elf_Internal_Sym *local_syms = NULL;
13484       struct plt_entry *ent;
13485
13486       if (!is_ppc64_elf (ibfd))
13487         continue;
13488
13489       lgot_ents = elf_local_got_ents (ibfd);
13490       if (!lgot_ents)
13491         continue;
13492
13493       symtab_hdr = &elf_symtab_hdr (ibfd);
13494       locsymcount = symtab_hdr->sh_info;
13495       end_lgot_ents = lgot_ents + locsymcount;
13496       local_plt = (struct plt_entry **) end_lgot_ents;
13497       end_local_plt = local_plt + locsymcount;
13498       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13499         for (ent = *lplt; ent != NULL; ent = ent->next)
13500           if (ent->plt.offset != (bfd_vma) -1)
13501             {
13502               Elf_Internal_Sym *sym;
13503               asection *sym_sec;
13504               asection *plt, *relplt;
13505               bfd_byte *loc;
13506               bfd_vma val;
13507
13508               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13509                               lplt - local_plt, ibfd))
13510                 {
13511                   if (local_syms != NULL
13512                       && symtab_hdr->contents != (unsigned char *) local_syms)
13513                     free (local_syms);
13514                   return FALSE;
13515                 }
13516
13517               val = sym->st_value + ent->addend;
13518               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13519               if (sym_sec != NULL && sym_sec->output_section != NULL)
13520                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13521
13522               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13523                 {
13524                   htab->local_ifunc_resolver = 1;
13525                   plt = htab->elf.iplt;
13526                   relplt = htab->elf.irelplt;
13527                 }
13528               else
13529                 {
13530                   plt = htab->pltlocal;
13531                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13532                 }
13533
13534               if (relplt == NULL)
13535                 {
13536                   loc = plt->contents + ent->plt.offset;
13537                   bfd_put_64 (info->output_bfd, val, loc);
13538                   if (htab->opd_abi)
13539                     {
13540                       bfd_vma toc = elf_gp (ibfd);
13541                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13542                     }
13543                 }
13544               else
13545                 {
13546                   Elf_Internal_Rela rela;
13547                   rela.r_offset = (ent->plt.offset
13548                                    + plt->output_offset
13549                                    + plt->output_section->vma);
13550                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13551                     {
13552                       if (htab->opd_abi)
13553                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13554                       else
13555                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13556                     }
13557                   else
13558                     {
13559                       if (htab->opd_abi)
13560                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13561                       else
13562                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13563                     }
13564                   rela.r_addend = val;
13565                   loc = relplt->contents + (relplt->reloc_count++
13566                                             * sizeof (Elf64_External_Rela));
13567                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13568                 }
13569             }
13570
13571       if (local_syms != NULL
13572           && symtab_hdr->contents != (unsigned char *) local_syms)
13573         {
13574           if (!info->keep_memory)
13575             free (local_syms);
13576           else
13577             symtab_hdr->contents = (unsigned char *) local_syms;
13578         }
13579     }
13580   return TRUE;
13581 }
13582
13583 /* Build all the stubs associated with the current output file.
13584    The stubs are kept in a hash table attached to the main linker
13585    hash table.  This function is called via gldelf64ppc_finish.  */
13586
13587 bfd_boolean
13588 ppc64_elf_build_stubs (struct bfd_link_info *info,
13589                        char **stats)
13590 {
13591   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13592   struct map_stub *group;
13593   asection *stub_sec;
13594   bfd_byte *p;
13595   int stub_sec_count = 0;
13596
13597   if (htab == NULL)
13598     return FALSE;
13599
13600   /* Allocate memory to hold the linker stubs.  */
13601   for (group = htab->group; group != NULL; group = group->next)
13602     if ((stub_sec = group->stub_sec) != NULL
13603         && stub_sec->size != 0)
13604       {
13605         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13606         if (stub_sec->contents == NULL)
13607           return FALSE;
13608         stub_sec->size = 0;
13609       }
13610
13611   if (htab->glink != NULL && htab->glink->size != 0)
13612     {
13613       unsigned int indx;
13614       bfd_vma plt0;
13615
13616       /* Build the .glink plt call stub.  */
13617       if (htab->params->emit_stub_syms)
13618         {
13619           struct elf_link_hash_entry *h;
13620           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13621                                     TRUE, FALSE, FALSE);
13622           if (h == NULL)
13623             return FALSE;
13624           if (h->root.type == bfd_link_hash_new)
13625             {
13626               h->root.type = bfd_link_hash_defined;
13627               h->root.u.def.section = htab->glink;
13628               h->root.u.def.value = 8;
13629               h->ref_regular = 1;
13630               h->def_regular = 1;
13631               h->ref_regular_nonweak = 1;
13632               h->forced_local = 1;
13633               h->non_elf = 0;
13634               h->root.linker_def = 1;
13635             }
13636         }
13637       plt0 = (htab->elf.splt->output_section->vma
13638               + htab->elf.splt->output_offset
13639               - 16);
13640       if (info->emitrelocations)
13641         {
13642           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13643           if (r == NULL)
13644             return FALSE;
13645           r->r_offset = (htab->glink->output_offset
13646                          + htab->glink->output_section->vma);
13647           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13648           r->r_addend = plt0;
13649         }
13650       p = htab->glink->contents;
13651       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13652       bfd_put_64 (htab->glink->owner, plt0, p);
13653       p += 8;
13654       if (htab->opd_abi)
13655         {
13656           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13657           p += 4;
13658           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13659           p += 4;
13660           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13661           p += 4;
13662           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13663           p += 4;
13664           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13665           p += 4;
13666           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13667           p += 4;
13668           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13669           p += 4;
13670           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13671           p += 4;
13672           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13673           p += 4;
13674           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13675           p += 4;
13676         }
13677       else
13678         {
13679           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13680           p += 4;
13681           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13682           p += 4;
13683           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13684           p += 4;
13685           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13686           p += 4;
13687           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13688           p += 4;
13689           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13690           p += 4;
13691           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13692           p += 4;
13693           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13694           p += 4;
13695           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13696           p += 4;
13697           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13698           p += 4;
13699           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13700           p += 4;
13701           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13702           p += 4;
13703           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13704           p += 4;
13705         }
13706       bfd_put_32 (htab->glink->owner, BCTR, p);
13707       p += 4;
13708       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13709
13710       /* Build the .glink lazy link call stubs.  */
13711       indx = 0;
13712       while (p < htab->glink->contents + htab->glink->size)
13713         {
13714           if (htab->opd_abi)
13715             {
13716               if (indx < 0x8000)
13717                 {
13718                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13719                   p += 4;
13720                 }
13721               else
13722                 {
13723                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13724                   p += 4;
13725                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13726                               p);
13727                   p += 4;
13728                 }
13729             }
13730           bfd_put_32 (htab->glink->owner,
13731                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13732           indx++;
13733           p += 4;
13734         }
13735     }
13736
13737   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13738   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13739
13740   if (!write_plt_relocs_for_local_syms (info))
13741     return FALSE;
13742
13743   if (htab->brlt != NULL && htab->brlt->size != 0)
13744     {
13745       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13746                                          htab->brlt->size);
13747       if (htab->brlt->contents == NULL)
13748         return FALSE;
13749     }
13750   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13751     {
13752       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13753                                             htab->relbrlt->size);
13754       if (htab->relbrlt->contents == NULL)
13755         return FALSE;
13756     }
13757
13758   /* Build the stubs as directed by the stub hash table.  */
13759   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13760
13761   for (group = htab->group; group != NULL; group = group->next)
13762     if (group->needs_save_res)
13763       group->stub_sec->size += htab->sfpr->size;
13764
13765   if (htab->relbrlt != NULL)
13766     htab->relbrlt->reloc_count = 0;
13767
13768   if (htab->params->plt_stub_align != 0)
13769     for (group = htab->group; group != NULL; group = group->next)
13770       if ((stub_sec = group->stub_sec) != NULL)
13771         {
13772           int align = abs (htab->params->plt_stub_align);
13773           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13774         }
13775
13776   for (group = htab->group; group != NULL; group = group->next)
13777     if (group->needs_save_res)
13778       {
13779         stub_sec = group->stub_sec;
13780         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13781                 htab->sfpr->contents, htab->sfpr->size);
13782         if (htab->params->emit_stub_syms)
13783           {
13784             unsigned int i;
13785
13786             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13787               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13788                 return FALSE;
13789           }
13790       }
13791
13792   for (group = htab->group; group != NULL; group = group->next)
13793     if ((stub_sec = group->stub_sec) != NULL)
13794       {
13795         stub_sec_count += 1;
13796         if (stub_sec->rawsize != stub_sec->size
13797             && (htab->stub_iteration <= STUB_SHRINK_ITER
13798                 || stub_sec->rawsize < stub_sec->size))
13799           break;
13800       }
13801
13802   if (group != NULL)
13803     {
13804       htab->stub_error = TRUE;
13805       _bfd_error_handler (_("stubs don't match calculated size"));
13806     }
13807
13808   if (htab->stub_error)
13809     return FALSE;
13810
13811   if (stats != NULL)
13812     {
13813       size_t len;
13814       *stats = bfd_malloc (500);
13815       if (*stats == NULL)
13816         return FALSE;
13817
13818       len = sprintf (*stats,
13819                      ngettext ("linker stubs in %u group\n",
13820                                "linker stubs in %u groups\n",
13821                                stub_sec_count),
13822                      stub_sec_count);
13823       sprintf (*stats + len, _("  branch       %lu\n"
13824                                "  toc adjust   %lu\n"
13825                                "  long branch  %lu\n"
13826                                "  long toc adj %lu\n"
13827                                "  plt call     %lu\n"
13828                                "  plt call toc %lu\n"
13829                                "  global entry %lu"),
13830                htab->stub_count[ppc_stub_long_branch - 1],
13831                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13832                htab->stub_count[ppc_stub_plt_branch - 1],
13833                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13834                htab->stub_count[ppc_stub_plt_call - 1],
13835                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13836                htab->stub_count[ppc_stub_global_entry - 1]);
13837     }
13838   return TRUE;
13839 }
13840
13841 /* What to do when ld finds relocations against symbols defined in
13842    discarded sections.  */
13843
13844 static unsigned int
13845 ppc64_elf_action_discarded (asection *sec)
13846 {
13847   if (strcmp (".opd", sec->name) == 0)
13848     return 0;
13849
13850   if (strcmp (".toc", sec->name) == 0)
13851     return 0;
13852
13853   if (strcmp (".toc1", sec->name) == 0)
13854     return 0;
13855
13856   return _bfd_elf_default_action_discarded (sec);
13857 }
13858
13859 /* The RELOCATE_SECTION function is called by the ELF backend linker
13860    to handle the relocations for a section.
13861
13862    The relocs are always passed as Rela structures; if the section
13863    actually uses Rel structures, the r_addend field will always be
13864    zero.
13865
13866    This function is responsible for adjust the section contents as
13867    necessary, and (if using Rela relocs and generating a
13868    relocatable output file) adjusting the reloc addend as
13869    necessary.
13870
13871    This function does not have to worry about setting the reloc
13872    address or the reloc symbol index.
13873
13874    LOCAL_SYMS is a pointer to the swapped in local symbols.
13875
13876    LOCAL_SECTIONS is an array giving the section in the input file
13877    corresponding to the st_shndx field of each local symbol.
13878
13879    The global hash table entry for the global symbols can be found
13880    via elf_sym_hashes (input_bfd).
13881
13882    When generating relocatable output, this function must handle
13883    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13884    going to be the section symbol corresponding to the output
13885    section, which means that the addend must be adjusted
13886    accordingly.  */
13887
13888 static bfd_boolean
13889 ppc64_elf_relocate_section (bfd *output_bfd,
13890                             struct bfd_link_info *info,
13891                             bfd *input_bfd,
13892                             asection *input_section,
13893                             bfd_byte *contents,
13894                             Elf_Internal_Rela *relocs,
13895                             Elf_Internal_Sym *local_syms,
13896                             asection **local_sections)
13897 {
13898   struct ppc_link_hash_table *htab;
13899   Elf_Internal_Shdr *symtab_hdr;
13900   struct elf_link_hash_entry **sym_hashes;
13901   Elf_Internal_Rela *rel;
13902   Elf_Internal_Rela *wrel;
13903   Elf_Internal_Rela *relend;
13904   Elf_Internal_Rela outrel;
13905   bfd_byte *loc;
13906   struct got_entry **local_got_ents;
13907   bfd_vma TOCstart;
13908   bfd_boolean ret = TRUE;
13909   bfd_boolean is_opd;
13910   /* Assume 'at' branch hints.  */
13911   bfd_boolean is_isa_v2 = TRUE;
13912   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13913
13914   /* Initialize howto table if needed.  */
13915   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13916     ppc_howto_init ();
13917
13918   htab = ppc_hash_table (info);
13919   if (htab == NULL)
13920     return FALSE;
13921
13922   /* Don't relocate stub sections.  */
13923   if (input_section->owner == htab->params->stub_bfd)
13924     return TRUE;
13925
13926   BFD_ASSERT (is_ppc64_elf (input_bfd));
13927
13928   local_got_ents = elf_local_got_ents (input_bfd);
13929   TOCstart = elf_gp (output_bfd);
13930   symtab_hdr = &elf_symtab_hdr (input_bfd);
13931   sym_hashes = elf_sym_hashes (input_bfd);
13932   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13933
13934   rel = wrel = relocs;
13935   relend = relocs + input_section->reloc_count;
13936   for (; rel < relend; wrel++, rel++)
13937     {
13938       enum elf_ppc64_reloc_type r_type;
13939       bfd_vma addend;
13940       bfd_reloc_status_type r;
13941       Elf_Internal_Sym *sym;
13942       asection *sec;
13943       struct elf_link_hash_entry *h_elf;
13944       struct ppc_link_hash_entry *h;
13945       struct ppc_link_hash_entry *fdh;
13946       const char *sym_name;
13947       unsigned long r_symndx, toc_symndx;
13948       bfd_vma toc_addend;
13949       unsigned char tls_mask, tls_gd, tls_type;
13950       unsigned char sym_type;
13951       bfd_vma relocation;
13952       bfd_boolean unresolved_reloc, save_unresolved_reloc;
13953       bfd_boolean warned;
13954       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13955       unsigned int insn;
13956       unsigned int mask;
13957       struct ppc_stub_hash_entry *stub_entry;
13958       bfd_vma max_br_offset;
13959       bfd_vma from;
13960       Elf_Internal_Rela orig_rel;
13961       reloc_howto_type *howto;
13962       struct reloc_howto_struct alt_howto;
13963
13964     again:
13965       orig_rel = *rel;
13966
13967       r_type = ELF64_R_TYPE (rel->r_info);
13968       r_symndx = ELF64_R_SYM (rel->r_info);
13969
13970       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13971          symbol of the previous ADDR64 reloc.  The symbol gives us the
13972          proper TOC base to use.  */
13973       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13974           && wrel != relocs
13975           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13976           && is_opd)
13977         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13978
13979       sym = NULL;
13980       sec = NULL;
13981       h_elf = NULL;
13982       sym_name = NULL;
13983       unresolved_reloc = FALSE;
13984       warned = FALSE;
13985
13986       if (r_symndx < symtab_hdr->sh_info)
13987         {
13988           /* It's a local symbol.  */
13989           struct _opd_sec_data *opd;
13990
13991           sym = local_syms + r_symndx;
13992           sec = local_sections[r_symndx];
13993           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13994           sym_type = ELF64_ST_TYPE (sym->st_info);
13995           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13996           opd = get_opd_info (sec);
13997           if (opd != NULL && opd->adjust != NULL)
13998             {
13999               long adjust = opd->adjust[OPD_NDX (sym->st_value
14000                                                  + rel->r_addend)];
14001               if (adjust == -1)
14002                 relocation = 0;
14003               else
14004                 {
14005                   /* If this is a relocation against the opd section sym
14006                      and we have edited .opd, adjust the reloc addend so
14007                      that ld -r and ld --emit-relocs output is correct.
14008                      If it is a reloc against some other .opd symbol,
14009                      then the symbol value will be adjusted later.  */
14010                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14011                     rel->r_addend += adjust;
14012                   else
14013                     relocation += adjust;
14014                 }
14015             }
14016         }
14017       else
14018         {
14019           bfd_boolean ignored;
14020
14021           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14022                                    r_symndx, symtab_hdr, sym_hashes,
14023                                    h_elf, sec, relocation,
14024                                    unresolved_reloc, warned, ignored);
14025           sym_name = h_elf->root.root.string;
14026           sym_type = h_elf->type;
14027           if (sec != NULL
14028               && sec->owner == output_bfd
14029               && strcmp (sec->name, ".opd") == 0)
14030             {
14031               /* This is a symbol defined in a linker script.  All
14032                  such are defined in output sections, even those
14033                  defined by simple assignment from a symbol defined in
14034                  an input section.  Transfer the symbol to an
14035                  appropriate input .opd section, so that a branch to
14036                  this symbol will be mapped to the location specified
14037                  by the opd entry.  */
14038               struct bfd_link_order *lo;
14039               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14040                 if (lo->type == bfd_indirect_link_order)
14041                   {
14042                     asection *isec = lo->u.indirect.section;
14043                     if (h_elf->root.u.def.value >= isec->output_offset
14044                         && h_elf->root.u.def.value < (isec->output_offset
14045                                                       + isec->size))
14046                       {
14047                         h_elf->root.u.def.value -= isec->output_offset;
14048                         h_elf->root.u.def.section = isec;
14049                         sec = isec;
14050                         break;
14051                       }
14052                   }
14053             }
14054         }
14055       h = (struct ppc_link_hash_entry *) h_elf;
14056
14057       if (sec != NULL && discarded_section (sec))
14058         {
14059           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14060                                input_bfd, input_section,
14061                                contents + rel->r_offset);
14062           wrel->r_offset = rel->r_offset;
14063           wrel->r_info = 0;
14064           wrel->r_addend = 0;
14065
14066           /* For ld -r, remove relocations in debug sections against
14067              symbols defined in discarded sections.  Not done for
14068              non-debug to preserve relocs in .eh_frame which the
14069              eh_frame editing code expects to be present.  */
14070           if (bfd_link_relocatable (info)
14071               && (input_section->flags & SEC_DEBUGGING))
14072             wrel--;
14073
14074           continue;
14075         }
14076
14077       if (bfd_link_relocatable (info))
14078         goto copy_reloc;
14079
14080       if (h != NULL && &h->elf == htab->elf.hgot)
14081         {
14082           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14083           sec = bfd_abs_section_ptr;
14084           unresolved_reloc = FALSE;
14085         }
14086
14087       /* TLS optimizations.  Replace instruction sequences and relocs
14088          based on information we collected in tls_optimize.  We edit
14089          RELOCS so that --emit-relocs will output something sensible
14090          for the final instruction stream.  */
14091       tls_mask = 0;
14092       tls_gd = 0;
14093       toc_symndx = 0;
14094       if (h != NULL)
14095         tls_mask = h->tls_mask;
14096       else if (local_got_ents != NULL)
14097         {
14098           struct plt_entry **local_plt = (struct plt_entry **)
14099             (local_got_ents + symtab_hdr->sh_info);
14100           unsigned char *lgot_masks = (unsigned char *)
14101             (local_plt + symtab_hdr->sh_info);
14102           tls_mask = lgot_masks[r_symndx];
14103         }
14104       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14105           && (r_type == R_PPC64_TLS
14106               || r_type == R_PPC64_TLSGD
14107               || r_type == R_PPC64_TLSLD))
14108         {
14109           /* Check for toc tls entries.  */
14110           unsigned char *toc_tls;
14111
14112           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14113                              &local_syms, rel, input_bfd))
14114             return FALSE;
14115
14116           if (toc_tls)
14117             tls_mask = *toc_tls;
14118         }
14119
14120       /* Check that tls relocs are used with tls syms, and non-tls
14121          relocs are used with non-tls syms.  */
14122       if (r_symndx != STN_UNDEF
14123           && r_type != R_PPC64_NONE
14124           && (h == NULL
14125               || h->elf.root.type == bfd_link_hash_defined
14126               || h->elf.root.type == bfd_link_hash_defweak)
14127           && (IS_PPC64_TLS_RELOC (r_type)
14128               != (sym_type == STT_TLS
14129                   || (sym_type == STT_SECTION
14130                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14131         {
14132           if ((tls_mask & TLS_TLS) != 0
14133               && (r_type == R_PPC64_TLS
14134                   || r_type == R_PPC64_TLSGD
14135                   || r_type == R_PPC64_TLSLD))
14136             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14137             ;
14138           else
14139             info->callbacks->einfo
14140               (!IS_PPC64_TLS_RELOC (r_type)
14141                /* xgettext:c-format */
14142                ? _("%H: %s used with TLS symbol `%pT'\n")
14143                /* xgettext:c-format */
14144                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14145                input_bfd, input_section, rel->r_offset,
14146                ppc64_elf_howto_table[r_type]->name,
14147                sym_name);
14148         }
14149
14150       /* Ensure reloc mapping code below stays sane.  */
14151       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14152           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14153           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14154           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14155           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14156           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14157           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14158           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14159           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14160           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14161         abort ();
14162
14163       switch (r_type)
14164         {
14165         default:
14166           break;
14167
14168         case R_PPC64_LO_DS_OPT:
14169           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14170           if ((insn & (0x3f << 26)) != 58u << 26)
14171             abort ();
14172           insn += (14u << 26) - (58u << 26);
14173           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14174           r_type = R_PPC64_TOC16_LO;
14175           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14176           break;
14177
14178         case R_PPC64_TOC16:
14179         case R_PPC64_TOC16_LO:
14180         case R_PPC64_TOC16_DS:
14181         case R_PPC64_TOC16_LO_DS:
14182           {
14183             /* Check for toc tls entries.  */
14184             unsigned char *toc_tls;
14185             int retval;
14186
14187             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14188                                    &local_syms, rel, input_bfd);
14189             if (retval == 0)
14190               return FALSE;
14191
14192             if (toc_tls)
14193               {
14194                 tls_mask = *toc_tls;
14195                 if (r_type == R_PPC64_TOC16_DS
14196                     || r_type == R_PPC64_TOC16_LO_DS)
14197                   {
14198                     if ((tls_mask & TLS_TLS) != 0
14199                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14200                       goto toctprel;
14201                   }
14202                 else
14203                   {
14204                     /* If we found a GD reloc pair, then we might be
14205                        doing a GD->IE transition.  */
14206                     if (retval == 2)
14207                       {
14208                         tls_gd = TLS_TPRELGD;
14209                         if ((tls_mask & TLS_TLS) != 0
14210                             && (tls_mask & TLS_GD) == 0)
14211                           goto tls_ldgd_opt;
14212                       }
14213                     else if (retval == 3)
14214                       {
14215                         if ((tls_mask & TLS_TLS) != 0
14216                             && (tls_mask & TLS_LD) == 0)
14217                           goto tls_ldgd_opt;
14218                       }
14219                   }
14220               }
14221           }
14222           break;
14223
14224         case R_PPC64_GOT_TPREL16_HI:
14225         case R_PPC64_GOT_TPREL16_HA:
14226           if ((tls_mask & TLS_TLS) != 0
14227               && (tls_mask & TLS_TPREL) == 0)
14228             {
14229               rel->r_offset -= d_offset;
14230               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14231               r_type = R_PPC64_NONE;
14232               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14233             }
14234           break;
14235
14236         case R_PPC64_GOT_TPREL16_DS:
14237         case R_PPC64_GOT_TPREL16_LO_DS:
14238           if ((tls_mask & TLS_TLS) != 0
14239               && (tls_mask & TLS_TPREL) == 0)
14240             {
14241             toctprel:
14242               insn = bfd_get_32 (input_bfd,
14243                                  contents + rel->r_offset - d_offset);
14244               insn &= 31 << 21;
14245               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14246               bfd_put_32 (input_bfd, insn,
14247                           contents + rel->r_offset - d_offset);
14248               r_type = R_PPC64_TPREL16_HA;
14249               if (toc_symndx != 0)
14250                 {
14251                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14252                   rel->r_addend = toc_addend;
14253                   /* We changed the symbol.  Start over in order to
14254                      get h, sym, sec etc. right.  */
14255                   goto again;
14256                 }
14257               else
14258                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14259             }
14260           break;
14261
14262         case R_PPC64_TLS:
14263           if ((tls_mask & TLS_TLS) != 0
14264               && (tls_mask & TLS_TPREL) == 0)
14265             {
14266               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14267               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14268               if (insn == 0)
14269                 abort ();
14270               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14271               /* Was PPC64_TLS which sits on insn boundary, now
14272                  PPC64_TPREL16_LO which is at low-order half-word.  */
14273               rel->r_offset += d_offset;
14274               r_type = R_PPC64_TPREL16_LO;
14275               if (toc_symndx != 0)
14276                 {
14277                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14278                   rel->r_addend = toc_addend;
14279                   /* We changed the symbol.  Start over in order to
14280                      get h, sym, sec etc. right.  */
14281                   goto again;
14282                 }
14283               else
14284                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14285             }
14286           break;
14287
14288         case R_PPC64_GOT_TLSGD16_HI:
14289         case R_PPC64_GOT_TLSGD16_HA:
14290           tls_gd = TLS_TPRELGD;
14291           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14292             goto tls_gdld_hi;
14293           break;
14294
14295         case R_PPC64_GOT_TLSLD16_HI:
14296         case R_PPC64_GOT_TLSLD16_HA:
14297           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14298             {
14299             tls_gdld_hi:
14300               if ((tls_mask & tls_gd) != 0)
14301                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14302                           + R_PPC64_GOT_TPREL16_DS);
14303               else
14304                 {
14305                   rel->r_offset -= d_offset;
14306                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14307                   r_type = R_PPC64_NONE;
14308                 }
14309               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14310             }
14311           break;
14312
14313         case R_PPC64_GOT_TLSGD16:
14314         case R_PPC64_GOT_TLSGD16_LO:
14315           tls_gd = TLS_TPRELGD;
14316           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14317             goto tls_ldgd_opt;
14318           break;
14319
14320         case R_PPC64_GOT_TLSLD16:
14321         case R_PPC64_GOT_TLSLD16_LO:
14322           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14323             {
14324               unsigned int insn1, insn2;
14325               bfd_vma offset;
14326
14327             tls_ldgd_opt:
14328               offset = (bfd_vma) -1;
14329               /* If not using the newer R_PPC64_TLSGD/LD to mark
14330                  __tls_get_addr calls, we must trust that the call
14331                  stays with its arg setup insns, ie. that the next
14332                  reloc is the __tls_get_addr call associated with
14333                  the current reloc.  Edit both insns.  */
14334               if (input_section->has_tls_get_addr_call
14335                   && rel + 1 < relend
14336                   && branch_reloc_hash_match (input_bfd, rel + 1,
14337                                               htab->tls_get_addr,
14338                                               htab->tls_get_addr_fd))
14339                 offset = rel[1].r_offset;
14340               /* We read the low GOT_TLS (or TOC16) insn because we
14341                  need to keep the destination reg.  It may be
14342                  something other than the usual r3, and moved to r3
14343                  before the call by intervening code.  */
14344               insn1 = bfd_get_32 (input_bfd,
14345                                   contents + rel->r_offset - d_offset);
14346               if ((tls_mask & tls_gd) != 0)
14347                 {
14348                   /* IE */
14349                   insn1 &= (0x1f << 21) | (0x1f << 16);
14350                   insn1 |= 58 << 26;    /* ld */
14351                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14352                   if (offset != (bfd_vma) -1)
14353                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14354                   if ((tls_mask & TLS_EXPLICIT) == 0)
14355                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14356                               + R_PPC64_GOT_TPREL16_DS);
14357                   else
14358                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14359                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14360                 }
14361               else
14362                 {
14363                   /* LE */
14364                   insn1 &= 0x1f << 21;
14365                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14366                   insn2 = 0x38630000;   /* addi 3,3,0 */
14367                   if (tls_gd == 0)
14368                     {
14369                       /* Was an LD reloc.  */
14370                       if (toc_symndx)
14371                         sec = local_sections[toc_symndx];
14372                       for (r_symndx = 0;
14373                            r_symndx < symtab_hdr->sh_info;
14374                            r_symndx++)
14375                         if (local_sections[r_symndx] == sec)
14376                           break;
14377                       if (r_symndx >= symtab_hdr->sh_info)
14378                         r_symndx = STN_UNDEF;
14379                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14380                       if (r_symndx != STN_UNDEF)
14381                         rel->r_addend -= (local_syms[r_symndx].st_value
14382                                           + sec->output_offset
14383                                           + sec->output_section->vma);
14384                     }
14385                   else if (toc_symndx != 0)
14386                     {
14387                       r_symndx = toc_symndx;
14388                       rel->r_addend = toc_addend;
14389                     }
14390                   r_type = R_PPC64_TPREL16_HA;
14391                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14392                   if (offset != (bfd_vma) -1)
14393                     {
14394                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14395                                                     R_PPC64_TPREL16_LO);
14396                       rel[1].r_offset = offset + d_offset;
14397                       rel[1].r_addend = rel->r_addend;
14398                     }
14399                 }
14400               bfd_put_32 (input_bfd, insn1,
14401                           contents + rel->r_offset - d_offset);
14402               if (offset != (bfd_vma) -1)
14403                 bfd_put_32 (input_bfd, insn2, contents + offset);
14404               if ((tls_mask & tls_gd) == 0
14405                   && (tls_gd == 0 || toc_symndx != 0))
14406                 {
14407                   /* We changed the symbol.  Start over in order
14408                      to get h, sym, sec etc. right.  */
14409                   goto again;
14410                 }
14411             }
14412           break;
14413
14414         case R_PPC64_TLSGD:
14415           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14416               && rel + 1 < relend)
14417             {
14418               unsigned int insn2;
14419               bfd_vma offset = rel->r_offset;
14420
14421               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14422                 {
14423                   bfd_put_32 (output_bfd, NOP, contents + offset);
14424                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14425                   break;
14426                 }
14427
14428               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14429                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14430
14431               if ((tls_mask & TLS_TPRELGD) != 0)
14432                 {
14433                   /* IE */
14434                   r_type = R_PPC64_NONE;
14435                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14436                 }
14437               else
14438                 {
14439                   /* LE */
14440                   if (toc_symndx != 0)
14441                     {
14442                       r_symndx = toc_symndx;
14443                       rel->r_addend = toc_addend;
14444                     }
14445                   r_type = R_PPC64_TPREL16_LO;
14446                   rel->r_offset = offset + d_offset;
14447                   insn2 = 0x38630000;   /* addi 3,3,0 */
14448                 }
14449               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14450               /* Zap the reloc on the _tls_get_addr call too.  */
14451               BFD_ASSERT (offset == rel[1].r_offset);
14452               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14453               bfd_put_32 (input_bfd, insn2, contents + offset);
14454               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14455                 goto again;
14456             }
14457           break;
14458
14459         case R_PPC64_TLSLD:
14460           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14461               && rel + 1 < relend)
14462             {
14463               unsigned int insn2;
14464               bfd_vma offset = rel->r_offset;
14465
14466               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14467                 {
14468                   bfd_put_32 (output_bfd, NOP, contents + offset);
14469                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14470                   break;
14471                 }
14472
14473               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14474                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14475
14476               if (toc_symndx)
14477                 sec = local_sections[toc_symndx];
14478               for (r_symndx = 0;
14479                    r_symndx < symtab_hdr->sh_info;
14480                    r_symndx++)
14481                 if (local_sections[r_symndx] == sec)
14482                   break;
14483               if (r_symndx >= symtab_hdr->sh_info)
14484                 r_symndx = STN_UNDEF;
14485               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14486               if (r_symndx != STN_UNDEF)
14487                 rel->r_addend -= (local_syms[r_symndx].st_value
14488                                   + sec->output_offset
14489                                   + sec->output_section->vma);
14490
14491               r_type = R_PPC64_TPREL16_LO;
14492               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14493               rel->r_offset = offset + d_offset;
14494               /* Zap the reloc on the _tls_get_addr call too.  */
14495               BFD_ASSERT (offset == rel[1].r_offset);
14496               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14497               insn2 = 0x38630000;       /* addi 3,3,0 */
14498               bfd_put_32 (input_bfd, insn2, contents + offset);
14499               goto again;
14500             }
14501           break;
14502
14503         case R_PPC64_DTPMOD64:
14504           if (rel + 1 < relend
14505               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14506               && rel[1].r_offset == rel->r_offset + 8)
14507             {
14508               if ((tls_mask & TLS_GD) == 0)
14509                 {
14510                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14511                   if ((tls_mask & TLS_TPRELGD) != 0)
14512                     r_type = R_PPC64_TPREL64;
14513                   else
14514                     {
14515                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14516                       r_type = R_PPC64_NONE;
14517                     }
14518                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14519                 }
14520             }
14521           else
14522             {
14523               if ((tls_mask & TLS_LD) == 0)
14524                 {
14525                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14526                   r_type = R_PPC64_NONE;
14527                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14528                 }
14529             }
14530           break;
14531
14532         case R_PPC64_TPREL64:
14533           if ((tls_mask & TLS_TPREL) == 0)
14534             {
14535               r_type = R_PPC64_NONE;
14536               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14537             }
14538           break;
14539
14540         case R_PPC64_ENTRY:
14541           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14542           if (!bfd_link_pic (info)
14543               && !info->traditional_format
14544               && relocation + 0x80008000 <= 0xffffffff)
14545             {
14546               unsigned int insn1, insn2;
14547
14548               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14549               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14550               if ((insn1 & ~0xfffc) == LD_R2_0R12
14551                   && insn2 == ADD_R2_R2_R12)
14552                 {
14553                   bfd_put_32 (input_bfd,
14554                               LIS_R2 + PPC_HA (relocation),
14555                               contents + rel->r_offset);
14556                   bfd_put_32 (input_bfd,
14557                               ADDI_R2_R2 + PPC_LO (relocation),
14558                               contents + rel->r_offset + 4);
14559                 }
14560             }
14561           else
14562             {
14563               relocation -= (rel->r_offset
14564                              + input_section->output_offset
14565                              + input_section->output_section->vma);
14566               if (relocation + 0x80008000 <= 0xffffffff)
14567                 {
14568                   unsigned int insn1, insn2;
14569
14570                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14571                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14572                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14573                       && insn2 == ADD_R2_R2_R12)
14574                     {
14575                       bfd_put_32 (input_bfd,
14576                                   ADDIS_R2_R12 + PPC_HA (relocation),
14577                                   contents + rel->r_offset);
14578                       bfd_put_32 (input_bfd,
14579                                   ADDI_R2_R2 + PPC_LO (relocation),
14580                                   contents + rel->r_offset + 4);
14581                     }
14582                 }
14583             }
14584           break;
14585
14586         case R_PPC64_REL16_HA:
14587           /* If we are generating a non-PIC executable, edit
14588              .  0:      addis 2,12,.TOC.-0b@ha
14589              .          addi 2,2,.TOC.-0b@l
14590              used by ELFv2 global entry points to set up r2, to
14591              .          lis 2,.TOC.@ha
14592              .          addi 2,2,.TOC.@l
14593              if .TOC. is in range.  */
14594           if (!bfd_link_pic (info)
14595               && !info->traditional_format
14596               && !htab->opd_abi
14597               && rel->r_addend == d_offset
14598               && h != NULL && &h->elf == htab->elf.hgot
14599               && rel + 1 < relend
14600               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14601               && rel[1].r_offset == rel->r_offset + 4
14602               && rel[1].r_addend == rel->r_addend + 4
14603               && relocation + 0x80008000 <= 0xffffffff)
14604             {
14605               unsigned int insn1, insn2;
14606               bfd_vma offset = rel->r_offset - d_offset;
14607               insn1 = bfd_get_32 (input_bfd, contents + offset);
14608               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14609               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14610                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14611                 {
14612                   r_type = R_PPC64_ADDR16_HA;
14613                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14614                   rel->r_addend -= d_offset;
14615                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14616                   rel[1].r_addend -= d_offset + 4;
14617                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14618                 }
14619             }
14620           break;
14621         }
14622
14623       /* Handle other relocations that tweak non-addend part of insn.  */
14624       insn = 0;
14625       max_br_offset = 1 << 25;
14626       addend = rel->r_addend;
14627       reloc_dest = DEST_NORMAL;
14628       switch (r_type)
14629         {
14630         default:
14631           break;
14632
14633         case R_PPC64_TOCSAVE:
14634           if (relocation + addend == (rel->r_offset
14635                                       + input_section->output_offset
14636                                       + input_section->output_section->vma)
14637               && tocsave_find (htab, NO_INSERT,
14638                                &local_syms, rel, input_bfd))
14639             {
14640               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14641               if (insn == NOP
14642                   || insn == CROR_151515 || insn == CROR_313131)
14643                 bfd_put_32 (input_bfd,
14644                             STD_R2_0R1 + STK_TOC (htab),
14645                             contents + rel->r_offset);
14646             }
14647           break;
14648
14649           /* Branch taken prediction relocations.  */
14650         case R_PPC64_ADDR14_BRTAKEN:
14651         case R_PPC64_REL14_BRTAKEN:
14652           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14653           /* Fall through.  */
14654
14655           /* Branch not taken prediction relocations.  */
14656         case R_PPC64_ADDR14_BRNTAKEN:
14657         case R_PPC64_REL14_BRNTAKEN:
14658           insn |= bfd_get_32 (input_bfd,
14659                               contents + rel->r_offset) & ~(0x01 << 21);
14660           /* Fall through.  */
14661
14662         case R_PPC64_REL14:
14663           max_br_offset = 1 << 15;
14664           /* Fall through.  */
14665
14666         case R_PPC64_REL24:
14667         case R_PPC64_PLTCALL:
14668           /* Calls to functions with a different TOC, such as calls to
14669              shared objects, need to alter the TOC pointer.  This is
14670              done using a linkage stub.  A REL24 branching to these
14671              linkage stubs needs to be followed by a nop, as the nop
14672              will be replaced with an instruction to restore the TOC
14673              base pointer.  */
14674           fdh = h;
14675           if (h != NULL
14676               && h->oh != NULL
14677               && h->oh->is_func_descriptor)
14678             fdh = ppc_follow_link (h->oh);
14679           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14680                                            htab);
14681           if (r_type == R_PPC64_PLTCALL
14682               && stub_entry != NULL
14683               && (stub_entry->stub_type == ppc_stub_plt_call
14684                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14685             stub_entry = NULL;
14686
14687           if (stub_entry != NULL
14688               && (stub_entry->stub_type == ppc_stub_plt_call
14689                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14690                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14691                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14692             {
14693               bfd_boolean can_plt_call = FALSE;
14694
14695               if (stub_entry->stub_type == ppc_stub_plt_call
14696                   && !htab->opd_abi
14697                   && htab->params->plt_localentry0 != 0
14698                   && is_elfv2_localentry0 (&h->elf))
14699                 {
14700                   /* The function doesn't use or change r2.  */
14701                   can_plt_call = TRUE;
14702                 }
14703
14704               /* All of these stubs may modify r2, so there must be a
14705                  branch and link followed by a nop.  The nop is
14706                  replaced by an insn to restore r2.  */
14707               else if (rel->r_offset + 8 <= input_section->size)
14708                 {
14709                   unsigned long br;
14710
14711                   br = bfd_get_32 (input_bfd,
14712                                    contents + rel->r_offset);
14713                   if ((br & 1) != 0)
14714                     {
14715                       unsigned long nop;
14716
14717                       nop = bfd_get_32 (input_bfd,
14718                                         contents + rel->r_offset + 4);
14719                       if (nop == LD_R2_0R1 + STK_TOC (htab))
14720                         can_plt_call = TRUE;
14721                       else if (nop == NOP
14722                                || nop == CROR_151515
14723                                || nop == CROR_313131)
14724                         {
14725                           if (h != NULL
14726                               && (h == htab->tls_get_addr_fd
14727                                   || h == htab->tls_get_addr)
14728                               && htab->params->tls_get_addr_opt)
14729                             {
14730                               /* Special stub used, leave nop alone.  */
14731                             }
14732                           else
14733                             bfd_put_32 (input_bfd,
14734                                         LD_R2_0R1 + STK_TOC (htab),
14735                                         contents + rel->r_offset + 4);
14736                           can_plt_call = TRUE;
14737                         }
14738                     }
14739                 }
14740
14741               if (!can_plt_call && h != NULL)
14742                 {
14743                   const char *name = h->elf.root.root.string;
14744
14745                   if (*name == '.')
14746                     ++name;
14747
14748                   if (strncmp (name, "__libc_start_main", 17) == 0
14749                       && (name[17] == 0 || name[17] == '@'))
14750                     {
14751                       /* Allow crt1 branch to go via a toc adjusting
14752                          stub.  Other calls that never return could do
14753                          the same, if we could detect such.  */
14754                       can_plt_call = TRUE;
14755                     }
14756                 }
14757
14758               if (!can_plt_call)
14759                 {
14760                   /* g++ as of 20130507 emits self-calls without a
14761                      following nop.  This is arguably wrong since we
14762                      have conflicting information.  On the one hand a
14763                      global symbol and on the other a local call
14764                      sequence, but don't error for this special case.
14765                      It isn't possible to cheaply verify we have
14766                      exactly such a call.  Allow all calls to the same
14767                      section.  */
14768                   asection *code_sec = sec;
14769
14770                   if (get_opd_info (sec) != NULL)
14771                     {
14772                       bfd_vma off = (relocation + addend
14773                                      - sec->output_section->vma
14774                                      - sec->output_offset);
14775
14776                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14777                     }
14778                   if (code_sec == input_section)
14779                     can_plt_call = TRUE;
14780                 }
14781
14782               if (!can_plt_call)
14783                 {
14784                   if (stub_entry->stub_type == ppc_stub_plt_call
14785                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14786                     info->callbacks->einfo
14787                       /* xgettext:c-format */
14788                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14789                          "recompile with -fPIC\n"),
14790                        input_bfd, input_section, rel->r_offset, sym_name);
14791                   else
14792                     info->callbacks->einfo
14793                       /* xgettext:c-format */
14794                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14795                          "(-mcmodel=small toc adjust stub)\n"),
14796                        input_bfd, input_section, rel->r_offset, sym_name);
14797
14798                   bfd_set_error (bfd_error_bad_value);
14799                   ret = FALSE;
14800                 }
14801
14802               if (can_plt_call
14803                   && (stub_entry->stub_type == ppc_stub_plt_call
14804                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14805                 unresolved_reloc = FALSE;
14806             }
14807
14808           if ((stub_entry == NULL
14809                || stub_entry->stub_type == ppc_stub_long_branch
14810                || stub_entry->stub_type == ppc_stub_plt_branch)
14811               && get_opd_info (sec) != NULL)
14812             {
14813               /* The branch destination is the value of the opd entry. */
14814               bfd_vma off = (relocation + addend
14815                              - sec->output_section->vma
14816                              - sec->output_offset);
14817               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14818               if (dest != (bfd_vma) -1)
14819                 {
14820                   relocation = dest;
14821                   addend = 0;
14822                   reloc_dest = DEST_OPD;
14823                 }
14824             }
14825
14826           /* If the branch is out of reach we ought to have a long
14827              branch stub.  */
14828           from = (rel->r_offset
14829                   + input_section->output_offset
14830                   + input_section->output_section->vma);
14831
14832           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14833                                                   ? fdh->elf.other
14834                                                   : sym->st_other);
14835
14836           if (stub_entry != NULL
14837               && (stub_entry->stub_type == ppc_stub_long_branch
14838                   || stub_entry->stub_type == ppc_stub_plt_branch)
14839               && (r_type == R_PPC64_ADDR14_BRTAKEN
14840                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14841                   || (relocation + addend - from + max_br_offset
14842                       < 2 * max_br_offset)))
14843             /* Don't use the stub if this branch is in range.  */
14844             stub_entry = NULL;
14845
14846           if (stub_entry != NULL)
14847             {
14848               /* Munge up the value and addend so that we call the stub
14849                  rather than the procedure directly.  */
14850               asection *stub_sec = stub_entry->group->stub_sec;
14851
14852               if (stub_entry->stub_type == ppc_stub_save_res)
14853                 relocation += (stub_sec->output_offset
14854                                + stub_sec->output_section->vma
14855                                + stub_sec->size - htab->sfpr->size
14856                                - htab->sfpr->output_offset
14857                                - htab->sfpr->output_section->vma);
14858               else
14859                 relocation = (stub_entry->stub_offset
14860                               + stub_sec->output_offset
14861                               + stub_sec->output_section->vma);
14862               addend = 0;
14863               reloc_dest = DEST_STUB;
14864
14865               if ((stub_entry->stub_type == ppc_stub_plt_call
14866                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14867                   && (ALWAYS_EMIT_R2SAVE
14868                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14869                   && rel + 1 < relend
14870                   && rel[1].r_offset == rel->r_offset + 4
14871                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14872                 relocation += 4;
14873             }
14874
14875           if (insn != 0)
14876             {
14877               if (is_isa_v2)
14878                 {
14879                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14880                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14881                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14882                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14883                     insn |= 0x02 << 21;
14884                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14885                     insn |= 0x08 << 21;
14886                   else
14887                     break;
14888                 }
14889               else
14890                 {
14891                   /* Invert 'y' bit if not the default.  */
14892                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14893                     insn ^= 0x01 << 21;
14894                 }
14895
14896               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14897             }
14898
14899           /* NOP out calls to undefined weak functions.
14900              We can thus call a weak function without first
14901              checking whether the function is defined.  */
14902           else if (h != NULL
14903                    && h->elf.root.type == bfd_link_hash_undefweak
14904                    && h->elf.dynindx == -1
14905                    && r_type == R_PPC64_REL24
14906                    && relocation == 0
14907                    && addend == 0)
14908             {
14909               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14910               goto copy_reloc;
14911             }
14912           break;
14913         }
14914
14915       /* Set `addend'.  */
14916       tls_type = 0;
14917       save_unresolved_reloc = unresolved_reloc;
14918       switch (r_type)
14919         {
14920         default:
14921           /* xgettext:c-format */
14922           _bfd_error_handler (_("%pB: %s unsupported"),
14923                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14924
14925           bfd_set_error (bfd_error_bad_value);
14926           ret = FALSE;
14927           goto copy_reloc;
14928
14929         case R_PPC64_NONE:
14930         case R_PPC64_TLS:
14931         case R_PPC64_TLSGD:
14932         case R_PPC64_TLSLD:
14933         case R_PPC64_TOCSAVE:
14934         case R_PPC64_GNU_VTINHERIT:
14935         case R_PPC64_GNU_VTENTRY:
14936         case R_PPC64_ENTRY:
14937           goto copy_reloc;
14938
14939           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14940              address in the GOT as relocation value instead of the
14941              symbol's value itself.  Also, create a GOT entry for the
14942              symbol and put the symbol value there.  */
14943         case R_PPC64_GOT_TLSGD16:
14944         case R_PPC64_GOT_TLSGD16_LO:
14945         case R_PPC64_GOT_TLSGD16_HI:
14946         case R_PPC64_GOT_TLSGD16_HA:
14947           tls_type = TLS_TLS | TLS_GD;
14948           goto dogot;
14949
14950         case R_PPC64_GOT_TLSLD16:
14951         case R_PPC64_GOT_TLSLD16_LO:
14952         case R_PPC64_GOT_TLSLD16_HI:
14953         case R_PPC64_GOT_TLSLD16_HA:
14954           tls_type = TLS_TLS | TLS_LD;
14955           goto dogot;
14956
14957         case R_PPC64_GOT_TPREL16_DS:
14958         case R_PPC64_GOT_TPREL16_LO_DS:
14959         case R_PPC64_GOT_TPREL16_HI:
14960         case R_PPC64_GOT_TPREL16_HA:
14961           tls_type = TLS_TLS | TLS_TPREL;
14962           goto dogot;
14963
14964         case R_PPC64_GOT_DTPREL16_DS:
14965         case R_PPC64_GOT_DTPREL16_LO_DS:
14966         case R_PPC64_GOT_DTPREL16_HI:
14967         case R_PPC64_GOT_DTPREL16_HA:
14968           tls_type = TLS_TLS | TLS_DTPREL;
14969           goto dogot;
14970
14971         case R_PPC64_GOT16:
14972         case R_PPC64_GOT16_LO:
14973         case R_PPC64_GOT16_HI:
14974         case R_PPC64_GOT16_HA:
14975         case R_PPC64_GOT16_DS:
14976         case R_PPC64_GOT16_LO_DS:
14977         dogot:
14978           {
14979             /* Relocation is to the entry for this symbol in the global
14980                offset table.  */
14981             asection *got;
14982             bfd_vma *offp;
14983             bfd_vma off;
14984             unsigned long indx = 0;
14985             struct got_entry *ent;
14986
14987             if (tls_type == (TLS_TLS | TLS_LD)
14988                 && (h == NULL
14989                     || !h->elf.def_dynamic))
14990               ent = ppc64_tlsld_got (input_bfd);
14991             else
14992               {
14993                 if (h != NULL)
14994                   {
14995                     if (!htab->elf.dynamic_sections_created
14996                         || h->elf.dynindx == -1
14997                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14998                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14999                       /* This is actually a static link, or it is a
15000                          -Bsymbolic link and the symbol is defined
15001                          locally, or the symbol was forced to be local
15002                          because of a version file.  */
15003                       ;
15004                     else
15005                       {
15006                         indx = h->elf.dynindx;
15007                         unresolved_reloc = FALSE;
15008                       }
15009                     ent = h->elf.got.glist;
15010                   }
15011                 else
15012                   {
15013                     if (local_got_ents == NULL)
15014                       abort ();
15015                     ent = local_got_ents[r_symndx];
15016                   }
15017
15018                 for (; ent != NULL; ent = ent->next)
15019                   if (ent->addend == orig_rel.r_addend
15020                       && ent->owner == input_bfd
15021                       && ent->tls_type == tls_type)
15022                     break;
15023               }
15024
15025             if (ent == NULL)
15026               abort ();
15027             if (ent->is_indirect)
15028               ent = ent->got.ent;
15029             offp = &ent->got.offset;
15030             got = ppc64_elf_tdata (ent->owner)->got;
15031             if (got == NULL)
15032               abort ();
15033
15034             /* The offset must always be a multiple of 8.  We use the
15035                least significant bit to record whether we have already
15036                processed this entry.  */
15037             off = *offp;
15038             if ((off & 1) != 0)
15039               off &= ~1;
15040             else
15041               {
15042                 /* Generate relocs for the dynamic linker, except in
15043                    the case of TLSLD where we'll use one entry per
15044                    module.  */
15045                 asection *relgot;
15046                 bfd_boolean ifunc;
15047
15048                 *offp = off | 1;
15049                 relgot = NULL;
15050                 ifunc = (h != NULL
15051                          ? h->elf.type == STT_GNU_IFUNC
15052                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15053                 if (ifunc)
15054                   {
15055                     relgot = htab->elf.irelplt;
15056                     if (indx == 0)
15057                       htab->local_ifunc_resolver = 1;
15058                     else if (is_static_defined (&h->elf))
15059                       htab->maybe_local_ifunc_resolver = 1;
15060                   }
15061                 else if (indx != 0
15062                          || (bfd_link_pic (info)
15063                              && (h == NULL
15064                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15065                                  || (tls_type == (TLS_TLS | TLS_LD)
15066                                      && !h->elf.def_dynamic))
15067                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15068                                   && bfd_link_executable (info)
15069                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15070                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15071                 if (relgot != NULL)
15072                   {
15073                     outrel.r_offset = (got->output_section->vma
15074                                        + got->output_offset
15075                                        + off);
15076                     outrel.r_addend = addend;
15077                     if (tls_type & (TLS_LD | TLS_GD))
15078                       {
15079                         outrel.r_addend = 0;
15080                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15081                         if (tls_type == (TLS_TLS | TLS_GD))
15082                           {
15083                             loc = relgot->contents;
15084                             loc += (relgot->reloc_count++
15085                                     * sizeof (Elf64_External_Rela));
15086                             bfd_elf64_swap_reloca_out (output_bfd,
15087                                                        &outrel, loc);
15088                             outrel.r_offset += 8;
15089                             outrel.r_addend = addend;
15090                             outrel.r_info
15091                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15092                           }
15093                       }
15094                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15095                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15096                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15097                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15098                     else if (indx != 0)
15099                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15100                     else
15101                       {
15102                         if (ifunc)
15103                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15104                         else
15105                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15106
15107                         /* Write the .got section contents for the sake
15108                            of prelink.  */
15109                         loc = got->contents + off;
15110                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15111                                     loc);
15112                       }
15113
15114                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15115                       {
15116                         outrel.r_addend += relocation;
15117                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15118                           {
15119                             if (htab->elf.tls_sec == NULL)
15120                               outrel.r_addend = 0;
15121                             else
15122                               outrel.r_addend -= htab->elf.tls_sec->vma;
15123                           }
15124                       }
15125                     loc = relgot->contents;
15126                     loc += (relgot->reloc_count++
15127                             * sizeof (Elf64_External_Rela));
15128                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15129                   }
15130
15131                 /* Init the .got section contents here if we're not
15132                    emitting a reloc.  */
15133                 else
15134                   {
15135                     relocation += addend;
15136                     if (tls_type != 0)
15137                       {
15138                         if (htab->elf.tls_sec == NULL)
15139                           relocation = 0;
15140                         else
15141                           {
15142                             if (tls_type & TLS_LD)
15143                               relocation = 0;
15144                             else
15145                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15146                             if (tls_type & TLS_TPREL)
15147                               relocation += DTP_OFFSET - TP_OFFSET;
15148                           }
15149
15150                         if (tls_type & (TLS_GD | TLS_LD))
15151                           {
15152                             bfd_put_64 (output_bfd, relocation,
15153                                         got->contents + off + 8);
15154                             relocation = 1;
15155                           }
15156                       }
15157                     bfd_put_64 (output_bfd, relocation,
15158                                 got->contents + off);
15159                   }
15160               }
15161
15162             if (off >= (bfd_vma) -2)
15163               abort ();
15164
15165             relocation = got->output_section->vma + got->output_offset + off;
15166             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15167           }
15168           break;
15169
15170         case R_PPC64_PLT16_HA:
15171         case R_PPC64_PLT16_HI:
15172         case R_PPC64_PLT16_LO:
15173         case R_PPC64_PLT16_LO_DS:
15174         case R_PPC64_PLT32:
15175         case R_PPC64_PLT64:
15176         case R_PPC64_PLTSEQ:
15177         case R_PPC64_PLTCALL:
15178           /* Relocation is to the entry for this symbol in the
15179              procedure linkage table.  */
15180           unresolved_reloc = TRUE;
15181           {
15182             struct plt_entry **plt_list = NULL;
15183             if (h != NULL)
15184               plt_list = &h->elf.plt.plist;
15185             else if (local_got_ents != NULL)
15186               {
15187                 struct plt_entry **local_plt = (struct plt_entry **)
15188                   (local_got_ents + symtab_hdr->sh_info);
15189                 plt_list = local_plt + r_symndx;
15190               }
15191             if (plt_list)
15192               {
15193                 struct plt_entry *ent;
15194
15195                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15196                   if (ent->plt.offset != (bfd_vma) -1
15197                       && ent->addend == orig_rel.r_addend)
15198                     {
15199                       asection *plt;
15200                       bfd_vma got;
15201
15202                       plt = htab->elf.splt;
15203                       if (!htab->elf.dynamic_sections_created
15204                           || h == NULL
15205                           || h->elf.dynindx == -1)
15206                         {
15207                           if (h != NULL
15208                               ? h->elf.type == STT_GNU_IFUNC
15209                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15210                             plt = htab->elf.iplt;
15211                           else
15212                             plt = htab->pltlocal;
15213                         }
15214                       relocation = (plt->output_section->vma
15215                                     + plt->output_offset
15216                                     + ent->plt.offset);
15217                       if (r_type == R_PPC64_PLT16_HA
15218                           || r_type ==R_PPC64_PLT16_HI
15219                           || r_type ==R_PPC64_PLT16_LO
15220                           || r_type ==R_PPC64_PLT16_LO_DS)
15221                         {
15222                           got = (elf_gp (output_bfd)
15223                                  + htab->sec_info[input_section->id].toc_off);
15224                           relocation -= got;
15225                         }
15226                       addend = 0;
15227                       unresolved_reloc = FALSE;
15228                       break;
15229                     }
15230               }
15231           }
15232           break;
15233
15234         case R_PPC64_TOC:
15235           /* Relocation value is TOC base.  */
15236           relocation = TOCstart;
15237           if (r_symndx == STN_UNDEF)
15238             relocation += htab->sec_info[input_section->id].toc_off;
15239           else if (unresolved_reloc)
15240             ;
15241           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15242             relocation += htab->sec_info[sec->id].toc_off;
15243           else
15244             unresolved_reloc = TRUE;
15245           goto dodyn;
15246
15247           /* TOC16 relocs.  We want the offset relative to the TOC base,
15248              which is the address of the start of the TOC plus 0x8000.
15249              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15250              in this order.  */
15251         case R_PPC64_TOC16:
15252         case R_PPC64_TOC16_LO:
15253         case R_PPC64_TOC16_HI:
15254         case R_PPC64_TOC16_DS:
15255         case R_PPC64_TOC16_LO_DS:
15256         case R_PPC64_TOC16_HA:
15257           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15258           break;
15259
15260           /* Relocate against the beginning of the section.  */
15261         case R_PPC64_SECTOFF:
15262         case R_PPC64_SECTOFF_LO:
15263         case R_PPC64_SECTOFF_HI:
15264         case R_PPC64_SECTOFF_DS:
15265         case R_PPC64_SECTOFF_LO_DS:
15266         case R_PPC64_SECTOFF_HA:
15267           if (sec != NULL)
15268             addend -= sec->output_section->vma;
15269           break;
15270
15271         case R_PPC64_REL16:
15272         case R_PPC64_REL16_LO:
15273         case R_PPC64_REL16_HI:
15274         case R_PPC64_REL16_HA:
15275         case R_PPC64_REL16DX_HA:
15276           break;
15277
15278         case R_PPC64_REL14:
15279         case R_PPC64_REL14_BRNTAKEN:
15280         case R_PPC64_REL14_BRTAKEN:
15281         case R_PPC64_REL24:
15282           break;
15283
15284         case R_PPC64_TPREL16:
15285         case R_PPC64_TPREL16_LO:
15286         case R_PPC64_TPREL16_HI:
15287         case R_PPC64_TPREL16_HA:
15288         case R_PPC64_TPREL16_DS:
15289         case R_PPC64_TPREL16_LO_DS:
15290         case R_PPC64_TPREL16_HIGH:
15291         case R_PPC64_TPREL16_HIGHA:
15292         case R_PPC64_TPREL16_HIGHER:
15293         case R_PPC64_TPREL16_HIGHERA:
15294         case R_PPC64_TPREL16_HIGHEST:
15295         case R_PPC64_TPREL16_HIGHESTA:
15296           if (h != NULL
15297               && h->elf.root.type == bfd_link_hash_undefweak
15298               && h->elf.dynindx == -1)
15299             {
15300               /* Make this relocation against an undefined weak symbol
15301                  resolve to zero.  This is really just a tweak, since
15302                  code using weak externs ought to check that they are
15303                  defined before using them.  */
15304               bfd_byte *p = contents + rel->r_offset - d_offset;
15305
15306               insn = bfd_get_32 (input_bfd, p);
15307               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15308               if (insn != 0)
15309                 bfd_put_32 (input_bfd, insn, p);
15310               break;
15311             }
15312           if (htab->elf.tls_sec != NULL)
15313             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15314           /* The TPREL16 relocs shouldn't really be used in shared
15315              libs or with non-local symbols as that will result in
15316              DT_TEXTREL being set, but support them anyway.  */
15317           goto dodyn;
15318
15319         case R_PPC64_DTPREL16:
15320         case R_PPC64_DTPREL16_LO:
15321         case R_PPC64_DTPREL16_HI:
15322         case R_PPC64_DTPREL16_HA:
15323         case R_PPC64_DTPREL16_DS:
15324         case R_PPC64_DTPREL16_LO_DS:
15325         case R_PPC64_DTPREL16_HIGH:
15326         case R_PPC64_DTPREL16_HIGHA:
15327         case R_PPC64_DTPREL16_HIGHER:
15328         case R_PPC64_DTPREL16_HIGHERA:
15329         case R_PPC64_DTPREL16_HIGHEST:
15330         case R_PPC64_DTPREL16_HIGHESTA:
15331           if (htab->elf.tls_sec != NULL)
15332             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15333           break;
15334
15335         case R_PPC64_ADDR64_LOCAL:
15336           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15337                                               ? h->elf.other
15338                                               : sym->st_other);
15339           break;
15340
15341         case R_PPC64_DTPMOD64:
15342           relocation = 1;
15343           addend = 0;
15344           goto dodyn;
15345
15346         case R_PPC64_TPREL64:
15347           if (htab->elf.tls_sec != NULL)
15348             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15349           goto dodyn;
15350
15351         case R_PPC64_DTPREL64:
15352           if (htab->elf.tls_sec != NULL)
15353             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15354           /* Fall through.  */
15355
15356           /* Relocations that may need to be propagated if this is a
15357              dynamic object.  */
15358         case R_PPC64_REL30:
15359         case R_PPC64_REL32:
15360         case R_PPC64_REL64:
15361         case R_PPC64_ADDR14:
15362         case R_PPC64_ADDR14_BRNTAKEN:
15363         case R_PPC64_ADDR14_BRTAKEN:
15364         case R_PPC64_ADDR16:
15365         case R_PPC64_ADDR16_DS:
15366         case R_PPC64_ADDR16_HA:
15367         case R_PPC64_ADDR16_HI:
15368         case R_PPC64_ADDR16_HIGH:
15369         case R_PPC64_ADDR16_HIGHA:
15370         case R_PPC64_ADDR16_HIGHER:
15371         case R_PPC64_ADDR16_HIGHERA:
15372         case R_PPC64_ADDR16_HIGHEST:
15373         case R_PPC64_ADDR16_HIGHESTA:
15374         case R_PPC64_ADDR16_LO:
15375         case R_PPC64_ADDR16_LO_DS:
15376         case R_PPC64_ADDR24:
15377         case R_PPC64_ADDR32:
15378         case R_PPC64_ADDR64:
15379         case R_PPC64_UADDR16:
15380         case R_PPC64_UADDR32:
15381         case R_PPC64_UADDR64:
15382         dodyn:
15383           if ((input_section->flags & SEC_ALLOC) == 0)
15384             break;
15385
15386           if (NO_OPD_RELOCS && is_opd)
15387             break;
15388
15389           if (bfd_link_pic (info)
15390               ? ((h == NULL
15391                   || h->dyn_relocs != NULL)
15392                  && ((h != NULL && pc_dynrelocs (h))
15393                      || must_be_dyn_reloc (info, r_type)))
15394               : (h != NULL
15395                  ? h->dyn_relocs != NULL
15396                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15397             {
15398               bfd_boolean skip, relocate;
15399               asection *sreloc;
15400               bfd_vma out_off;
15401               long indx = 0;
15402
15403               /* When generating a dynamic object, these relocations
15404                  are copied into the output file to be resolved at run
15405                  time.  */
15406
15407               skip = FALSE;
15408               relocate = FALSE;
15409
15410               out_off = _bfd_elf_section_offset (output_bfd, info,
15411                                                  input_section, rel->r_offset);
15412               if (out_off == (bfd_vma) -1)
15413                 skip = TRUE;
15414               else if (out_off == (bfd_vma) -2)
15415                 skip = TRUE, relocate = TRUE;
15416               out_off += (input_section->output_section->vma
15417                           + input_section->output_offset);
15418               outrel.r_offset = out_off;
15419               outrel.r_addend = rel->r_addend;
15420
15421               /* Optimize unaligned reloc use.  */
15422               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15423                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15424                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15425               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15426                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15427                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15428               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15429                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15430                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15431
15432               if (skip)
15433                 memset (&outrel, 0, sizeof outrel);
15434               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15435                        && !is_opd
15436                        && r_type != R_PPC64_TOC)
15437                 {
15438                   indx = h->elf.dynindx;
15439                   BFD_ASSERT (indx != -1);
15440                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15441                 }
15442               else
15443                 {
15444                   /* This symbol is local, or marked to become local,
15445                      or this is an opd section reloc which must point
15446                      at a local function.  */
15447                   outrel.r_addend += relocation;
15448                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15449                     {
15450                       if (is_opd && h != NULL)
15451                         {
15452                           /* Lie about opd entries.  This case occurs
15453                              when building shared libraries and we
15454                              reference a function in another shared
15455                              lib.  The same thing happens for a weak
15456                              definition in an application that's
15457                              overridden by a strong definition in a
15458                              shared lib.  (I believe this is a generic
15459                              bug in binutils handling of weak syms.)
15460                              In these cases we won't use the opd
15461                              entry in this lib.  */
15462                           unresolved_reloc = FALSE;
15463                         }
15464                       if (!is_opd
15465                           && r_type == R_PPC64_ADDR64
15466                           && (h != NULL
15467                               ? h->elf.type == STT_GNU_IFUNC
15468                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15469                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15470                       else
15471                         {
15472                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15473
15474                           /* We need to relocate .opd contents for ld.so.
15475                              Prelink also wants simple and consistent rules
15476                              for relocs.  This make all RELATIVE relocs have
15477                              *r_offset equal to r_addend.  */
15478                           relocate = TRUE;
15479                         }
15480                     }
15481                   else
15482                     {
15483                       if (h != NULL
15484                           ? h->elf.type == STT_GNU_IFUNC
15485                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15486                         {
15487                           info->callbacks->einfo
15488                             /* xgettext:c-format */
15489                             (_("%H: %s for indirect "
15490                                "function `%pT' unsupported\n"),
15491                              input_bfd, input_section, rel->r_offset,
15492                              ppc64_elf_howto_table[r_type]->name,
15493                              sym_name);
15494                           ret = FALSE;
15495                         }
15496                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15497                         ;
15498                       else if (sec == NULL || sec->owner == NULL)
15499                         {
15500                           bfd_set_error (bfd_error_bad_value);
15501                           return FALSE;
15502                         }
15503                       else
15504                         {
15505                           asection *osec;
15506
15507                           osec = sec->output_section;
15508                           indx = elf_section_data (osec)->dynindx;
15509
15510                           if (indx == 0)
15511                             {
15512                               if ((osec->flags & SEC_READONLY) == 0
15513                                   && htab->elf.data_index_section != NULL)
15514                                 osec = htab->elf.data_index_section;
15515                               else
15516                                 osec = htab->elf.text_index_section;
15517                               indx = elf_section_data (osec)->dynindx;
15518                             }
15519                           BFD_ASSERT (indx != 0);
15520
15521                           /* We are turning this relocation into one
15522                              against a section symbol, so subtract out
15523                              the output section's address but not the
15524                              offset of the input section in the output
15525                              section.  */
15526                           outrel.r_addend -= osec->vma;
15527                         }
15528
15529                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15530                     }
15531                 }
15532
15533               sreloc = elf_section_data (input_section)->sreloc;
15534               if (h != NULL
15535                   ? h->elf.type == STT_GNU_IFUNC
15536                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15537                 {
15538                   sreloc = htab->elf.irelplt;
15539                   if (indx == 0)
15540                     htab->local_ifunc_resolver = 1;
15541                   else if (is_static_defined (&h->elf))
15542                     htab->maybe_local_ifunc_resolver = 1;
15543                 }
15544               if (sreloc == NULL)
15545                 abort ();
15546
15547               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15548                   >= sreloc->size)
15549                 abort ();
15550               loc = sreloc->contents;
15551               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15552               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15553
15554               /* If this reloc is against an external symbol, it will
15555                  be computed at runtime, so there's no need to do
15556                  anything now.  However, for the sake of prelink ensure
15557                  that the section contents are a known value.  */
15558               if (! relocate)
15559                 {
15560                   unresolved_reloc = FALSE;
15561                   /* The value chosen here is quite arbitrary as ld.so
15562                      ignores section contents except for the special
15563                      case of .opd where the contents might be accessed
15564                      before relocation.  Choose zero, as that won't
15565                      cause reloc overflow.  */
15566                   relocation = 0;
15567                   addend = 0;
15568                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15569                      to improve backward compatibility with older
15570                      versions of ld.  */
15571                   if (r_type == R_PPC64_ADDR64)
15572                     addend = outrel.r_addend;
15573                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15574                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15575                     addend = outrel.r_offset;
15576                 }
15577             }
15578           break;
15579
15580         case R_PPC64_COPY:
15581         case R_PPC64_GLOB_DAT:
15582         case R_PPC64_JMP_SLOT:
15583         case R_PPC64_JMP_IREL:
15584         case R_PPC64_RELATIVE:
15585           /* We shouldn't ever see these dynamic relocs in relocatable
15586              files.  */
15587           /* Fall through.  */
15588
15589         case R_PPC64_PLTGOT16:
15590         case R_PPC64_PLTGOT16_DS:
15591         case R_PPC64_PLTGOT16_HA:
15592         case R_PPC64_PLTGOT16_HI:
15593         case R_PPC64_PLTGOT16_LO:
15594         case R_PPC64_PLTGOT16_LO_DS:
15595         case R_PPC64_PLTREL32:
15596         case R_PPC64_PLTREL64:
15597           /* These ones haven't been implemented yet.  */
15598
15599           info->callbacks->einfo
15600             /* xgettext:c-format */
15601             (_("%P: %pB: %s is not supported for `%pT'\n"),
15602              input_bfd,
15603              ppc64_elf_howto_table[r_type]->name, sym_name);
15604
15605           bfd_set_error (bfd_error_invalid_operation);
15606           ret = FALSE;
15607           goto copy_reloc;
15608         }
15609
15610       /* Multi-instruction sequences that access the TOC can be
15611          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15612          to             nop;           addi rb,r2,x;  */
15613       switch (r_type)
15614         {
15615         default:
15616           break;
15617
15618         case R_PPC64_GOT_TLSLD16_HI:
15619         case R_PPC64_GOT_TLSGD16_HI:
15620         case R_PPC64_GOT_TPREL16_HI:
15621         case R_PPC64_GOT_DTPREL16_HI:
15622         case R_PPC64_GOT16_HI:
15623         case R_PPC64_TOC16_HI:
15624           /* These relocs would only be useful if building up an
15625              offset to later add to r2, perhaps in an indexed
15626              addressing mode instruction.  Don't try to optimize.
15627              Unfortunately, the possibility of someone building up an
15628              offset like this or even with the HA relocs, means that
15629              we need to check the high insn when optimizing the low
15630              insn.  */
15631           break;
15632
15633         case R_PPC64_PLTCALL:
15634           if (unresolved_reloc)
15635             {
15636               /* No plt entry.  Make this into a direct call.  */
15637               bfd_byte *p = contents + rel->r_offset;
15638               insn = bfd_get_32 (input_bfd, p);
15639               insn &= 1;
15640               bfd_put_32 (input_bfd, B_DOT | insn, p);
15641               bfd_put_32 (input_bfd, NOP, p + 4);
15642               unresolved_reloc = save_unresolved_reloc;
15643               r_type = R_PPC64_REL24;
15644             }
15645           break;
15646
15647         case R_PPC64_PLTSEQ:
15648           if (unresolved_reloc)
15649             {
15650               unresolved_reloc = FALSE;
15651               goto nop_it;
15652             }
15653           break;
15654
15655         case R_PPC64_PLT16_HA:
15656           if (unresolved_reloc)
15657             {
15658               unresolved_reloc = FALSE;
15659               goto nop_it;
15660             }
15661           /* Fall through.  */
15662         case R_PPC64_GOT_TLSLD16_HA:
15663         case R_PPC64_GOT_TLSGD16_HA:
15664         case R_PPC64_GOT_TPREL16_HA:
15665         case R_PPC64_GOT_DTPREL16_HA:
15666         case R_PPC64_GOT16_HA:
15667         case R_PPC64_TOC16_HA:
15668           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15669               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15670             {
15671               bfd_byte *p;
15672             nop_it:
15673               p = contents + (rel->r_offset & ~3);
15674               bfd_put_32 (input_bfd, NOP, p);
15675               goto copy_reloc;
15676             }
15677           break;
15678
15679         case R_PPC64_PLT16_LO:
15680         case R_PPC64_PLT16_LO_DS:
15681           if (unresolved_reloc)
15682             {
15683               unresolved_reloc = FALSE;
15684               goto nop_it;
15685             }
15686           /* Fall through.  */
15687         case R_PPC64_GOT_TLSLD16_LO:
15688         case R_PPC64_GOT_TLSGD16_LO:
15689         case R_PPC64_GOT_TPREL16_LO_DS:
15690         case R_PPC64_GOT_DTPREL16_LO_DS:
15691         case R_PPC64_GOT16_LO:
15692         case R_PPC64_GOT16_LO_DS:
15693         case R_PPC64_TOC16_LO:
15694         case R_PPC64_TOC16_LO_DS:
15695           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15696               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15697             {
15698               bfd_byte *p = contents + (rel->r_offset & ~3);
15699               insn = bfd_get_32 (input_bfd, p);
15700               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15701                 {
15702                   /* Transform addic to addi when we change reg.  */
15703                   insn &= ~((0x3f << 26) | (0x1f << 16));
15704                   insn |= (14u << 26) | (2 << 16);
15705                 }
15706               else
15707                 {
15708                   insn &= ~(0x1f << 16);
15709                   insn |= 2 << 16;
15710                 }
15711               bfd_put_32 (input_bfd, insn, p);
15712             }
15713           break;
15714
15715         case R_PPC64_TPREL16_HA:
15716           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15717             {
15718               bfd_byte *p = contents + (rel->r_offset & ~3);
15719               insn = bfd_get_32 (input_bfd, p);
15720               if ((insn & ((0x3f << 26) | 0x1f << 16))
15721                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15722                 /* xgettext:c-format */
15723                 info->callbacks->minfo
15724                   (_("%H: warning: %s unexpected insn %#x.\n"),
15725                    input_bfd, input_section, rel->r_offset,
15726                    ppc64_elf_howto_table[r_type]->name, insn);
15727               else
15728                 {
15729                   bfd_put_32 (input_bfd, NOP, p);
15730                   goto copy_reloc;
15731                 }
15732             }
15733           break;
15734
15735         case R_PPC64_TPREL16_LO:
15736         case R_PPC64_TPREL16_LO_DS:
15737           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15738             {
15739               bfd_byte *p = contents + (rel->r_offset & ~3);
15740               insn = bfd_get_32 (input_bfd, p);
15741               insn &= ~(0x1f << 16);
15742               insn |= 13 << 16;
15743               bfd_put_32 (input_bfd, insn, p);
15744             }
15745           break;
15746         }
15747
15748       /* Do any further special processing.  */
15749       switch (r_type)
15750         {
15751         default:
15752           break;
15753
15754         case R_PPC64_REL16_HA:
15755         case R_PPC64_REL16DX_HA:
15756         case R_PPC64_ADDR16_HA:
15757         case R_PPC64_ADDR16_HIGHA:
15758         case R_PPC64_ADDR16_HIGHERA:
15759         case R_PPC64_ADDR16_HIGHESTA:
15760         case R_PPC64_TOC16_HA:
15761         case R_PPC64_SECTOFF_HA:
15762         case R_PPC64_TPREL16_HA:
15763         case R_PPC64_TPREL16_HIGHA:
15764         case R_PPC64_TPREL16_HIGHERA:
15765         case R_PPC64_TPREL16_HIGHESTA:
15766         case R_PPC64_DTPREL16_HA:
15767         case R_PPC64_DTPREL16_HIGHA:
15768         case R_PPC64_DTPREL16_HIGHERA:
15769         case R_PPC64_DTPREL16_HIGHESTA:
15770           /* It's just possible that this symbol is a weak symbol
15771              that's not actually defined anywhere. In that case,
15772              'sec' would be NULL, and we should leave the symbol
15773              alone (it will be set to zero elsewhere in the link).  */
15774           if (sec == NULL)
15775             break;
15776           /* Fall through.  */
15777
15778         case R_PPC64_GOT16_HA:
15779         case R_PPC64_PLTGOT16_HA:
15780         case R_PPC64_PLT16_HA:
15781         case R_PPC64_GOT_TLSGD16_HA:
15782         case R_PPC64_GOT_TLSLD16_HA:
15783         case R_PPC64_GOT_TPREL16_HA:
15784         case R_PPC64_GOT_DTPREL16_HA:
15785           /* Add 0x10000 if sign bit in 0:15 is set.
15786              Bits 0:15 are not used.  */
15787           addend += 0x8000;
15788           break;
15789
15790         case R_PPC64_ADDR16_DS:
15791         case R_PPC64_ADDR16_LO_DS:
15792         case R_PPC64_GOT16_DS:
15793         case R_PPC64_GOT16_LO_DS:
15794         case R_PPC64_PLT16_LO_DS:
15795         case R_PPC64_SECTOFF_DS:
15796         case R_PPC64_SECTOFF_LO_DS:
15797         case R_PPC64_TOC16_DS:
15798         case R_PPC64_TOC16_LO_DS:
15799         case R_PPC64_PLTGOT16_DS:
15800         case R_PPC64_PLTGOT16_LO_DS:
15801         case R_PPC64_GOT_TPREL16_DS:
15802         case R_PPC64_GOT_TPREL16_LO_DS:
15803         case R_PPC64_GOT_DTPREL16_DS:
15804         case R_PPC64_GOT_DTPREL16_LO_DS:
15805         case R_PPC64_TPREL16_DS:
15806         case R_PPC64_TPREL16_LO_DS:
15807         case R_PPC64_DTPREL16_DS:
15808         case R_PPC64_DTPREL16_LO_DS:
15809           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15810           mask = 3;
15811           /* If this reloc is against an lq, lxv, or stxv insn, then
15812              the value must be a multiple of 16.  This is somewhat of
15813              a hack, but the "correct" way to do this by defining _DQ
15814              forms of all the _DS relocs bloats all reloc switches in
15815              this file.  It doesn't make much sense to use these
15816              relocs in data, so testing the insn should be safe.  */
15817           if ((insn & (0x3f << 26)) == (56u << 26)
15818               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15819             mask = 15;
15820           relocation += addend;
15821           addend = insn & (mask ^ 3);
15822           if ((relocation & mask) != 0)
15823             {
15824               relocation ^= relocation & mask;
15825               info->callbacks->einfo
15826                 /* xgettext:c-format */
15827                 (_("%H: error: %s not a multiple of %u\n"),
15828                  input_bfd, input_section, rel->r_offset,
15829                  ppc64_elf_howto_table[r_type]->name,
15830                  mask + 1);
15831               bfd_set_error (bfd_error_bad_value);
15832               ret = FALSE;
15833               goto copy_reloc;
15834             }
15835           break;
15836         }
15837
15838       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15839          because such sections are not SEC_ALLOC and thus ld.so will
15840          not process them.  */
15841       howto = ppc64_elf_howto_table[(int) r_type];
15842       if (unresolved_reloc
15843           && !((input_section->flags & SEC_DEBUGGING) != 0
15844                && h->elf.def_dynamic)
15845           && _bfd_elf_section_offset (output_bfd, info, input_section,
15846                                       rel->r_offset) != (bfd_vma) -1)
15847         {
15848           info->callbacks->einfo
15849             /* xgettext:c-format */
15850             (_("%H: unresolvable %s against `%pT'\n"),
15851              input_bfd, input_section, rel->r_offset,
15852              howto->name,
15853              h->elf.root.root.string);
15854           ret = FALSE;
15855         }
15856
15857       /* 16-bit fields in insns mostly have signed values, but a
15858          few insns have 16-bit unsigned values.  Really, we should
15859          have different reloc types.  */
15860       if (howto->complain_on_overflow != complain_overflow_dont
15861           && howto->dst_mask == 0xffff
15862           && (input_section->flags & SEC_CODE) != 0)
15863         {
15864           enum complain_overflow complain = complain_overflow_signed;
15865
15866           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15867           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15868             complain = complain_overflow_bitfield;
15869           else if (howto->rightshift == 0
15870                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15871                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15872                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15873                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15874                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15875                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15876             complain = complain_overflow_unsigned;
15877           if (howto->complain_on_overflow != complain)
15878             {
15879               alt_howto = *howto;
15880               alt_howto.complain_on_overflow = complain;
15881               howto = &alt_howto;
15882             }
15883         }
15884
15885       if (r_type == R_PPC64_REL16DX_HA)
15886         {
15887           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15888           if (rel->r_offset + 4 > input_section->size)
15889             r = bfd_reloc_outofrange;
15890           else
15891             {
15892               relocation += addend;
15893               relocation -= (rel->r_offset
15894                              + input_section->output_offset
15895                              + input_section->output_section->vma);
15896               relocation = (bfd_signed_vma) relocation >> 16;
15897               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15898               insn &= ~0x1fffc1;
15899               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15900               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15901               r = bfd_reloc_ok;
15902               if (relocation + 0x8000 > 0xffff)
15903                 r = bfd_reloc_overflow;
15904             }
15905         }
15906       else
15907         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15908                                       rel->r_offset, relocation, addend);
15909
15910       if (r != bfd_reloc_ok)
15911         {
15912           char *more_info = NULL;
15913           const char *reloc_name = howto->name;
15914
15915           if (reloc_dest != DEST_NORMAL)
15916             {
15917               more_info = bfd_malloc (strlen (reloc_name) + 8);
15918               if (more_info != NULL)
15919                 {
15920                   strcpy (more_info, reloc_name);
15921                   strcat (more_info, (reloc_dest == DEST_OPD
15922                                       ? " (OPD)" : " (stub)"));
15923                   reloc_name = more_info;
15924                 }
15925             }
15926
15927           if (r == bfd_reloc_overflow)
15928             {
15929               /* On code like "if (foo) foo();" don't report overflow
15930                  on a branch to zero when foo is undefined.  */
15931               if (!warned
15932                   && (reloc_dest == DEST_STUB
15933                       || !(h != NULL
15934                            && (h->elf.root.type == bfd_link_hash_undefweak
15935                                || h->elf.root.type == bfd_link_hash_undefined)
15936                            && is_branch_reloc (r_type))))
15937                 info->callbacks->reloc_overflow (info, &h->elf.root,
15938                                                  sym_name, reloc_name,
15939                                                  orig_rel.r_addend,
15940                                                  input_bfd, input_section,
15941                                                  rel->r_offset);
15942             }
15943           else
15944             {
15945               info->callbacks->einfo
15946                 /* xgettext:c-format */
15947                 (_("%H: %s against `%pT': error %d\n"),
15948                  input_bfd, input_section, rel->r_offset,
15949                  reloc_name, sym_name, (int) r);
15950               ret = FALSE;
15951             }
15952           if (more_info != NULL)
15953             free (more_info);
15954         }
15955     copy_reloc:
15956       if (wrel != rel)
15957         *wrel = *rel;
15958     }
15959
15960   if (wrel != rel)
15961     {
15962       Elf_Internal_Shdr *rel_hdr;
15963       size_t deleted = rel - wrel;
15964
15965       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15966       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15967       if (rel_hdr->sh_size == 0)
15968         {
15969           /* It is too late to remove an empty reloc section.  Leave
15970              one NONE reloc.
15971              ??? What is wrong with an empty section???  */
15972           rel_hdr->sh_size = rel_hdr->sh_entsize;
15973           deleted -= 1;
15974         }
15975       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15976       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15977       input_section->reloc_count -= deleted;
15978     }
15979
15980   /* If we're emitting relocations, then shortly after this function
15981      returns, reloc offsets and addends for this section will be
15982      adjusted.  Worse, reloc symbol indices will be for the output
15983      file rather than the input.  Save a copy of the relocs for
15984      opd_entry_value.  */
15985   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15986     {
15987       bfd_size_type amt;
15988       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15989       rel = bfd_alloc (input_bfd, amt);
15990       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15991       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15992       if (rel == NULL)
15993         return FALSE;
15994       memcpy (rel, relocs, amt);
15995     }
15996   return ret;
15997 }
15998
15999 /* Adjust the value of any local symbols in opd sections.  */
16000
16001 static int
16002 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16003                               const char *name ATTRIBUTE_UNUSED,
16004                               Elf_Internal_Sym *elfsym,
16005                               asection *input_sec,
16006                               struct elf_link_hash_entry *h)
16007 {
16008   struct _opd_sec_data *opd;
16009   long adjust;
16010   bfd_vma value;
16011
16012   if (h != NULL)
16013     return 1;
16014
16015   opd = get_opd_info (input_sec);
16016   if (opd == NULL || opd->adjust == NULL)
16017     return 1;
16018
16019   value = elfsym->st_value - input_sec->output_offset;
16020   if (!bfd_link_relocatable (info))
16021     value -= input_sec->output_section->vma;
16022
16023   adjust = opd->adjust[OPD_NDX (value)];
16024   if (adjust == -1)
16025     return 2;
16026
16027   elfsym->st_value += adjust;
16028   return 1;
16029 }
16030
16031 /* Finish up dynamic symbol handling.  We set the contents of various
16032    dynamic sections here.  */
16033
16034 static bfd_boolean
16035 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16036                                  struct bfd_link_info *info,
16037                                  struct elf_link_hash_entry *h,
16038                                  Elf_Internal_Sym *sym)
16039 {
16040   struct ppc_link_hash_table *htab;
16041   struct plt_entry *ent;
16042
16043   htab = ppc_hash_table (info);
16044   if (htab == NULL)
16045     return FALSE;
16046
16047   if (!htab->opd_abi && !h->def_regular)
16048     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16049       if (ent->plt.offset != (bfd_vma) -1)
16050         {
16051           /* Mark the symbol as undefined, rather than as
16052              defined in glink.  Leave the value if there were
16053              any relocations where pointer equality matters
16054              (this is a clue for the dynamic linker, to make
16055              function pointer comparisons work between an
16056              application and shared library), otherwise set it
16057              to zero.  */
16058           sym->st_shndx = SHN_UNDEF;
16059           if (!h->pointer_equality_needed)
16060             sym->st_value = 0;
16061           else if (!h->ref_regular_nonweak)
16062             {
16063               /* This breaks function pointer comparisons, but
16064                  that is better than breaking tests for a NULL
16065                  function pointer.  */
16066               sym->st_value = 0;
16067             }
16068           break;
16069         }
16070
16071   if (h->needs_copy)
16072     {
16073       /* This symbol needs a copy reloc.  Set it up.  */
16074       Elf_Internal_Rela rela;
16075       asection *srel;
16076       bfd_byte *loc;
16077
16078       if (h->dynindx == -1
16079           || (h->root.type != bfd_link_hash_defined
16080               && h->root.type != bfd_link_hash_defweak)
16081           || htab->elf.srelbss == NULL
16082           || htab->elf.sreldynrelro == NULL)
16083         abort ();
16084
16085       rela.r_offset = (h->root.u.def.value
16086                        + h->root.u.def.section->output_section->vma
16087                        + h->root.u.def.section->output_offset);
16088       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16089       rela.r_addend = 0;
16090       if (h->root.u.def.section == htab->elf.sdynrelro)
16091         srel = htab->elf.sreldynrelro;
16092       else
16093         srel = htab->elf.srelbss;
16094       loc = srel->contents;
16095       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16096       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16097     }
16098
16099   return TRUE;
16100 }
16101
16102 /* Used to decide how to sort relocs in an optimal manner for the
16103    dynamic linker, before writing them out.  */
16104
16105 static enum elf_reloc_type_class
16106 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16107                             const asection *rel_sec,
16108                             const Elf_Internal_Rela *rela)
16109 {
16110   enum elf_ppc64_reloc_type r_type;
16111   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16112
16113   if (rel_sec == htab->elf.irelplt)
16114     return reloc_class_ifunc;
16115
16116   r_type = ELF64_R_TYPE (rela->r_info);
16117   switch (r_type)
16118     {
16119     case R_PPC64_RELATIVE:
16120       return reloc_class_relative;
16121     case R_PPC64_JMP_SLOT:
16122       return reloc_class_plt;
16123     case R_PPC64_COPY:
16124       return reloc_class_copy;
16125     default:
16126       return reloc_class_normal;
16127     }
16128 }
16129
16130 /* Finish up the dynamic sections.  */
16131
16132 static bfd_boolean
16133 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16134                                    struct bfd_link_info *info)
16135 {
16136   struct ppc_link_hash_table *htab;
16137   bfd *dynobj;
16138   asection *sdyn;
16139
16140   htab = ppc_hash_table (info);
16141   if (htab == NULL)
16142     return FALSE;
16143
16144   dynobj = htab->elf.dynobj;
16145   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16146
16147   if (htab->elf.dynamic_sections_created)
16148     {
16149       Elf64_External_Dyn *dyncon, *dynconend;
16150
16151       if (sdyn == NULL || htab->elf.sgot == NULL)
16152         abort ();
16153
16154       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16155       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16156       for (; dyncon < dynconend; dyncon++)
16157         {
16158           Elf_Internal_Dyn dyn;
16159           asection *s;
16160
16161           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16162
16163           switch (dyn.d_tag)
16164             {
16165             default:
16166               continue;
16167
16168             case DT_PPC64_GLINK:
16169               s = htab->glink;
16170               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16171               /* We stupidly defined DT_PPC64_GLINK to be the start
16172                  of glink rather than the first entry point, which is
16173                  what ld.so needs, and now have a bigger stub to
16174                  support automatic multiple TOCs.  */
16175               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16176               break;
16177
16178             case DT_PPC64_OPD:
16179               s = bfd_get_section_by_name (output_bfd, ".opd");
16180               if (s == NULL)
16181                 continue;
16182               dyn.d_un.d_ptr = s->vma;
16183               break;
16184
16185             case DT_PPC64_OPT:
16186               if (htab->do_multi_toc && htab->multi_toc_needed)
16187                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16188               if (htab->has_plt_localentry0)
16189                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16190               break;
16191
16192             case DT_PPC64_OPDSZ:
16193               s = bfd_get_section_by_name (output_bfd, ".opd");
16194               if (s == NULL)
16195                 continue;
16196               dyn.d_un.d_val = s->size;
16197               break;
16198
16199             case DT_PLTGOT:
16200               s = htab->elf.splt;
16201               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16202               break;
16203
16204             case DT_JMPREL:
16205               s = htab->elf.srelplt;
16206               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16207               break;
16208
16209             case DT_PLTRELSZ:
16210               dyn.d_un.d_val = htab->elf.srelplt->size;
16211               break;
16212
16213             case DT_TEXTREL:
16214               if (htab->local_ifunc_resolver)
16215                 info->callbacks->einfo
16216                   (_("%X%P: text relocations and GNU indirect "
16217                      "functions will result in a segfault at runtime\n"));
16218               else if (htab->maybe_local_ifunc_resolver)
16219                 info->callbacks->einfo
16220                   (_("%P: warning: text relocations and GNU indirect "
16221                      "functions may result in a segfault at runtime\n"));
16222               continue;
16223             }
16224
16225           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16226         }
16227     }
16228
16229   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16230       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16231     {
16232       /* Fill in the first entry in the global offset table.
16233          We use it to hold the link-time TOCbase.  */
16234       bfd_put_64 (output_bfd,
16235                   elf_gp (output_bfd) + TOC_BASE_OFF,
16236                   htab->elf.sgot->contents);
16237
16238       /* Set .got entry size.  */
16239       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16240     }
16241
16242   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16243       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16244     {
16245       /* Set .plt entry size.  */
16246       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16247         = PLT_ENTRY_SIZE (htab);
16248     }
16249
16250   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16251      brlt ourselves if emitrelocations.  */
16252   if (htab->brlt != NULL
16253       && htab->brlt->reloc_count != 0
16254       && !_bfd_elf_link_output_relocs (output_bfd,
16255                                        htab->brlt,
16256                                        elf_section_data (htab->brlt)->rela.hdr,
16257                                        elf_section_data (htab->brlt)->relocs,
16258                                        NULL))
16259     return FALSE;
16260
16261   if (htab->glink != NULL
16262       && htab->glink->reloc_count != 0
16263       && !_bfd_elf_link_output_relocs (output_bfd,
16264                                        htab->glink,
16265                                        elf_section_data (htab->glink)->rela.hdr,
16266                                        elf_section_data (htab->glink)->relocs,
16267                                        NULL))
16268     return FALSE;
16269
16270   if (htab->glink_eh_frame != NULL
16271       && htab->glink_eh_frame->size != 0)
16272     {
16273       bfd_vma val;
16274       bfd_byte *p;
16275       struct map_stub *group;
16276       size_t align = 4;
16277
16278       p = htab->glink_eh_frame->contents;
16279       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16280
16281       for (group = htab->group; group != NULL; group = group->next)
16282         if (group->stub_sec != NULL)
16283           {
16284             /* Offset to stub section.  */
16285             val = (group->stub_sec->output_section->vma
16286                    + group->stub_sec->output_offset);
16287             val -= (htab->glink_eh_frame->output_section->vma
16288                     + htab->glink_eh_frame->output_offset
16289                     + (p + 8 - htab->glink_eh_frame->contents));
16290             if (val + 0x80000000 > 0xffffffff)
16291               {
16292                 _bfd_error_handler
16293                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16294                    group->stub_sec->name);
16295                 return FALSE;
16296               }
16297             bfd_put_32 (dynobj, val, p + 8);
16298             p += stub_eh_frame_size (group, align);
16299           }
16300       if (htab->glink != NULL && htab->glink->size != 0)
16301         {
16302           /* Offset to .glink.  */
16303           val = (htab->glink->output_section->vma
16304                  + htab->glink->output_offset
16305                  + 8);
16306           val -= (htab->glink_eh_frame->output_section->vma
16307                   + htab->glink_eh_frame->output_offset
16308                   + (p + 8 - htab->glink_eh_frame->contents));
16309           if (val + 0x80000000 > 0xffffffff)
16310             {
16311               _bfd_error_handler
16312                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16313                  htab->glink->name);
16314               return FALSE;
16315             }
16316           bfd_put_32 (dynobj, val, p + 8);
16317           p += (24 + align - 1) & -align;
16318         }
16319
16320       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16321           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16322                                                htab->glink_eh_frame,
16323                                                htab->glink_eh_frame->contents))
16324         return FALSE;
16325     }
16326
16327   /* We need to handle writing out multiple GOT sections ourselves,
16328      since we didn't add them to DYNOBJ.  We know dynobj is the first
16329      bfd.  */
16330   while ((dynobj = dynobj->link.next) != NULL)
16331     {
16332       asection *s;
16333
16334       if (!is_ppc64_elf (dynobj))
16335         continue;
16336
16337       s = ppc64_elf_tdata (dynobj)->got;
16338       if (s != NULL
16339           && s->size != 0
16340           && s->output_section != bfd_abs_section_ptr
16341           && !bfd_set_section_contents (output_bfd, s->output_section,
16342                                         s->contents, s->output_offset,
16343                                         s->size))
16344         return FALSE;
16345       s = ppc64_elf_tdata (dynobj)->relgot;
16346       if (s != NULL
16347           && s->size != 0
16348           && s->output_section != bfd_abs_section_ptr
16349           && !bfd_set_section_contents (output_bfd, s->output_section,
16350                                         s->contents, s->output_offset,
16351                                         s->size))
16352         return FALSE;
16353     }
16354
16355   return TRUE;
16356 }
16357
16358 #include "elf64-target.h"
16359
16360 /* FreeBSD support */
16361
16362 #undef  TARGET_LITTLE_SYM
16363 #undef  TARGET_LITTLE_NAME
16364
16365 #undef  TARGET_BIG_SYM
16366 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16367 #undef  TARGET_BIG_NAME
16368 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16369
16370 #undef  ELF_OSABI
16371 #define ELF_OSABI       ELFOSABI_FREEBSD
16372
16373 #undef  elf64_bed
16374 #define elf64_bed       elf64_powerpc_fbsd_bed
16375
16376 #include "elf64-target.h"