bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2018 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define ELF_RELROPAGESIZE       ELF_MAXPAGESIZE
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_want_dynrelro 1
  77 #define elf_backend_can_gc_sections 1
  78 #define elf_backend_can_refcount 1
  79 #define elf_backend_rela_normal 1
  80 #define elf_backend_dtrel_excludes_plt 1
  81 #define elf_backend_default_execstack 0
  82
  83 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  84 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  85 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  86 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  87 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  88 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  89 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  90 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  91 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  92 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  93
  94 #define elf_backend_object_p                  ppc64_elf_object_p
  95 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  96 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  97 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  98 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  99 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
 100 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 101 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 102 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 103 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 104 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 105 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
 106 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 107 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 108 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 109 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 110 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 111 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 112 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 113 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 114 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 115 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 116 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 117 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 118 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 119 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 120 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 121 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 122 #define elf_backend_special_sections          ppc64_elf_special_sections
 123 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 124 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 125 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 126
 127 /* The name of the dynamic interpreter.  This is put in the .interp
 128    section.  */
 129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 130
 131 /* The size in bytes of an entry in the procedure linkage table.  */
 132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
 134
 135 /* The initial size of the plt reserved for the dynamic linker.  */
 136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 137
 138 /* Offsets to some stack save slots.  */
 139 #define STK_LR 16
 140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 141 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 142    CR save slot.  Used only by optimised __tls_get_addr call stub,
 143    relying on __tls_get_addr_opt not saving CR..  */
 144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 145
 146 /* TOC base pointers offset from start of TOC.  */
 147 #define TOC_BASE_OFF    0x8000
 148 /* TOC base alignment.  */
 149 #define TOC_BASE_ALIGN  256
 150
 151 /* Offset of tp and dtp pointers from start of TLS block.  */
 152 #define TP_OFFSET       0x7000
 153 #define DTP_OFFSET      0x8000
 154
 155 /* .plt call stub instructions.  The normal stub is like this, but
 156    sometimes the .plt entry crosses a 64k boundary and we need to
 157    insert an addi to adjust r11.  */
 158 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 159 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 160 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 161 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 162 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 163 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 164 #define BCTR            0x4e800420      /* bctr                      */
 165
 166 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 167 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 168 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 169
 170 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 171 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 172 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 173 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 174 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 175 #define BNECTR          0x4ca20420      /* bnectr+               */
 176 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 177
 178 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 179 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 180 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 181
 182 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 183 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 184 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 185
 186 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 187 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 188 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 189 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 190 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 191
 192 /* __glink_PLTresolve stub instructions.  We enter with the index in R0.  */
 193 #define GLINK_PLTRESOLVE_SIZE(htab)                     \
 194   (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
 195                                         /* 0:                           */
 196                                         /*  .quad plt0-1f               */
 197                                         /* __glink:                     */
 198 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 199 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 200                                         /* 1:                           */
 201 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 202                                         /*  ld %2,(0b-1b)(%11)          */
 203 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 204 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 205                                         /*  ld %12,0(%11)               */
 206                                         /*  ld %2,8(%11)                */
 207                                         /*  mtctr %12                   */
 208                                         /*  ld %11,16(%11)              */
 209                                         /*  bctr                        */
 210 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 211 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 212 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 213 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 214 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 215
 216 /* Pad with this.  */
 217 #define NOP             0x60000000
 218
 219 /* Some other nops.  */
 220 #define CROR_151515     0x4def7b82
 221 #define CROR_313131     0x4ffffb82
 222
 223 /* .glink entries for the first 32k functions are two instructions.  */
 224 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 225 #define B_DOT           0x48000000      /* b     .              */
 226
 227 /* After that, we need two instructions to load the index, followed by
 228    a branch.  */
 229 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 230 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 231
 232 /* Instructions used by the save and restore reg functions.  */
 233 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 234 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 235 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 236 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 237 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 238 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 239 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 240 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 241 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 242 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 243 #define BLR             0x4e800020      /* blr                  */
 244
 245 /* Since .opd is an array of descriptors and each entry will end up
 246    with identical R_PPC64_RELATIVE relocs, there is really no need to
 247    propagate .opd relocs;  The dynamic linker should be taught to
 248    relocate .opd without reloc entries.  */
 249 #ifndef NO_OPD_RELOCS
 250 #define NO_OPD_RELOCS 0
 251 #endif
 252
 253 #ifndef ARRAY_SIZE
 254 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 255 #endif
 256
 257 static inline int
 258 abiversion (bfd *abfd)
 259 {
 260   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 261 }
 262
 263 static inline void
 264 set_abiversion (bfd *abfd, int ver)
 265 {
 266   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 267   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 268 }
 269 \f
 270 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 271
 272 /* Relocation HOWTO's.  */
 273 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 274
 275 static reloc_howto_type ppc64_elf_howto_raw[] =
 276 {
 277   /* This reloc does nothing.  */
 278   HOWTO (R_PPC64_NONE,          /* type */
 279          0,                     /* rightshift */
 280          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          0,                     /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_dont, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_NONE",        /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0,                     /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 32 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR32,        /* type */
 294          0,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          32,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR32",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffffffff,            /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* An absolute 26 bit branch; the lower two bits must be zero.
 308      FIXME: we don't check that, we just clear them.  */
 309   HOWTO (R_PPC64_ADDR24,        /* type */
 310          0,                     /* rightshift */
 311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 312          26,                    /* bitsize */
 313          FALSE,                 /* pc_relative */
 314          0,                     /* bitpos */
 315          complain_overflow_bitfield, /* complain_on_overflow */
 316          bfd_elf_generic_reloc, /* special_function */
 317          "R_PPC64_ADDR24",      /* name */
 318          FALSE,                 /* partial_inplace */
 319          0,                     /* src_mask */
 320          0x03fffffc,            /* dst_mask */
 321          FALSE),                /* pcrel_offset */
 322
 323   /* A standard 16 bit relocation.  */
 324   HOWTO (R_PPC64_ADDR16,        /* type */
 325          0,                     /* rightshift */
 326          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          16,                    /* bitsize */
 328          FALSE,                 /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield, /* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* special_function */
 332          "R_PPC64_ADDR16",      /* name */
 333          FALSE,                 /* partial_inplace */
 334          0,                     /* src_mask */
 335          0xffff,                /* dst_mask */
 336          FALSE),                /* pcrel_offset */
 337
 338   /* A 16 bit relocation without overflow.  */
 339   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 340          0,                     /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_dont,/* complain_on_overflow */
 346          bfd_elf_generic_reloc, /* special_function */
 347          "R_PPC64_ADDR16_LO",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* Bits 16-31 of an address.  */
 354   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 355          16,                    /* rightshift */
 356          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_signed, /* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_PPC64_ADDR16_HI",   /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0xffff,                /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 369      bits, treated as a signed number, is negative.  */
 370   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 371          16,                    /* rightshift */
 372          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 373          16,                    /* bitsize */
 374          FALSE,                 /* pc_relative */
 375          0,                     /* bitpos */
 376          complain_overflow_signed, /* complain_on_overflow */
 377          ppc64_elf_ha_reloc,    /* special_function */
 378          "R_PPC64_ADDR16_HA",   /* name */
 379          FALSE,                 /* partial_inplace */
 380          0,                     /* src_mask */
 381          0xffff,                /* dst_mask */
 382          FALSE),                /* pcrel_offset */
 383
 384   /* An absolute 16 bit branch; the lower two bits must be zero.
 385      FIXME: we don't check that, we just clear them.  */
 386   HOWTO (R_PPC64_ADDR14,        /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          16,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_signed, /* complain_on_overflow */
 393          ppc64_elf_branch_reloc, /* special_function */
 394          "R_PPC64_ADDR14",      /* name */
 395          FALSE,                 /* partial_inplace */
 396          0,                     /* src_mask */
 397          0x0000fffc,            /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   /* An absolute 16 bit branch, for which bit 10 should be set to
 401      indicate that the branch is expected to be taken.  The lower two
 402      bits must be zero.  */
 403   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          16,                    /* bitsize */
 407          FALSE,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_brtaken_reloc, /* special_function */
 411          "R_PPC64_ADDR14_BRTAKEN",/* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000fffc,            /* dst_mask */
 415          FALSE),                /* pcrel_offset */
 416
 417   /* An absolute 16 bit branch, for which bit 10 should be set to
 418      indicate that the branch is not expected to be taken.  The lower
 419      two bits must be zero.  */
 420   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 421          0,                     /* rightshift */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          FALSE,                 /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed, /* complain_on_overflow */
 427          ppc64_elf_brtaken_reloc, /* special_function */
 428          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 429          FALSE,                 /* partial_inplace */
 430          0,                     /* src_mask */
 431          0x0000fffc,            /* dst_mask */
 432          FALSE),                /* pcrel_offset */
 433
 434   /* A relative 26 bit branch; the lower two bits must be zero.  */
 435   HOWTO (R_PPC64_REL24,         /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          26,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_branch_reloc, /* special_function */
 443          "R_PPC64_REL24",       /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x03fffffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch; the lower two bits must be zero.  */
 450   HOWTO (R_PPC64_REL14,         /* type */
 451          0,                     /* rightshift */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          TRUE,                  /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_signed, /* complain_on_overflow */
 457          ppc64_elf_branch_reloc, /* special_function */
 458          "R_PPC64_REL14",       /* name */
 459          FALSE,                 /* partial_inplace */
 460          0,                     /* src_mask */
 461          0x0000fffc,            /* dst_mask */
 462          TRUE),                 /* pcrel_offset */
 463
 464   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 465      the branch is expected to be taken.  The lower two bits must be
 466      zero.  */
 467   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 468          0,                     /* rightshift */
 469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          16,                    /* bitsize */
 471          TRUE,                  /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_signed, /* complain_on_overflow */
 474          ppc64_elf_brtaken_reloc, /* special_function */
 475          "R_PPC64_REL14_BRTAKEN", /* name */
 476          FALSE,                 /* partial_inplace */
 477          0,                     /* src_mask */
 478          0x0000fffc,            /* dst_mask */
 479          TRUE),                 /* pcrel_offset */
 480
 481   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 482      the branch is not expected to be taken.  The lower two bits must
 483      be zero.  */
 484   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          TRUE,                  /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_signed, /* complain_on_overflow */
 491          ppc64_elf_brtaken_reloc, /* special_function */
 492          "R_PPC64_REL14_BRNTAKEN",/* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0x0000fffc,            /* dst_mask */
 496          TRUE),                 /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 499      symbol.  */
 500   HOWTO (R_PPC64_GOT16,         /* type */
 501          0,                     /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed, /* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16",       /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_LO,      /* type */
 517          0,                     /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_dont, /* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_LO",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 531      the symbol.  */
 532   HOWTO (R_PPC64_GOT16_HI,      /* type */
 533          16,                    /* rightshift */
 534          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 535          16,                    /* bitsize */
 536          FALSE,                 /* pc_relative */
 537          0,                     /* bitpos */
 538          complain_overflow_signed,/* complain_on_overflow */
 539          ppc64_elf_unhandled_reloc, /* special_function */
 540          "R_PPC64_GOT16_HI",    /* name */
 541          FALSE,                 /* partial_inplace */
 542          0,                     /* src_mask */
 543          0xffff,                /* dst_mask */
 544          FALSE),                /* pcrel_offset */
 545
 546   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 547      the symbol.  */
 548   HOWTO (R_PPC64_GOT16_HA,      /* type */
 549          16,                    /* rightshift */
 550          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 551          16,                    /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_signed,/* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_GOT16_HA",    /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0xffff,                /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* This is used only by the dynamic linker.  The symbol should exist
 563      both in the object being run and in some shared library.  The
 564      dynamic linker copies the data addressed by the symbol from the
 565      shared library into the object, because the object being
 566      run has to have the data at some particular address.  */
 567   HOWTO (R_PPC64_COPY,          /* type */
 568          0,                     /* rightshift */
 569          0,                     /* this one is variable size */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_COPY",        /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Like R_PPC64_ADDR64, but used when setting global offset table
 582      entries.  */
 583   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 584          0,                     /* rightshift */
 585          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 586          64,                    /* bitsize */
 587          FALSE,                 /* pc_relative */
 588          0,                     /* bitpos */
 589          complain_overflow_dont, /* complain_on_overflow */
 590          ppc64_elf_unhandled_reloc,  /* special_function */
 591          "R_PPC64_GLOB_DAT",    /* name */
 592          FALSE,                 /* partial_inplace */
 593          0,                     /* src_mask */
 594          ONES (64),             /* dst_mask */
 595          FALSE),                /* pcrel_offset */
 596
 597   /* Created by the link editor.  Marks a procedure linkage table
 598      entry for a symbol.  */
 599   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 600          0,                     /* rightshift */
 601          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          0,                     /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_dont, /* complain_on_overflow */
 606          ppc64_elf_unhandled_reloc, /* special_function */
 607          "R_PPC64_JMP_SLOT",    /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0,                     /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Used only by the dynamic linker.  When the object is run, this
 614      doubleword64 is set to the load address of the object, plus the
 615      addend.  */
 616   HOWTO (R_PPC64_RELATIVE,      /* type */
 617          0,                     /* rightshift */
 618          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 619          64,                    /* bitsize */
 620          FALSE,                 /* pc_relative */
 621          0,                     /* bitpos */
 622          complain_overflow_dont, /* complain_on_overflow */
 623          bfd_elf_generic_reloc, /* special_function */
 624          "R_PPC64_RELATIVE",    /* name */
 625          FALSE,                 /* partial_inplace */
 626          0,                     /* src_mask */
 627          ONES (64),             /* dst_mask */
 628          FALSE),                /* pcrel_offset */
 629
 630   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 631   HOWTO (R_PPC64_UADDR32,       /* type */
 632          0,                     /* rightshift */
 633          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 634          32,                    /* bitsize */
 635          FALSE,                 /* pc_relative */
 636          0,                     /* bitpos */
 637          complain_overflow_bitfield, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_UADDR32",     /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          FALSE),                /* pcrel_offset */
 644
 645   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 646   HOWTO (R_PPC64_UADDR16,       /* type */
 647          0,                     /* rightshift */
 648          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          16,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          bfd_elf_generic_reloc, /* special_function */
 654          "R_PPC64_UADDR16",     /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffff,                /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative.  */
 661   HOWTO (R_PPC64_REL32,         /* type */
 662          0,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          32,                    /* bitsize */
 665          TRUE,                  /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_signed, /* complain_on_overflow */
 668          bfd_elf_generic_reloc, /* special_function */
 669          "R_PPC64_REL32",       /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffffffff,            /* dst_mask */
 673          TRUE),                 /* pcrel_offset */
 674
 675   /* 32-bit relocation to the symbol's procedure linkage table.  */
 676   HOWTO (R_PPC64_PLT32,         /* type */
 677          0,                     /* rightshift */
 678          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          32,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_bitfield, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT32",       /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffffffff,            /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 691      FIXME: R_PPC64_PLTREL32 not supported.  */
 692   HOWTO (R_PPC64_PLTREL32,      /* type */
 693          0,                     /* rightshift */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          32,                    /* bitsize */
 696          TRUE,                  /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLTREL32",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffffffff,            /* dst_mask */
 704          TRUE),                 /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_LO,      /* type */
 709          0,                     /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_dont, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_LO",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 723      the symbol.  */
 724   HOWTO (R_PPC64_PLT16_HI,      /* type */
 725          16,                    /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_signed, /* complain_on_overflow */
 731          ppc64_elf_unhandled_reloc, /* special_function */
 732          "R_PPC64_PLT16_HI",    /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 739      the symbol.  */
 740   HOWTO (R_PPC64_PLT16_HA,      /* type */
 741          16,                    /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_signed, /* complain_on_overflow */
 747          ppc64_elf_unhandled_reloc, /* special_function */
 748          "R_PPC64_PLT16_HA",    /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF,       /* type */
 756          0,                     /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF",     /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 770   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 771          0,                     /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_dont, /* complain_on_overflow */
 777          ppc64_elf_sectoff_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_LO",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* 16-bit upper half section relative relocation.  */
 785   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 786          16,                    /* rightshift */
 787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          16,                    /* bitsize */
 789          FALSE,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_signed, /* complain_on_overflow */
 792          ppc64_elf_sectoff_reloc, /* special_function */
 793          "R_PPC64_SECTOFF_HI",  /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xffff,                /* dst_mask */
 797          FALSE),                /* pcrel_offset */
 798
 799   /* 16-bit upper half adjusted section relative relocation.  */
 800   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 801          16,                    /* rightshift */
 802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_signed, /* complain_on_overflow */
 807          ppc64_elf_sectoff_ha_reloc, /* special_function */
 808          "R_PPC64_SECTOFF_HA",  /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 815   HOWTO (R_PPC64_REL30,         /* type */
 816          2,                     /* rightshift */
 817          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          30,                    /* bitsize */
 819          TRUE,                  /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_REL30",       /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xfffffffc,            /* dst_mask */
 827          TRUE),                 /* pcrel_offset */
 828
 829   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 830
 831   /* A standard 64-bit relocation.  */
 832   HOWTO (R_PPC64_ADDR64,        /* type */
 833          0,                     /* rightshift */
 834          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 835          64,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          bfd_elf_generic_reloc, /* special_function */
 840          "R_PPC64_ADDR64",      /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          ONES (64),             /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 32-47 of an address.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 848          32,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_PPC64_ADDR16_HIGHER", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* The bits 32-47 of an address, plus 1 if the contents of the low
 862      16 bits, treated as a signed number, is negative.  */
 863   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 864          32,                    /* rightshift */
 865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          16,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          ppc64_elf_ha_reloc,    /* special_function */
 871          "R_PPC64_ADDR16_HIGHERA", /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          0xffff,                /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* The bits 48-63 of an address.  */
 878   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 879          48,                    /* rightshift */
 880          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 881          16,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_ADDR16_HIGHEST", /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          0xffff,                /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   /* The bits 48-63 of an address, plus 1 if the contents of the low
 893      16 bits, treated as a signed number, is negative.  */
 894   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 895          48,                    /* rightshift */
 896          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 897          16,                    /* bitsize */
 898          FALSE,                 /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          ppc64_elf_ha_reloc,    /* special_function */
 902          "R_PPC64_ADDR16_HIGHESTA", /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          0xffff,                /* dst_mask */
 906          FALSE),                /* pcrel_offset */
 907
 908   /* Like ADDR64, but may be unaligned.  */
 909   HOWTO (R_PPC64_UADDR64,       /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          bfd_elf_generic_reloc, /* special_function */
 917          "R_PPC64_UADDR64",     /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit relative relocation.  */
 924   HOWTO (R_PPC64_REL64,         /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          bfd_elf_generic_reloc, /* special_function */
 932          "R_PPC64_REL64",       /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 64-bit relocation to the symbol's procedure linkage table.  */
 939   HOWTO (R_PPC64_PLT64,         /* type */
 940          0,                     /* rightshift */
 941          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 942          64,                    /* bitsize */
 943          FALSE,                 /* pc_relative */
 944          0,                     /* bitpos */
 945          complain_overflow_dont, /* complain_on_overflow */
 946          ppc64_elf_unhandled_reloc, /* special_function */
 947          "R_PPC64_PLT64",       /* name */
 948          FALSE,                 /* partial_inplace */
 949          0,                     /* src_mask */
 950          ONES (64),             /* dst_mask */
 951          FALSE),                /* pcrel_offset */
 952
 953   /* 64-bit PC relative relocation to the symbol's procedure linkage
 954      table.  */
 955   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 956   HOWTO (R_PPC64_PLTREL64,      /* type */
 957          0,                     /* rightshift */
 958          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 959          64,                    /* bitsize */
 960          TRUE,                  /* pc_relative */
 961          0,                     /* bitpos */
 962          complain_overflow_dont, /* complain_on_overflow */
 963          ppc64_elf_unhandled_reloc, /* special_function */
 964          "R_PPC64_PLTREL64",    /* name */
 965          FALSE,                 /* partial_inplace */
 966          0,                     /* src_mask */
 967          ONES (64),             /* dst_mask */
 968          TRUE),                 /* pcrel_offset */
 969
 970   /* 16 bit TOC-relative relocation.  */
 971
 972   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 973   HOWTO (R_PPC64_TOC16,         /* type */
 974          0,                     /* rightshift */
 975          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 976          16,                    /* bitsize */
 977          FALSE,                 /* pc_relative */
 978          0,                     /* bitpos */
 979          complain_overflow_signed, /* complain_on_overflow */
 980          ppc64_elf_toc_reloc,   /* special_function */
 981          "R_PPC64_TOC16",       /* name */
 982          FALSE,                 /* partial_inplace */
 983          0,                     /* src_mask */
 984          0xffff,                /* dst_mask */
 985          FALSE),                /* pcrel_offset */
 986
 987   /* 16 bit TOC-relative relocation without overflow.  */
 988
 989   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 990   HOWTO (R_PPC64_TOC16_LO,      /* type */
 991          0,                     /* rightshift */
 992          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 993          16,                    /* bitsize */
 994          FALSE,                 /* pc_relative */
 995          0,                     /* bitpos */
 996          complain_overflow_dont, /* complain_on_overflow */
 997          ppc64_elf_toc_reloc,   /* special_function */
 998          "R_PPC64_TOC16_LO",    /* name */
 999          FALSE,                 /* partial_inplace */
1000          0,                     /* src_mask */
1001          0xffff,                /* dst_mask */
1002          FALSE),                /* pcrel_offset */
1003
1004   /* 16 bit TOC-relative relocation, high 16 bits.  */
1005
1006   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HI,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_reloc,   /* special_function */
1015          "R_PPC64_TOC16_HI",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1022      contents of the low 16 bits, treated as a signed number, is
1023      negative.  */
1024
1025   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1026   HOWTO (R_PPC64_TOC16_HA,      /* type */
1027          16,                    /* rightshift */
1028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          16,                    /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_signed, /* complain_on_overflow */
1033          ppc64_elf_toc_ha_reloc, /* special_function */
1034          "R_PPC64_TOC16_HA",    /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0xffff,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1041
1042   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1043   HOWTO (R_PPC64_TOC,           /* type */
1044          0,                     /* rightshift */
1045          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1046          64,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_toc64_reloc, /* special_function */
1051          "R_PPC64_TOC",         /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          ONES (64),             /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_GOT16, but also informs the link editor that the
1058      value to relocate may (!) refer to a PLT entry which the link
1059      editor (a) may replace with the symbol value.  If the link editor
1060      is unable to fully resolve the symbol, it may (b) create a PLT
1061      entry and store the address to the new PLT entry in the GOT.
1062      This permits lazy resolution of function symbols at run time.
1063      The link editor may also skip all of this and just (c) emit a
1064      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1065   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1066     HOWTO (R_PPC64_PLTGOT16,    /* type */
1067          0,                     /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16",    /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1081   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1082   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1083          0,                     /* rightshift */
1084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1085          16,                    /* bitsize */
1086          FALSE,                 /* pc_relative */
1087          0,                     /* bitpos */
1088          complain_overflow_dont, /* complain_on_overflow */
1089          ppc64_elf_unhandled_reloc, /* special_function */
1090          "R_PPC64_PLTGOT16_LO", /* name */
1091          FALSE,                 /* partial_inplace */
1092          0,                     /* src_mask */
1093          0xffff,                /* dst_mask */
1094          FALSE),                /* pcrel_offset */
1095
1096   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1097   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1098   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1099          16,                    /* rightshift */
1100          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1101          16,                    /* bitsize */
1102          FALSE,                 /* pc_relative */
1103          0,                     /* bitpos */
1104          complain_overflow_signed, /* complain_on_overflow */
1105          ppc64_elf_unhandled_reloc, /* special_function */
1106          "R_PPC64_PLTGOT16_HI", /* name */
1107          FALSE,                 /* partial_inplace */
1108          0,                     /* src_mask */
1109          0xffff,                /* dst_mask */
1110          FALSE),                /* pcrel_offset */
1111
1112   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1113      1 if the contents of the low 16 bits, treated as a signed number,
1114      is negative.  */
1115   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1116   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1117          16,                    /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_signed, /* complain_on_overflow */
1123          ppc64_elf_unhandled_reloc, /* special_function */
1124          "R_PPC64_PLTGOT16_HA", /* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xffff,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          bfd_elf_generic_reloc, /* special_function */
1139          "R_PPC64_ADDR16_DS",   /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont,/* complain_on_overflow */
1153          bfd_elf_generic_reloc, /* special_function */
1154          "R_PPC64_ADDR16_LO_DS",/* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_GOT16_DS,      /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_signed, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_GOT16_DS",    /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_dont, /* complain_on_overflow */
1183          ppc64_elf_unhandled_reloc, /* special_function */
1184          "R_PPC64_GOT16_LO_DS", /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_unhandled_reloc, /* special_function */
1199          "R_PPC64_PLT16_LO_DS", /* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_sectoff_reloc, /* special_function */
1214          "R_PPC64_SECTOFF_DS",  /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_sectoff_reloc, /* special_function */
1229          "R_PPC64_SECTOFF_LO_DS",/* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1236   HOWTO (R_PPC64_TOC16_DS,      /* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_signed, /* complain_on_overflow */
1243          ppc64_elf_toc_reloc,   /* special_function */
1244          "R_PPC64_TOC16_DS",    /* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1251   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_toc_reloc,   /* special_function */
1259          "R_PPC64_TOC16_LO_DS", /* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1266   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1267   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1268          0,                     /* rightshift */
1269          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1270          16,                    /* bitsize */
1271          FALSE,                 /* pc_relative */
1272          0,                     /* bitpos */
1273          complain_overflow_signed, /* complain_on_overflow */
1274          ppc64_elf_unhandled_reloc, /* special_function */
1275          "R_PPC64_PLTGOT16_DS", /* name */
1276          FALSE,                 /* partial_inplace */
1277          0,                     /* src_mask */
1278          0xfffc,                /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1282   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1283   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1284          0,                     /* rightshift */
1285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1286          16,                    /* bitsize */
1287          FALSE,                 /* pc_relative */
1288          0,                     /* bitpos */
1289          complain_overflow_dont, /* complain_on_overflow */
1290          ppc64_elf_unhandled_reloc, /* special_function */
1291          "R_PPC64_PLTGOT16_LO_DS",/* name */
1292          FALSE,                 /* partial_inplace */
1293          0,                     /* src_mask */
1294          0xfffc,                /* dst_mask */
1295          FALSE),                /* pcrel_offset */
1296
1297   /* Marker relocs for TLS.  */
1298   HOWTO (R_PPC64_TLS,
1299          0,                     /* rightshift */
1300          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1301          32,                    /* bitsize */
1302          FALSE,                 /* pc_relative */
1303          0,                     /* bitpos */
1304          complain_overflow_dont, /* complain_on_overflow */
1305          bfd_elf_generic_reloc, /* special_function */
1306          "R_PPC64_TLS",         /* name */
1307          FALSE,                 /* partial_inplace */
1308          0,                     /* src_mask */
1309          0,                     /* dst_mask */
1310          FALSE),                /* pcrel_offset */
1311
1312   HOWTO (R_PPC64_TLSGD,
1313          0,                     /* rightshift */
1314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1315          32,                    /* bitsize */
1316          FALSE,                 /* pc_relative */
1317          0,                     /* bitpos */
1318          complain_overflow_dont, /* complain_on_overflow */
1319          bfd_elf_generic_reloc, /* special_function */
1320          "R_PPC64_TLSGD",       /* name */
1321          FALSE,                 /* partial_inplace */
1322          0,                     /* src_mask */
1323          0,                     /* dst_mask */
1324          FALSE),                /* pcrel_offset */
1325
1326   HOWTO (R_PPC64_TLSLD,
1327          0,                     /* rightshift */
1328          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          32,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          bfd_elf_generic_reloc, /* special_function */
1334          "R_PPC64_TLSLD",       /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          0,                     /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Marker reloc for optimizing r2 save in prologue rather than on
1341      each plt call stub.  */
1342   HOWTO (R_PPC64_TOCSAVE,
1343          0,                     /* rightshift */
1344          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          32,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_dont, /* complain_on_overflow */
1349          bfd_elf_generic_reloc, /* special_function */
1350          "R_PPC64_TOCSAVE",     /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          0,                     /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* Marker relocs on inline plt call instructions.  */
1357   HOWTO (R_PPC64_PLTSEQ,
1358          0,                     /* rightshift */
1359          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          32,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_dont, /* complain_on_overflow */
1364          bfd_elf_generic_reloc, /* special_function */
1365          "R_PPC64_PLTSEQ",      /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0,                     /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   HOWTO (R_PPC64_PLTCALL,
1372          0,                     /* rightshift */
1373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          32,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          bfd_elf_generic_reloc, /* special_function */
1379          "R_PPC64_PLTCALL",     /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0,                     /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Computes the load module index of the load module that contains the
1386      definition of its TLS sym.  */
1387   HOWTO (R_PPC64_DTPMOD64,
1388          0,                     /* rightshift */
1389          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          64,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_dont, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPMOD64",    /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          ONES (64),             /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Computes a dtv-relative displacement, the difference between the value
1402      of sym+add and the base address of the thread-local storage block that
1403      contains the definition of sym, minus 0x8000.  */
1404   HOWTO (R_PPC64_DTPREL64,
1405          0,                     /* rightshift */
1406          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1407          64,                    /* bitsize */
1408          FALSE,                 /* pc_relative */
1409          0,                     /* bitpos */
1410          complain_overflow_dont, /* complain_on_overflow */
1411          ppc64_elf_unhandled_reloc, /* special_function */
1412          "R_PPC64_DTPREL64",    /* name */
1413          FALSE,                 /* partial_inplace */
1414          0,                     /* src_mask */
1415          ONES (64),             /* dst_mask */
1416          FALSE),                /* pcrel_offset */
1417
1418   /* A 16 bit dtprel reloc.  */
1419   HOWTO (R_PPC64_DTPREL16,
1420          0,                     /* rightshift */
1421          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1422          16,                    /* bitsize */
1423          FALSE,                 /* pc_relative */
1424          0,                     /* bitpos */
1425          complain_overflow_signed, /* complain_on_overflow */
1426          ppc64_elf_unhandled_reloc, /* special_function */
1427          "R_PPC64_DTPREL16",    /* name */
1428          FALSE,                 /* partial_inplace */
1429          0,                     /* src_mask */
1430          0xffff,                /* dst_mask */
1431          FALSE),                /* pcrel_offset */
1432
1433   /* Like DTPREL16, but no overflow.  */
1434   HOWTO (R_PPC64_DTPREL16_LO,
1435          0,                     /* rightshift */
1436          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1437          16,                    /* bitsize */
1438          FALSE,                 /* pc_relative */
1439          0,                     /* bitpos */
1440          complain_overflow_dont, /* complain_on_overflow */
1441          ppc64_elf_unhandled_reloc, /* special_function */
1442          "R_PPC64_DTPREL16_LO", /* name */
1443          FALSE,                 /* partial_inplace */
1444          0,                     /* src_mask */
1445          0xffff,                /* dst_mask */
1446          FALSE),                /* pcrel_offset */
1447
1448   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1449   HOWTO (R_PPC64_DTPREL16_HI,
1450          16,                    /* rightshift */
1451          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1452          16,                    /* bitsize */
1453          FALSE,                 /* pc_relative */
1454          0,                     /* bitpos */
1455          complain_overflow_signed, /* complain_on_overflow */
1456          ppc64_elf_unhandled_reloc, /* special_function */
1457          "R_PPC64_DTPREL16_HI", /* name */
1458          FALSE,                 /* partial_inplace */
1459          0,                     /* src_mask */
1460          0xffff,                /* dst_mask */
1461          FALSE),                /* pcrel_offset */
1462
1463   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1464   HOWTO (R_PPC64_DTPREL16_HA,
1465          16,                    /* rightshift */
1466          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1467          16,                    /* bitsize */
1468          FALSE,                 /* pc_relative */
1469          0,                     /* bitpos */
1470          complain_overflow_signed, /* complain_on_overflow */
1471          ppc64_elf_unhandled_reloc, /* special_function */
1472          "R_PPC64_DTPREL16_HA", /* name */
1473          FALSE,                 /* partial_inplace */
1474          0,                     /* src_mask */
1475          0xffff,                /* dst_mask */
1476          FALSE),                /* pcrel_offset */
1477
1478   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1479   HOWTO (R_PPC64_DTPREL16_HIGHER,
1480          32,                    /* rightshift */
1481          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1482          16,                    /* bitsize */
1483          FALSE,                 /* pc_relative */
1484          0,                     /* bitpos */
1485          complain_overflow_dont, /* complain_on_overflow */
1486          ppc64_elf_unhandled_reloc, /* special_function */
1487          "R_PPC64_DTPREL16_HIGHER", /* name */
1488          FALSE,                 /* partial_inplace */
1489          0,                     /* src_mask */
1490          0xffff,                /* dst_mask */
1491          FALSE),                /* pcrel_offset */
1492
1493   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1494   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1495          32,                    /* rightshift */
1496          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1497          16,                    /* bitsize */
1498          FALSE,                 /* pc_relative */
1499          0,                     /* bitpos */
1500          complain_overflow_dont, /* complain_on_overflow */
1501          ppc64_elf_unhandled_reloc, /* special_function */
1502          "R_PPC64_DTPREL16_HIGHERA", /* name */
1503          FALSE,                 /* partial_inplace */
1504          0,                     /* src_mask */
1505          0xffff,                /* dst_mask */
1506          FALSE),                /* pcrel_offset */
1507
1508   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1509   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1510          48,                    /* rightshift */
1511          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          16,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_DTPREL16_HIGHEST", /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          0xffff,                /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1524   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1525          48,                    /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_dont, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like DTPREL16, but for insns with a DS field.  */
1539   HOWTO (R_PPC64_DTPREL16_DS,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_signed, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_DTPREL16_DS", /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xfffc,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like DTPREL16_DS, but no overflow.  */
1554   HOWTO (R_PPC64_DTPREL16_LO_DS,
1555          0,                     /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_dont, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_DTPREL16_LO_DS", /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xfffc,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Computes a tp-relative displacement, the difference between the value of
1569      sym+add and the value of the thread pointer (r13).  */
1570   HOWTO (R_PPC64_TPREL64,
1571          0,                     /* rightshift */
1572          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1573          64,                    /* bitsize */
1574          FALSE,                 /* pc_relative */
1575          0,                     /* bitpos */
1576          complain_overflow_dont, /* complain_on_overflow */
1577          ppc64_elf_unhandled_reloc, /* special_function */
1578          "R_PPC64_TPREL64",     /* name */
1579          FALSE,                 /* partial_inplace */
1580          0,                     /* src_mask */
1581          ONES (64),             /* dst_mask */
1582          FALSE),                /* pcrel_offset */
1583
1584   /* A 16 bit tprel reloc.  */
1585   HOWTO (R_PPC64_TPREL16,
1586          0,                     /* rightshift */
1587          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1588          16,                    /* bitsize */
1589          FALSE,                 /* pc_relative */
1590          0,                     /* bitpos */
1591          complain_overflow_signed, /* complain_on_overflow */
1592          ppc64_elf_unhandled_reloc, /* special_function */
1593          "R_PPC64_TPREL16",     /* name */
1594          FALSE,                 /* partial_inplace */
1595          0,                     /* src_mask */
1596          0xffff,                /* dst_mask */
1597          FALSE),                /* pcrel_offset */
1598
1599   /* Like TPREL16, but no overflow.  */
1600   HOWTO (R_PPC64_TPREL16_LO,
1601          0,                     /* rightshift */
1602          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1603          16,                    /* bitsize */
1604          FALSE,                 /* pc_relative */
1605          0,                     /* bitpos */
1606          complain_overflow_dont, /* complain_on_overflow */
1607          ppc64_elf_unhandled_reloc, /* special_function */
1608          "R_PPC64_TPREL16_LO",  /* name */
1609          FALSE,                 /* partial_inplace */
1610          0,                     /* src_mask */
1611          0xffff,                /* dst_mask */
1612          FALSE),                /* pcrel_offset */
1613
1614   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1615   HOWTO (R_PPC64_TPREL16_HI,
1616          16,                    /* rightshift */
1617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1618          16,                    /* bitsize */
1619          FALSE,                 /* pc_relative */
1620          0,                     /* bitpos */
1621          complain_overflow_signed, /* complain_on_overflow */
1622          ppc64_elf_unhandled_reloc, /* special_function */
1623          "R_PPC64_TPREL16_HI",  /* name */
1624          FALSE,                 /* partial_inplace */
1625          0,                     /* src_mask */
1626          0xffff,                /* dst_mask */
1627          FALSE),                /* pcrel_offset */
1628
1629   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1630   HOWTO (R_PPC64_TPREL16_HA,
1631          16,                    /* rightshift */
1632          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1633          16,                    /* bitsize */
1634          FALSE,                 /* pc_relative */
1635          0,                     /* bitpos */
1636          complain_overflow_signed, /* complain_on_overflow */
1637          ppc64_elf_unhandled_reloc, /* special_function */
1638          "R_PPC64_TPREL16_HA",  /* name */
1639          FALSE,                 /* partial_inplace */
1640          0,                     /* src_mask */
1641          0xffff,                /* dst_mask */
1642          FALSE),                /* pcrel_offset */
1643
1644   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1645   HOWTO (R_PPC64_TPREL16_HIGHER,
1646          32,                    /* rightshift */
1647          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1648          16,                    /* bitsize */
1649          FALSE,                 /* pc_relative */
1650          0,                     /* bitpos */
1651          complain_overflow_dont, /* complain_on_overflow */
1652          ppc64_elf_unhandled_reloc, /* special_function */
1653          "R_PPC64_TPREL16_HIGHER",      /* name */
1654          FALSE,                 /* partial_inplace */
1655          0,                     /* src_mask */
1656          0xffff,                /* dst_mask */
1657          FALSE),                /* pcrel_offset */
1658
1659   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1660   HOWTO (R_PPC64_TPREL16_HIGHERA,
1661          32,                    /* rightshift */
1662          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1663          16,                    /* bitsize */
1664          FALSE,                 /* pc_relative */
1665          0,                     /* bitpos */
1666          complain_overflow_dont, /* complain_on_overflow */
1667          ppc64_elf_unhandled_reloc, /* special_function */
1668          "R_PPC64_TPREL16_HIGHERA", /* name */
1669          FALSE,                 /* partial_inplace */
1670          0,                     /* src_mask */
1671          0xffff,                /* dst_mask */
1672          FALSE),                /* pcrel_offset */
1673
1674   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1675   HOWTO (R_PPC64_TPREL16_HIGHEST,
1676          48,                    /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_dont, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_TPREL16_HIGHEST", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1690   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1691          48,                    /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_dont, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_TPREL16_HIGHESTA", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like TPREL16, but for insns with a DS field.  */
1705   HOWTO (R_PPC64_TPREL16_DS,
1706          0,                     /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_TPREL16_DS",  /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xfffc,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like TPREL16_DS, but no overflow.  */
1720   HOWTO (R_PPC64_TPREL16_LO_DS,
1721          0,                     /* rightshift */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1723          16,                    /* bitsize */
1724          FALSE,                 /* pc_relative */
1725          0,                     /* bitpos */
1726          complain_overflow_dont, /* complain_on_overflow */
1727          ppc64_elf_unhandled_reloc, /* special_function */
1728          "R_PPC64_TPREL16_LO_DS", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xfffc,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1736      to the first entry relative to the TOC base (r2).  */
1737   HOWTO (R_PPC64_GOT_TLSGD16,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_signed, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSGD16", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSGD16, but no overflow.  */
1752   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_dont, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSGD16_LO", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1768          16,                    /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSGD16_HI", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1782   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1783          16,                    /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSGD16_HA", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1797      with values (sym+add)@dtpmod and zero, and computes the offset to the
1798      first entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_TLSLD16,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_TLSLD16", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xffff,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_TLSLD16, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_TLSLD16_LO", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xffff,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_TLSLD16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_TLSLD16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1859      the offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_DTPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_DTPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_DTPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_DTPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1920      offset to the entry relative to the TOC base (r2).  */
1921   HOWTO (R_PPC64_GOT_TPREL16_DS,
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          FALSE,                 /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_signed, /* complain_on_overflow */
1928          ppc64_elf_unhandled_reloc, /* special_function */
1929          "R_PPC64_GOT_TPREL16_DS", /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xfffc,                /* dst_mask */
1933          FALSE),                /* pcrel_offset */
1934
1935   /* Like GOT_TPREL16_DS, but no overflow.  */
1936   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1937          0,                     /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          FALSE,                 /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          ppc64_elf_unhandled_reloc, /* special_function */
1944          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xfffc,                /* dst_mask */
1948          FALSE),                /* pcrel_offset */
1949
1950   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1951   HOWTO (R_PPC64_GOT_TPREL16_HI,
1952          16,                    /* rightshift */
1953          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1954          16,                    /* bitsize */
1955          FALSE,                 /* pc_relative */
1956          0,                     /* bitpos */
1957          complain_overflow_signed, /* complain_on_overflow */
1958          ppc64_elf_unhandled_reloc, /* special_function */
1959          "R_PPC64_GOT_TPREL16_HI", /* name */
1960          FALSE,                 /* partial_inplace */
1961          0,                     /* src_mask */
1962          0xffff,                /* dst_mask */
1963          FALSE),                /* pcrel_offset */
1964
1965   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1966   HOWTO (R_PPC64_GOT_TPREL16_HA,
1967          16,                    /* rightshift */
1968          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1969          16,                    /* bitsize */
1970          FALSE,                 /* pc_relative */
1971          0,                     /* bitpos */
1972          complain_overflow_signed, /* complain_on_overflow */
1973          ppc64_elf_unhandled_reloc, /* special_function */
1974          "R_PPC64_GOT_TPREL16_HA", /* name */
1975          FALSE,                 /* partial_inplace */
1976          0,                     /* src_mask */
1977          0xffff,                /* dst_mask */
1978          FALSE),                /* pcrel_offset */
1979
1980   HOWTO (R_PPC64_JMP_IREL,      /* type */
1981          0,                     /* rightshift */
1982          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1983          0,                     /* bitsize */
1984          FALSE,                 /* pc_relative */
1985          0,                     /* bitpos */
1986          complain_overflow_dont, /* complain_on_overflow */
1987          ppc64_elf_unhandled_reloc, /* special_function */
1988          "R_PPC64_JMP_IREL",    /* name */
1989          FALSE,                 /* partial_inplace */
1990          0,                     /* src_mask */
1991          0,                     /* dst_mask */
1992          FALSE),                /* pcrel_offset */
1993
1994   HOWTO (R_PPC64_IRELATIVE,     /* type */
1995          0,                     /* rightshift */
1996          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1997          64,                    /* bitsize */
1998          FALSE,                 /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_dont, /* complain_on_overflow */
2001          bfd_elf_generic_reloc, /* special_function */
2002          "R_PPC64_IRELATIVE",   /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          ONES (64),             /* dst_mask */
2006          FALSE),                /* pcrel_offset */
2007
2008   /* A 16 bit relative relocation.  */
2009   HOWTO (R_PPC64_REL16,         /* type */
2010          0,                     /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          TRUE,                  /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_signed, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_REL16",       /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          TRUE),                 /* pcrel_offset */
2022
2023   /* A 16 bit relative relocation without overflow.  */
2024   HOWTO (R_PPC64_REL16_LO,      /* type */
2025          0,                     /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          TRUE,                  /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont,/* complain_on_overflow */
2031          bfd_elf_generic_reloc, /* special_function */
2032          "R_PPC64_REL16_LO",    /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          TRUE),                 /* pcrel_offset */
2037
2038   /* The high order 16 bits of a relative address.  */
2039   HOWTO (R_PPC64_REL16_HI,      /* type */
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          TRUE,                  /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_signed, /* complain_on_overflow */
2046          bfd_elf_generic_reloc, /* special_function */
2047          "R_PPC64_REL16_HI",    /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          TRUE),                 /* pcrel_offset */
2052
2053   /* The high order 16 bits of a relative address, plus 1 if the contents of
2054      the low 16 bits, treated as a signed number, is negative.  */
2055   HOWTO (R_PPC64_REL16_HA,      /* type */
2056          16,                    /* rightshift */
2057          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2058          16,                    /* bitsize */
2059          TRUE,                  /* pc_relative */
2060          0,                     /* bitpos */
2061          complain_overflow_signed, /* complain_on_overflow */
2062          ppc64_elf_ha_reloc,    /* special_function */
2063          "R_PPC64_REL16_HA",    /* name */
2064          FALSE,                 /* partial_inplace */
2065          0,                     /* src_mask */
2066          0xffff,                /* dst_mask */
2067          TRUE),                 /* pcrel_offset */
2068
2069   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2070   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2071          16,                    /* rightshift */
2072          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2073          16,                    /* bitsize */
2074          TRUE,                  /* pc_relative */
2075          0,                     /* bitpos */
2076          complain_overflow_signed, /* complain_on_overflow */
2077          ppc64_elf_ha_reloc,    /* special_function */
2078          "R_PPC64_REL16DX_HA",  /* name */
2079          FALSE,                 /* partial_inplace */
2080          0,                     /* src_mask */
2081          0x1fffc1,              /* dst_mask */
2082          TRUE),                 /* pcrel_offset */
2083
2084   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2085   HOWTO (R_PPC64_16DX_HA,       /* type */
2086          16,                    /* rightshift */
2087          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2088          16,                    /* bitsize */
2089          FALSE,                 /* pc_relative */
2090          0,                     /* bitpos */
2091          complain_overflow_signed, /* complain_on_overflow */
2092          ppc64_elf_ha_reloc,    /* special_function */
2093          "R_PPC64_16DX_HA",     /* name */
2094          FALSE,                 /* partial_inplace */
2095          0,                     /* src_mask */
2096          0x1fffc1,              /* dst_mask */
2097          FALSE),                /* pcrel_offset */
2098
2099   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2100   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2101          16,                    /* rightshift */
2102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2103          16,                    /* bitsize */
2104          FALSE,                 /* pc_relative */
2105          0,                     /* bitpos */
2106          complain_overflow_dont, /* complain_on_overflow */
2107          bfd_elf_generic_reloc, /* special_function */
2108          "R_PPC64_ADDR16_HIGH", /* name */
2109          FALSE,                 /* partial_inplace */
2110          0,                     /* src_mask */
2111          0xffff,                /* dst_mask */
2112          FALSE),                /* pcrel_offset */
2113
2114   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2115   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2116          16,                    /* rightshift */
2117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2118          16,                    /* bitsize */
2119          FALSE,                 /* pc_relative */
2120          0,                     /* bitpos */
2121          complain_overflow_dont, /* complain_on_overflow */
2122          ppc64_elf_ha_reloc,    /* special_function */
2123          "R_PPC64_ADDR16_HIGHA",        /* name */
2124          FALSE,                 /* partial_inplace */
2125          0,                     /* src_mask */
2126          0xffff,                /* dst_mask */
2127          FALSE),                /* pcrel_offset */
2128
2129   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2130   HOWTO (R_PPC64_DTPREL16_HIGH,
2131          16,                    /* rightshift */
2132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2133          16,                    /* bitsize */
2134          FALSE,                 /* pc_relative */
2135          0,                     /* bitpos */
2136          complain_overflow_dont, /* complain_on_overflow */
2137          ppc64_elf_unhandled_reloc, /* special_function */
2138          "R_PPC64_DTPREL16_HIGH", /* name */
2139          FALSE,                 /* partial_inplace */
2140          0,                     /* src_mask */
2141          0xffff,                /* dst_mask */
2142          FALSE),                /* pcrel_offset */
2143
2144   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2145   HOWTO (R_PPC64_DTPREL16_HIGHA,
2146          16,                    /* rightshift */
2147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2148          16,                    /* bitsize */
2149          FALSE,                 /* pc_relative */
2150          0,                     /* bitpos */
2151          complain_overflow_dont, /* complain_on_overflow */
2152          ppc64_elf_unhandled_reloc, /* special_function */
2153          "R_PPC64_DTPREL16_HIGHA", /* name */
2154          FALSE,                 /* partial_inplace */
2155          0,                     /* src_mask */
2156          0xffff,                /* dst_mask */
2157          FALSE),                /* pcrel_offset */
2158
2159   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2160   HOWTO (R_PPC64_TPREL16_HIGH,
2161          16,                    /* rightshift */
2162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2163          16,                    /* bitsize */
2164          FALSE,                 /* pc_relative */
2165          0,                     /* bitpos */
2166          complain_overflow_dont, /* complain_on_overflow */
2167          ppc64_elf_unhandled_reloc, /* special_function */
2168          "R_PPC64_TPREL16_HIGH",        /* name */
2169          FALSE,                 /* partial_inplace */
2170          0,                     /* src_mask */
2171          0xffff,                /* dst_mask */
2172          FALSE),                /* pcrel_offset */
2173
2174   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2175   HOWTO (R_PPC64_TPREL16_HIGHA,
2176          16,                    /* rightshift */
2177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2178          16,                    /* bitsize */
2179          FALSE,                 /* pc_relative */
2180          0,                     /* bitpos */
2181          complain_overflow_dont, /* complain_on_overflow */
2182          ppc64_elf_unhandled_reloc, /* special_function */
2183          "R_PPC64_TPREL16_HIGHA",       /* name */
2184          FALSE,                 /* partial_inplace */
2185          0,                     /* src_mask */
2186          0xffff,                /* dst_mask */
2187          FALSE),                /* pcrel_offset */
2188
2189   /* Marker reloc on ELFv2 large-model function entry.  */
2190   HOWTO (R_PPC64_ENTRY,
2191          0,                     /* rightshift */
2192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2193          32,                    /* bitsize */
2194          FALSE,                 /* pc_relative */
2195          0,                     /* bitpos */
2196          complain_overflow_dont, /* complain_on_overflow */
2197          bfd_elf_generic_reloc, /* special_function */
2198          "R_PPC64_ENTRY",       /* name */
2199          FALSE,                 /* partial_inplace */
2200          0,                     /* src_mask */
2201          0,                     /* dst_mask */
2202          FALSE),                /* pcrel_offset */
2203
2204   /* Like ADDR64, but use local entry point of function.  */
2205   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2206          0,                     /* rightshift */
2207          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2208          64,                    /* bitsize */
2209          FALSE,                 /* pc_relative */
2210          0,                     /* bitpos */
2211          complain_overflow_dont, /* complain_on_overflow */
2212          bfd_elf_generic_reloc, /* special_function */
2213          "R_PPC64_ADDR64_LOCAL", /* name */
2214          FALSE,                 /* partial_inplace */
2215          0,                     /* src_mask */
2216          ONES (64),             /* dst_mask */
2217          FALSE),                /* pcrel_offset */
2218
2219   /* GNU extension to record C++ vtable hierarchy.  */
2220   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2221          0,                     /* rightshift */
2222          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2223          0,                     /* bitsize */
2224          FALSE,                 /* pc_relative */
2225          0,                     /* bitpos */
2226          complain_overflow_dont, /* complain_on_overflow */
2227          NULL,                  /* special_function */
2228          "R_PPC64_GNU_VTINHERIT", /* name */
2229          FALSE,                 /* partial_inplace */
2230          0,                     /* src_mask */
2231          0,                     /* dst_mask */
2232          FALSE),                /* pcrel_offset */
2233
2234   /* GNU extension to record C++ vtable member usage.  */
2235   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2236          0,                     /* rightshift */
2237          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2238          0,                     /* bitsize */
2239          FALSE,                 /* pc_relative */
2240          0,                     /* bitpos */
2241          complain_overflow_dont, /* complain_on_overflow */
2242          NULL,                  /* special_function */
2243          "R_PPC64_GNU_VTENTRY", /* name */
2244          FALSE,                 /* partial_inplace */
2245          0,                     /* src_mask */
2246          0,                     /* dst_mask */
2247          FALSE),                /* pcrel_offset */
2248 };
2249
2250 \f
2251 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2252    be done.  */
2253
2254 static void
2255 ppc_howto_init (void)
2256 {
2257   unsigned int i, type;
2258
2259   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2260     {
2261       type = ppc64_elf_howto_raw[i].type;
2262       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2263       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2264     }
2265 }
2266
2267 static reloc_howto_type *
2268 ppc64_elf_reloc_type_lookup (bfd *abfd,
2269                              bfd_reloc_code_real_type code)
2270 {
2271   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2272
2273   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2274     /* Initialize howto table if needed.  */
2275     ppc_howto_init ();
2276
2277   switch (code)
2278     {
2279     default:
2280       /* xgettext:c-format */
2281       _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2282       bfd_set_error (bfd_error_bad_value);
2283       return NULL;
2284
2285     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2286       break;
2287     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2288       break;
2289     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2290       break;
2291     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2292       break;
2293     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2294       break;
2295     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2296       break;
2297     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2298       break;
2299     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2300       break;
2301     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2302       break;
2303     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2304       break;
2305     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2306       break;
2307     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2308       break;
2309     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2310       break;
2311     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2312       break;
2313     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2314       break;
2315     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2316       break;
2317     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2318       break;
2319     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2320       break;
2321     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2322       break;
2323     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2324       break;
2325     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2326       break;
2327     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2328       break;
2329     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2330       break;
2331     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2332       break;
2333     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2334       break;
2335     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2336       break;
2337     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2338       break;
2339     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2340       break;
2341     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2342       break;
2343     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2344       break;
2345     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2346       break;
2347     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2348       break;
2349     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2350       break;
2351     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2352       break;
2353     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2354       break;
2355     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2356       break;
2357     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2358       break;
2359     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2360       break;
2361     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2362       break;
2363     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2364       break;
2365     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2366       break;
2367     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2368       break;
2369     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2370       break;
2371     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2372       break;
2373     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2374       break;
2375     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2376       break;
2377     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2378       break;
2379     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2380       break;
2381     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2384       break;
2385     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2386       break;
2387     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2388       break;
2389     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2390       break;
2391     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2392       break;
2393     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2394       break;
2395     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2396       break;
2397     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2398       break;
2399     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2400       break;
2401     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2402       break;
2403     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2404       break;
2405     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2406       break;
2407     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2408       break;
2409     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2410       break;
2411     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2412       break;
2413     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2414       break;
2415     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2416       break;
2417     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2418       break;
2419     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2422       break;
2423     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2426       break;
2427     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2428       break;
2429     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2430       break;
2431     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2432       break;
2433     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2436       break;
2437     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2440       break;
2441     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2442       break;
2443     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2444       break;
2445     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2446       break;
2447     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2448       break;
2449     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2450       break;
2451     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2452       break;
2453     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2454       break;
2455     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2456       break;
2457     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2458       break;
2459     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2460       break;
2461     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2462       break;
2463     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2464       break;
2465     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2466       break;
2467     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2468       break;
2469     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2470       break;
2471     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2472       break;
2473     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2474       break;
2475     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2476       break;
2477     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2478       break;
2479     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2480       break;
2481     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2482       break;
2483     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2484       break;
2485     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2486       break;
2487     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2488       break;
2489     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2490       break;
2491     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2492       break;
2493     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2494       break;
2495     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2496       break;
2497     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2498       break;
2499     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2500       break;
2501     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2502       break;
2503     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2504       break;
2505     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2506       break;
2507     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2508       break;
2509     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2510       break;
2511     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2512       break;
2513     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2514       break;
2515     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2516       break;
2517     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2518       break;
2519     }
2520
2521   return ppc64_elf_howto_table[r];
2522 };
2523
2524 static reloc_howto_type *
2525 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2526                              const char *r_name)
2527 {
2528   unsigned int i;
2529
2530   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2531     if (ppc64_elf_howto_raw[i].name != NULL
2532         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2533       return &ppc64_elf_howto_raw[i];
2534
2535
2536   return NULL;
2537 }
2538
2539 /* Set the howto pointer for a PowerPC ELF reloc.  */
2540
2541 static bfd_boolean
2542 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2543                          Elf_Internal_Rela *dst)
2544 {
2545   unsigned int type;
2546
2547   /* Initialize howto table if needed.  */
2548   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2549     ppc_howto_init ();
2550
2551   type = ELF64_R_TYPE (dst->r_info);
2552   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2553     {
2554       /* xgettext:c-format */
2555       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2556                           abfd, type);
2557       bfd_set_error (bfd_error_bad_value);
2558       return FALSE;
2559     }
2560   cache_ptr->howto = ppc64_elf_howto_table[type];
2561   if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2562     {
2563       /* xgettext:c-format */
2564       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2565                           abfd, type);
2566       bfd_set_error (bfd_error_bad_value);
2567       return FALSE;
2568     }
2569
2570   return TRUE;
2571 }
2572
2573 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2574
2575 static bfd_reloc_status_type
2576 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2577                     void *data, asection *input_section,
2578                     bfd *output_bfd, char **error_message)
2579 {
2580   enum elf_ppc64_reloc_type r_type;
2581   long insn;
2582   bfd_size_type octets;
2583   bfd_vma value;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   /* Adjust the addend for sign extension of the low 16 bits.
2593      We won't actually be using the low 16 bits, so trashing them
2594      doesn't matter.  */
2595   reloc_entry->addend += 0x8000;
2596   r_type = reloc_entry->howto->type;
2597   if (r_type != R_PPC64_REL16DX_HA)
2598     return bfd_reloc_continue;
2599
2600   value = 0;
2601   if (!bfd_is_com_section (symbol->section))
2602     value = symbol->value;
2603   value += (reloc_entry->addend
2604             + symbol->section->output_offset
2605             + symbol->section->output_section->vma);
2606   value -= (reloc_entry->address
2607             + input_section->output_offset
2608             + input_section->output_section->vma);
2609   value = (bfd_signed_vma) value >> 16;
2610
2611   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2612   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2613   insn &= ~0x1fffc1;
2614   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2615   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2616   if (value + 0x8000 > 0xffff)
2617     return bfd_reloc_overflow;
2618   return bfd_reloc_ok;
2619 }
2620
2621 static bfd_reloc_status_type
2622 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2623                         void *data, asection *input_section,
2624                         bfd *output_bfd, char **error_message)
2625 {
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   if (strcmp (symbol->section->name, ".opd") == 0
2631       && (symbol->section->owner->flags & DYNAMIC) == 0)
2632     {
2633       bfd_vma dest = opd_entry_value (symbol->section,
2634                                       symbol->value + reloc_entry->addend,
2635                                       NULL, NULL, FALSE);
2636       if (dest != (bfd_vma) -1)
2637         reloc_entry->addend = dest - (symbol->value
2638                                       + symbol->section->output_section->vma
2639                                       + symbol->section->output_offset);
2640     }
2641   else
2642     {
2643       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2644
2645       if (symbol->section->owner != abfd
2646           && symbol->section->owner != NULL
2647           && abiversion (symbol->section->owner) >= 2)
2648         {
2649           unsigned int i;
2650
2651           for (i = 0; i < symbol->section->owner->symcount; ++i)
2652             {
2653               asymbol *symdef = symbol->section->owner->outsymbols[i];
2654
2655               if (strcmp (symdef->name, symbol->name) == 0)
2656                 {
2657                   elfsym = (elf_symbol_type *) symdef;
2658                   break;
2659                 }
2660             }
2661         }
2662       reloc_entry->addend
2663         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2664     }
2665   return bfd_reloc_continue;
2666 }
2667
2668 static bfd_reloc_status_type
2669 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2670                          void *data, asection *input_section,
2671                          bfd *output_bfd, char **error_message)
2672 {
2673   long insn;
2674   enum elf_ppc64_reloc_type r_type;
2675   bfd_size_type octets;
2676   /* Assume 'at' branch hints.  */
2677   bfd_boolean is_isa_v2 = TRUE;
2678
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2687   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2688   insn &= ~(0x01 << 21);
2689   r_type = reloc_entry->howto->type;
2690   if (r_type == R_PPC64_ADDR14_BRTAKEN
2691       || r_type == R_PPC64_REL14_BRTAKEN)
2692     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2693
2694   if (is_isa_v2)
2695     {
2696       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2697          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2698          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2699       if ((insn & (0x14 << 21)) == (0x04 << 21))
2700         insn |= 0x02 << 21;
2701       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2702         insn |= 0x08 << 21;
2703       else
2704         goto out;
2705     }
2706   else
2707     {
2708       bfd_vma target = 0;
2709       bfd_vma from;
2710
2711       if (!bfd_is_com_section (symbol->section))
2712         target = symbol->value;
2713       target += symbol->section->output_section->vma;
2714       target += symbol->section->output_offset;
2715       target += reloc_entry->addend;
2716
2717       from = (reloc_entry->address
2718               + input_section->output_offset
2719               + input_section->output_section->vma);
2720
2721       /* Invert 'y' bit if not the default.  */
2722       if ((bfd_signed_vma) (target - from) < 0)
2723         insn ^= 0x01 << 21;
2724     }
2725   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2726  out:
2727   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2728                                  input_section, output_bfd, error_message);
2729 }
2730
2731 static bfd_reloc_status_type
2732 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2733                          void *data, asection *input_section,
2734                          bfd *output_bfd, char **error_message)
2735 {
2736   /* If this is a relocatable link (output_bfd test tells us), just
2737      call the generic function.  Any adjustment will be done at final
2738      link time.  */
2739   if (output_bfd != NULL)
2740     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2741                                   input_section, output_bfd, error_message);
2742
2743   /* Subtract the symbol section base address.  */
2744   reloc_entry->addend -= symbol->section->output_section->vma;
2745   return bfd_reloc_continue;
2746 }
2747
2748 static bfd_reloc_status_type
2749 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2750                             void *data, asection *input_section,
2751                             bfd *output_bfd, char **error_message)
2752 {
2753   /* If this is a relocatable link (output_bfd test tells us), just
2754      call the generic function.  Any adjustment will be done at final
2755      link time.  */
2756   if (output_bfd != NULL)
2757     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2758                                   input_section, output_bfd, error_message);
2759
2760   /* Subtract the symbol section base address.  */
2761   reloc_entry->addend -= symbol->section->output_section->vma;
2762
2763   /* Adjust the addend for sign extension of the low 16 bits.  */
2764   reloc_entry->addend += 0x8000;
2765   return bfd_reloc_continue;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                      void *data, asection *input_section,
2771                      bfd *output_bfd, char **error_message)
2772 {
2773   bfd_vma TOCstart;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   /* Subtract the TOC base address.  */
2787   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2788   return bfd_reloc_continue;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                         void *data, asection *input_section,
2794                         bfd *output_bfd, char **error_message)
2795 {
2796   bfd_vma TOCstart;
2797
2798   /* If this is a relocatable link (output_bfd test tells us), just
2799      call the generic function.  Any adjustment will be done at final
2800      link time.  */
2801   if (output_bfd != NULL)
2802     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2803                                   input_section, output_bfd, error_message);
2804
2805   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2806   if (TOCstart == 0)
2807     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2808
2809   /* Subtract the TOC base address.  */
2810   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2811
2812   /* Adjust the addend for sign extension of the low 16 bits.  */
2813   reloc_entry->addend += 0x8000;
2814   return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819                        void *data, asection *input_section,
2820                        bfd *output_bfd, char **error_message)
2821 {
2822   bfd_vma TOCstart;
2823   bfd_size_type octets;
2824
2825   /* If this is a relocatable link (output_bfd test tells us), just
2826      call the generic function.  Any adjustment will be done at final
2827      link time.  */
2828   if (output_bfd != NULL)
2829     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2830                                   input_section, output_bfd, error_message);
2831
2832   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2833   if (TOCstart == 0)
2834     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2835
2836   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2837   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2838   return bfd_reloc_ok;
2839 }
2840
2841 static bfd_reloc_status_type
2842 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2843                            void *data, asection *input_section,
2844                            bfd *output_bfd, char **error_message)
2845 {
2846   /* If this is a relocatable link (output_bfd test tells us), just
2847      call the generic function.  Any adjustment will be done at final
2848      link time.  */
2849   if (output_bfd != NULL)
2850     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2851                                   input_section, output_bfd, error_message);
2852
2853   if (error_message != NULL)
2854     {
2855       static char buf[60];
2856       sprintf (buf, "generic linker can't handle %s",
2857                reloc_entry->howto->name);
2858       *error_message = buf;
2859     }
2860   return bfd_reloc_dangerous;
2861 }
2862
2863 /* Track GOT entries needed for a given symbol.  We might need more
2864    than one got entry per symbol.  */
2865 struct got_entry
2866 {
2867   struct got_entry *next;
2868
2869   /* The symbol addend that we'll be placing in the GOT.  */
2870   bfd_vma addend;
2871
2872   /* Unlike other ELF targets, we use separate GOT entries for the same
2873      symbol referenced from different input files.  This is to support
2874      automatic multiple TOC/GOT sections, where the TOC base can vary
2875      from one input file to another.  After partitioning into TOC groups
2876      we merge entries within the group.
2877
2878      Point to the BFD owning this GOT entry.  */
2879   bfd *owner;
2880
2881   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2882      TLS_TPREL or TLS_DTPREL for tls entries.  */
2883   unsigned char tls_type;
2884
2885   /* Non-zero if got.ent points to real entry.  */
2886   unsigned char is_indirect;
2887
2888   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2889   union
2890     {
2891       bfd_signed_vma refcount;
2892       bfd_vma offset;
2893       struct got_entry *ent;
2894     } got;
2895 };
2896
2897 /* The same for PLT.  */
2898 struct plt_entry
2899 {
2900   struct plt_entry *next;
2901
2902   bfd_vma addend;
2903
2904   union
2905     {
2906       bfd_signed_vma refcount;
2907       bfd_vma offset;
2908     } plt;
2909 };
2910
2911 struct ppc64_elf_obj_tdata
2912 {
2913   struct elf_obj_tdata elf;
2914
2915   /* Shortcuts to dynamic linker sections.  */
2916   asection *got;
2917   asection *relgot;
2918
2919   /* Used during garbage collection.  We attach global symbols defined
2920      on removed .opd entries to this section so that the sym is removed.  */
2921   asection *deleted_section;
2922
2923   /* TLS local dynamic got entry handling.  Support for multiple GOT
2924      sections means we potentially need one of these for each input bfd.  */
2925   struct got_entry tlsld_got;
2926
2927   union {
2928     /* A copy of relocs before they are modified for --emit-relocs.  */
2929     Elf_Internal_Rela *relocs;
2930
2931     /* Section contents.  */
2932     bfd_byte *contents;
2933   } opd;
2934
2935   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2936      the reloc to be in the range -32768 to 32767.  */
2937   unsigned int has_small_toc_reloc : 1;
2938
2939   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2940      instruction not one we handle.  */
2941   unsigned int unexpected_toc_insn : 1;
2942 };
2943
2944 #define ppc64_elf_tdata(bfd) \
2945   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2946
2947 #define ppc64_tlsld_got(bfd) \
2948   (&ppc64_elf_tdata (bfd)->tlsld_got)
2949
2950 #define is_ppc64_elf(bfd) \
2951   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2952    && elf_object_id (bfd) == PPC64_ELF_DATA)
2953
2954 /* Override the generic function because we store some extras.  */
2955
2956 static bfd_boolean
2957 ppc64_elf_mkobject (bfd *abfd)
2958 {
2959   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2960                                   PPC64_ELF_DATA);
2961 }
2962
2963 /* Fix bad default arch selected for a 64 bit input bfd when the
2964    default is 32 bit.  Also select arch based on apuinfo.  */
2965
2966 static bfd_boolean
2967 ppc64_elf_object_p (bfd *abfd)
2968 {
2969   if (!abfd->arch_info->the_default)
2970     return TRUE;
2971
2972   if (abfd->arch_info->bits_per_word == 32)
2973     {
2974       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2975
2976       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2977         {
2978           /* Relies on arch after 32 bit default being 64 bit default.  */
2979           abfd->arch_info = abfd->arch_info->next;
2980           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2981         }
2982     }
2983   return _bfd_elf_ppc_set_arch (abfd);
2984 }
2985
2986 /* Support for core dump NOTE sections.  */
2987
2988 static bfd_boolean
2989 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2990 {
2991   size_t offset, size;
2992
2993   if (note->descsz != 504)
2994     return FALSE;
2995
2996   /* pr_cursig */
2997   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2998
2999   /* pr_pid */
3000   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3001
3002   /* pr_reg */
3003   offset = 112;
3004   size = 384;
3005
3006   /* Make a ".reg/999" section.  */
3007   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3008                                           size, note->descpos + offset);
3009 }
3010
3011 static bfd_boolean
3012 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3013 {
3014   if (note->descsz != 136)
3015     return FALSE;
3016
3017   elf_tdata (abfd)->core->pid
3018     = bfd_get_32 (abfd, note->descdata + 24);
3019   elf_tdata (abfd)->core->program
3020     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3021   elf_tdata (abfd)->core->command
3022     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3023
3024   return TRUE;
3025 }
3026
3027 static char *
3028 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3029                            ...)
3030 {
3031   switch (note_type)
3032     {
3033     default:
3034       return NULL;
3035
3036     case NT_PRPSINFO:
3037       {
3038         char data[136] ATTRIBUTE_NONSTRING;
3039         va_list ap;
3040
3041         va_start (ap, note_type);
3042         memset (data, 0, sizeof (data));
3043         strncpy (data + 40, va_arg (ap, const char *), 16);
3044 #if GCC_VERSION == 8001
3045         DIAGNOSTIC_PUSH;
3046         /* GCC 8.1 warns about 80 equals destination size with
3047            -Wstringop-truncation:
3048            https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3049          */
3050         DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3051 #endif
3052         strncpy (data + 56, va_arg (ap, const char *), 80);
3053 #if GCC_VERSION == 8001
3054         DIAGNOSTIC_POP;
3055 #endif
3056         va_end (ap);
3057         return elfcore_write_note (abfd, buf, bufsiz,
3058                                    "CORE", note_type, data, sizeof (data));
3059       }
3060
3061     case NT_PRSTATUS:
3062       {
3063         char data[504];
3064         va_list ap;
3065         long pid;
3066         int cursig;
3067         const void *greg;
3068
3069         va_start (ap, note_type);
3070         memset (data, 0, 112);
3071         pid = va_arg (ap, long);
3072         bfd_put_32 (abfd, pid, data + 32);
3073         cursig = va_arg (ap, int);
3074         bfd_put_16 (abfd, cursig, data + 12);
3075         greg = va_arg (ap, const void *);
3076         memcpy (data + 112, greg, 384);
3077         memset (data + 496, 0, 8);
3078         va_end (ap);
3079         return elfcore_write_note (abfd, buf, bufsiz,
3080                                    "CORE", note_type, data, sizeof (data));
3081       }
3082     }
3083 }
3084
3085 /* Add extra PPC sections.  */
3086
3087 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3088 {
3089   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3090   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3091   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3092   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3093   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3094   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3095   { NULL,                     0,  0, 0,            0 }
3096 };
3097
3098 enum _ppc64_sec_type {
3099   sec_normal = 0,
3100   sec_opd = 1,
3101   sec_toc = 2
3102 };
3103
3104 struct _ppc64_elf_section_data
3105 {
3106   struct bfd_elf_section_data elf;
3107
3108   union
3109   {
3110     /* An array with one entry for each opd function descriptor,
3111        and some spares since opd entries may be either 16 or 24 bytes.  */
3112 #define OPD_NDX(OFF) ((OFF) >> 4)
3113     struct _opd_sec_data
3114     {
3115       /* Points to the function code section for local opd entries.  */
3116       asection **func_sec;
3117
3118       /* After editing .opd, adjust references to opd local syms.  */
3119       long *adjust;
3120     } opd;
3121
3122     /* An array for toc sections, indexed by offset/8.  */
3123     struct _toc_sec_data
3124     {
3125       /* Specifies the relocation symbol index used at a given toc offset.  */
3126       unsigned *symndx;
3127
3128       /* And the relocation addend.  */
3129       bfd_vma *add;
3130     } toc;
3131   } u;
3132
3133   enum _ppc64_sec_type sec_type:2;
3134
3135   /* Flag set when small branches are detected.  Used to
3136      select suitable defaults for the stub group size.  */
3137   unsigned int has_14bit_branch:1;
3138
3139   /* Flag set when PLTCALL relocs are detected.  */
3140   unsigned int has_pltcall:1;
3141 };
3142
3143 #define ppc64_elf_section_data(sec) \
3144   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3145
3146 static bfd_boolean
3147 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3148 {
3149   if (!sec->used_by_bfd)
3150     {
3151       struct _ppc64_elf_section_data *sdata;
3152       bfd_size_type amt = sizeof (*sdata);
3153
3154       sdata = bfd_zalloc (abfd, amt);
3155       if (sdata == NULL)
3156         return FALSE;
3157       sec->used_by_bfd = sdata;
3158     }
3159
3160   return _bfd_elf_new_section_hook (abfd, sec);
3161 }
3162
3163 static struct _opd_sec_data *
3164 get_opd_info (asection * sec)
3165 {
3166   if (sec != NULL
3167       && ppc64_elf_section_data (sec) != NULL
3168       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3169     return &ppc64_elf_section_data (sec)->u.opd;
3170   return NULL;
3171 }
3172 \f
3173 /* Parameters for the qsort hook.  */
3174 static bfd_boolean synthetic_relocatable;
3175 static asection *synthetic_opd;
3176
3177 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3178
3179 static int
3180 compare_symbols (const void *ap, const void *bp)
3181 {
3182   const asymbol *a = * (const asymbol **) ap;
3183   const asymbol *b = * (const asymbol **) bp;
3184
3185   /* Section symbols first.  */
3186   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3187     return -1;
3188   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3189     return 1;
3190
3191   /* then .opd symbols.  */
3192   if (synthetic_opd != NULL)
3193     {
3194       if (strcmp (a->section->name, ".opd") == 0
3195           && strcmp (b->section->name, ".opd") != 0)
3196         return -1;
3197       if (strcmp (a->section->name, ".opd") != 0
3198           && strcmp (b->section->name, ".opd") == 0)
3199         return 1;
3200     }
3201
3202   /* then other code symbols.  */
3203   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3204       == (SEC_CODE | SEC_ALLOC)
3205       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3206          != (SEC_CODE | SEC_ALLOC))
3207     return -1;
3208
3209   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3210       != (SEC_CODE | SEC_ALLOC)
3211       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3212          == (SEC_CODE | SEC_ALLOC))
3213     return 1;
3214
3215   if (synthetic_relocatable)
3216     {
3217       if (a->section->id < b->section->id)
3218         return -1;
3219
3220       if (a->section->id > b->section->id)
3221         return 1;
3222     }
3223
3224   if (a->value + a->section->vma < b->value + b->section->vma)
3225     return -1;
3226
3227   if (a->value + a->section->vma > b->value + b->section->vma)
3228     return 1;
3229
3230   /* For syms with the same value, prefer strong dynamic global function
3231      syms over other syms.  */
3232   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3233     return -1;
3234
3235   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3236     return 1;
3237
3238   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3239     return -1;
3240
3241   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3242     return 1;
3243
3244   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3245     return -1;
3246
3247   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3248     return 1;
3249
3250   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3251     return -1;
3252
3253   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3254     return 1;
3255
3256   return a > b;
3257 }
3258
3259 /* Search SYMS for a symbol of the given VALUE.  */
3260
3261 static asymbol *
3262 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3263 {
3264   long mid;
3265
3266   if (id == (unsigned) -1)
3267     {
3268       while (lo < hi)
3269         {
3270           mid = (lo + hi) >> 1;
3271           if (syms[mid]->value + syms[mid]->section->vma < value)
3272             lo = mid + 1;
3273           else if (syms[mid]->value + syms[mid]->section->vma > value)
3274             hi = mid;
3275           else
3276             return syms[mid];
3277         }
3278     }
3279   else
3280     {
3281       while (lo < hi)
3282         {
3283           mid = (lo + hi) >> 1;
3284           if (syms[mid]->section->id < id)
3285             lo = mid + 1;
3286           else if (syms[mid]->section->id > id)
3287             hi = mid;
3288           else if (syms[mid]->value < value)
3289             lo = mid + 1;
3290           else if (syms[mid]->value > value)
3291             hi = mid;
3292           else
3293             return syms[mid];
3294         }
3295     }
3296   return NULL;
3297 }
3298
3299 static bfd_boolean
3300 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3301 {
3302   bfd_vma vma = *(bfd_vma *) ptr;
3303   return ((section->flags & SEC_ALLOC) != 0
3304           && section->vma <= vma
3305           && vma < section->vma + section->size);
3306 }
3307
3308 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3309    entry syms.  Also generate @plt symbols for the glink branch table.
3310    Returns count of synthetic symbols in RET or -1 on error.  */
3311
3312 static long
3313 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3314                                 long static_count, asymbol **static_syms,
3315                                 long dyn_count, asymbol **dyn_syms,
3316                                 asymbol **ret)
3317 {
3318   asymbol *s;
3319   size_t i, j, count;
3320   char *names;
3321   size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3322   asection *opd = NULL;
3323   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3324   asymbol **syms;
3325   int abi = abiversion (abfd);
3326
3327   *ret = NULL;
3328
3329   if (abi < 2)
3330     {
3331       opd = bfd_get_section_by_name (abfd, ".opd");
3332       if (opd == NULL && abi == 1)
3333         return 0;
3334     }
3335
3336   syms = NULL;
3337   codesecsym = 0;
3338   codesecsymend = 0;
3339   secsymend = 0;
3340   opdsymend = 0;
3341   symcount = 0;
3342   if (opd != NULL)
3343     {
3344       symcount = static_count;
3345       if (!relocatable)
3346         symcount += dyn_count;
3347       if (symcount == 0)
3348         return 0;
3349
3350       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3351       if (syms == NULL)
3352         return -1;
3353
3354       if (!relocatable && static_count != 0 && dyn_count != 0)
3355         {
3356           /* Use both symbol tables.  */
3357           memcpy (syms, static_syms, static_count * sizeof (*syms));
3358           memcpy (syms + static_count, dyn_syms,
3359                   (dyn_count + 1) * sizeof (*syms));
3360         }
3361       else if (!relocatable && static_count == 0)
3362         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3363       else
3364         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3365
3366       /* Trim uninteresting symbols.  Interesting symbols are section,
3367          function, and notype symbols.  */
3368       for (i = 0, j = 0; i < symcount; ++i)
3369         if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3370                                | BSF_RELC | BSF_SRELC)) == 0)
3371           syms[j++] = syms[i];
3372       symcount = j;
3373
3374       synthetic_relocatable = relocatable;
3375       synthetic_opd = opd;
3376       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3377
3378       if (!relocatable && symcount > 1)
3379         {
3380           /* Trim duplicate syms, since we may have merged the normal
3381              and dynamic symbols.  Actually, we only care about syms
3382              that have different values, so trim any with the same
3383              value.  Don't consider ifunc and ifunc resolver symbols
3384              duplicates however, because GDB wants to know whether a
3385              text symbol is an ifunc resolver.  */
3386           for (i = 1, j = 1; i < symcount; ++i)
3387             {
3388               const asymbol *s0 = syms[i - 1];
3389               const asymbol *s1 = syms[i];
3390
3391               if ((s0->value + s0->section->vma
3392                    != s1->value + s1->section->vma)
3393                   || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3394                       != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3395                 syms[j++] = syms[i];
3396             }
3397           symcount = j;
3398         }
3399
3400       i = 0;
3401       /* Note that here and in compare_symbols we can't compare opd and
3402          sym->section directly.  With separate debug info files, the
3403          symbols will be extracted from the debug file while abfd passed
3404          to this function is the real binary.  */
3405       if (strcmp (syms[i]->section->name, ".opd") == 0)
3406         ++i;
3407       codesecsym = i;
3408
3409       for (; i < symcount; ++i)
3410         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3411                                          | SEC_THREAD_LOCAL))
3412              != (SEC_CODE | SEC_ALLOC))
3413             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3414           break;
3415       codesecsymend = i;
3416
3417       for (; i < symcount; ++i)
3418         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3419           break;
3420       secsymend = i;
3421
3422       for (; i < symcount; ++i)
3423         if (strcmp (syms[i]->section->name, ".opd") != 0)
3424           break;
3425       opdsymend = i;
3426
3427       for (; i < symcount; ++i)
3428         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3429             != (SEC_CODE | SEC_ALLOC))
3430           break;
3431       symcount = i;
3432     }
3433   count = 0;
3434
3435   if (relocatable)
3436     {
3437       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3438       arelent *r;
3439       size_t size;
3440       size_t relcount;
3441
3442       if (opdsymend == secsymend)
3443         goto done;
3444
3445       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3446       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3447       if (relcount == 0)
3448         goto done;
3449
3450       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3451         {
3452           count = -1;
3453           goto done;
3454         }
3455
3456       size = 0;
3457       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3458         {
3459           asymbol *sym;
3460
3461           while (r < opd->relocation + relcount
3462                  && r->address < syms[i]->value + opd->vma)
3463             ++r;
3464
3465           if (r == opd->relocation + relcount)
3466             break;
3467
3468           if (r->address != syms[i]->value + opd->vma)
3469             continue;
3470
3471           if (r->howto->type != R_PPC64_ADDR64)
3472             continue;
3473
3474           sym = *r->sym_ptr_ptr;
3475           if (!sym_exists_at (syms, opdsymend, symcount,
3476                               sym->section->id, sym->value + r->addend))
3477             {
3478               ++count;
3479               size += sizeof (asymbol);
3480               size += strlen (syms[i]->name) + 2;
3481             }
3482         }
3483
3484       if (size == 0)
3485         goto done;
3486       s = *ret = bfd_malloc (size);
3487       if (s == NULL)
3488         {
3489           count = -1;
3490           goto done;
3491         }
3492
3493       names = (char *) (s + count);
3494
3495       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3496         {
3497           asymbol *sym;
3498
3499           while (r < opd->relocation + relcount
3500                  && r->address < syms[i]->value + opd->vma)
3501             ++r;
3502
3503           if (r == opd->relocation + relcount)
3504             break;
3505
3506           if (r->address != syms[i]->value + opd->vma)
3507             continue;
3508
3509           if (r->howto->type != R_PPC64_ADDR64)
3510             continue;
3511
3512           sym = *r->sym_ptr_ptr;
3513           if (!sym_exists_at (syms, opdsymend, symcount,
3514                               sym->section->id, sym->value + r->addend))
3515             {
3516               size_t len;
3517
3518               *s = *syms[i];
3519               s->flags |= BSF_SYNTHETIC;
3520               s->section = sym->section;
3521               s->value = sym->value + r->addend;
3522               s->name = names;
3523               *names++ = '.';
3524               len = strlen (syms[i]->name);
3525               memcpy (names, syms[i]->name, len + 1);
3526               names += len + 1;
3527               /* Have udata.p point back to the original symbol this
3528                  synthetic symbol was derived from.  */
3529               s->udata.p = syms[i];
3530               s++;
3531             }
3532         }
3533     }
3534   else
3535     {
3536       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3537       bfd_byte *contents = NULL;
3538       size_t size;
3539       size_t plt_count = 0;
3540       bfd_vma glink_vma = 0, resolv_vma = 0;
3541       asection *dynamic, *glink = NULL, *relplt = NULL;
3542       arelent *p;
3543
3544       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3545         {
3546         free_contents_and_exit_err:
3547           count = -1;
3548         free_contents_and_exit:
3549           if (contents)
3550             free (contents);
3551           goto done;
3552         }
3553
3554       size = 0;
3555       for (i = secsymend; i < opdsymend; ++i)
3556         {
3557           bfd_vma ent;
3558
3559           /* Ignore bogus symbols.  */
3560           if (syms[i]->value > opd->size - 8)
3561             continue;
3562
3563           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3564           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3565             {
3566               ++count;
3567               size += sizeof (asymbol);
3568               size += strlen (syms[i]->name) + 2;
3569             }
3570         }
3571
3572       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3573       if (dyn_count != 0
3574           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3575         {
3576           bfd_byte *dynbuf, *extdyn, *extdynend;
3577           size_t extdynsize;
3578           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3579
3580           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3581             goto free_contents_and_exit_err;
3582
3583           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3584           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3585
3586           extdyn = dynbuf;
3587           extdynend = extdyn + dynamic->size;
3588           for (; extdyn < extdynend; extdyn += extdynsize)
3589             {
3590               Elf_Internal_Dyn dyn;
3591               (*swap_dyn_in) (abfd, extdyn, &dyn);
3592
3593               if (dyn.d_tag == DT_NULL)
3594                 break;
3595
3596               if (dyn.d_tag == DT_PPC64_GLINK)
3597                 {
3598                   /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3599                      See comment in ppc64_elf_finish_dynamic_sections. */
3600                   glink_vma = dyn.d_un.d_val + 8 * 4;
3601                   /* The .glink section usually does not survive the final
3602                      link; search for the section (usually .text) where the
3603                      glink stubs now reside.  */
3604                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3605                                                 &glink_vma);
3606                   break;
3607                 }
3608             }
3609
3610           free (dynbuf);
3611         }
3612
3613       if (glink != NULL)
3614         {
3615           /* Determine __glink trampoline by reading the relative branch
3616              from the first glink stub.  */
3617           bfd_byte buf[4];
3618           unsigned int off = 0;
3619
3620           while (bfd_get_section_contents (abfd, glink, buf,
3621                                            glink_vma + off - glink->vma, 4))
3622             {
3623               unsigned int insn = bfd_get_32 (abfd, buf);
3624               insn ^= B_DOT;
3625               if ((insn & ~0x3fffffc) == 0)
3626                 {
3627                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3628                   break;
3629                 }
3630               off += 4;
3631               if (off > 4)
3632                 break;
3633             }
3634
3635           if (resolv_vma)
3636             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3637
3638           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3639           if (relplt != NULL)
3640             {
3641               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3642               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3643                 goto free_contents_and_exit_err;
3644
3645               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3646               size += plt_count * sizeof (asymbol);
3647
3648               p = relplt->relocation;
3649               for (i = 0; i < plt_count; i++, p++)
3650                 {
3651                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3652                   if (p->addend != 0)
3653                     size += sizeof ("+0x") - 1 + 16;
3654                 }
3655             }
3656         }
3657
3658       if (size == 0)
3659         goto free_contents_and_exit;
3660       s = *ret = bfd_malloc (size);
3661       if (s == NULL)
3662         goto free_contents_and_exit_err;
3663
3664       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3665
3666       for (i = secsymend; i < opdsymend; ++i)
3667         {
3668           bfd_vma ent;
3669
3670           if (syms[i]->value > opd->size - 8)
3671             continue;
3672
3673           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3674           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3675             {
3676               size_t lo, hi;
3677               size_t len;
3678               asection *sec = abfd->sections;
3679
3680               *s = *syms[i];
3681               lo = codesecsym;
3682               hi = codesecsymend;
3683               while (lo < hi)
3684                 {
3685                   size_t mid = (lo + hi) >> 1;
3686                   if (syms[mid]->section->vma < ent)
3687                     lo = mid + 1;
3688                   else if (syms[mid]->section->vma > ent)
3689                     hi = mid;
3690                   else
3691                     {
3692                       sec = syms[mid]->section;
3693                       break;
3694                     }
3695                 }
3696
3697               if (lo >= hi && lo > codesecsym)
3698                 sec = syms[lo - 1]->section;
3699
3700               for (; sec != NULL; sec = sec->next)
3701                 {
3702                   if (sec->vma > ent)
3703                     break;
3704                   /* SEC_LOAD may not be set if SEC is from a separate debug
3705                      info file.  */
3706                   if ((sec->flags & SEC_ALLOC) == 0)
3707                     break;
3708                   if ((sec->flags & SEC_CODE) != 0)
3709                     s->section = sec;
3710                 }
3711               s->flags |= BSF_SYNTHETIC;
3712               s->value = ent - s->section->vma;
3713               s->name = names;
3714               *names++ = '.';
3715               len = strlen (syms[i]->name);
3716               memcpy (names, syms[i]->name, len + 1);
3717               names += len + 1;
3718               /* Have udata.p point back to the original symbol this
3719                  synthetic symbol was derived from.  */
3720               s->udata.p = syms[i];
3721               s++;
3722             }
3723         }
3724       free (contents);
3725
3726       if (glink != NULL && relplt != NULL)
3727         {
3728           if (resolv_vma)
3729             {
3730               /* Add a symbol for the main glink trampoline.  */
3731               memset (s, 0, sizeof *s);
3732               s->the_bfd = abfd;
3733               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3734               s->section = glink;
3735               s->value = resolv_vma - glink->vma;
3736               s->name = names;
3737               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3738               names += sizeof ("__glink_PLTresolve");
3739               s++;
3740               count++;
3741             }
3742
3743           /* FIXME: It would be very much nicer to put sym@plt on the
3744              stub rather than on the glink branch table entry.  The
3745              objdump disassembler would then use a sensible symbol
3746              name on plt calls.  The difficulty in doing so is
3747              a) finding the stubs, and,
3748              b) matching stubs against plt entries, and,
3749              c) there can be multiple stubs for a given plt entry.
3750
3751              Solving (a) could be done by code scanning, but older
3752              ppc64 binaries used different stubs to current code.
3753              (b) is the tricky one since you need to known the toc
3754              pointer for at least one function that uses a pic stub to
3755              be able to calculate the plt address referenced.
3756              (c) means gdb would need to set multiple breakpoints (or
3757              find the glink branch itself) when setting breakpoints
3758              for pending shared library loads.  */
3759           p = relplt->relocation;
3760           for (i = 0; i < plt_count; i++, p++)
3761             {
3762               size_t len;
3763
3764               *s = **p->sym_ptr_ptr;
3765               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3766                  we are defining a symbol, ensure one of them is set.  */
3767               if ((s->flags & BSF_LOCAL) == 0)
3768                 s->flags |= BSF_GLOBAL;
3769               s->flags |= BSF_SYNTHETIC;
3770               s->section = glink;
3771               s->value = glink_vma - glink->vma;
3772               s->name = names;
3773               s->udata.p = NULL;
3774               len = strlen ((*p->sym_ptr_ptr)->name);
3775               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3776               names += len;
3777               if (p->addend != 0)
3778                 {
3779                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3780                   names += sizeof ("+0x") - 1;
3781                   bfd_sprintf_vma (abfd, names, p->addend);
3782                   names += strlen (names);
3783                 }
3784               memcpy (names, "@plt", sizeof ("@plt"));
3785               names += sizeof ("@plt");
3786               s++;
3787               if (abi < 2)
3788                 {
3789                   glink_vma += 8;
3790                   if (i >= 0x8000)
3791                     glink_vma += 4;
3792                 }
3793               else
3794                 glink_vma += 4;
3795             }
3796           count += plt_count;
3797         }
3798     }
3799
3800  done:
3801   free (syms);
3802   return count;
3803 }
3804 \f
3805 /* The following functions are specific to the ELF linker, while
3806    functions above are used generally.  Those named ppc64_elf_* are
3807    called by the main ELF linker code.  They appear in this file more
3808    or less in the order in which they are called.  eg.
3809    ppc64_elf_check_relocs is called early in the link process,
3810    ppc64_elf_finish_dynamic_sections is one of the last functions
3811    called.
3812
3813    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3814    functions have both a function code symbol and a function descriptor
3815    symbol.  A call to foo in a relocatable object file looks like:
3816
3817    .            .text
3818    .    x:
3819    .            bl      .foo
3820    .            nop
3821
3822    The function definition in another object file might be:
3823
3824    .            .section .opd
3825    .    foo:    .quad   .foo
3826    .            .quad   .TOC.@tocbase
3827    .            .quad   0
3828    .
3829    .            .text
3830    .    .foo:   blr
3831
3832    When the linker resolves the call during a static link, the branch
3833    unsurprisingly just goes to .foo and the .opd information is unused.
3834    If the function definition is in a shared library, things are a little
3835    different:  The call goes via a plt call stub, the opd information gets
3836    copied to the plt, and the linker patches the nop.
3837
3838    .    x:
3839    .            bl      .foo_stub
3840    .            ld      2,40(1)
3841    .
3842    .
3843    .    .foo_stub:
3844    .            std     2,40(1)                 # in practice, the call stub
3845    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3846    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3847    .            ld      12,0(11)
3848    .            ld      2,8(11)
3849    .            mtctr   12
3850    .            ld      11,16(11)
3851    .            bctr
3852    .
3853    .            .section .plt
3854    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3855
3856    The "reloc ()" notation is supposed to indicate that the linker emits
3857    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3858    copying.
3859
3860    What are the difficulties here?  Well, firstly, the relocations
3861    examined by the linker in check_relocs are against the function code
3862    sym .foo, while the dynamic relocation in the plt is emitted against
3863    the function descriptor symbol, foo.  Somewhere along the line, we need
3864    to carefully copy dynamic link information from one symbol to the other.
3865    Secondly, the generic part of the elf linker will make .foo a dynamic
3866    symbol as is normal for most other backends.  We need foo dynamic
3867    instead, at least for an application final link.  However, when
3868    creating a shared library containing foo, we need to have both symbols
3869    dynamic so that references to .foo are satisfied during the early
3870    stages of linking.  Otherwise the linker might decide to pull in a
3871    definition from some other object, eg. a static library.
3872
3873    Update: As of August 2004, we support a new convention.  Function
3874    calls may use the function descriptor symbol, ie. "bl foo".  This
3875    behaves exactly as "bl .foo".  */
3876
3877 /* Of those relocs that might be copied as dynamic relocs, this
3878    function selects those that must be copied when linking a shared
3879    library or PIE, even when the symbol is local.  */
3880
3881 static int
3882 must_be_dyn_reloc (struct bfd_link_info *info,
3883                    enum elf_ppc64_reloc_type r_type)
3884 {
3885   switch (r_type)
3886     {
3887     default:
3888       /* Only relative relocs can be resolved when the object load
3889          address isn't fixed.  DTPREL64 is excluded because the
3890          dynamic linker needs to differentiate global dynamic from
3891          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3892       return 1;
3893
3894     case R_PPC64_REL32:
3895     case R_PPC64_REL64:
3896     case R_PPC64_REL30:
3897       return 0;
3898
3899     case R_PPC64_TPREL16:
3900     case R_PPC64_TPREL16_LO:
3901     case R_PPC64_TPREL16_HI:
3902     case R_PPC64_TPREL16_HA:
3903     case R_PPC64_TPREL16_DS:
3904     case R_PPC64_TPREL16_LO_DS:
3905     case R_PPC64_TPREL16_HIGH:
3906     case R_PPC64_TPREL16_HIGHA:
3907     case R_PPC64_TPREL16_HIGHER:
3908     case R_PPC64_TPREL16_HIGHERA:
3909     case R_PPC64_TPREL16_HIGHEST:
3910     case R_PPC64_TPREL16_HIGHESTA:
3911     case R_PPC64_TPREL64:
3912       /* These relocations are relative but in a shared library the
3913          linker doesn't know the thread pointer base.  */
3914       return bfd_link_dll (info);
3915     }
3916 }
3917
3918 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3919    copying dynamic variables from a shared lib into an app's dynbss
3920    section, and instead use a dynamic relocation to point into the
3921    shared lib.  With code that gcc generates, it's vital that this be
3922    enabled;  In the PowerPC64 ABI, the address of a function is actually
3923    the address of a function descriptor, which resides in the .opd
3924    section.  gcc uses the descriptor directly rather than going via the
3925    GOT as some other ABI's do, which means that initialized function
3926    pointers must reference the descriptor.  Thus, a function pointer
3927    initialized to the address of a function in a shared library will
3928    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3929    redefines the function descriptor symbol to point to the copy.  This
3930    presents a problem as a plt entry for that function is also
3931    initialized from the function descriptor symbol and the copy reloc
3932    may not be initialized first.  */
3933 #define ELIMINATE_COPY_RELOCS 1
3934
3935 /* Section name for stubs is the associated section name plus this
3936    string.  */
3937 #define STUB_SUFFIX ".stub"
3938
3939 /* Linker stubs.
3940    ppc_stub_long_branch:
3941    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3942    destination, but a 24 bit branch in a stub section will reach.
3943    .    b       dest
3944
3945    ppc_stub_plt_branch:
3946    Similar to the above, but a 24 bit branch in the stub section won't
3947    reach its destination.
3948    .    addis   %r11,%r2,xxx@toc@ha
3949    .    ld      %r12,xxx@toc@l(%r11)
3950    .    mtctr   %r12
3951    .    bctr
3952
3953    ppc_stub_plt_call:
3954    Used to call a function in a shared library.  If it so happens that
3955    the plt entry referenced crosses a 64k boundary, then an extra
3956    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3957    .    std     %r2,40(%r1)
3958    .    addis   %r11,%r2,xxx@toc@ha
3959    .    ld      %r12,xxx+0@toc@l(%r11)
3960    .    mtctr   %r12
3961    .    ld      %r2,xxx+8@toc@l(%r11)
3962    .    ld      %r11,xxx+16@toc@l(%r11)
3963    .    bctr
3964
3965    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3966    code to adjust the value and save r2 to support multiple toc sections.
3967    A ppc_stub_long_branch with an r2 offset looks like:
3968    .    std     %r2,40(%r1)
3969    .    addis   %r2,%r2,off@ha
3970    .    addi    %r2,%r2,off@l
3971    .    b       dest
3972
3973    A ppc_stub_plt_branch with an r2 offset looks like:
3974    .    std     %r2,40(%r1)
3975    .    addis   %r11,%r2,xxx@toc@ha
3976    .    ld      %r12,xxx@toc@l(%r11)
3977    .    addis   %r2,%r2,off@ha
3978    .    addi    %r2,%r2,off@l
3979    .    mtctr   %r12
3980    .    bctr
3981
3982    In cases where the "addis" instruction would add zero, the "addis" is
3983    omitted and following instructions modified slightly in some cases.
3984 */
3985
3986 enum ppc_stub_type {
3987   ppc_stub_none,
3988   ppc_stub_long_branch,
3989   ppc_stub_long_branch_r2off,
3990   ppc_stub_plt_branch,
3991   ppc_stub_plt_branch_r2off,
3992   ppc_stub_plt_call,
3993   ppc_stub_plt_call_r2save,
3994   ppc_stub_global_entry,
3995   ppc_stub_save_res
3996 };
3997
3998 /* Information on stub grouping.  */
3999 struct map_stub
4000 {
4001   /* The stub section.  */
4002   asection *stub_sec;
4003   /* This is the section to which stubs in the group will be attached.  */
4004   asection *link_sec;
4005   /* Next group.  */
4006   struct map_stub *next;
4007   /* Whether to emit a copy of register save/restore functions in this
4008      group.  */
4009   int needs_save_res;
4010   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
4011      or -1u if no such stub with bctrl exists.  */
4012   unsigned int tls_get_addr_opt_bctrl;
4013 };
4014
4015 struct ppc_stub_hash_entry {
4016
4017   /* Base hash table entry structure.  */
4018   struct bfd_hash_entry root;
4019
4020   enum ppc_stub_type stub_type;
4021
4022   /* Group information.  */
4023   struct map_stub *group;
4024
4025   /* Offset within stub_sec of the beginning of this stub.  */
4026   bfd_vma stub_offset;
4027
4028   /* Given the symbol's value and its section we can determine its final
4029      value when building the stubs (so the stub knows where to jump.  */
4030   bfd_vma target_value;
4031   asection *target_section;
4032
4033   /* The symbol table entry, if any, that this was derived from.  */
4034   struct ppc_link_hash_entry *h;
4035   struct plt_entry *plt_ent;
4036
4037   /* Symbol type.  */
4038   unsigned char symtype;
4039
4040   /* Symbol st_other.  */
4041   unsigned char other;
4042 };
4043
4044 struct ppc_branch_hash_entry {
4045
4046   /* Base hash table entry structure.  */
4047   struct bfd_hash_entry root;
4048
4049   /* Offset within branch lookup table.  */
4050   unsigned int offset;
4051
4052   /* Generation marker.  */
4053   unsigned int iter;
4054 };
4055
4056 /* Used to track dynamic relocations for local symbols.  */
4057 struct ppc_dyn_relocs
4058 {
4059   struct ppc_dyn_relocs *next;
4060
4061   /* The input section of the reloc.  */
4062   asection *sec;
4063
4064   /* Total number of relocs copied for the input section.  */
4065   unsigned int count : 31;
4066
4067   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
4068   unsigned int ifunc : 1;
4069 };
4070
4071 struct ppc_link_hash_entry
4072 {
4073   struct elf_link_hash_entry elf;
4074
4075   union {
4076     /* A pointer to the most recently used stub hash entry against this
4077        symbol.  */
4078     struct ppc_stub_hash_entry *stub_cache;
4079
4080     /* A pointer to the next symbol starting with a '.'  */
4081     struct ppc_link_hash_entry *next_dot_sym;
4082   } u;
4083
4084   /* Track dynamic relocs copied for this symbol.  */
4085   struct elf_dyn_relocs *dyn_relocs;
4086
4087   /* Link between function code and descriptor symbols.  */
4088   struct ppc_link_hash_entry *oh;
4089
4090   /* Flag function code and descriptor symbols.  */
4091   unsigned int is_func:1;
4092   unsigned int is_func_descriptor:1;
4093   unsigned int fake:1;
4094
4095   /* Whether global opd/toc sym has been adjusted or not.
4096      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4097      should be set for all globals defined in any opd/toc section.  */
4098   unsigned int adjust_done:1;
4099
4100   /* Set if this is an out-of-line register save/restore function,
4101      with non-standard calling convention.  */
4102   unsigned int save_res:1;
4103
4104   /* Set if a duplicate symbol with non-zero localentry is detected,
4105      even when the duplicate symbol does not provide a definition.  */
4106   unsigned int non_zero_localentry:1;
4107
4108   /* Contexts in which symbol is used in the GOT (or TOC).
4109      Bits are or'd into the mask as the corresponding relocs are
4110      encountered during check_relocs, with TLS_TLS being set when any
4111      of the other TLS bits are set.  tls_optimize clears bits when
4112      optimizing to indicate the corresponding GOT entry type is not
4113      needed.  If set, TLS_TLS is never cleared.  tls_optimize may also
4114      set TLS_TPRELGD when a GD reloc turns into a TPREL one.  We use a
4115      separate flag rather than setting TPREL just for convenience in
4116      distinguishing the two cases.
4117      These flags are also kept for local symbols.  */
4118 #define TLS_TLS          1      /* Any TLS reloc.  */
4119 #define TLS_GD           2      /* GD reloc. */
4120 #define TLS_LD           4      /* LD reloc. */
4121 #define TLS_TPREL        8      /* TPREL reloc, => IE. */
4122 #define TLS_DTPREL      16      /* DTPREL reloc, => LD. */
4123 #define TLS_MARK        32      /* __tls_get_addr call marked. */
4124 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4125 #define TLS_EXPLICIT   128      /* Marks TOC section TLS relocs. */
4126   unsigned char tls_mask;
4127
4128   /* The above field is also used to mark function symbols.  In which
4129      case TLS_TLS will be 0.  */
4130 #define PLT_IFUNC        2      /* STT_GNU_IFUNC.  */
4131 #define PLT_KEEP         4      /* inline plt call requires plt entry.  */
4132 #define NON_GOT        256      /* local symbol plt, not stored.  */
4133 };
4134
4135 /* ppc64 ELF linker hash table.  */
4136
4137 struct ppc_link_hash_table
4138 {
4139   struct elf_link_hash_table elf;
4140
4141   /* The stub hash table.  */
4142   struct bfd_hash_table stub_hash_table;
4143
4144   /* Another hash table for plt_branch stubs.  */
4145   struct bfd_hash_table branch_hash_table;
4146
4147   /* Hash table for function prologue tocsave.  */
4148   htab_t tocsave_htab;
4149
4150   /* Various options and other info passed from the linker.  */
4151   struct ppc64_elf_params *params;
4152
4153   /* The size of sec_info below.  */
4154   unsigned int sec_info_arr_size;
4155
4156   /* Per-section array of extra section info.  Done this way rather
4157      than as part of ppc64_elf_section_data so we have the info for
4158      non-ppc64 sections.  */
4159   struct
4160   {
4161     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4162     bfd_vma toc_off;
4163
4164     union
4165     {
4166       /* The section group that this section belongs to.  */
4167       struct map_stub *group;
4168       /* A temp section list pointer.  */
4169       asection *list;
4170     } u;
4171   } *sec_info;
4172
4173   /* Linked list of groups.  */
4174   struct map_stub *group;
4175
4176   /* Temp used when calculating TOC pointers.  */
4177   bfd_vma toc_curr;
4178   bfd *toc_bfd;
4179   asection *toc_first_sec;
4180
4181   /* Used when adding symbols.  */
4182   struct ppc_link_hash_entry *dot_syms;
4183
4184   /* Shortcuts to get to dynamic linker sections.  */
4185   asection *glink;
4186   asection *global_entry;
4187   asection *sfpr;
4188   asection *pltlocal;
4189   asection *relpltlocal;
4190   asection *brlt;
4191   asection *relbrlt;
4192   asection *glink_eh_frame;
4193
4194   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4195   struct ppc_link_hash_entry *tls_get_addr;
4196   struct ppc_link_hash_entry *tls_get_addr_fd;
4197
4198   /* The size of reliplt used by got entry relocs.  */
4199   bfd_size_type got_reli_size;
4200
4201   /* Statistics.  */
4202   unsigned long stub_count[ppc_stub_global_entry];
4203
4204   /* Number of stubs against global syms.  */
4205   unsigned long stub_globals;
4206
4207   /* Set if we're linking code with function descriptors.  */
4208   unsigned int opd_abi:1;
4209
4210   /* Support for multiple toc sections.  */
4211   unsigned int do_multi_toc:1;
4212   unsigned int multi_toc_needed:1;
4213   unsigned int second_toc_pass:1;
4214   unsigned int do_toc_opt:1;
4215
4216   /* Set if tls optimization is enabled.  */
4217   unsigned int do_tls_opt:1;
4218
4219   /* Set if inline plt calls should be converted to direct calls.  */
4220   unsigned int can_convert_all_inline_plt:1;
4221
4222   /* Set on error.  */
4223   unsigned int stub_error:1;
4224
4225   /* Whether func_desc_adjust needs to be run over symbols.  */
4226   unsigned int need_func_desc_adj:1;
4227
4228   /* Whether there exist local gnu indirect function resolvers,
4229      referenced by dynamic relocations.  */
4230   unsigned int local_ifunc_resolver:1;
4231   unsigned int maybe_local_ifunc_resolver:1;
4232
4233   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4234   unsigned int has_plt_localentry0:1;
4235
4236   /* Incremented every time we size stubs.  */
4237   unsigned int stub_iteration;
4238
4239   /* Small local sym cache.  */
4240   struct sym_cache sym_cache;
4241 };
4242
4243 /* Rename some of the generic section flags to better document how they
4244    are used here.  */
4245
4246 /* Nonzero if this section has TLS related relocations.  */
4247 #define has_tls_reloc sec_flg0
4248
4249 /* Nonzero if this section has an old-style call to __tls_get_addr.  */
4250 #define has_tls_get_addr_call sec_flg1
4251
4252 /* Nonzero if this section has any toc or got relocs.  */
4253 #define has_toc_reloc sec_flg2
4254
4255 /* Nonzero if this section has a call to another section that uses
4256    the toc or got.  */
4257 #define makes_toc_func_call sec_flg3
4258
4259 /* Recursion protection when determining above flag.  */
4260 #define call_check_in_progress sec_flg4
4261 #define call_check_done sec_flg5
4262
4263 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4264
4265 #define ppc_hash_table(p) \
4266   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4267   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4268
4269 #define ppc_stub_hash_lookup(table, string, create, copy) \
4270   ((struct ppc_stub_hash_entry *) \
4271    bfd_hash_lookup ((table), (string), (create), (copy)))
4272
4273 #define ppc_branch_hash_lookup(table, string, create, copy) \
4274   ((struct ppc_branch_hash_entry *) \
4275    bfd_hash_lookup ((table), (string), (create), (copy)))
4276
4277 /* Create an entry in the stub hash table.  */
4278
4279 static struct bfd_hash_entry *
4280 stub_hash_newfunc (struct bfd_hash_entry *entry,
4281                    struct bfd_hash_table *table,
4282                    const char *string)
4283 {
4284   /* Allocate the structure if it has not already been allocated by a
4285      subclass.  */
4286   if (entry == NULL)
4287     {
4288       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4289       if (entry == NULL)
4290         return entry;
4291     }
4292
4293   /* Call the allocation method of the superclass.  */
4294   entry = bfd_hash_newfunc (entry, table, string);
4295   if (entry != NULL)
4296     {
4297       struct ppc_stub_hash_entry *eh;
4298
4299       /* Initialize the local fields.  */
4300       eh = (struct ppc_stub_hash_entry *) entry;
4301       eh->stub_type = ppc_stub_none;
4302       eh->group = NULL;
4303       eh->stub_offset = 0;
4304       eh->target_value = 0;
4305       eh->target_section = NULL;
4306       eh->h = NULL;
4307       eh->plt_ent = NULL;
4308       eh->other = 0;
4309     }
4310
4311   return entry;
4312 }
4313
4314 /* Create an entry in the branch hash table.  */
4315
4316 static struct bfd_hash_entry *
4317 branch_hash_newfunc (struct bfd_hash_entry *entry,
4318                      struct bfd_hash_table *table,
4319                      const char *string)
4320 {
4321   /* Allocate the structure if it has not already been allocated by a
4322      subclass.  */
4323   if (entry == NULL)
4324     {
4325       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4326       if (entry == NULL)
4327         return entry;
4328     }
4329
4330   /* Call the allocation method of the superclass.  */
4331   entry = bfd_hash_newfunc (entry, table, string);
4332   if (entry != NULL)
4333     {
4334       struct ppc_branch_hash_entry *eh;
4335
4336       /* Initialize the local fields.  */
4337       eh = (struct ppc_branch_hash_entry *) entry;
4338       eh->offset = 0;
4339       eh->iter = 0;
4340     }
4341
4342   return entry;
4343 }
4344
4345 /* Create an entry in a ppc64 ELF linker hash table.  */
4346
4347 static struct bfd_hash_entry *
4348 link_hash_newfunc (struct bfd_hash_entry *entry,
4349                    struct bfd_hash_table *table,
4350                    const char *string)
4351 {
4352   /* Allocate the structure if it has not already been allocated by a
4353      subclass.  */
4354   if (entry == NULL)
4355     {
4356       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4357       if (entry == NULL)
4358         return entry;
4359     }
4360
4361   /* Call the allocation method of the superclass.  */
4362   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4363   if (entry != NULL)
4364     {
4365       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4366
4367       memset (&eh->u.stub_cache, 0,
4368               (sizeof (struct ppc_link_hash_entry)
4369                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4370
4371       /* When making function calls, old ABI code references function entry
4372          points (dot symbols), while new ABI code references the function
4373          descriptor symbol.  We need to make any combination of reference and
4374          definition work together, without breaking archive linking.
4375
4376          For a defined function "foo" and an undefined call to "bar":
4377          An old object defines "foo" and ".foo", references ".bar" (possibly
4378          "bar" too).
4379          A new object defines "foo" and references "bar".
4380
4381          A new object thus has no problem with its undefined symbols being
4382          satisfied by definitions in an old object.  On the other hand, the
4383          old object won't have ".bar" satisfied by a new object.
4384
4385          Keep a list of newly added dot-symbols.  */
4386
4387       if (string[0] == '.')
4388         {
4389           struct ppc_link_hash_table *htab;
4390
4391           htab = (struct ppc_link_hash_table *) table;
4392           eh->u.next_dot_sym = htab->dot_syms;
4393           htab->dot_syms = eh;
4394         }
4395     }
4396
4397   return entry;
4398 }
4399
4400 struct tocsave_entry {
4401   asection *sec;
4402   bfd_vma offset;
4403 };
4404
4405 static hashval_t
4406 tocsave_htab_hash (const void *p)
4407 {
4408   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4409   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4410 }
4411
4412 static int
4413 tocsave_htab_eq (const void *p1, const void *p2)
4414 {
4415   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4416   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4417   return e1->sec == e2->sec && e1->offset == e2->offset;
4418 }
4419
4420 /* Destroy a ppc64 ELF linker hash table.  */
4421
4422 static void
4423 ppc64_elf_link_hash_table_free (bfd *obfd)
4424 {
4425   struct ppc_link_hash_table *htab;
4426
4427   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4428   if (htab->tocsave_htab)
4429     htab_delete (htab->tocsave_htab);
4430   bfd_hash_table_free (&htab->branch_hash_table);
4431   bfd_hash_table_free (&htab->stub_hash_table);
4432   _bfd_elf_link_hash_table_free (obfd);
4433 }
4434
4435 /* Create a ppc64 ELF linker hash table.  */
4436
4437 static struct bfd_link_hash_table *
4438 ppc64_elf_link_hash_table_create (bfd *abfd)
4439 {
4440   struct ppc_link_hash_table *htab;
4441   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4442
4443   htab = bfd_zmalloc (amt);
4444   if (htab == NULL)
4445     return NULL;
4446
4447   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4448                                       sizeof (struct ppc_link_hash_entry),
4449                                       PPC64_ELF_DATA))
4450     {
4451       free (htab);
4452       return NULL;
4453     }
4454
4455   /* Init the stub hash table too.  */
4456   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4457                             sizeof (struct ppc_stub_hash_entry)))
4458     {
4459       _bfd_elf_link_hash_table_free (abfd);
4460       return NULL;
4461     }
4462
4463   /* And the branch hash table.  */
4464   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4465                             sizeof (struct ppc_branch_hash_entry)))
4466     {
4467       bfd_hash_table_free (&htab->stub_hash_table);
4468       _bfd_elf_link_hash_table_free (abfd);
4469       return NULL;
4470     }
4471
4472   htab->tocsave_htab = htab_try_create (1024,
4473                                         tocsave_htab_hash,
4474                                         tocsave_htab_eq,
4475                                         NULL);
4476   if (htab->tocsave_htab == NULL)
4477     {
4478       ppc64_elf_link_hash_table_free (abfd);
4479       return NULL;
4480     }
4481   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4482
4483   /* Initializing two fields of the union is just cosmetic.  We really
4484      only care about glist, but when compiled on a 32-bit host the
4485      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4486      debugger inspection of these fields look nicer.  */
4487   htab->elf.init_got_refcount.refcount = 0;
4488   htab->elf.init_got_refcount.glist = NULL;
4489   htab->elf.init_plt_refcount.refcount = 0;
4490   htab->elf.init_plt_refcount.glist = NULL;
4491   htab->elf.init_got_offset.offset = 0;
4492   htab->elf.init_got_offset.glist = NULL;
4493   htab->elf.init_plt_offset.offset = 0;
4494   htab->elf.init_plt_offset.glist = NULL;
4495
4496   return &htab->elf.root;
4497 }
4498
4499 /* Create sections for linker generated code.  */
4500
4501 static bfd_boolean
4502 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4503 {
4504   struct ppc_link_hash_table *htab;
4505   flagword flags;
4506
4507   htab = ppc_hash_table (info);
4508
4509   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4510            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4511   if (htab->params->save_restore_funcs)
4512     {
4513       /* Create .sfpr for code to save and restore fp regs.  */
4514       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4515                                                        flags);
4516       if (htab->sfpr == NULL
4517           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4518         return FALSE;
4519     }
4520
4521   if (bfd_link_relocatable (info))
4522     return TRUE;
4523
4524   /* Create .glink for lazy dynamic linking support.  */
4525   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4526                                                     flags);
4527   if (htab->glink == NULL
4528       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4529     return FALSE;
4530
4531   /* The part of .glink used by global entry stubs, separate so that
4532      it can be aligned appropriately without affecting htab->glink.  */
4533   htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4534                                                            flags);
4535   if (htab->global_entry == NULL
4536       || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4537     return FALSE;
4538
4539   if (!info->no_ld_generated_unwind_info)
4540     {
4541       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4542                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4543       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4544                                                                  ".eh_frame",
4545                                                                  flags);
4546       if (htab->glink_eh_frame == NULL
4547           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4548         return FALSE;
4549     }
4550
4551   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4552   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4553   if (htab->elf.iplt == NULL
4554       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4555     return FALSE;
4556
4557   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4558            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4559   htab->elf.irelplt
4560     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4561   if (htab->elf.irelplt == NULL
4562       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4563     return FALSE;
4564
4565   /* Create branch lookup table for plt_branch stubs.  */
4566   flags = (SEC_ALLOC | SEC_LOAD
4567            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4568   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4569                                                    flags);
4570   if (htab->brlt == NULL
4571       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4572     return FALSE;
4573
4574   /* Local plt entries, put in .branch_lt but a separate section for
4575      convenience.  */
4576   htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4577                                                        flags);
4578   if (htab->pltlocal == NULL
4579       || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4580     return FALSE;
4581
4582   if (!bfd_link_pic (info))
4583     return TRUE;
4584
4585   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4586            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4587   htab->relbrlt
4588     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4589   if (htab->relbrlt == NULL
4590       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4591     return FALSE;
4592
4593   htab->relpltlocal
4594     = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4595   if (htab->relpltlocal == NULL
4596       || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4597     return FALSE;
4598
4599   return TRUE;
4600 }
4601
4602 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4603
4604 bfd_boolean
4605 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4606                          struct ppc64_elf_params *params)
4607 {
4608   struct ppc_link_hash_table *htab;
4609
4610   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4611
4612 /* Always hook our dynamic sections into the first bfd, which is the
4613    linker created stub bfd.  This ensures that the GOT header is at
4614    the start of the output TOC section.  */
4615   htab = ppc_hash_table (info);
4616   htab->elf.dynobj = params->stub_bfd;
4617   htab->params = params;
4618
4619   return create_linkage_sections (htab->elf.dynobj, info);
4620 }
4621
4622 /* Build a name for an entry in the stub hash table.  */
4623
4624 static char *
4625 ppc_stub_name (const asection *input_section,
4626                const asection *sym_sec,
4627                const struct ppc_link_hash_entry *h,
4628                const Elf_Internal_Rela *rel)
4629 {
4630   char *stub_name;
4631   ssize_t len;
4632
4633   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4634      offsets from a sym as a branch target?  In fact, we could
4635      probably assume the addend is always zero.  */
4636   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4637
4638   if (h)
4639     {
4640       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4641       stub_name = bfd_malloc (len);
4642       if (stub_name == NULL)
4643         return stub_name;
4644
4645       len = sprintf (stub_name, "%08x.%s+%x",
4646                      input_section->id & 0xffffffff,
4647                      h->elf.root.root.string,
4648                      (int) rel->r_addend & 0xffffffff);
4649     }
4650   else
4651     {
4652       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4653       stub_name = bfd_malloc (len);
4654       if (stub_name == NULL)
4655         return stub_name;
4656
4657       len = sprintf (stub_name, "%08x.%x:%x+%x",
4658                      input_section->id & 0xffffffff,
4659                      sym_sec->id & 0xffffffff,
4660                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4661                      (int) rel->r_addend & 0xffffffff);
4662     }
4663   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4664     stub_name[len - 2] = 0;
4665   return stub_name;
4666 }
4667
4668 /* Look up an entry in the stub hash.  Stub entries are cached because
4669    creating the stub name takes a bit of time.  */
4670
4671 static struct ppc_stub_hash_entry *
4672 ppc_get_stub_entry (const asection *input_section,
4673                     const asection *sym_sec,
4674                     struct ppc_link_hash_entry *h,
4675                     const Elf_Internal_Rela *rel,
4676                     struct ppc_link_hash_table *htab)
4677 {
4678   struct ppc_stub_hash_entry *stub_entry;
4679   struct map_stub *group;
4680
4681   /* If this input section is part of a group of sections sharing one
4682      stub section, then use the id of the first section in the group.
4683      Stub names need to include a section id, as there may well be
4684      more than one stub used to reach say, printf, and we need to
4685      distinguish between them.  */
4686   group = htab->sec_info[input_section->id].u.group;
4687   if (group == NULL)
4688     return NULL;
4689
4690   if (h != NULL && h->u.stub_cache != NULL
4691       && h->u.stub_cache->h == h
4692       && h->u.stub_cache->group == group)
4693     {
4694       stub_entry = h->u.stub_cache;
4695     }
4696   else
4697     {
4698       char *stub_name;
4699
4700       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4701       if (stub_name == NULL)
4702         return NULL;
4703
4704       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4705                                          stub_name, FALSE, FALSE);
4706       if (h != NULL)
4707         h->u.stub_cache = stub_entry;
4708
4709       free (stub_name);
4710     }
4711
4712   return stub_entry;
4713 }
4714
4715 /* Add a new stub entry to the stub hash.  Not all fields of the new
4716    stub entry are initialised.  */
4717
4718 static struct ppc_stub_hash_entry *
4719 ppc_add_stub (const char *stub_name,
4720               asection *section,
4721               struct bfd_link_info *info)
4722 {
4723   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4724   struct map_stub *group;
4725   asection *link_sec;
4726   asection *stub_sec;
4727   struct ppc_stub_hash_entry *stub_entry;
4728
4729   group = htab->sec_info[section->id].u.group;
4730   link_sec = group->link_sec;
4731   stub_sec = group->stub_sec;
4732   if (stub_sec == NULL)
4733     {
4734       size_t namelen;
4735       bfd_size_type len;
4736       char *s_name;
4737
4738       namelen = strlen (link_sec->name);
4739       len = namelen + sizeof (STUB_SUFFIX);
4740       s_name = bfd_alloc (htab->params->stub_bfd, len);
4741       if (s_name == NULL)
4742         return NULL;
4743
4744       memcpy (s_name, link_sec->name, namelen);
4745       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4746       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4747       if (stub_sec == NULL)
4748         return NULL;
4749       group->stub_sec = stub_sec;
4750     }
4751
4752   /* Enter this entry into the linker stub hash table.  */
4753   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4754                                      TRUE, FALSE);
4755   if (stub_entry == NULL)
4756     {
4757       /* xgettext:c-format */
4758       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4759                           section->owner, stub_name);
4760       return NULL;
4761     }
4762
4763   stub_entry->group = group;
4764   stub_entry->stub_offset = 0;
4765   return stub_entry;
4766 }
4767
4768 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4769    not already done.  */
4770
4771 static bfd_boolean
4772 create_got_section (bfd *abfd, struct bfd_link_info *info)
4773 {
4774   asection *got, *relgot;
4775   flagword flags;
4776   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4777
4778   if (!is_ppc64_elf (abfd))
4779     return FALSE;
4780   if (htab == NULL)
4781     return FALSE;
4782
4783   if (!htab->elf.sgot
4784       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4785     return FALSE;
4786
4787   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4788            | SEC_LINKER_CREATED);
4789
4790   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4791   if (!got
4792       || !bfd_set_section_alignment (abfd, got, 3))
4793     return FALSE;
4794
4795   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4796                                                flags | SEC_READONLY);
4797   if (!relgot
4798       || ! bfd_set_section_alignment (abfd, relgot, 3))
4799     return FALSE;
4800
4801   ppc64_elf_tdata (abfd)->got = got;
4802   ppc64_elf_tdata (abfd)->relgot = relgot;
4803   return TRUE;
4804 }
4805
4806 /* Follow indirect and warning symbol links.  */
4807
4808 static inline struct bfd_link_hash_entry *
4809 follow_link (struct bfd_link_hash_entry *h)
4810 {
4811   while (h->type == bfd_link_hash_indirect
4812          || h->type == bfd_link_hash_warning)
4813     h = h->u.i.link;
4814   return h;
4815 }
4816
4817 static inline struct elf_link_hash_entry *
4818 elf_follow_link (struct elf_link_hash_entry *h)
4819 {
4820   return (struct elf_link_hash_entry *) follow_link (&h->root);
4821 }
4822
4823 static inline struct ppc_link_hash_entry *
4824 ppc_follow_link (struct ppc_link_hash_entry *h)
4825 {
4826   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4827 }
4828
4829 /* Merge PLT info on FROM with that on TO.  */
4830
4831 static void
4832 move_plt_plist (struct ppc_link_hash_entry *from,
4833                 struct ppc_link_hash_entry *to)
4834 {
4835   if (from->elf.plt.plist != NULL)
4836     {
4837       if (to->elf.plt.plist != NULL)
4838         {
4839           struct plt_entry **entp;
4840           struct plt_entry *ent;
4841
4842           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4843             {
4844               struct plt_entry *dent;
4845
4846               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4847                 if (dent->addend == ent->addend)
4848                   {
4849                     dent->plt.refcount += ent->plt.refcount;
4850                     *entp = ent->next;
4851                     break;
4852                   }
4853               if (dent == NULL)
4854                 entp = &ent->next;
4855             }
4856           *entp = to->elf.plt.plist;
4857         }
4858
4859       to->elf.plt.plist = from->elf.plt.plist;
4860       from->elf.plt.plist = NULL;
4861     }
4862 }
4863
4864 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4865
4866 static void
4867 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4868                                 struct elf_link_hash_entry *dir,
4869                                 struct elf_link_hash_entry *ind)
4870 {
4871   struct ppc_link_hash_entry *edir, *eind;
4872
4873   edir = (struct ppc_link_hash_entry *) dir;
4874   eind = (struct ppc_link_hash_entry *) ind;
4875
4876   edir->is_func |= eind->is_func;
4877   edir->is_func_descriptor |= eind->is_func_descriptor;
4878   edir->tls_mask |= eind->tls_mask;
4879   if (eind->oh != NULL)
4880     edir->oh = ppc_follow_link (eind->oh);
4881
4882   if (edir->elf.versioned != versioned_hidden)
4883     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4884   edir->elf.ref_regular |= eind->elf.ref_regular;
4885   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4886   edir->elf.non_got_ref |= eind->elf.non_got_ref;
4887   edir->elf.needs_plt |= eind->elf.needs_plt;
4888   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4889
4890   /* If we were called to copy over info for a weak sym, don't copy
4891      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4892      in order to simplify readonly_dynrelocs and save a field in the
4893      symbol hash entry, but that means dyn_relocs can't be used in any
4894      tests about a specific symbol, or affect other symbol flags which
4895      are then tested.  */
4896   if (eind->elf.root.type != bfd_link_hash_indirect)
4897     return;
4898
4899   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4900   if (eind->dyn_relocs != NULL)
4901     {
4902       if (edir->dyn_relocs != NULL)
4903         {
4904           struct elf_dyn_relocs **pp;
4905           struct elf_dyn_relocs *p;
4906
4907           /* Add reloc counts against the indirect sym to the direct sym
4908              list.  Merge any entries against the same section.  */
4909           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4910             {
4911               struct elf_dyn_relocs *q;
4912
4913               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4914                 if (q->sec == p->sec)
4915                   {
4916                     q->pc_count += p->pc_count;
4917                     q->count += p->count;
4918                     *pp = p->next;
4919                     break;
4920                   }
4921               if (q == NULL)
4922                 pp = &p->next;
4923             }
4924           *pp = edir->dyn_relocs;
4925         }
4926
4927       edir->dyn_relocs = eind->dyn_relocs;
4928       eind->dyn_relocs = NULL;
4929     }
4930
4931   /* Copy over got entries that we may have already seen to the
4932      symbol which just became indirect.  */
4933   if (eind->elf.got.glist != NULL)
4934     {
4935       if (edir->elf.got.glist != NULL)
4936         {
4937           struct got_entry **entp;
4938           struct got_entry *ent;
4939
4940           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4941             {
4942               struct got_entry *dent;
4943
4944               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4945                 if (dent->addend == ent->addend
4946                     && dent->owner == ent->owner
4947                     && dent->tls_type == ent->tls_type)
4948                   {
4949                     dent->got.refcount += ent->got.refcount;
4950                     *entp = ent->next;
4951                     break;
4952                   }
4953               if (dent == NULL)
4954                 entp = &ent->next;
4955             }
4956           *entp = edir->elf.got.glist;
4957         }
4958
4959       edir->elf.got.glist = eind->elf.got.glist;
4960       eind->elf.got.glist = NULL;
4961     }
4962
4963   /* And plt entries.  */
4964   move_plt_plist (eind, edir);
4965
4966   if (eind->elf.dynindx != -1)
4967     {
4968       if (edir->elf.dynindx != -1)
4969         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4970                                 edir->elf.dynstr_index);
4971       edir->elf.dynindx = eind->elf.dynindx;
4972       edir->elf.dynstr_index = eind->elf.dynstr_index;
4973       eind->elf.dynindx = -1;
4974       eind->elf.dynstr_index = 0;
4975     }
4976 }
4977
4978 /* Find the function descriptor hash entry from the given function code
4979    hash entry FH.  Link the entries via their OH fields.  */
4980
4981 static struct ppc_link_hash_entry *
4982 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4983 {
4984   struct ppc_link_hash_entry *fdh = fh->oh;
4985
4986   if (fdh == NULL)
4987     {
4988       const char *fd_name = fh->elf.root.root.string + 1;
4989
4990       fdh = (struct ppc_link_hash_entry *)
4991         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4992       if (fdh == NULL)
4993         return fdh;
4994
4995       fdh->is_func_descriptor = 1;
4996       fdh->oh = fh;
4997       fh->is_func = 1;
4998       fh->oh = fdh;
4999     }
5000
5001   fdh = ppc_follow_link (fdh);
5002   fdh->is_func_descriptor = 1;
5003   fdh->oh = fh;
5004   return fdh;
5005 }
5006
5007 /* Make a fake function descriptor sym for the undefined code sym FH.  */
5008
5009 static struct ppc_link_hash_entry *
5010 make_fdh (struct bfd_link_info *info,
5011           struct ppc_link_hash_entry *fh)
5012 {
5013   bfd *abfd = fh->elf.root.u.undef.abfd;
5014   struct bfd_link_hash_entry *bh = NULL;
5015   struct ppc_link_hash_entry *fdh;
5016   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5017                     ? BSF_WEAK
5018                     : BSF_GLOBAL);
5019
5020   if (!_bfd_generic_link_add_one_symbol (info, abfd,
5021                                          fh->elf.root.root.string + 1,
5022                                          flags, bfd_und_section_ptr, 0,
5023                                          NULL, FALSE, FALSE, &bh))
5024     return NULL;
5025
5026   fdh = (struct ppc_link_hash_entry *) bh;
5027   fdh->elf.non_elf = 0;
5028   fdh->fake = 1;
5029   fdh->is_func_descriptor = 1;
5030   fdh->oh = fh;
5031   fh->is_func = 1;
5032   fh->oh = fdh;
5033   return fdh;
5034 }
5035
5036 /* Fix function descriptor symbols defined in .opd sections to be
5037    function type.  */
5038
5039 static bfd_boolean
5040 ppc64_elf_add_symbol_hook (bfd *ibfd,
5041                            struct bfd_link_info *info,
5042                            Elf_Internal_Sym *isym,
5043                            const char **name,
5044                            flagword *flags ATTRIBUTE_UNUSED,
5045                            asection **sec,
5046                            bfd_vma *value)
5047 {
5048   if (*sec != NULL
5049       && strcmp ((*sec)->name, ".opd") == 0)
5050     {
5051       asection *code_sec;
5052
5053       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5054             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5055         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5056
5057       /* If the symbol is a function defined in .opd, and the function
5058          code is in a discarded group, let it appear to be undefined.  */
5059       if (!bfd_link_relocatable (info)
5060           && (*sec)->reloc_count != 0
5061           && opd_entry_value (*sec, *value, &code_sec, NULL,
5062                               FALSE) != (bfd_vma) -1
5063           && discarded_section (code_sec))
5064         {
5065           *sec = bfd_und_section_ptr;
5066           isym->st_shndx = SHN_UNDEF;
5067         }
5068     }
5069   else if (*sec != NULL
5070            && strcmp ((*sec)->name, ".toc") == 0
5071            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5072     {
5073       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5074       if (htab != NULL)
5075         htab->params->object_in_toc = 1;
5076     }
5077
5078   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5079     {
5080       if (abiversion (ibfd) == 0)
5081         set_abiversion (ibfd, 2);
5082       else if (abiversion (ibfd) == 1)
5083         {
5084           _bfd_error_handler (_("symbol '%s' has invalid st_other"
5085                                 " for ABI version 1"), *name);
5086           bfd_set_error (bfd_error_bad_value);
5087           return FALSE;
5088         }
5089     }
5090
5091   return TRUE;
5092 }
5093
5094 /* Merge non-visibility st_other attributes: local entry point.  */
5095
5096 static void
5097 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5098                                   const Elf_Internal_Sym *isym,
5099                                   bfd_boolean definition,
5100                                   bfd_boolean dynamic)
5101 {
5102   if (definition && (!dynamic || !h->def_regular))
5103     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5104                 | ELF_ST_VISIBILITY (h->other));
5105 }
5106
5107 /* Hook called on merging a symbol.  We use this to clear "fake" since
5108    we now have a real symbol.  */
5109
5110 static bfd_boolean
5111 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5112                         const Elf_Internal_Sym *isym,
5113                         asection **psec ATTRIBUTE_UNUSED,
5114                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5115                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5116                         bfd *oldbfd ATTRIBUTE_UNUSED,
5117                         const asection *oldsec ATTRIBUTE_UNUSED)
5118 {
5119   ((struct ppc_link_hash_entry *) h)->fake = 0;
5120   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5121     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5122   return TRUE;
5123 }
5124
5125 /* This function makes an old ABI object reference to ".bar" cause the
5126    inclusion of a new ABI object archive that defines "bar".
5127    NAME is a symbol defined in an archive.  Return a symbol in the hash
5128    table that might be satisfied by the archive symbols.  */
5129
5130 static struct elf_link_hash_entry *
5131 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5132                                  struct bfd_link_info *info,
5133                                  const char *name)
5134 {
5135   struct elf_link_hash_entry *h;
5136   char *dot_name;
5137   size_t len;
5138
5139   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5140   if (h != NULL
5141       /* Don't return this sym if it is a fake function descriptor
5142          created by add_symbol_adjust.  */
5143       && !((struct ppc_link_hash_entry *) h)->fake)
5144     return h;
5145
5146   if (name[0] == '.')
5147     return h;
5148
5149   len = strlen (name);
5150   dot_name = bfd_alloc (abfd, len + 2);
5151   if (dot_name == NULL)
5152     return (struct elf_link_hash_entry *) -1;
5153   dot_name[0] = '.';
5154   memcpy (dot_name + 1, name, len + 1);
5155   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5156   bfd_release (abfd, dot_name);
5157   return h;
5158 }
5159
5160 /* This function satisfies all old ABI object references to ".bar" if a
5161    new ABI object defines "bar".  Well, at least, undefined dot symbols
5162    are made weak.  This stops later archive searches from including an
5163    object if we already have a function descriptor definition.  It also
5164    prevents the linker complaining about undefined symbols.
5165    We also check and correct mismatched symbol visibility here.  The
5166    most restrictive visibility of the function descriptor and the
5167    function entry symbol is used.  */
5168
5169 static bfd_boolean
5170 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5171 {
5172   struct ppc_link_hash_table *htab;
5173   struct ppc_link_hash_entry *fdh;
5174
5175   if (eh->elf.root.type == bfd_link_hash_warning)
5176     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5177
5178   if (eh->elf.root.type == bfd_link_hash_indirect)
5179     return TRUE;
5180
5181   if (eh->elf.root.root.string[0] != '.')
5182     abort ();
5183
5184   htab = ppc_hash_table (info);
5185   if (htab == NULL)
5186     return FALSE;
5187
5188   fdh = lookup_fdh (eh, htab);
5189   if (fdh == NULL
5190       && !bfd_link_relocatable (info)
5191       && (eh->elf.root.type == bfd_link_hash_undefined
5192           || eh->elf.root.type == bfd_link_hash_undefweak)
5193       && eh->elf.ref_regular)
5194     {
5195       /* Make an undefined function descriptor sym, in order to
5196          pull in an --as-needed shared lib.  Archives are handled
5197          elsewhere.  */
5198       fdh = make_fdh (info, eh);
5199       if (fdh == NULL)
5200         return FALSE;
5201     }
5202
5203   if (fdh != NULL)
5204     {
5205       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5206       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5207
5208       /* Make both descriptor and entry symbol have the most
5209          constraining visibility of either symbol.  */
5210       if (entry_vis < descr_vis)
5211         fdh->elf.other += entry_vis - descr_vis;
5212       else if (entry_vis > descr_vis)
5213         eh->elf.other += descr_vis - entry_vis;
5214
5215       /* Propagate reference flags from entry symbol to function
5216          descriptor symbol.  */
5217       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5218       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5219       fdh->elf.ref_regular |= eh->elf.ref_regular;
5220       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5221
5222       if (!fdh->elf.forced_local
5223           && fdh->elf.dynindx == -1
5224           && fdh->elf.versioned != versioned_hidden
5225           && (bfd_link_dll (info)
5226               || fdh->elf.def_dynamic
5227               || fdh->elf.ref_dynamic)
5228           && (eh->elf.ref_regular
5229               || eh->elf.def_regular))
5230         {
5231           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5232             return FALSE;
5233         }
5234     }
5235
5236   return TRUE;
5237 }
5238
5239 /* Set up opd section info and abiversion for IBFD, and process list
5240    of dot-symbols we made in link_hash_newfunc.  */
5241
5242 static bfd_boolean
5243 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5244 {
5245   struct ppc_link_hash_table *htab;
5246   struct ppc_link_hash_entry **p, *eh;
5247   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5248
5249   if (opd != NULL && opd->size != 0)
5250     {
5251       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5252       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5253
5254       if (abiversion (ibfd) == 0)
5255         set_abiversion (ibfd, 1);
5256       else if (abiversion (ibfd) >= 2)
5257         {
5258           /* xgettext:c-format */
5259           _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5260                               ibfd, abiversion (ibfd));
5261           bfd_set_error (bfd_error_bad_value);
5262           return FALSE;
5263         }
5264     }
5265
5266   if (is_ppc64_elf (info->output_bfd))
5267     {
5268       /* For input files without an explicit abiversion in e_flags
5269          we should have flagged any with symbol st_other bits set
5270          as ELFv1 and above flagged those with .opd as ELFv2.
5271          Set the output abiversion if not yet set, and for any input
5272          still ambiguous, take its abiversion from the output.
5273          Differences in ABI are reported later.  */
5274       if (abiversion (info->output_bfd) == 0)
5275         set_abiversion (info->output_bfd, abiversion (ibfd));
5276       else if (abiversion (ibfd) == 0)
5277         set_abiversion (ibfd, abiversion (info->output_bfd));
5278     }
5279
5280   htab = ppc_hash_table (info);
5281   if (htab == NULL)
5282     return TRUE;
5283
5284   if (opd != NULL && opd->size != 0
5285       && (ibfd->flags & DYNAMIC) == 0
5286       && (opd->flags & SEC_RELOC) != 0
5287       && opd->reloc_count != 0
5288       && !bfd_is_abs_section (opd->output_section)
5289       && info->gc_sections)
5290     {
5291       /* Garbage collection needs some extra help with .opd sections.
5292          We don't want to necessarily keep everything referenced by
5293          relocs in .opd, as that would keep all functions.  Instead,
5294          if we reference an .opd symbol (a function descriptor), we
5295          want to keep the function code symbol's section.  This is
5296          easy for global symbols, but for local syms we need to keep
5297          information about the associated function section.  */
5298       bfd_size_type amt;
5299       asection **opd_sym_map;
5300       Elf_Internal_Shdr *symtab_hdr;
5301       Elf_Internal_Rela *relocs, *rel_end, *rel;
5302
5303       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5304       opd_sym_map = bfd_zalloc (ibfd, amt);
5305       if (opd_sym_map == NULL)
5306         return FALSE;
5307       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5308       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5309                                           info->keep_memory);
5310       if (relocs == NULL)
5311         return FALSE;
5312       symtab_hdr = &elf_symtab_hdr (ibfd);
5313       rel_end = relocs + opd->reloc_count - 1;
5314       for (rel = relocs; rel < rel_end; rel++)
5315         {
5316           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5317           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5318
5319           if (r_type == R_PPC64_ADDR64
5320               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5321               && r_symndx < symtab_hdr->sh_info)
5322             {
5323               Elf_Internal_Sym *isym;
5324               asection *s;
5325
5326               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5327               if (isym == NULL)
5328                 {
5329                   if (elf_section_data (opd)->relocs != relocs)
5330                     free (relocs);
5331                   return FALSE;
5332                 }
5333
5334               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5335               if (s != NULL && s != opd)
5336                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5337             }
5338         }
5339       if (elf_section_data (opd)->relocs != relocs)
5340         free (relocs);
5341     }
5342
5343   p = &htab->dot_syms;
5344   while ((eh = *p) != NULL)
5345     {
5346       *p = NULL;
5347       if (&eh->elf == htab->elf.hgot)
5348         ;
5349       else if (htab->elf.hgot == NULL
5350                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5351         htab->elf.hgot = &eh->elf;
5352       else if (abiversion (ibfd) <= 1)
5353         {
5354           htab->need_func_desc_adj = 1;
5355           if (!add_symbol_adjust (eh, info))
5356             return FALSE;
5357         }
5358       p = &eh->u.next_dot_sym;
5359     }
5360   return TRUE;
5361 }
5362
5363 /* Undo hash table changes when an --as-needed input file is determined
5364    not to be needed.  */
5365
5366 static bfd_boolean
5367 ppc64_elf_notice_as_needed (bfd *ibfd,
5368                             struct bfd_link_info *info,
5369                             enum notice_asneeded_action act)
5370 {
5371   if (act == notice_not_needed)
5372     {
5373       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5374
5375       if (htab == NULL)
5376         return FALSE;
5377
5378       htab->dot_syms = NULL;
5379     }
5380   return _bfd_elf_notice_as_needed (ibfd, info, act);
5381 }
5382
5383 /* If --just-symbols against a final linked binary, then assume we need
5384    toc adjusting stubs when calling functions defined there.  */
5385
5386 static void
5387 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5388 {
5389   if ((sec->flags & SEC_CODE) != 0
5390       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5391       && is_ppc64_elf (sec->owner))
5392     {
5393       if (abiversion (sec->owner) >= 2
5394           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5395         sec->has_toc_reloc = 1;
5396     }
5397   _bfd_elf_link_just_syms (sec, info);
5398 }
5399
5400 static struct plt_entry **
5401 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5402                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5403 {
5404   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5405   struct plt_entry **local_plt;
5406   unsigned char *local_got_tls_masks;
5407
5408   if (local_got_ents == NULL)
5409     {
5410       bfd_size_type size = symtab_hdr->sh_info;
5411
5412       size *= (sizeof (*local_got_ents)
5413                + sizeof (*local_plt)
5414                + sizeof (*local_got_tls_masks));
5415       local_got_ents = bfd_zalloc (abfd, size);
5416       if (local_got_ents == NULL)
5417         return NULL;
5418       elf_local_got_ents (abfd) = local_got_ents;
5419     }
5420
5421   if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5422     {
5423       struct got_entry *ent;
5424
5425       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5426         if (ent->addend == r_addend
5427             && ent->owner == abfd
5428             && ent->tls_type == tls_type)
5429           break;
5430       if (ent == NULL)
5431         {
5432           bfd_size_type amt = sizeof (*ent);
5433           ent = bfd_alloc (abfd, amt);
5434           if (ent == NULL)
5435             return FALSE;
5436           ent->next = local_got_ents[r_symndx];
5437           ent->addend = r_addend;
5438           ent->owner = abfd;
5439           ent->tls_type = tls_type;
5440           ent->is_indirect = FALSE;
5441           ent->got.refcount = 0;
5442           local_got_ents[r_symndx] = ent;
5443         }
5444       ent->got.refcount += 1;
5445     }
5446
5447   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5448   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5449   local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5450
5451   return local_plt + r_symndx;
5452 }
5453
5454 static bfd_boolean
5455 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5456 {
5457   struct plt_entry *ent;
5458
5459   for (ent = *plist; ent != NULL; ent = ent->next)
5460     if (ent->addend == addend)
5461       break;
5462   if (ent == NULL)
5463     {
5464       bfd_size_type amt = sizeof (*ent);
5465       ent = bfd_alloc (abfd, amt);
5466       if (ent == NULL)
5467         return FALSE;
5468       ent->next = *plist;
5469       ent->addend = addend;
5470       ent->plt.refcount = 0;
5471       *plist = ent;
5472     }
5473   ent->plt.refcount += 1;
5474   return TRUE;
5475 }
5476
5477 static bfd_boolean
5478 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5479 {
5480   return (r_type == R_PPC64_REL24
5481           || r_type == R_PPC64_REL14
5482           || r_type == R_PPC64_REL14_BRTAKEN
5483           || r_type == R_PPC64_REL14_BRNTAKEN
5484           || r_type == R_PPC64_ADDR24
5485           || r_type == R_PPC64_ADDR14
5486           || r_type == R_PPC64_ADDR14_BRTAKEN
5487           || r_type == R_PPC64_ADDR14_BRNTAKEN
5488           || r_type == R_PPC64_PLTCALL);
5489 }
5490
5491 /* Relocs on inline plt call sequence insns prior to the call.  */
5492
5493 static bfd_boolean
5494 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5495 {
5496   return (r_type == R_PPC64_PLT16_HA
5497           || r_type == R_PPC64_PLT16_HI
5498           || r_type == R_PPC64_PLT16_LO
5499           || r_type == R_PPC64_PLT16_LO_DS
5500           || r_type == R_PPC64_PLTSEQ);
5501 }
5502
5503 /* Look through the relocs for a section during the first phase, and
5504    calculate needed space in the global offset table, procedure
5505    linkage table, and dynamic reloc sections.  */
5506
5507 static bfd_boolean
5508 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5509                         asection *sec, const Elf_Internal_Rela *relocs)
5510 {
5511   struct ppc_link_hash_table *htab;
5512   Elf_Internal_Shdr *symtab_hdr;
5513   struct elf_link_hash_entry **sym_hashes;
5514   const Elf_Internal_Rela *rel;
5515   const Elf_Internal_Rela *rel_end;
5516   asection *sreloc;
5517   struct elf_link_hash_entry *tga, *dottga;
5518   bfd_boolean is_opd;
5519
5520   if (bfd_link_relocatable (info))
5521     return TRUE;
5522
5523   /* Don't do anything special with non-loaded, non-alloced sections.
5524      In particular, any relocs in such sections should not affect GOT
5525      and PLT reference counting (ie. we don't allow them to create GOT
5526      or PLT entries), there's no possibility or desire to optimize TLS
5527      relocs, and there's not much point in propagating relocs to shared
5528      libs that the dynamic linker won't relocate.  */
5529   if ((sec->flags & SEC_ALLOC) == 0)
5530     return TRUE;
5531
5532   BFD_ASSERT (is_ppc64_elf (abfd));
5533
5534   htab = ppc_hash_table (info);
5535   if (htab == NULL)
5536     return FALSE;
5537
5538   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5539                               FALSE, FALSE, TRUE);
5540   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5541                                  FALSE, FALSE, TRUE);
5542   symtab_hdr = &elf_symtab_hdr (abfd);
5543   sym_hashes = elf_sym_hashes (abfd);
5544   sreloc = NULL;
5545   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5546   rel_end = relocs + sec->reloc_count;
5547   for (rel = relocs; rel < rel_end; rel++)
5548     {
5549       unsigned long r_symndx;
5550       struct elf_link_hash_entry *h;
5551       enum elf_ppc64_reloc_type r_type;
5552       int tls_type;
5553       struct _ppc64_elf_section_data *ppc64_sec;
5554       struct plt_entry **ifunc, **plt_list;
5555
5556       r_symndx = ELF64_R_SYM (rel->r_info);
5557       if (r_symndx < symtab_hdr->sh_info)
5558         h = NULL;
5559       else
5560         {
5561           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5562           h = elf_follow_link (h);
5563
5564           if (h == htab->elf.hgot)
5565             sec->has_toc_reloc = 1;
5566         }
5567
5568       tls_type = 0;
5569       ifunc = NULL;
5570       if (h != NULL)
5571         {
5572           if (h->type == STT_GNU_IFUNC)
5573             {
5574               h->needs_plt = 1;
5575               ifunc = &h->plt.plist;
5576             }
5577         }
5578       else
5579         {
5580           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5581                                                           abfd, r_symndx);
5582           if (isym == NULL)
5583             return FALSE;
5584
5585           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5586             {
5587               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5588                                              rel->r_addend,
5589                                              NON_GOT | PLT_IFUNC);
5590               if (ifunc == NULL)
5591                 return FALSE;
5592             }
5593         }
5594
5595       r_type = ELF64_R_TYPE (rel->r_info);
5596       switch (r_type)
5597         {
5598         case R_PPC64_TLSGD:
5599         case R_PPC64_TLSLD:
5600           /* These special tls relocs tie a call to __tls_get_addr with
5601              its parameter symbol.  */
5602           if (h != NULL)
5603             ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5604           else
5605             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5606                                         rel->r_addend,
5607                                         NON_GOT | TLS_TLS | TLS_MARK))
5608               return FALSE;
5609           sec->has_tls_reloc = 1;
5610           break;
5611
5612         case R_PPC64_GOT_TLSLD16:
5613         case R_PPC64_GOT_TLSLD16_LO:
5614         case R_PPC64_GOT_TLSLD16_HI:
5615         case R_PPC64_GOT_TLSLD16_HA:
5616           tls_type = TLS_TLS | TLS_LD;
5617           goto dogottls;
5618
5619         case R_PPC64_GOT_TLSGD16:
5620         case R_PPC64_GOT_TLSGD16_LO:
5621         case R_PPC64_GOT_TLSGD16_HI:
5622         case R_PPC64_GOT_TLSGD16_HA:
5623           tls_type = TLS_TLS | TLS_GD;
5624           goto dogottls;
5625
5626         case R_PPC64_GOT_TPREL16_DS:
5627         case R_PPC64_GOT_TPREL16_LO_DS:
5628         case R_PPC64_GOT_TPREL16_HI:
5629         case R_PPC64_GOT_TPREL16_HA:
5630           if (bfd_link_dll (info))
5631             info->flags |= DF_STATIC_TLS;
5632           tls_type = TLS_TLS | TLS_TPREL;
5633           goto dogottls;
5634
5635         case R_PPC64_GOT_DTPREL16_DS:
5636         case R_PPC64_GOT_DTPREL16_LO_DS:
5637         case R_PPC64_GOT_DTPREL16_HI:
5638         case R_PPC64_GOT_DTPREL16_HA:
5639           tls_type = TLS_TLS | TLS_DTPREL;
5640         dogottls:
5641           sec->has_tls_reloc = 1;
5642           /* Fall through */
5643
5644         case R_PPC64_GOT16:
5645         case R_PPC64_GOT16_DS:
5646         case R_PPC64_GOT16_HA:
5647         case R_PPC64_GOT16_HI:
5648         case R_PPC64_GOT16_LO:
5649         case R_PPC64_GOT16_LO_DS:
5650           /* This symbol requires a global offset table entry.  */
5651           sec->has_toc_reloc = 1;
5652           if (r_type == R_PPC64_GOT_TLSLD16
5653               || r_type == R_PPC64_GOT_TLSGD16
5654               || r_type == R_PPC64_GOT_TPREL16_DS
5655               || r_type == R_PPC64_GOT_DTPREL16_DS
5656               || r_type == R_PPC64_GOT16
5657               || r_type == R_PPC64_GOT16_DS)
5658             {
5659               htab->do_multi_toc = 1;
5660               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5661             }
5662
5663           if (ppc64_elf_tdata (abfd)->got == NULL
5664               && !create_got_section (abfd, info))
5665             return FALSE;
5666
5667           if (h != NULL)
5668             {
5669               struct ppc_link_hash_entry *eh;
5670               struct got_entry *ent;
5671
5672               eh = (struct ppc_link_hash_entry *) h;
5673               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5674                 if (ent->addend == rel->r_addend
5675                     && ent->owner == abfd
5676                     && ent->tls_type == tls_type)
5677                   break;
5678               if (ent == NULL)
5679                 {
5680                   bfd_size_type amt = sizeof (*ent);
5681                   ent = bfd_alloc (abfd, amt);
5682                   if (ent == NULL)
5683                     return FALSE;
5684                   ent->next = eh->elf.got.glist;
5685                   ent->addend = rel->r_addend;
5686                   ent->owner = abfd;
5687                   ent->tls_type = tls_type;
5688                   ent->is_indirect = FALSE;
5689                   ent->got.refcount = 0;
5690                   eh->elf.got.glist = ent;
5691                 }
5692               ent->got.refcount += 1;
5693               eh->tls_mask |= tls_type;
5694             }
5695           else
5696             /* This is a global offset table entry for a local symbol.  */
5697             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5698                                         rel->r_addend, tls_type))
5699               return FALSE;
5700
5701           /* We may also need a plt entry if the symbol turns out to be
5702              an ifunc.  */
5703           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5704             {
5705               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5706                 return FALSE;
5707             }
5708           break;
5709
5710         case R_PPC64_PLT16_HA:
5711         case R_PPC64_PLT16_HI:
5712         case R_PPC64_PLT16_LO:
5713         case R_PPC64_PLT16_LO_DS:
5714         case R_PPC64_PLT32:
5715         case R_PPC64_PLT64:
5716           /* This symbol requires a procedure linkage table entry.  */
5717           plt_list = ifunc;
5718           if (h != NULL)
5719             {
5720               h->needs_plt = 1;
5721               if (h->root.root.string[0] == '.'
5722                   && h->root.root.string[1] != '\0')
5723                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5724               ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5725               plt_list = &h->plt.plist;
5726             }
5727           if (plt_list == NULL)
5728             plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5729                                               rel->r_addend,
5730                                               NON_GOT | PLT_KEEP);
5731           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5732             return FALSE;
5733           break;
5734
5735           /* The following relocations don't need to propagate the
5736              relocation if linking a shared object since they are
5737              section relative.  */
5738         case R_PPC64_SECTOFF:
5739         case R_PPC64_SECTOFF_LO:
5740         case R_PPC64_SECTOFF_HI:
5741         case R_PPC64_SECTOFF_HA:
5742         case R_PPC64_SECTOFF_DS:
5743         case R_PPC64_SECTOFF_LO_DS:
5744         case R_PPC64_DTPREL16:
5745         case R_PPC64_DTPREL16_LO:
5746         case R_PPC64_DTPREL16_HI:
5747         case R_PPC64_DTPREL16_HA:
5748         case R_PPC64_DTPREL16_DS:
5749         case R_PPC64_DTPREL16_LO_DS:
5750         case R_PPC64_DTPREL16_HIGH:
5751         case R_PPC64_DTPREL16_HIGHA:
5752         case R_PPC64_DTPREL16_HIGHER:
5753         case R_PPC64_DTPREL16_HIGHERA:
5754         case R_PPC64_DTPREL16_HIGHEST:
5755         case R_PPC64_DTPREL16_HIGHESTA:
5756           break;
5757
5758           /* Nor do these.  */
5759         case R_PPC64_REL16:
5760         case R_PPC64_REL16_LO:
5761         case R_PPC64_REL16_HI:
5762         case R_PPC64_REL16_HA:
5763         case R_PPC64_REL16DX_HA:
5764           break;
5765
5766           /* Not supported as a dynamic relocation.  */
5767         case R_PPC64_ADDR64_LOCAL:
5768           if (bfd_link_pic (info))
5769             {
5770               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5771                 ppc_howto_init ();
5772               /* xgettext:c-format */
5773               info->callbacks->einfo (_("%H: %s reloc unsupported "
5774                                         "in shared libraries and PIEs\n"),
5775                                       abfd, sec, rel->r_offset,
5776                                       ppc64_elf_howto_table[r_type]->name);
5777               bfd_set_error (bfd_error_bad_value);
5778               return FALSE;
5779             }
5780           break;
5781
5782         case R_PPC64_TOC16:
5783         case R_PPC64_TOC16_DS:
5784           htab->do_multi_toc = 1;
5785           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5786           /* Fall through.  */
5787         case R_PPC64_TOC16_LO:
5788         case R_PPC64_TOC16_HI:
5789         case R_PPC64_TOC16_HA:
5790         case R_PPC64_TOC16_LO_DS:
5791           sec->has_toc_reloc = 1;
5792           break;
5793
5794           /* Marker reloc.  */
5795         case R_PPC64_ENTRY:
5796           break;
5797
5798           /* This relocation describes the C++ object vtable hierarchy.
5799              Reconstruct it for later use during GC.  */
5800         case R_PPC64_GNU_VTINHERIT:
5801           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5802             return FALSE;
5803           break;
5804
5805           /* This relocation describes which C++ vtable entries are actually
5806              used.  Record for later use during GC.  */
5807         case R_PPC64_GNU_VTENTRY:
5808           BFD_ASSERT (h != NULL);
5809           if (h != NULL
5810               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5811             return FALSE;
5812           break;
5813
5814         case R_PPC64_REL14:
5815         case R_PPC64_REL14_BRTAKEN:
5816         case R_PPC64_REL14_BRNTAKEN:
5817           {
5818             asection *dest = NULL;
5819
5820             /* Heuristic: If jumping outside our section, chances are
5821                we are going to need a stub.  */
5822             if (h != NULL)
5823               {
5824                 /* If the sym is weak it may be overridden later, so
5825                    don't assume we know where a weak sym lives.  */
5826                 if (h->root.type == bfd_link_hash_defined)
5827                   dest = h->root.u.def.section;
5828               }
5829             else
5830               {
5831                 Elf_Internal_Sym *isym;
5832
5833                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5834                                               abfd, r_symndx);
5835                 if (isym == NULL)
5836                   return FALSE;
5837
5838                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5839               }
5840
5841             if (dest != sec)
5842               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5843           }
5844           goto rel24;
5845
5846         case R_PPC64_PLTCALL:
5847           ppc64_elf_section_data (sec)->has_pltcall = 1;
5848           /* Fall through.  */
5849
5850         case R_PPC64_REL24:
5851         rel24:
5852           plt_list = ifunc;
5853           if (h != NULL)
5854             {
5855               h->needs_plt = 1;
5856               if (h->root.root.string[0] == '.'
5857                   && h->root.root.string[1] != '\0')
5858                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5859
5860               if (h == tga || h == dottga)
5861                 {
5862                   sec->has_tls_reloc = 1;
5863                   if (rel != relocs
5864                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5865                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5866                     /* We have a new-style __tls_get_addr call with
5867                        a marker reloc.  */
5868                     ;
5869                   else
5870                     /* Mark this section as having an old-style call.  */
5871                     sec->has_tls_get_addr_call = 1;
5872                 }
5873               plt_list = &h->plt.plist;
5874             }
5875
5876           /* We may need a .plt entry if the function this reloc
5877              refers to is in a shared lib.  */
5878           if (plt_list
5879               && !update_plt_info (abfd, plt_list, rel->r_addend))
5880             return FALSE;
5881           break;
5882
5883         case R_PPC64_ADDR14:
5884         case R_PPC64_ADDR14_BRNTAKEN:
5885         case R_PPC64_ADDR14_BRTAKEN:
5886         case R_PPC64_ADDR24:
5887           goto dodyn;
5888
5889         case R_PPC64_TPREL64:
5890           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5891           if (bfd_link_dll (info))
5892             info->flags |= DF_STATIC_TLS;
5893           goto dotlstoc;
5894
5895         case R_PPC64_DTPMOD64:
5896           if (rel + 1 < rel_end
5897               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5898               && rel[1].r_offset == rel->r_offset + 8)
5899             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5900           else
5901             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5902           goto dotlstoc;
5903
5904         case R_PPC64_DTPREL64:
5905           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5906           if (rel != relocs
5907               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5908               && rel[-1].r_offset == rel->r_offset - 8)
5909             /* This is the second reloc of a dtpmod, dtprel pair.
5910                Don't mark with TLS_DTPREL.  */
5911             goto dodyn;
5912
5913         dotlstoc:
5914           sec->has_tls_reloc = 1;
5915           if (h != NULL)
5916             {
5917               struct ppc_link_hash_entry *eh;
5918               eh = (struct ppc_link_hash_entry *) h;
5919               eh->tls_mask |= tls_type;
5920             }
5921           else
5922             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5923                                         rel->r_addend, tls_type))
5924               return FALSE;
5925
5926           ppc64_sec = ppc64_elf_section_data (sec);
5927           if (ppc64_sec->sec_type != sec_toc)
5928             {
5929               bfd_size_type amt;
5930
5931               /* One extra to simplify get_tls_mask.  */
5932               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5933               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5934               if (ppc64_sec->u.toc.symndx == NULL)
5935                 return FALSE;
5936               amt = sec->size * sizeof (bfd_vma) / 8;
5937               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5938               if (ppc64_sec->u.toc.add == NULL)
5939                 return FALSE;
5940               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5941               ppc64_sec->sec_type = sec_toc;
5942             }
5943           BFD_ASSERT (rel->r_offset % 8 == 0);
5944           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5945           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5946
5947           /* Mark the second slot of a GD or LD entry.
5948              -1 to indicate GD and -2 to indicate LD.  */
5949           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5950             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5951           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5952             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5953           goto dodyn;
5954
5955         case R_PPC64_TPREL16:
5956         case R_PPC64_TPREL16_LO:
5957         case R_PPC64_TPREL16_HI:
5958         case R_PPC64_TPREL16_HA:
5959         case R_PPC64_TPREL16_DS:
5960         case R_PPC64_TPREL16_LO_DS:
5961         case R_PPC64_TPREL16_HIGH:
5962         case R_PPC64_TPREL16_HIGHA:
5963         case R_PPC64_TPREL16_HIGHER:
5964         case R_PPC64_TPREL16_HIGHERA:
5965         case R_PPC64_TPREL16_HIGHEST:
5966         case R_PPC64_TPREL16_HIGHESTA:
5967           if (bfd_link_dll (info))
5968             info->flags |= DF_STATIC_TLS;
5969           goto dodyn;
5970
5971         case R_PPC64_ADDR64:
5972           if (is_opd
5973               && rel + 1 < rel_end
5974               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5975             {
5976               if (h != NULL)
5977                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5978             }
5979           /* Fall through.  */
5980
5981         case R_PPC64_ADDR16:
5982         case R_PPC64_ADDR16_DS:
5983         case R_PPC64_ADDR16_HA:
5984         case R_PPC64_ADDR16_HI:
5985         case R_PPC64_ADDR16_HIGH:
5986         case R_PPC64_ADDR16_HIGHA:
5987         case R_PPC64_ADDR16_HIGHER:
5988         case R_PPC64_ADDR16_HIGHERA:
5989         case R_PPC64_ADDR16_HIGHEST:
5990         case R_PPC64_ADDR16_HIGHESTA:
5991         case R_PPC64_ADDR16_LO:
5992         case R_PPC64_ADDR16_LO_DS:
5993           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5994               && rel->r_addend == 0)
5995             {
5996               /* We may need a .plt entry if this reloc refers to a
5997                  function in a shared lib.  */
5998               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5999                 return FALSE;
6000               h->pointer_equality_needed = 1;
6001             }
6002           /* Fall through.  */
6003
6004         case R_PPC64_REL30:
6005         case R_PPC64_REL32:
6006         case R_PPC64_REL64:
6007         case R_PPC64_ADDR32:
6008         case R_PPC64_UADDR16:
6009         case R_PPC64_UADDR32:
6010         case R_PPC64_UADDR64:
6011         case R_PPC64_TOC:
6012           if (h != NULL && !bfd_link_pic (info))
6013             /* We may need a copy reloc.  */
6014             h->non_got_ref = 1;
6015
6016           /* Don't propagate .opd relocs.  */
6017           if (NO_OPD_RELOCS && is_opd)
6018             break;
6019
6020           /* If we are creating a shared library, and this is a reloc
6021              against a global symbol, or a non PC relative reloc
6022              against a local symbol, then we need to copy the reloc
6023              into the shared library.  However, if we are linking with
6024              -Bsymbolic, we do not need to copy a reloc against a
6025              global symbol which is defined in an object we are
6026              including in the link (i.e., DEF_REGULAR is set).  At
6027              this point we have not seen all the input files, so it is
6028              possible that DEF_REGULAR is not set now but will be set
6029              later (it is never cleared).  In case of a weak definition,
6030              DEF_REGULAR may be cleared later by a strong definition in
6031              a shared library.  We account for that possibility below by
6032              storing information in the dyn_relocs field of the hash
6033              table entry.  A similar situation occurs when creating
6034              shared libraries and symbol visibility changes render the
6035              symbol local.
6036
6037              If on the other hand, we are creating an executable, we
6038              may need to keep relocations for symbols satisfied by a
6039              dynamic library if we manage to avoid copy relocs for the
6040              symbol.  */
6041         dodyn:
6042           if ((bfd_link_pic (info)
6043                && (must_be_dyn_reloc (info, r_type)
6044                    || (h != NULL
6045                        && (!SYMBOLIC_BIND (info, h)
6046                            || h->root.type == bfd_link_hash_defweak
6047                            || !h->def_regular))))
6048               || (ELIMINATE_COPY_RELOCS
6049                   && !bfd_link_pic (info)
6050                   && h != NULL
6051                   && (h->root.type == bfd_link_hash_defweak
6052                       || !h->def_regular))
6053               || (!bfd_link_pic (info)
6054                   && ifunc != NULL))
6055             {
6056               /* We must copy these reloc types into the output file.
6057                  Create a reloc section in dynobj and make room for
6058                  this reloc.  */
6059               if (sreloc == NULL)
6060                 {
6061                   sreloc = _bfd_elf_make_dynamic_reloc_section
6062                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6063
6064                   if (sreloc == NULL)
6065                     return FALSE;
6066                 }
6067
6068               /* If this is a global symbol, we count the number of
6069                  relocations we need for this symbol.  */
6070               if (h != NULL)
6071                 {
6072                   struct elf_dyn_relocs *p;
6073                   struct elf_dyn_relocs **head;
6074
6075                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6076                   p = *head;
6077                   if (p == NULL || p->sec != sec)
6078                     {
6079                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6080                       if (p == NULL)
6081                         return FALSE;
6082                       p->next = *head;
6083                       *head = p;
6084                       p->sec = sec;
6085                       p->count = 0;
6086                       p->pc_count = 0;
6087                     }
6088                   p->count += 1;
6089                   if (!must_be_dyn_reloc (info, r_type))
6090                     p->pc_count += 1;
6091                 }
6092               else
6093                 {
6094                   /* Track dynamic relocs needed for local syms too.
6095                      We really need local syms available to do this
6096                      easily.  Oh well.  */
6097                   struct ppc_dyn_relocs *p;
6098                   struct ppc_dyn_relocs **head;
6099                   bfd_boolean is_ifunc;
6100                   asection *s;
6101                   void *vpp;
6102                   Elf_Internal_Sym *isym;
6103
6104                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6105                                                 abfd, r_symndx);
6106                   if (isym == NULL)
6107                     return FALSE;
6108
6109                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6110                   if (s == NULL)
6111                     s = sec;
6112
6113                   vpp = &elf_section_data (s)->local_dynrel;
6114                   head = (struct ppc_dyn_relocs **) vpp;
6115                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6116                   p = *head;
6117                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6118                     p = p->next;
6119                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6120                     {
6121                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6122                       if (p == NULL)
6123                         return FALSE;
6124                       p->next = *head;
6125                       *head = p;
6126                       p->sec = sec;
6127                       p->ifunc = is_ifunc;
6128                       p->count = 0;
6129                     }
6130                   p->count += 1;
6131                 }
6132             }
6133           break;
6134
6135         default:
6136           break;
6137         }
6138     }
6139
6140   return TRUE;
6141 }
6142
6143 /* Merge backend specific data from an object file to the output
6144    object file when linking.  */
6145
6146 static bfd_boolean
6147 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6148 {
6149   bfd *obfd = info->output_bfd;
6150   unsigned long iflags, oflags;
6151
6152   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6153     return TRUE;
6154
6155   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6156     return TRUE;
6157
6158   if (!_bfd_generic_verify_endian_match (ibfd, info))
6159     return FALSE;
6160
6161   iflags = elf_elfheader (ibfd)->e_flags;
6162   oflags = elf_elfheader (obfd)->e_flags;
6163
6164   if (iflags & ~EF_PPC64_ABI)
6165     {
6166       _bfd_error_handler
6167         /* xgettext:c-format */
6168         (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6169       bfd_set_error (bfd_error_bad_value);
6170       return FALSE;
6171     }
6172   else if (iflags != oflags && iflags != 0)
6173     {
6174       _bfd_error_handler
6175         /* xgettext:c-format */
6176         (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6177          ibfd, iflags, oflags);
6178       bfd_set_error (bfd_error_bad_value);
6179       return FALSE;
6180     }
6181
6182   if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
6183     return FALSE;
6184
6185   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6186   return _bfd_elf_merge_object_attributes (ibfd, info);
6187 }
6188
6189 static bfd_boolean
6190 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6191 {
6192   /* Print normal ELF private data.  */
6193   _bfd_elf_print_private_bfd_data (abfd, ptr);
6194
6195   if (elf_elfheader (abfd)->e_flags != 0)
6196     {
6197       FILE *file = ptr;
6198
6199       fprintf (file, _("private flags = 0x%lx:"),
6200                elf_elfheader (abfd)->e_flags);
6201
6202       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6203         fprintf (file, _(" [abiv%ld]"),
6204                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6205       fputc ('\n', file);
6206     }
6207
6208   return TRUE;
6209 }
6210
6211 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6212    of the code entry point, and its section, which must be in the same
6213    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6214
6215 static bfd_vma
6216 opd_entry_value (asection *opd_sec,
6217                  bfd_vma offset,
6218                  asection **code_sec,
6219                  bfd_vma *code_off,
6220                  bfd_boolean in_code_sec)
6221 {
6222   bfd *opd_bfd = opd_sec->owner;
6223   Elf_Internal_Rela *relocs;
6224   Elf_Internal_Rela *lo, *hi, *look;
6225   bfd_vma val;
6226
6227   /* No relocs implies we are linking a --just-symbols object, or looking
6228      at a final linked executable with addr2line or somesuch.  */
6229   if (opd_sec->reloc_count == 0)
6230     {
6231       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6232
6233       if (contents == NULL)
6234         {
6235           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6236             return (bfd_vma) -1;
6237           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6238         }
6239
6240       /* PR 17512: file: 64b9dfbb.  */
6241       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6242         return (bfd_vma) -1;
6243
6244       val = bfd_get_64 (opd_bfd, contents + offset);
6245       if (code_sec != NULL)
6246         {
6247           asection *sec, *likely = NULL;
6248
6249           if (in_code_sec)
6250             {
6251               sec = *code_sec;
6252               if (sec->vma <= val
6253                   && val < sec->vma + sec->size)
6254                 likely = sec;
6255               else
6256                 val = -1;
6257             }
6258           else
6259             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6260               if (sec->vma <= val
6261                   && (sec->flags & SEC_LOAD) != 0
6262                   && (sec->flags & SEC_ALLOC) != 0)
6263                 likely = sec;
6264           if (likely != NULL)
6265             {
6266               *code_sec = likely;
6267               if (code_off != NULL)
6268                 *code_off = val - likely->vma;
6269             }
6270         }
6271       return val;
6272     }
6273
6274   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6275
6276   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6277   if (relocs == NULL)
6278     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6279   /* PR 17512: file: df8e1fd6.  */
6280   if (relocs == NULL)
6281     return (bfd_vma) -1;
6282
6283   /* Go find the opd reloc at the sym address.  */
6284   lo = relocs;
6285   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6286   val = (bfd_vma) -1;
6287   while (lo < hi)
6288     {
6289       look = lo + (hi - lo) / 2;
6290       if (look->r_offset < offset)
6291         lo = look + 1;
6292       else if (look->r_offset > offset)
6293         hi = look;
6294       else
6295         {
6296           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6297
6298           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6299               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6300             {
6301               unsigned long symndx = ELF64_R_SYM (look->r_info);
6302               asection *sec = NULL;
6303
6304               if (symndx >= symtab_hdr->sh_info
6305                   && elf_sym_hashes (opd_bfd) != NULL)
6306                 {
6307                   struct elf_link_hash_entry **sym_hashes;
6308                   struct elf_link_hash_entry *rh;
6309
6310                   sym_hashes = elf_sym_hashes (opd_bfd);
6311                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6312                   if (rh != NULL)
6313                     {
6314                       rh = elf_follow_link (rh);
6315                       if (rh->root.type != bfd_link_hash_defined
6316                           && rh->root.type != bfd_link_hash_defweak)
6317                         break;
6318                       if (rh->root.u.def.section->owner == opd_bfd)
6319                         {
6320                           val = rh->root.u.def.value;
6321                           sec = rh->root.u.def.section;
6322                         }
6323                     }
6324                 }
6325
6326               if (sec == NULL)
6327                 {
6328                   Elf_Internal_Sym *sym;
6329
6330                   if (symndx < symtab_hdr->sh_info)
6331                     {
6332                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6333                       if (sym == NULL)
6334                         {
6335                           size_t symcnt = symtab_hdr->sh_info;
6336                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6337                                                       symcnt, 0,
6338                                                       NULL, NULL, NULL);
6339                           if (sym == NULL)
6340                             break;
6341                           symtab_hdr->contents = (bfd_byte *) sym;
6342                         }
6343                       sym += symndx;
6344                     }
6345                   else
6346                     {
6347                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6348                                                   1, symndx,
6349                                                   NULL, NULL, NULL);
6350                       if (sym == NULL)
6351                         break;
6352                     }
6353                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6354                   if (sec == NULL)
6355                     break;
6356                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6357                   val = sym->st_value;
6358                 }
6359
6360               val += look->r_addend;
6361               if (code_off != NULL)
6362                 *code_off = val;
6363               if (code_sec != NULL)
6364                 {
6365                   if (in_code_sec && *code_sec != sec)
6366                     return -1;
6367                   else
6368                     *code_sec = sec;
6369                 }
6370               if (sec->output_section != NULL)
6371                 val += sec->output_section->vma + sec->output_offset;
6372             }
6373           break;
6374         }
6375     }
6376
6377   return val;
6378 }
6379
6380 /* If the ELF symbol SYM might be a function in SEC, return the
6381    function size and set *CODE_OFF to the function's entry point,
6382    otherwise return zero.  */
6383
6384 static bfd_size_type
6385 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6386                               bfd_vma *code_off)
6387 {
6388   bfd_size_type size;
6389
6390   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6391                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6392     return 0;
6393
6394   size = 0;
6395   if (!(sym->flags & BSF_SYNTHETIC))
6396     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6397
6398   if (strcmp (sym->section->name, ".opd") == 0)
6399     {
6400       struct _opd_sec_data *opd = get_opd_info (sym->section);
6401       bfd_vma symval = sym->value;
6402
6403       if (opd != NULL
6404           && opd->adjust != NULL
6405           && elf_section_data (sym->section)->relocs != NULL)
6406         {
6407           /* opd_entry_value will use cached relocs that have been
6408              adjusted, but with raw symbols.  That means both local
6409              and global symbols need adjusting.  */
6410           long adjust = opd->adjust[OPD_NDX (symval)];
6411           if (adjust == -1)
6412             return 0;
6413           symval += adjust;
6414         }
6415
6416       if (opd_entry_value (sym->section, symval,
6417                            &sec, code_off, TRUE) == (bfd_vma) -1)
6418         return 0;
6419       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6420          symbol.  This size has nothing to do with the code size of the
6421          function, which is what we're supposed to return, but the
6422          code size isn't available without looking up the dot-sym.
6423          However, doing that would be a waste of time particularly
6424          since elf_find_function will look at the dot-sym anyway.
6425          Now, elf_find_function will keep the largest size of any
6426          function sym found at the code address of interest, so return
6427          1 here to avoid it incorrectly caching a larger function size
6428          for a small function.  This does mean we return the wrong
6429          size for a new-ABI function of size 24, but all that does is
6430          disable caching for such functions.  */
6431       if (size == 24)
6432         size = 1;
6433     }
6434   else
6435     {
6436       if (sym->section != sec)
6437         return 0;
6438       *code_off = sym->value;
6439     }
6440   if (size == 0)
6441     size = 1;
6442   return size;
6443 }
6444
6445 /* Return true if symbol is a strong function defined in an ELFv2
6446    object with st_other localentry bits of zero, ie. its local entry
6447    point coincides with its global entry point.  */
6448
6449 static bfd_boolean
6450 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6451 {
6452   return (h != NULL
6453           && h->type == STT_FUNC
6454           && h->root.type == bfd_link_hash_defined
6455           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6456           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6457           && is_ppc64_elf (h->root.u.def.section->owner)
6458           && abiversion (h->root.u.def.section->owner) >= 2);
6459 }
6460
6461 /* Return true if symbol is defined in a regular object file.  */
6462
6463 static bfd_boolean
6464 is_static_defined (struct elf_link_hash_entry *h)
6465 {
6466   return ((h->root.type == bfd_link_hash_defined
6467            || h->root.type == bfd_link_hash_defweak)
6468           && h->root.u.def.section != NULL
6469           && h->root.u.def.section->output_section != NULL);
6470 }
6471
6472 /* If FDH is a function descriptor symbol, return the associated code
6473    entry symbol if it is defined.  Return NULL otherwise.  */
6474
6475 static struct ppc_link_hash_entry *
6476 defined_code_entry (struct ppc_link_hash_entry *fdh)
6477 {
6478   if (fdh->is_func_descriptor)
6479     {
6480       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6481       if (fh->elf.root.type == bfd_link_hash_defined
6482           || fh->elf.root.type == bfd_link_hash_defweak)
6483         return fh;
6484     }
6485   return NULL;
6486 }
6487
6488 /* If FH is a function code entry symbol, return the associated
6489    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6490
6491 static struct ppc_link_hash_entry *
6492 defined_func_desc (struct ppc_link_hash_entry *fh)
6493 {
6494   if (fh->oh != NULL
6495       && fh->oh->is_func_descriptor)
6496     {
6497       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6498       if (fdh->elf.root.type == bfd_link_hash_defined
6499           || fdh->elf.root.type == bfd_link_hash_defweak)
6500         return fdh;
6501     }
6502   return NULL;
6503 }
6504
6505 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6506
6507 /* Garbage collect sections, after first dealing with dot-symbols.  */
6508
6509 static bfd_boolean
6510 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6511 {
6512   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6513
6514   if (htab != NULL && htab->need_func_desc_adj)
6515     {
6516       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6517       htab->need_func_desc_adj = 0;
6518     }
6519   return bfd_elf_gc_sections (abfd, info);
6520 }
6521
6522 /* Mark all our entry sym sections, both opd and code section.  */
6523
6524 static void
6525 ppc64_elf_gc_keep (struct bfd_link_info *info)
6526 {
6527   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6528   struct bfd_sym_chain *sym;
6529
6530   if (htab == NULL)
6531     return;
6532
6533   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6534     {
6535       struct ppc_link_hash_entry *eh, *fh;
6536       asection *sec;
6537
6538       eh = (struct ppc_link_hash_entry *)
6539         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6540       if (eh == NULL)
6541         continue;
6542       if (eh->elf.root.type != bfd_link_hash_defined
6543           && eh->elf.root.type != bfd_link_hash_defweak)
6544         continue;
6545
6546       fh = defined_code_entry (eh);
6547       if (fh != NULL)
6548         {
6549           sec = fh->elf.root.u.def.section;
6550           sec->flags |= SEC_KEEP;
6551         }
6552       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6553                && opd_entry_value (eh->elf.root.u.def.section,
6554                                    eh->elf.root.u.def.value,
6555                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6556         sec->flags |= SEC_KEEP;
6557
6558       sec = eh->elf.root.u.def.section;
6559       sec->flags |= SEC_KEEP;
6560     }
6561 }
6562
6563 /* Mark sections containing dynamically referenced symbols.  When
6564    building shared libraries, we must assume that any visible symbol is
6565    referenced.  */
6566
6567 static bfd_boolean
6568 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6569 {
6570   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6571   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6572   struct ppc_link_hash_entry *fdh;
6573   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6574
6575   /* Dynamic linking info is on the func descriptor sym.  */
6576   fdh = defined_func_desc (eh);
6577   if (fdh != NULL)
6578     eh = fdh;
6579
6580   if ((eh->elf.root.type == bfd_link_hash_defined
6581        || eh->elf.root.type == bfd_link_hash_defweak)
6582       && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6583           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6584               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6585               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6586               && (!bfd_link_executable (info)
6587                   || info->gc_keep_exported
6588                   || info->export_dynamic
6589                   || (eh->elf.dynamic
6590                       && d != NULL
6591                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6592               && (eh->elf.versioned >= versioned
6593                   || !bfd_hide_sym_by_version (info->version_info,
6594                                                eh->elf.root.root.string)))))
6595     {
6596       asection *code_sec;
6597       struct ppc_link_hash_entry *fh;
6598
6599       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6600
6601       /* Function descriptor syms cause the associated
6602          function code sym section to be marked.  */
6603       fh = defined_code_entry (eh);
6604       if (fh != NULL)
6605         {
6606           code_sec = fh->elf.root.u.def.section;
6607           code_sec->flags |= SEC_KEEP;
6608         }
6609       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6610                && opd_entry_value (eh->elf.root.u.def.section,
6611                                    eh->elf.root.u.def.value,
6612                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6613         code_sec->flags |= SEC_KEEP;
6614     }
6615
6616   return TRUE;
6617 }
6618
6619 /* Return the section that should be marked against GC for a given
6620    relocation.  */
6621
6622 static asection *
6623 ppc64_elf_gc_mark_hook (asection *sec,
6624                         struct bfd_link_info *info,
6625                         Elf_Internal_Rela *rel,
6626                         struct elf_link_hash_entry *h,
6627                         Elf_Internal_Sym *sym)
6628 {
6629   asection *rsec;
6630
6631   /* Syms return NULL if we're marking .opd, so we avoid marking all
6632      function sections, as all functions are referenced in .opd.  */
6633   rsec = NULL;
6634   if (get_opd_info (sec) != NULL)
6635     return rsec;
6636
6637   if (h != NULL)
6638     {
6639       enum elf_ppc64_reloc_type r_type;
6640       struct ppc_link_hash_entry *eh, *fh, *fdh;
6641
6642       r_type = ELF64_R_TYPE (rel->r_info);
6643       switch (r_type)
6644         {
6645         case R_PPC64_GNU_VTINHERIT:
6646         case R_PPC64_GNU_VTENTRY:
6647           break;
6648
6649         default:
6650           switch (h->root.type)
6651             {
6652             case bfd_link_hash_defined:
6653             case bfd_link_hash_defweak:
6654               eh = (struct ppc_link_hash_entry *) h;
6655               fdh = defined_func_desc (eh);
6656               if (fdh != NULL)
6657                 {
6658                   /* -mcall-aixdesc code references the dot-symbol on
6659                      a call reloc.  Mark the function descriptor too
6660                      against garbage collection.  */
6661                   fdh->elf.mark = 1;
6662                   if (fdh->elf.is_weakalias)
6663                     weakdef (&fdh->elf)->mark = 1;
6664                   eh = fdh;
6665                 }
6666
6667               /* Function descriptor syms cause the associated
6668                  function code sym section to be marked.  */
6669               fh = defined_code_entry (eh);
6670               if (fh != NULL)
6671                 {
6672                   /* They also mark their opd section.  */
6673                   eh->elf.root.u.def.section->gc_mark = 1;
6674
6675                   rsec = fh->elf.root.u.def.section;
6676                 }
6677               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6678                        && opd_entry_value (eh->elf.root.u.def.section,
6679                                            eh->elf.root.u.def.value,
6680                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6681                 eh->elf.root.u.def.section->gc_mark = 1;
6682               else
6683                 rsec = h->root.u.def.section;
6684               break;
6685
6686             case bfd_link_hash_common:
6687               rsec = h->root.u.c.p->section;
6688               break;
6689
6690             default:
6691               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6692             }
6693         }
6694     }
6695   else
6696     {
6697       struct _opd_sec_data *opd;
6698
6699       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6700       opd = get_opd_info (rsec);
6701       if (opd != NULL && opd->func_sec != NULL)
6702         {
6703           rsec->gc_mark = 1;
6704
6705           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6706         }
6707     }
6708
6709   return rsec;
6710 }
6711
6712 /* The maximum size of .sfpr.  */
6713 #define SFPR_MAX (218*4)
6714
6715 struct sfpr_def_parms
6716 {
6717   const char name[12];
6718   unsigned char lo, hi;
6719   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6720   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6721 };
6722
6723 /* Auto-generate _save*, _rest* functions in .sfpr.
6724    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6725    instead.  */
6726
6727 static bfd_boolean
6728 sfpr_define (struct bfd_link_info *info,
6729              const struct sfpr_def_parms *parm,
6730              asection *stub_sec)
6731 {
6732   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6733   unsigned int i;
6734   size_t len = strlen (parm->name);
6735   bfd_boolean writing = FALSE;
6736   char sym[16];
6737
6738   if (htab == NULL)
6739     return FALSE;
6740
6741   memcpy (sym, parm->name, len);
6742   sym[len + 2] = 0;
6743
6744   for (i = parm->lo; i <= parm->hi; i++)
6745     {
6746       struct ppc_link_hash_entry *h;
6747
6748       sym[len + 0] = i / 10 + '0';
6749       sym[len + 1] = i % 10 + '0';
6750       h = (struct ppc_link_hash_entry *)
6751         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6752       if (stub_sec != NULL)
6753         {
6754           if (h != NULL
6755               && h->elf.root.type == bfd_link_hash_defined
6756               && h->elf.root.u.def.section == htab->sfpr)
6757             {
6758               struct elf_link_hash_entry *s;
6759               char buf[32];
6760               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6761               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6762               if (s == NULL)
6763                 return FALSE;
6764               if (s->root.type == bfd_link_hash_new
6765                   || (s->root.type = bfd_link_hash_defined
6766                       && s->root.u.def.section == stub_sec))
6767                 {
6768                   s->root.type = bfd_link_hash_defined;
6769                   s->root.u.def.section = stub_sec;
6770                   s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6771                                          + h->elf.root.u.def.value);
6772                   s->ref_regular = 1;
6773                   s->def_regular = 1;
6774                   s->ref_regular_nonweak = 1;
6775                   s->forced_local = 1;
6776                   s->non_elf = 0;
6777                   s->root.linker_def = 1;
6778                 }
6779             }
6780           continue;
6781         }
6782       if (h != NULL)
6783         {
6784           h->save_res = 1;
6785           if (!h->elf.def_regular)
6786             {
6787               h->elf.root.type = bfd_link_hash_defined;
6788               h->elf.root.u.def.section = htab->sfpr;
6789               h->elf.root.u.def.value = htab->sfpr->size;
6790               h->elf.type = STT_FUNC;
6791               h->elf.def_regular = 1;
6792               h->elf.non_elf = 0;
6793               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6794               writing = TRUE;
6795               if (htab->sfpr->contents == NULL)
6796                 {
6797                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6798                   if (htab->sfpr->contents == NULL)
6799                     return FALSE;
6800                 }
6801             }
6802         }
6803       if (writing)
6804         {
6805           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6806           if (i != parm->hi)
6807             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6808           else
6809             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6810           htab->sfpr->size = p - htab->sfpr->contents;
6811         }
6812     }
6813
6814   return TRUE;
6815 }
6816
6817 static bfd_byte *
6818 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6819 {
6820   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6821   return p + 4;
6822 }
6823
6824 static bfd_byte *
6825 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6826 {
6827   p = savegpr0 (abfd, p, r);
6828   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6829   p = p + 4;
6830   bfd_put_32 (abfd, BLR, p);
6831   return p + 4;
6832 }
6833
6834 static bfd_byte *
6835 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6836 {
6837   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6838   return p + 4;
6839 }
6840
6841 static bfd_byte *
6842 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6843 {
6844   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6845   p = p + 4;
6846   p = restgpr0 (abfd, p, r);
6847   bfd_put_32 (abfd, MTLR_R0, p);
6848   p = p + 4;
6849   if (r == 29)
6850     {
6851       p = restgpr0 (abfd, p, 30);
6852       p = restgpr0 (abfd, p, 31);
6853     }
6854   bfd_put_32 (abfd, BLR, p);
6855   return p + 4;
6856 }
6857
6858 static bfd_byte *
6859 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6860 {
6861   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6862   return p + 4;
6863 }
6864
6865 static bfd_byte *
6866 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6867 {
6868   p = savegpr1 (abfd, p, r);
6869   bfd_put_32 (abfd, BLR, p);
6870   return p + 4;
6871 }
6872
6873 static bfd_byte *
6874 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6875 {
6876   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6877   return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6882 {
6883   p = restgpr1 (abfd, p, r);
6884   bfd_put_32 (abfd, BLR, p);
6885   return p + 4;
6886 }
6887
6888 static bfd_byte *
6889 savefpr (bfd *abfd, bfd_byte *p, int r)
6890 {
6891   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6892   return p + 4;
6893 }
6894
6895 static bfd_byte *
6896 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6897 {
6898   p = savefpr (abfd, p, r);
6899   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6900   p = p + 4;
6901   bfd_put_32 (abfd, BLR, p);
6902   return p + 4;
6903 }
6904
6905 static bfd_byte *
6906 restfpr (bfd *abfd, bfd_byte *p, int r)
6907 {
6908   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6909   return p + 4;
6910 }
6911
6912 static bfd_byte *
6913 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6914 {
6915   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6916   p = p + 4;
6917   p = restfpr (abfd, p, r);
6918   bfd_put_32 (abfd, MTLR_R0, p);
6919   p = p + 4;
6920   if (r == 29)
6921     {
6922       p = restfpr (abfd, p, 30);
6923       p = restfpr (abfd, p, 31);
6924     }
6925   bfd_put_32 (abfd, BLR, p);
6926   return p + 4;
6927 }
6928
6929 static bfd_byte *
6930 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6931 {
6932   p = savefpr (abfd, p, r);
6933   bfd_put_32 (abfd, BLR, p);
6934   return p + 4;
6935 }
6936
6937 static bfd_byte *
6938 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6939 {
6940   p = restfpr (abfd, p, r);
6941   bfd_put_32 (abfd, BLR, p);
6942   return p + 4;
6943 }
6944
6945 static bfd_byte *
6946 savevr (bfd *abfd, bfd_byte *p, int r)
6947 {
6948   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6949   p = p + 4;
6950   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6951   return p + 4;
6952 }
6953
6954 static bfd_byte *
6955 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6956 {
6957   p = savevr (abfd, p, r);
6958   bfd_put_32 (abfd, BLR, p);
6959   return p + 4;
6960 }
6961
6962 static bfd_byte *
6963 restvr (bfd *abfd, bfd_byte *p, int r)
6964 {
6965   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6966   p = p + 4;
6967   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6968   return p + 4;
6969 }
6970
6971 static bfd_byte *
6972 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6973 {
6974   p = restvr (abfd, p, r);
6975   bfd_put_32 (abfd, BLR, p);
6976   return p + 4;
6977 }
6978
6979 /* Called via elf_link_hash_traverse to transfer dynamic linking
6980    information on function code symbol entries to their corresponding
6981    function descriptor symbol entries.  */
6982
6983 static bfd_boolean
6984 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6985 {
6986   struct bfd_link_info *info;
6987   struct ppc_link_hash_table *htab;
6988   struct ppc_link_hash_entry *fh;
6989   struct ppc_link_hash_entry *fdh;
6990   bfd_boolean force_local;
6991
6992   fh = (struct ppc_link_hash_entry *) h;
6993   if (fh->elf.root.type == bfd_link_hash_indirect)
6994     return TRUE;
6995
6996   if (!fh->is_func)
6997     return TRUE;
6998
6999   if (fh->elf.root.root.string[0] != '.'
7000       || fh->elf.root.root.string[1] == '\0')
7001     return TRUE;
7002
7003   info = inf;
7004   htab = ppc_hash_table (info);
7005   if (htab == NULL)
7006     return FALSE;
7007
7008   /* Find the corresponding function descriptor symbol.  */
7009   fdh = lookup_fdh (fh, htab);
7010
7011   /* Resolve undefined references to dot-symbols as the value
7012      in the function descriptor, if we have one in a regular object.
7013      This is to satisfy cases like ".quad .foo".  Calls to functions
7014      in dynamic objects are handled elsewhere.  */
7015   if ((fh->elf.root.type == bfd_link_hash_undefined
7016        || fh->elf.root.type == bfd_link_hash_undefweak)
7017       && (fdh->elf.root.type == bfd_link_hash_defined
7018           || fdh->elf.root.type == bfd_link_hash_defweak)
7019       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7020       && opd_entry_value (fdh->elf.root.u.def.section,
7021                           fdh->elf.root.u.def.value,
7022                           &fh->elf.root.u.def.section,
7023                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7024     {
7025       fh->elf.root.type = fdh->elf.root.type;
7026       fh->elf.forced_local = 1;
7027       fh->elf.def_regular = fdh->elf.def_regular;
7028       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7029     }
7030
7031   if (!fh->elf.dynamic)
7032     {
7033       struct plt_entry *ent;
7034
7035       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7036         if (ent->plt.refcount > 0)
7037           break;
7038       if (ent == NULL)
7039         return TRUE;
7040     }
7041
7042   /* Create a descriptor as undefined if necessary.  */
7043   if (fdh == NULL
7044       && !bfd_link_executable (info)
7045       && (fh->elf.root.type == bfd_link_hash_undefined
7046           || fh->elf.root.type == bfd_link_hash_undefweak))
7047     {
7048       fdh = make_fdh (info, fh);
7049       if (fdh == NULL)
7050         return FALSE;
7051     }
7052
7053   /* We can't support overriding of symbols on a fake descriptor.  */
7054   if (fdh != NULL
7055       && fdh->fake
7056       && (fh->elf.root.type == bfd_link_hash_defined
7057           || fh->elf.root.type == bfd_link_hash_defweak))
7058     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7059
7060   /* Transfer dynamic linking information to the function descriptor.  */
7061   if (fdh != NULL)
7062     {
7063       fdh->elf.ref_regular |= fh->elf.ref_regular;
7064       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7065       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7066       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7067       fdh->elf.dynamic |= fh->elf.dynamic;
7068       fdh->elf.needs_plt |= (fh->elf.needs_plt
7069                              || fh->elf.type == STT_FUNC
7070                              || fh->elf.type == STT_GNU_IFUNC);
7071       move_plt_plist (fh, fdh);
7072
7073       if (!fdh->elf.forced_local
7074           && fh->elf.dynindx != -1)
7075         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7076           return FALSE;
7077     }
7078
7079   /* Now that the info is on the function descriptor, clear the
7080      function code sym info.  Any function code syms for which we
7081      don't have a definition in a regular file, we force local.
7082      This prevents a shared library from exporting syms that have
7083      been imported from another library.  Function code syms that
7084      are really in the library we must leave global to prevent the
7085      linker dragging in a definition from a static library.  */
7086   force_local = (!fh->elf.def_regular
7087                  || fdh == NULL
7088                  || !fdh->elf.def_regular
7089                  || fdh->elf.forced_local);
7090   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7091
7092   return TRUE;
7093 }
7094
7095 static const struct sfpr_def_parms save_res_funcs[] =
7096   {
7097     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7098     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7099     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7100     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7101     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7102     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7103     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7104     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7105     { "._savef", 14, 31, savefpr, savefpr1_tail },
7106     { "._restf", 14, 31, restfpr, restfpr1_tail },
7107     { "_savevr_", 20, 31, savevr, savevr_tail },
7108     { "_restvr_", 20, 31, restvr, restvr_tail }
7109   };
7110
7111 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7112    this hook to a) provide some gcc support functions, and b) transfer
7113    dynamic linking information gathered so far on function code symbol
7114    entries, to their corresponding function descriptor symbol entries.  */
7115
7116 static bfd_boolean
7117 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7118                             struct bfd_link_info *info)
7119 {
7120   struct ppc_link_hash_table *htab;
7121
7122   htab = ppc_hash_table (info);
7123   if (htab == NULL)
7124     return FALSE;
7125
7126   /* Provide any missing _save* and _rest* functions.  */
7127   if (htab->sfpr != NULL)
7128     {
7129       unsigned int i;
7130
7131       htab->sfpr->size = 0;
7132       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7133         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7134           return FALSE;
7135       if (htab->sfpr->size == 0)
7136         htab->sfpr->flags |= SEC_EXCLUDE;
7137     }
7138
7139   if (bfd_link_relocatable (info))
7140     return TRUE;
7141
7142   if (htab->elf.hgot != NULL)
7143     {
7144       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7145       /* Make .TOC. defined so as to prevent it being made dynamic.
7146          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7147       if (!htab->elf.hgot->def_regular
7148           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7149         {
7150           htab->elf.hgot->root.type = bfd_link_hash_defined;
7151           htab->elf.hgot->root.u.def.value = 0;
7152           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7153           htab->elf.hgot->def_regular = 1;
7154           htab->elf.hgot->root.linker_def = 1;
7155         }
7156       htab->elf.hgot->type = STT_OBJECT;
7157       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7158                                | STV_HIDDEN);
7159     }
7160
7161   if (htab->need_func_desc_adj)
7162     {
7163       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7164       htab->need_func_desc_adj = 0;
7165     }
7166
7167   return TRUE;
7168 }
7169
7170 /* Find dynamic relocs for H that apply to read-only sections.  */
7171
7172 static asection *
7173 readonly_dynrelocs (struct elf_link_hash_entry *h)
7174 {
7175   struct ppc_link_hash_entry *eh;
7176   struct elf_dyn_relocs *p;
7177
7178   eh = (struct ppc_link_hash_entry *) h;
7179   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7180     {
7181       asection *s = p->sec->output_section;
7182
7183       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7184         return p->sec;
7185     }
7186   return NULL;
7187 }
7188
7189 /* Return true if we have dynamic relocs against H or any of its weak
7190    aliases, that apply to read-only sections.  Cannot be used after
7191    size_dynamic_sections.  */
7192
7193 static bfd_boolean
7194 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7195 {
7196   struct ppc_link_hash_entry *eh;
7197
7198   eh = (struct ppc_link_hash_entry *) h;
7199   do
7200     {
7201       if (readonly_dynrelocs (&eh->elf))
7202         return TRUE;
7203       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7204     } while (eh != NULL && &eh->elf != h);
7205
7206   return FALSE;
7207 }
7208
7209 /* Return whether EH has pc-relative dynamic relocs.  */
7210
7211 static bfd_boolean
7212 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7213 {
7214   struct elf_dyn_relocs *p;
7215
7216   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7217     if (p->pc_count != 0)
7218       return TRUE;
7219   return FALSE;
7220 }
7221
7222 /* Return true if a global entry stub will be created for H.  Valid
7223    for ELFv2 before plt entries have been allocated.  */
7224
7225 static bfd_boolean
7226 global_entry_stub (struct elf_link_hash_entry *h)
7227 {
7228   struct plt_entry *pent;
7229
7230   if (!h->pointer_equality_needed
7231       || h->def_regular)
7232     return FALSE;
7233
7234   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7235     if (pent->plt.refcount > 0
7236         && pent->addend == 0)
7237       return TRUE;
7238
7239   return FALSE;
7240 }
7241
7242 /* Adjust a symbol defined by a dynamic object and referenced by a
7243    regular object.  The current definition is in some section of the
7244    dynamic object, but we're not including those sections.  We have to
7245    change the definition to something the rest of the link can
7246    understand.  */
7247
7248 static bfd_boolean
7249 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7250                                  struct elf_link_hash_entry *h)
7251 {
7252   struct ppc_link_hash_table *htab;
7253   asection *s, *srel;
7254
7255   htab = ppc_hash_table (info);
7256   if (htab == NULL)
7257     return FALSE;
7258
7259   /* Deal with function syms.  */
7260   if (h->type == STT_FUNC
7261       || h->type == STT_GNU_IFUNC
7262       || h->needs_plt)
7263     {
7264       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7265                            || SYMBOL_CALLS_LOCAL (info, h)
7266                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7267       /* Discard dyn_relocs when non-pic if we've decided that a
7268          function symbol is local and not an ifunc.  We keep dynamic
7269          relocs for ifuncs when local rather than always emitting a
7270          plt call stub for them and defining the symbol on the call
7271          stub.  We can't do that for ELFv1 anyway (a function symbol
7272          is defined on a descriptor, not code) and it can be faster at
7273          run-time due to not needing to bounce through a stub.  The
7274          dyn_relocs for ifuncs will be applied even in a static
7275          executable.  */
7276       if (!bfd_link_pic (info)
7277           && h->type != STT_GNU_IFUNC
7278           && local)
7279         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7280
7281       /* Clear procedure linkage table information for any symbol that
7282          won't need a .plt entry.  */
7283       struct plt_entry *ent;
7284       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7285         if (ent->plt.refcount > 0)
7286           break;
7287       if (ent == NULL
7288           || (h->type != STT_GNU_IFUNC
7289               && local
7290               && (htab->can_convert_all_inline_plt
7291                   || (((struct ppc_link_hash_entry *) h)->tls_mask
7292                       & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7293         {
7294           h->plt.plist = NULL;
7295           h->needs_plt = 0;
7296           h->pointer_equality_needed = 0;
7297         }
7298       else if (abiversion (info->output_bfd) >= 2)
7299         {
7300           /* Taking a function's address in a read/write section
7301              doesn't require us to define the function symbol in the
7302              executable on a global entry stub.  A dynamic reloc can
7303              be used instead.  The reason we prefer a few more dynamic
7304              relocs is that calling via a global entry stub costs a
7305              few more instructions, and pointer_equality_needed causes
7306              extra work in ld.so when resolving these symbols.  */
7307           if (global_entry_stub (h))
7308             {
7309               if (!readonly_dynrelocs (h))
7310                 {
7311                   h->pointer_equality_needed = 0;
7312                   /* If we haven't seen a branch reloc and the symbol
7313                      isn't an ifunc then we don't need a plt entry.  */
7314                   if (!h->needs_plt)
7315                     h->plt.plist = NULL;
7316                 }
7317               else if (!bfd_link_pic (info))
7318                 /* We are going to be defining the function symbol on the
7319                    plt stub, so no dyn_relocs needed when non-pic.  */
7320                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7321             }
7322
7323           /* ELFv2 function symbols can't have copy relocs.  */
7324           return TRUE;
7325         }
7326       else if (!h->needs_plt
7327                && !readonly_dynrelocs (h))
7328         {
7329           /* If we haven't seen a branch reloc and the symbol isn't an
7330              ifunc then we don't need a plt entry.  */
7331           h->plt.plist = NULL;
7332           h->pointer_equality_needed = 0;
7333           return TRUE;
7334         }
7335     }
7336   else
7337     h->plt.plist = NULL;
7338
7339   /* If this is a weak symbol, and there is a real definition, the
7340      processor independent code will have arranged for us to see the
7341      real definition first, and we can just use the same value.  */
7342   if (h->is_weakalias)
7343     {
7344       struct elf_link_hash_entry *def = weakdef (h);
7345       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7346       h->root.u.def.section = def->root.u.def.section;
7347       h->root.u.def.value = def->root.u.def.value;
7348       if (def->root.u.def.section == htab->elf.sdynbss
7349           || def->root.u.def.section == htab->elf.sdynrelro)
7350         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7351       return TRUE;
7352     }
7353
7354   /* If we are creating a shared library, we must presume that the
7355      only references to the symbol are via the global offset table.
7356      For such cases we need not do anything here; the relocations will
7357      be handled correctly by relocate_section.  */
7358   if (bfd_link_pic (info))
7359     return TRUE;
7360
7361   /* If there are no references to this symbol that do not use the
7362      GOT, we don't need to generate a copy reloc.  */
7363   if (!h->non_got_ref)
7364     return TRUE;
7365
7366   /* Don't generate a copy reloc for symbols defined in the executable.  */
7367   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7368
7369       /* If -z nocopyreloc was given, don't generate them either.  */
7370       || info->nocopyreloc
7371
7372       /* If we don't find any dynamic relocs in read-only sections, then
7373          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7374       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7375
7376       /* Protected variables do not work with .dynbss.  The copy in
7377          .dynbss won't be used by the shared library with the protected
7378          definition for the variable.  Text relocations are preferable
7379          to an incorrect program.  */
7380       || h->protected_def)
7381     return TRUE;
7382
7383   if (h->plt.plist != NULL)
7384     {
7385       /* We should never get here, but unfortunately there are versions
7386          of gcc out there that improperly (for this ABI) put initialized
7387          function pointers, vtable refs and suchlike in read-only
7388          sections.  Allow them to proceed, but warn that this might
7389          break at runtime.  */
7390       info->callbacks->einfo
7391         (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7392            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7393          h->root.root.string);
7394     }
7395
7396   /* This is a reference to a symbol defined by a dynamic object which
7397      is not a function.  */
7398
7399   /* We must allocate the symbol in our .dynbss section, which will
7400      become part of the .bss section of the executable.  There will be
7401      an entry for this symbol in the .dynsym section.  The dynamic
7402      object will contain position independent code, so all references
7403      from the dynamic object to this symbol will go through the global
7404      offset table.  The dynamic linker will use the .dynsym entry to
7405      determine the address it must put in the global offset table, so
7406      both the dynamic object and the regular object will refer to the
7407      same memory location for the variable.  */
7408   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7409     {
7410       s = htab->elf.sdynrelro;
7411       srel = htab->elf.sreldynrelro;
7412     }
7413   else
7414     {
7415       s = htab->elf.sdynbss;
7416       srel = htab->elf.srelbss;
7417     }
7418   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7419     {
7420       /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7421          linker to copy the initial value out of the dynamic object
7422          and into the runtime process image.  */
7423       srel->size += sizeof (Elf64_External_Rela);
7424       h->needs_copy = 1;
7425     }
7426
7427   /* We no longer want dyn_relocs.  */
7428   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7429   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7430 }
7431
7432 /* If given a function descriptor symbol, hide both the function code
7433    sym and the descriptor.  */
7434 static void
7435 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7436                        struct elf_link_hash_entry *h,
7437                        bfd_boolean force_local)
7438 {
7439   struct ppc_link_hash_entry *eh;
7440   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7441
7442   eh = (struct ppc_link_hash_entry *) h;
7443   if (eh->is_func_descriptor)
7444     {
7445       struct ppc_link_hash_entry *fh = eh->oh;
7446
7447       if (fh == NULL)
7448         {
7449           const char *p, *q;
7450           struct elf_link_hash_table *htab = elf_hash_table (info);
7451           char save;
7452
7453           /* We aren't supposed to use alloca in BFD because on
7454              systems which do not have alloca the version in libiberty
7455              calls xmalloc, which might cause the program to crash
7456              when it runs out of memory.  This function doesn't have a
7457              return status, so there's no way to gracefully return an
7458              error.  So cheat.  We know that string[-1] can be safely
7459              accessed;  It's either a string in an ELF string table,
7460              or allocated in an objalloc structure.  */
7461
7462           p = eh->elf.root.root.string - 1;
7463           save = *p;
7464           *(char *) p = '.';
7465           fh = (struct ppc_link_hash_entry *)
7466             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7467           *(char *) p = save;
7468
7469           /* Unfortunately, if it so happens that the string we were
7470              looking for was allocated immediately before this string,
7471              then we overwrote the string terminator.  That's the only
7472              reason the lookup should fail.  */
7473           if (fh == NULL)
7474             {
7475               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7476               while (q >= eh->elf.root.root.string && *q == *p)
7477                 --q, --p;
7478               if (q < eh->elf.root.root.string && *p == '.')
7479                 fh = (struct ppc_link_hash_entry *)
7480                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7481             }
7482           if (fh != NULL)
7483             {
7484               eh->oh = fh;
7485               fh->oh = eh;
7486             }
7487         }
7488       if (fh != NULL)
7489         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7490     }
7491 }
7492
7493 static bfd_boolean
7494 get_sym_h (struct elf_link_hash_entry **hp,
7495            Elf_Internal_Sym **symp,
7496            asection **symsecp,
7497            unsigned char **tls_maskp,
7498            Elf_Internal_Sym **locsymsp,
7499            unsigned long r_symndx,
7500            bfd *ibfd)
7501 {
7502   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7503
7504   if (r_symndx >= symtab_hdr->sh_info)
7505     {
7506       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7507       struct elf_link_hash_entry *h;
7508
7509       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7510       h = elf_follow_link (h);
7511
7512       if (hp != NULL)
7513         *hp = h;
7514
7515       if (symp != NULL)
7516         *symp = NULL;
7517
7518       if (symsecp != NULL)
7519         {
7520           asection *symsec = NULL;
7521           if (h->root.type == bfd_link_hash_defined
7522               || h->root.type == bfd_link_hash_defweak)
7523             symsec = h->root.u.def.section;
7524           *symsecp = symsec;
7525         }
7526
7527       if (tls_maskp != NULL)
7528         {
7529           struct ppc_link_hash_entry *eh;
7530
7531           eh = (struct ppc_link_hash_entry *) h;
7532           *tls_maskp = &eh->tls_mask;
7533         }
7534     }
7535   else
7536     {
7537       Elf_Internal_Sym *sym;
7538       Elf_Internal_Sym *locsyms = *locsymsp;
7539
7540       if (locsyms == NULL)
7541         {
7542           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7543           if (locsyms == NULL)
7544             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7545                                             symtab_hdr->sh_info,
7546                                             0, NULL, NULL, NULL);
7547           if (locsyms == NULL)
7548             return FALSE;
7549           *locsymsp = locsyms;
7550         }
7551       sym = locsyms + r_symndx;
7552
7553       if (hp != NULL)
7554         *hp = NULL;
7555
7556       if (symp != NULL)
7557         *symp = sym;
7558
7559       if (symsecp != NULL)
7560         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7561
7562       if (tls_maskp != NULL)
7563         {
7564           struct got_entry **lgot_ents;
7565           unsigned char *tls_mask;
7566
7567           tls_mask = NULL;
7568           lgot_ents = elf_local_got_ents (ibfd);
7569           if (lgot_ents != NULL)
7570             {
7571               struct plt_entry **local_plt = (struct plt_entry **)
7572                 (lgot_ents + symtab_hdr->sh_info);
7573               unsigned char *lgot_masks = (unsigned char *)
7574                 (local_plt + symtab_hdr->sh_info);
7575               tls_mask = &lgot_masks[r_symndx];
7576             }
7577           *tls_maskp = tls_mask;
7578         }
7579     }
7580   return TRUE;
7581 }
7582
7583 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7584    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7585    type suitable for optimization, and 1 otherwise.  */
7586
7587 static int
7588 get_tls_mask (unsigned char **tls_maskp,
7589               unsigned long *toc_symndx,
7590               bfd_vma *toc_addend,
7591               Elf_Internal_Sym **locsymsp,
7592               const Elf_Internal_Rela *rel,
7593               bfd *ibfd)
7594 {
7595   unsigned long r_symndx;
7596   int next_r;
7597   struct elf_link_hash_entry *h;
7598   Elf_Internal_Sym *sym;
7599   asection *sec;
7600   bfd_vma off;
7601
7602   r_symndx = ELF64_R_SYM (rel->r_info);
7603   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7604     return 0;
7605
7606   if ((*tls_maskp != NULL
7607        && (**tls_maskp & TLS_TLS) != 0
7608        && **tls_maskp != (TLS_TLS | TLS_MARK))
7609       || sec == NULL
7610       || ppc64_elf_section_data (sec) == NULL
7611       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7612     return 1;
7613
7614   /* Look inside a TOC section too.  */
7615   if (h != NULL)
7616     {
7617       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7618       off = h->root.u.def.value;
7619     }
7620   else
7621     off = sym->st_value;
7622   off += rel->r_addend;
7623   BFD_ASSERT (off % 8 == 0);
7624   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7625   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7626   if (toc_symndx != NULL)
7627     *toc_symndx = r_symndx;
7628   if (toc_addend != NULL)
7629     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7630   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7631     return 0;
7632   if ((h == NULL || is_static_defined (h))
7633       && (next_r == -1 || next_r == -2))
7634     return 1 - next_r;
7635   return 1;
7636 }
7637
7638 /* Find (or create) an entry in the tocsave hash table.  */
7639
7640 static struct tocsave_entry *
7641 tocsave_find (struct ppc_link_hash_table *htab,
7642               enum insert_option insert,
7643               Elf_Internal_Sym **local_syms,
7644               const Elf_Internal_Rela *irela,
7645               bfd *ibfd)
7646 {
7647   unsigned long r_indx;
7648   struct elf_link_hash_entry *h;
7649   Elf_Internal_Sym *sym;
7650   struct tocsave_entry ent, *p;
7651   hashval_t hash;
7652   struct tocsave_entry **slot;
7653
7654   r_indx = ELF64_R_SYM (irela->r_info);
7655   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7656     return NULL;
7657   if (ent.sec == NULL || ent.sec->output_section == NULL)
7658     {
7659       _bfd_error_handler
7660         (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7661       return NULL;
7662     }
7663
7664   if (h != NULL)
7665     ent.offset = h->root.u.def.value;
7666   else
7667     ent.offset = sym->st_value;
7668   ent.offset += irela->r_addend;
7669
7670   hash = tocsave_htab_hash (&ent);
7671   slot = ((struct tocsave_entry **)
7672           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7673   if (slot == NULL)
7674     return NULL;
7675
7676   if (*slot == NULL)
7677     {
7678       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7679       if (p == NULL)
7680         return NULL;
7681       *p = ent;
7682       *slot = p;
7683     }
7684   return *slot;
7685 }
7686
7687 /* Adjust all global syms defined in opd sections.  In gcc generated
7688    code for the old ABI, these will already have been done.  */
7689
7690 static bfd_boolean
7691 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7692 {
7693   struct ppc_link_hash_entry *eh;
7694   asection *sym_sec;
7695   struct _opd_sec_data *opd;
7696
7697   if (h->root.type == bfd_link_hash_indirect)
7698     return TRUE;
7699
7700   if (h->root.type != bfd_link_hash_defined
7701       && h->root.type != bfd_link_hash_defweak)
7702     return TRUE;
7703
7704   eh = (struct ppc_link_hash_entry *) h;
7705   if (eh->adjust_done)
7706     return TRUE;
7707
7708   sym_sec = eh->elf.root.u.def.section;
7709   opd = get_opd_info (sym_sec);
7710   if (opd != NULL && opd->adjust != NULL)
7711     {
7712       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7713       if (adjust == -1)
7714         {
7715           /* This entry has been deleted.  */
7716           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7717           if (dsec == NULL)
7718             {
7719               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7720                 if (discarded_section (dsec))
7721                   {
7722                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7723                     break;
7724                   }
7725             }
7726           eh->elf.root.u.def.value = 0;
7727           eh->elf.root.u.def.section = dsec;
7728         }
7729       else
7730         eh->elf.root.u.def.value += adjust;
7731       eh->adjust_done = 1;
7732     }
7733   return TRUE;
7734 }
7735
7736 /* Handles decrementing dynamic reloc counts for the reloc specified by
7737    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7738    have already been determined.  */
7739
7740 static bfd_boolean
7741 dec_dynrel_count (bfd_vma r_info,
7742                   asection *sec,
7743                   struct bfd_link_info *info,
7744                   Elf_Internal_Sym **local_syms,
7745                   struct elf_link_hash_entry *h,
7746                   Elf_Internal_Sym *sym)
7747 {
7748   enum elf_ppc64_reloc_type r_type;
7749   asection *sym_sec = NULL;
7750
7751   /* Can this reloc be dynamic?  This switch, and later tests here
7752      should be kept in sync with the code in check_relocs.  */
7753   r_type = ELF64_R_TYPE (r_info);
7754   switch (r_type)
7755     {
7756     default:
7757       return TRUE;
7758
7759     case R_PPC64_TPREL16:
7760     case R_PPC64_TPREL16_LO:
7761     case R_PPC64_TPREL16_HI:
7762     case R_PPC64_TPREL16_HA:
7763     case R_PPC64_TPREL16_DS:
7764     case R_PPC64_TPREL16_LO_DS:
7765     case R_PPC64_TPREL16_HIGH:
7766     case R_PPC64_TPREL16_HIGHA:
7767     case R_PPC64_TPREL16_HIGHER:
7768     case R_PPC64_TPREL16_HIGHERA:
7769     case R_PPC64_TPREL16_HIGHEST:
7770     case R_PPC64_TPREL16_HIGHESTA:
7771     case R_PPC64_TPREL64:
7772     case R_PPC64_DTPMOD64:
7773     case R_PPC64_DTPREL64:
7774     case R_PPC64_ADDR64:
7775     case R_PPC64_REL30:
7776     case R_PPC64_REL32:
7777     case R_PPC64_REL64:
7778     case R_PPC64_ADDR14:
7779     case R_PPC64_ADDR14_BRNTAKEN:
7780     case R_PPC64_ADDR14_BRTAKEN:
7781     case R_PPC64_ADDR16:
7782     case R_PPC64_ADDR16_DS:
7783     case R_PPC64_ADDR16_HA:
7784     case R_PPC64_ADDR16_HI:
7785     case R_PPC64_ADDR16_HIGH:
7786     case R_PPC64_ADDR16_HIGHA:
7787     case R_PPC64_ADDR16_HIGHER:
7788     case R_PPC64_ADDR16_HIGHERA:
7789     case R_PPC64_ADDR16_HIGHEST:
7790     case R_PPC64_ADDR16_HIGHESTA:
7791     case R_PPC64_ADDR16_LO:
7792     case R_PPC64_ADDR16_LO_DS:
7793     case R_PPC64_ADDR24:
7794     case R_PPC64_ADDR32:
7795     case R_PPC64_UADDR16:
7796     case R_PPC64_UADDR32:
7797     case R_PPC64_UADDR64:
7798     case R_PPC64_TOC:
7799       break;
7800     }
7801
7802   if (local_syms != NULL)
7803     {
7804       unsigned long r_symndx;
7805       bfd *ibfd = sec->owner;
7806
7807       r_symndx = ELF64_R_SYM (r_info);
7808       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7809         return FALSE;
7810     }
7811
7812   if ((bfd_link_pic (info)
7813        && (must_be_dyn_reloc (info, r_type)
7814            || (h != NULL
7815                && (!SYMBOLIC_BIND (info, h)
7816                    || h->root.type == bfd_link_hash_defweak
7817                    || !h->def_regular))))
7818       || (ELIMINATE_COPY_RELOCS
7819           && !bfd_link_pic (info)
7820           && h != NULL
7821           && (h->root.type == bfd_link_hash_defweak
7822               || !h->def_regular)))
7823     ;
7824   else
7825     return TRUE;
7826
7827   if (h != NULL)
7828     {
7829       struct elf_dyn_relocs *p;
7830       struct elf_dyn_relocs **pp;
7831       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7832
7833       /* elf_gc_sweep may have already removed all dyn relocs associated
7834          with local syms for a given section.  Also, symbol flags are
7835          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7836          report a dynreloc miscount.  */
7837       if (*pp == NULL && info->gc_sections)
7838         return TRUE;
7839
7840       while ((p = *pp) != NULL)
7841         {
7842           if (p->sec == sec)
7843             {
7844               if (!must_be_dyn_reloc (info, r_type))
7845                 p->pc_count -= 1;
7846               p->count -= 1;
7847               if (p->count == 0)
7848                 *pp = p->next;
7849               return TRUE;
7850             }
7851           pp = &p->next;
7852         }
7853     }
7854   else
7855     {
7856       struct ppc_dyn_relocs *p;
7857       struct ppc_dyn_relocs **pp;
7858       void *vpp;
7859       bfd_boolean is_ifunc;
7860
7861       if (local_syms == NULL)
7862         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7863       if (sym_sec == NULL)
7864         sym_sec = sec;
7865
7866       vpp = &elf_section_data (sym_sec)->local_dynrel;
7867       pp = (struct ppc_dyn_relocs **) vpp;
7868
7869       if (*pp == NULL && info->gc_sections)
7870         return TRUE;
7871
7872       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7873       while ((p = *pp) != NULL)
7874         {
7875           if (p->sec == sec && p->ifunc == is_ifunc)
7876             {
7877               p->count -= 1;
7878               if (p->count == 0)
7879                 *pp = p->next;
7880               return TRUE;
7881             }
7882           pp = &p->next;
7883         }
7884     }
7885
7886   /* xgettext:c-format */
7887   _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7888                       sec->owner, sec);
7889   bfd_set_error (bfd_error_bad_value);
7890   return FALSE;
7891 }
7892
7893 /* Remove unused Official Procedure Descriptor entries.  Currently we
7894    only remove those associated with functions in discarded link-once
7895    sections, or weakly defined functions that have been overridden.  It
7896    would be possible to remove many more entries for statically linked
7897    applications.  */
7898
7899 bfd_boolean
7900 ppc64_elf_edit_opd (struct bfd_link_info *info)
7901 {
7902   bfd *ibfd;
7903   bfd_boolean some_edited = FALSE;
7904   asection *need_pad = NULL;
7905   struct ppc_link_hash_table *htab;
7906
7907   htab = ppc_hash_table (info);
7908   if (htab == NULL)
7909     return FALSE;
7910
7911   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7912     {
7913       asection *sec;
7914       Elf_Internal_Rela *relstart, *rel, *relend;
7915       Elf_Internal_Shdr *symtab_hdr;
7916       Elf_Internal_Sym *local_syms;
7917       struct _opd_sec_data *opd;
7918       bfd_boolean need_edit, add_aux_fields, broken;
7919       bfd_size_type cnt_16b = 0;
7920
7921       if (!is_ppc64_elf (ibfd))
7922         continue;
7923
7924       sec = bfd_get_section_by_name (ibfd, ".opd");
7925       if (sec == NULL || sec->size == 0)
7926         continue;
7927
7928       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7929         continue;
7930
7931       if (sec->output_section == bfd_abs_section_ptr)
7932         continue;
7933
7934       /* Look through the section relocs.  */
7935       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7936         continue;
7937
7938       local_syms = NULL;
7939       symtab_hdr = &elf_symtab_hdr (ibfd);
7940
7941       /* Read the relocations.  */
7942       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7943                                             info->keep_memory);
7944       if (relstart == NULL)
7945         return FALSE;
7946
7947       /* First run through the relocs to check they are sane, and to
7948          determine whether we need to edit this opd section.  */
7949       need_edit = FALSE;
7950       broken = FALSE;
7951       need_pad = sec;
7952       relend = relstart + sec->reloc_count;
7953       for (rel = relstart; rel < relend; )
7954         {
7955           enum elf_ppc64_reloc_type r_type;
7956           unsigned long r_symndx;
7957           asection *sym_sec;
7958           struct elf_link_hash_entry *h;
7959           Elf_Internal_Sym *sym;
7960           bfd_vma offset;
7961
7962           /* .opd contains an array of 16 or 24 byte entries.  We're
7963              only interested in the reloc pointing to a function entry
7964              point.  */
7965           offset = rel->r_offset;
7966           if (rel + 1 == relend
7967               || rel[1].r_offset != offset + 8)
7968             {
7969               /* If someone messes with .opd alignment then after a
7970                  "ld -r" we might have padding in the middle of .opd.
7971                  Also, there's nothing to prevent someone putting
7972                  something silly in .opd with the assembler.  No .opd
7973                  optimization for them!  */
7974             broken_opd:
7975               _bfd_error_handler
7976                 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
7977               broken = TRUE;
7978               break;
7979             }
7980
7981           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7982               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7983             {
7984               _bfd_error_handler
7985                 /* xgettext:c-format */
7986                 (_("%pB: unexpected reloc type %u in .opd section"),
7987                  ibfd, r_type);
7988               broken = TRUE;
7989               break;
7990             }
7991
7992           r_symndx = ELF64_R_SYM (rel->r_info);
7993           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7994                           r_symndx, ibfd))
7995             goto error_ret;
7996
7997           if (sym_sec == NULL || sym_sec->owner == NULL)
7998             {
7999               const char *sym_name;
8000               if (h != NULL)
8001                 sym_name = h->root.root.string;
8002               else
8003                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8004                                              sym_sec);
8005
8006               _bfd_error_handler
8007                 /* xgettext:c-format */
8008                 (_("%pB: undefined sym `%s' in .opd section"),
8009                  ibfd, sym_name);
8010               broken = TRUE;
8011               break;
8012             }
8013
8014           /* opd entries are always for functions defined in the
8015              current input bfd.  If the symbol isn't defined in the
8016              input bfd, then we won't be using the function in this
8017              bfd;  It must be defined in a linkonce section in another
8018              bfd, or is weak.  It's also possible that we are
8019              discarding the function due to a linker script /DISCARD/,
8020              which we test for via the output_section.  */
8021           if (sym_sec->owner != ibfd
8022               || sym_sec->output_section == bfd_abs_section_ptr)
8023             need_edit = TRUE;
8024
8025           rel += 2;
8026           if (rel + 1 == relend
8027               || (rel + 2 < relend
8028                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8029             ++rel;
8030
8031           if (rel == relend)
8032             {
8033               if (sec->size == offset + 24)
8034                 {
8035                   need_pad = NULL;
8036                   break;
8037                 }
8038               if (sec->size == offset + 16)
8039                 {
8040                   cnt_16b++;
8041                   break;
8042                 }
8043               goto broken_opd;
8044             }
8045           else if (rel + 1 < relend
8046                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8047                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8048             {
8049               if (rel[0].r_offset == offset + 16)
8050                 cnt_16b++;
8051               else if (rel[0].r_offset != offset + 24)
8052                 goto broken_opd;
8053             }
8054           else
8055             goto broken_opd;
8056         }
8057
8058       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8059
8060       if (!broken && (need_edit || add_aux_fields))
8061         {
8062           Elf_Internal_Rela *write_rel;
8063           Elf_Internal_Shdr *rel_hdr;
8064           bfd_byte *rptr, *wptr;
8065           bfd_byte *new_contents;
8066           bfd_size_type amt;
8067
8068           new_contents = NULL;
8069           amt = OPD_NDX (sec->size) * sizeof (long);
8070           opd = &ppc64_elf_section_data (sec)->u.opd;
8071           opd->adjust = bfd_zalloc (sec->owner, amt);
8072           if (opd->adjust == NULL)
8073             return FALSE;
8074
8075           /* This seems a waste of time as input .opd sections are all
8076              zeros as generated by gcc, but I suppose there's no reason
8077              this will always be so.  We might start putting something in
8078              the third word of .opd entries.  */
8079           if ((sec->flags & SEC_IN_MEMORY) == 0)
8080             {
8081               bfd_byte *loc;
8082               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8083                 {
8084                   if (loc != NULL)
8085                     free (loc);
8086                 error_ret:
8087                   if (local_syms != NULL
8088                       && symtab_hdr->contents != (unsigned char *) local_syms)
8089                     free (local_syms);
8090                   if (elf_section_data (sec)->relocs != relstart)
8091                     free (relstart);
8092                   return FALSE;
8093                 }
8094               sec->contents = loc;
8095               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8096             }
8097
8098           elf_section_data (sec)->relocs = relstart;
8099
8100           new_contents = sec->contents;
8101           if (add_aux_fields)
8102             {
8103               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8104               if (new_contents == NULL)
8105                 return FALSE;
8106               need_pad = NULL;
8107             }
8108           wptr = new_contents;
8109           rptr = sec->contents;
8110           write_rel = relstart;
8111           for (rel = relstart; rel < relend; )
8112             {
8113               unsigned long r_symndx;
8114               asection *sym_sec;
8115               struct elf_link_hash_entry *h;
8116               struct ppc_link_hash_entry *fdh = NULL;
8117               Elf_Internal_Sym *sym;
8118               long opd_ent_size;
8119               Elf_Internal_Rela *next_rel;
8120               bfd_boolean skip;
8121
8122               r_symndx = ELF64_R_SYM (rel->r_info);
8123               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8124                               r_symndx, ibfd))
8125                 goto error_ret;
8126
8127               next_rel = rel + 2;
8128               if (next_rel + 1 == relend
8129                   || (next_rel + 2 < relend
8130                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8131                 ++next_rel;
8132
8133               /* See if the .opd entry is full 24 byte or
8134                  16 byte (with fd_aux entry overlapped with next
8135                  fd_func).  */
8136               opd_ent_size = 24;
8137               if (next_rel == relend)
8138                 {
8139                   if (sec->size == rel->r_offset + 16)
8140                     opd_ent_size = 16;
8141                 }
8142               else if (next_rel->r_offset == rel->r_offset + 16)
8143                 opd_ent_size = 16;
8144
8145               if (h != NULL
8146                   && h->root.root.string[0] == '.')
8147                 {
8148                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8149                   if (fdh != NULL)
8150                     {
8151                       fdh = ppc_follow_link (fdh);
8152                       if (fdh->elf.root.type != bfd_link_hash_defined
8153                           && fdh->elf.root.type != bfd_link_hash_defweak)
8154                         fdh = NULL;
8155                     }
8156                 }
8157
8158               skip = (sym_sec->owner != ibfd
8159                       || sym_sec->output_section == bfd_abs_section_ptr);
8160               if (skip)
8161                 {
8162                   if (fdh != NULL && sym_sec->owner == ibfd)
8163                     {
8164                       /* Arrange for the function descriptor sym
8165                          to be dropped.  */
8166                       fdh->elf.root.u.def.value = 0;
8167                       fdh->elf.root.u.def.section = sym_sec;
8168                     }
8169                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8170
8171                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8172                     rel = next_rel;
8173                   else
8174                     while (1)
8175                       {
8176                         if (!dec_dynrel_count (rel->r_info, sec, info,
8177                                                NULL, h, sym))
8178                           goto error_ret;
8179
8180                         if (++rel == next_rel)
8181                           break;
8182
8183                         r_symndx = ELF64_R_SYM (rel->r_info);
8184                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8185                                         r_symndx, ibfd))
8186                           goto error_ret;
8187                       }
8188                 }
8189               else
8190                 {
8191                   /* We'll be keeping this opd entry.  */
8192                   long adjust;
8193
8194                   if (fdh != NULL)
8195                     {
8196                       /* Redefine the function descriptor symbol to
8197                          this location in the opd section.  It is
8198                          necessary to update the value here rather
8199                          than using an array of adjustments as we do
8200                          for local symbols, because various places
8201                          in the generic ELF code use the value
8202                          stored in u.def.value.  */
8203                       fdh->elf.root.u.def.value = wptr - new_contents;
8204                       fdh->adjust_done = 1;
8205                     }
8206
8207                   /* Local syms are a bit tricky.  We could
8208                      tweak them as they can be cached, but
8209                      we'd need to look through the local syms
8210                      for the function descriptor sym which we
8211                      don't have at the moment.  So keep an
8212                      array of adjustments.  */
8213                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8214                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8215
8216                   if (wptr != rptr)
8217                     memcpy (wptr, rptr, opd_ent_size);
8218                   wptr += opd_ent_size;
8219                   if (add_aux_fields && opd_ent_size == 16)
8220                     {
8221                       memset (wptr, '\0', 8);
8222                       wptr += 8;
8223                     }
8224
8225                   /* We need to adjust any reloc offsets to point to the
8226                      new opd entries.  */
8227                   for ( ; rel != next_rel; ++rel)
8228                     {
8229                       rel->r_offset += adjust;
8230                       if (write_rel != rel)
8231                         memcpy (write_rel, rel, sizeof (*rel));
8232                       ++write_rel;
8233                     }
8234                 }
8235
8236               rptr += opd_ent_size;
8237             }
8238
8239           sec->size = wptr - new_contents;
8240           sec->reloc_count = write_rel - relstart;
8241           if (add_aux_fields)
8242             {
8243               free (sec->contents);
8244               sec->contents = new_contents;
8245             }
8246
8247           /* Fudge the header size too, as this is used later in
8248              elf_bfd_final_link if we are emitting relocs.  */
8249           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8250           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8251           some_edited = TRUE;
8252         }
8253       else if (elf_section_data (sec)->relocs != relstart)
8254         free (relstart);
8255
8256       if (local_syms != NULL
8257           && symtab_hdr->contents != (unsigned char *) local_syms)
8258         {
8259           if (!info->keep_memory)
8260             free (local_syms);
8261           else
8262             symtab_hdr->contents = (unsigned char *) local_syms;
8263         }
8264     }
8265
8266   if (some_edited)
8267     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8268
8269   /* If we are doing a final link and the last .opd entry is just 16 byte
8270      long, add a 8 byte padding after it.  */
8271   if (need_pad != NULL && !bfd_link_relocatable (info))
8272     {
8273       bfd_byte *p;
8274
8275       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8276         {
8277           BFD_ASSERT (need_pad->size > 0);
8278
8279           p = bfd_malloc (need_pad->size + 8);
8280           if (p == NULL)
8281             return FALSE;
8282
8283           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8284                                           p, 0, need_pad->size))
8285             return FALSE;
8286
8287           need_pad->contents = p;
8288           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8289         }
8290       else
8291         {
8292           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8293           if (p == NULL)
8294             return FALSE;
8295
8296           need_pad->contents = p;
8297         }
8298
8299       memset (need_pad->contents + need_pad->size, 0, 8);
8300       need_pad->size += 8;
8301     }
8302
8303   return TRUE;
8304 }
8305
8306 /* Analyze inline PLT call relocations to see whether calls to locally
8307    defined functions can be converted to direct calls.  */
8308
8309 bfd_boolean
8310 ppc64_elf_inline_plt (struct bfd_link_info *info)
8311 {
8312   struct ppc_link_hash_table *htab;
8313   bfd *ibfd;
8314   asection *sec;
8315   bfd_vma low_vma, high_vma, limit;
8316
8317   htab = ppc_hash_table (info);
8318   if (htab == NULL)
8319     return FALSE;
8320
8321   /* A bl insn can reach -0x2000000 to 0x1fffffc.  The limit is
8322      reduced somewhat to cater for possible stubs that might be added
8323      between the call and its destination.  */
8324   if (htab->params->group_size < 0)
8325     {
8326       limit = -htab->params->group_size;
8327       if (limit == 1)
8328         limit = 0x1e00000;
8329     }
8330   else
8331     {
8332       limit = htab->params->group_size;
8333       if (limit == 1)
8334         limit = 0x1c00000;
8335     }
8336
8337   low_vma = -1;
8338   high_vma = 0;
8339   for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8340     if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8341       {
8342         if (low_vma > sec->vma)
8343           low_vma = sec->vma;
8344         if (high_vma < sec->vma + sec->size)
8345           high_vma = sec->vma + sec->size;
8346       }
8347
8348   /* If a "bl" can reach anywhere in local code sections, then we can
8349      convert all inline PLT sequences to direct calls when the symbol
8350      is local.  */
8351   if (high_vma - low_vma < limit)
8352     {
8353       htab->can_convert_all_inline_plt = 1;
8354       return TRUE;
8355     }
8356
8357   /* Otherwise, go looking through relocs for cases where a direct
8358      call won't reach.  Mark the symbol on any such reloc to disable
8359      the optimization and keep the PLT entry as it seems likely that
8360      this will be better than creating trampolines.  Note that this
8361      will disable the optimization for all inline PLT calls to a
8362      particular symbol, not just those that won't reach.  The
8363      difficulty in doing a more precise optimization is that the
8364      linker needs to make a decision depending on whether a
8365      particular R_PPC64_PLTCALL insn can be turned into a direct
8366      call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8367      the sequence, and there is nothing that ties those relocs
8368      together except their symbol.  */
8369
8370   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8371     {
8372       Elf_Internal_Shdr *symtab_hdr;
8373       Elf_Internal_Sym *local_syms;
8374
8375       if (!is_ppc64_elf (ibfd))
8376         continue;
8377
8378       local_syms = NULL;
8379       symtab_hdr = &elf_symtab_hdr (ibfd);
8380
8381       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8382         if (ppc64_elf_section_data (sec)->has_pltcall
8383             && !bfd_is_abs_section (sec->output_section))
8384           {
8385             Elf_Internal_Rela *relstart, *rel, *relend;
8386
8387             /* Read the relocations.  */
8388             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8389                                                   info->keep_memory);
8390             if (relstart == NULL)
8391               return FALSE;
8392
8393             relend = relstart + sec->reloc_count;
8394             for (rel = relstart; rel < relend; )
8395               {
8396                 enum elf_ppc64_reloc_type r_type;
8397                 unsigned long r_symndx;
8398                 asection *sym_sec;
8399                 struct elf_link_hash_entry *h;
8400                 Elf_Internal_Sym *sym;
8401                 unsigned char *tls_maskp;
8402
8403                 r_type = ELF64_R_TYPE (rel->r_info);
8404                 if (r_type != R_PPC64_PLTCALL)
8405                   continue;
8406
8407                 r_symndx = ELF64_R_SYM (rel->r_info);
8408                 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8409                                 r_symndx, ibfd))
8410                   {
8411                     if (elf_section_data (sec)->relocs != relstart)
8412                       free (relstart);
8413                     if (local_syms != NULL
8414                         && symtab_hdr->contents != (unsigned char *) local_syms)
8415                       free (local_syms);
8416                     return FALSE;
8417                   }
8418
8419                 if (sym_sec != NULL && sym_sec->output_section != NULL)
8420                   {
8421                     bfd_vma from, to;
8422                     if (h != NULL)
8423                       to = h->root.u.def.value;
8424                     else
8425                       to = sym->st_value;
8426                     to += (rel->r_addend
8427                            + sym_sec->output_offset
8428                            + sym_sec->output_section->vma);
8429                     from = (rel->r_offset
8430                             + sec->output_offset
8431                             + sec->output_section->vma);
8432                     if (to - from + limit < 2 * limit)
8433                       *tls_maskp &= ~PLT_KEEP;
8434                   }
8435               }
8436             if (elf_section_data (sec)->relocs != relstart)
8437               free (relstart);
8438           }
8439
8440       if (local_syms != NULL
8441           && symtab_hdr->contents != (unsigned char *) local_syms)
8442         {
8443           if (!info->keep_memory)
8444             free (local_syms);
8445           else
8446             symtab_hdr->contents = (unsigned char *) local_syms;
8447         }
8448     }
8449
8450   return TRUE;
8451 }
8452
8453 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8454
8455 asection *
8456 ppc64_elf_tls_setup (struct bfd_link_info *info)
8457 {
8458   struct ppc_link_hash_table *htab;
8459
8460   htab = ppc_hash_table (info);
8461   if (htab == NULL)
8462     return NULL;
8463
8464   if (abiversion (info->output_bfd) == 1)
8465     htab->opd_abi = 1;
8466
8467   if (htab->params->no_multi_toc)
8468     htab->do_multi_toc = 0;
8469   else if (!htab->do_multi_toc)
8470     htab->params->no_multi_toc = 1;
8471
8472   /* Default to --no-plt-localentry, as this option can cause problems
8473      with symbol interposition.  For example, glibc libpthread.so and
8474      libc.so duplicate many pthread symbols, with a fallback
8475      implementation in libc.so.  In some cases the fallback does more
8476      work than the pthread implementation.  __pthread_condattr_destroy
8477      is one such symbol: the libpthread.so implementation is
8478      localentry:0 while the libc.so implementation is localentry:8.
8479      An app that "cleverly" uses dlopen to only load necessary
8480      libraries at runtime may omit loading libpthread.so when not
8481      running multi-threaded, which then results in the libc.so
8482      fallback symbols being used and ld.so complaining.  Now there
8483      are workarounds in ld (see non_zero_localentry) to detect the
8484      pthread situation, but that may not be the only case where
8485      --plt-localentry can cause trouble.  */
8486   if (htab->params->plt_localentry0 < 0)
8487     htab->params->plt_localentry0 = 0;
8488   if (htab->params->plt_localentry0
8489       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8490                                FALSE, FALSE, FALSE) == NULL)
8491     _bfd_error_handler
8492       (_("warning: --plt-localentry is especially dangerous without "
8493          "ld.so support to detect ABI violations"));
8494
8495   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8496                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8497                                               FALSE, FALSE, TRUE));
8498   /* Move dynamic linking info to the function descriptor sym.  */
8499   if (htab->tls_get_addr != NULL)
8500     func_desc_adjust (&htab->tls_get_addr->elf, info);
8501   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8502                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8503                                                  FALSE, FALSE, TRUE));
8504   if (htab->params->tls_get_addr_opt)
8505     {
8506       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8507
8508       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8509                                   FALSE, FALSE, TRUE);
8510       if (opt != NULL)
8511         func_desc_adjust (opt, info);
8512       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8513                                      FALSE, FALSE, TRUE);
8514       if (opt_fd != NULL
8515           && (opt_fd->root.type == bfd_link_hash_defined
8516               || opt_fd->root.type == bfd_link_hash_defweak))
8517         {
8518           /* If glibc supports an optimized __tls_get_addr call stub,
8519              signalled by the presence of __tls_get_addr_opt, and we'll
8520              be calling __tls_get_addr via a plt call stub, then
8521              make __tls_get_addr point to __tls_get_addr_opt.  */
8522           tga_fd = &htab->tls_get_addr_fd->elf;
8523           if (htab->elf.dynamic_sections_created
8524               && tga_fd != NULL
8525               && (tga_fd->type == STT_FUNC
8526                   || tga_fd->needs_plt)
8527               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8528                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8529             {
8530               struct plt_entry *ent;
8531
8532               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8533                 if (ent->plt.refcount > 0)
8534                   break;
8535               if (ent != NULL)
8536                 {
8537                   tga_fd->root.type = bfd_link_hash_indirect;
8538                   tga_fd->root.u.i.link = &opt_fd->root;
8539                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8540                   opt_fd->mark = 1;
8541                   if (opt_fd->dynindx != -1)
8542                     {
8543                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8544                       opt_fd->dynindx = -1;
8545                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8546                                               opt_fd->dynstr_index);
8547                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8548                         return NULL;
8549                     }
8550                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8551                   tga = &htab->tls_get_addr->elf;
8552                   if (opt != NULL && tga != NULL)
8553                     {
8554                       tga->root.type = bfd_link_hash_indirect;
8555                       tga->root.u.i.link = &opt->root;
8556                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8557                       opt->mark = 1;
8558                       _bfd_elf_link_hash_hide_symbol (info, opt,
8559                                                       tga->forced_local);
8560                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8561                     }
8562                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8563                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8564                   if (htab->tls_get_addr != NULL)
8565                     {
8566                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8567                       htab->tls_get_addr->is_func = 1;
8568                     }
8569                 }
8570             }
8571         }
8572       else if (htab->params->tls_get_addr_opt < 0)
8573         htab->params->tls_get_addr_opt = 0;
8574     }
8575   return _bfd_elf_tls_setup (info->output_bfd, info);
8576 }
8577
8578 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8579    HASH1 or HASH2.  */
8580
8581 static bfd_boolean
8582 branch_reloc_hash_match (const bfd *ibfd,
8583                          const Elf_Internal_Rela *rel,
8584                          const struct ppc_link_hash_entry *hash1,
8585                          const struct ppc_link_hash_entry *hash2)
8586 {
8587   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8588   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8589   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8590
8591   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8592     {
8593       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8594       struct elf_link_hash_entry *h;
8595
8596       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8597       h = elf_follow_link (h);
8598       if (h == &hash1->elf || h == &hash2->elf)
8599         return TRUE;
8600     }
8601   return FALSE;
8602 }
8603
8604 /* Run through all the TLS relocs looking for optimization
8605    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8606    a preliminary section layout so that we know the TLS segment
8607    offsets.  We can't optimize earlier because some optimizations need
8608    to know the tp offset, and we need to optimize before allocating
8609    dynamic relocations.  */
8610
8611 bfd_boolean
8612 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8613 {
8614   bfd *ibfd;
8615   asection *sec;
8616   struct ppc_link_hash_table *htab;
8617   unsigned char *toc_ref;
8618   int pass;
8619
8620   if (!bfd_link_executable (info))
8621     return TRUE;
8622
8623   htab = ppc_hash_table (info);
8624   if (htab == NULL)
8625     return FALSE;
8626
8627   /* Make two passes over the relocs.  On the first pass, mark toc
8628      entries involved with tls relocs, and check that tls relocs
8629      involved in setting up a tls_get_addr call are indeed followed by
8630      such a call.  If they are not, we can't do any tls optimization.
8631      On the second pass twiddle tls_mask flags to notify
8632      relocate_section that optimization can be done, and adjust got
8633      and plt refcounts.  */
8634   toc_ref = NULL;
8635   for (pass = 0; pass < 2; ++pass)
8636     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8637       {
8638         Elf_Internal_Sym *locsyms = NULL;
8639         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8640
8641         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8642           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8643             {
8644               Elf_Internal_Rela *relstart, *rel, *relend;
8645               bfd_boolean found_tls_get_addr_arg = 0;
8646
8647               /* Read the relocations.  */
8648               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8649                                                     info->keep_memory);
8650               if (relstart == NULL)
8651                 {
8652                   free (toc_ref);
8653                   return FALSE;
8654                 }
8655
8656               relend = relstart + sec->reloc_count;
8657               for (rel = relstart; rel < relend; rel++)
8658                 {
8659                   enum elf_ppc64_reloc_type r_type;
8660                   unsigned long r_symndx;
8661                   struct elf_link_hash_entry *h;
8662                   Elf_Internal_Sym *sym;
8663                   asection *sym_sec;
8664                   unsigned char *tls_mask;
8665                   unsigned char tls_set, tls_clear, tls_type = 0;
8666                   bfd_vma value;
8667                   bfd_boolean ok_tprel, is_local;
8668                   long toc_ref_index = 0;
8669                   int expecting_tls_get_addr = 0;
8670                   bfd_boolean ret = FALSE;
8671
8672                   r_symndx = ELF64_R_SYM (rel->r_info);
8673                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8674                                   r_symndx, ibfd))
8675                     {
8676                     err_free_rel:
8677                       if (elf_section_data (sec)->relocs != relstart)
8678                         free (relstart);
8679                       if (toc_ref != NULL)
8680                         free (toc_ref);
8681                       if (locsyms != NULL
8682                           && (elf_symtab_hdr (ibfd).contents
8683                               != (unsigned char *) locsyms))
8684                         free (locsyms);
8685                       return ret;
8686                     }
8687
8688                   if (h != NULL)
8689                     {
8690                       if (h->root.type == bfd_link_hash_defined
8691                           || h->root.type == bfd_link_hash_defweak)
8692                         value = h->root.u.def.value;
8693                       else if (h->root.type == bfd_link_hash_undefweak)
8694                         value = 0;
8695                       else
8696                         {
8697                           found_tls_get_addr_arg = 0;
8698                           continue;
8699                         }
8700                     }
8701                   else
8702                     /* Symbols referenced by TLS relocs must be of type
8703                        STT_TLS.  So no need for .opd local sym adjust.  */
8704                     value = sym->st_value;
8705
8706                   ok_tprel = FALSE;
8707                   is_local = FALSE;
8708                   if (h == NULL
8709                       || !h->def_dynamic)
8710                     {
8711                       is_local = TRUE;
8712                       if (h != NULL
8713                           && h->root.type == bfd_link_hash_undefweak)
8714                         ok_tprel = TRUE;
8715                       else if (sym_sec != NULL
8716                                && sym_sec->output_section != NULL)
8717                         {
8718                           value += sym_sec->output_offset;
8719                           value += sym_sec->output_section->vma;
8720                           value -= htab->elf.tls_sec->vma;
8721                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8722                                       < (bfd_vma) 1 << 32);
8723                         }
8724                     }
8725
8726                   r_type = ELF64_R_TYPE (rel->r_info);
8727                   /* If this section has old-style __tls_get_addr calls
8728                      without marker relocs, then check that each
8729                      __tls_get_addr call reloc is preceded by a reloc
8730                      that conceivably belongs to the __tls_get_addr arg
8731                      setup insn.  If we don't find matching arg setup
8732                      relocs, don't do any tls optimization.  */
8733                   if (pass == 0
8734                       && sec->has_tls_get_addr_call
8735                       && h != NULL
8736                       && (h == &htab->tls_get_addr->elf
8737                           || h == &htab->tls_get_addr_fd->elf)
8738                       && !found_tls_get_addr_arg
8739                       && is_branch_reloc (r_type))
8740                     {
8741                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8742                                                 "TLS optimization disabled\n"),
8743                                               ibfd, sec, rel->r_offset);
8744                       ret = TRUE;
8745                       goto err_free_rel;
8746                     }
8747
8748                   found_tls_get_addr_arg = 0;
8749                   switch (r_type)
8750                     {
8751                     case R_PPC64_GOT_TLSLD16:
8752                     case R_PPC64_GOT_TLSLD16_LO:
8753                       expecting_tls_get_addr = 1;
8754                       found_tls_get_addr_arg = 1;
8755                       /* Fall through.  */
8756
8757                     case R_PPC64_GOT_TLSLD16_HI:
8758                     case R_PPC64_GOT_TLSLD16_HA:
8759                       /* These relocs should never be against a symbol
8760                          defined in a shared lib.  Leave them alone if
8761                          that turns out to be the case.  */
8762                       if (!is_local)
8763                         continue;
8764
8765                       /* LD -> LE */
8766                       tls_set = 0;
8767                       tls_clear = TLS_LD;
8768                       tls_type = TLS_TLS | TLS_LD;
8769                       break;
8770
8771                     case R_PPC64_GOT_TLSGD16:
8772                     case R_PPC64_GOT_TLSGD16_LO:
8773                       expecting_tls_get_addr = 1;
8774                       found_tls_get_addr_arg = 1;
8775                       /* Fall through. */
8776
8777                     case R_PPC64_GOT_TLSGD16_HI:
8778                     case R_PPC64_GOT_TLSGD16_HA:
8779                       if (ok_tprel)
8780                         /* GD -> LE */
8781                         tls_set = 0;
8782                       else
8783                         /* GD -> IE */
8784                         tls_set = TLS_TLS | TLS_TPRELGD;
8785                       tls_clear = TLS_GD;
8786                       tls_type = TLS_TLS | TLS_GD;
8787                       break;
8788
8789                     case R_PPC64_GOT_TPREL16_DS:
8790                     case R_PPC64_GOT_TPREL16_LO_DS:
8791                     case R_PPC64_GOT_TPREL16_HI:
8792                     case R_PPC64_GOT_TPREL16_HA:
8793                       if (ok_tprel)
8794                         {
8795                           /* IE -> LE */
8796                           tls_set = 0;
8797                           tls_clear = TLS_TPREL;
8798                           tls_type = TLS_TLS | TLS_TPREL;
8799                           break;
8800                         }
8801                       continue;
8802
8803                     case R_PPC64_TLSGD:
8804                     case R_PPC64_TLSLD:
8805                       if (rel + 1 < relend
8806                           && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8807                         {
8808                           if (pass != 0
8809                               && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8810                             {
8811                               r_symndx = ELF64_R_SYM (rel[1].r_info);
8812                               if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8813                                   r_symndx, ibfd))
8814                                 goto err_free_rel;
8815                               if (h != NULL)
8816                                 {
8817                                   struct plt_entry *ent = NULL;
8818
8819                                   for (ent = h->plt.plist;
8820                                        ent != NULL;
8821                                        ent = ent->next)
8822                                     if (ent->addend == rel[1].r_addend)
8823                                       break;
8824
8825                                   if (ent != NULL
8826                                       && ent->plt.refcount > 0)
8827                                     ent->plt.refcount -= 1;
8828                                 }
8829                             }
8830                           continue;
8831                         }
8832                       found_tls_get_addr_arg = 1;
8833                       /* Fall through.  */
8834
8835                     case R_PPC64_TLS:
8836                     case R_PPC64_TOC16:
8837                     case R_PPC64_TOC16_LO:
8838                       if (sym_sec == NULL || sym_sec != toc)
8839                         continue;
8840
8841                       /* Mark this toc entry as referenced by a TLS
8842                          code sequence.  We can do that now in the
8843                          case of R_PPC64_TLS, and after checking for
8844                          tls_get_addr for the TOC16 relocs.  */
8845                       if (toc_ref == NULL)
8846                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8847                       if (toc_ref == NULL)
8848                         goto err_free_rel;
8849
8850                       if (h != NULL)
8851                         value = h->root.u.def.value;
8852                       else
8853                         value = sym->st_value;
8854                       value += rel->r_addend;
8855                       if (value % 8 != 0)
8856                         continue;
8857                       BFD_ASSERT (value < toc->size
8858                                   && toc->output_offset % 8 == 0);
8859                       toc_ref_index = (value + toc->output_offset) / 8;
8860                       if (r_type == R_PPC64_TLS
8861                           || r_type == R_PPC64_TLSGD
8862                           || r_type == R_PPC64_TLSLD)
8863                         {
8864                           toc_ref[toc_ref_index] = 1;
8865                           continue;
8866                         }
8867
8868                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8869                         continue;
8870
8871                       tls_set = 0;
8872                       tls_clear = 0;
8873                       expecting_tls_get_addr = 2;
8874                       break;
8875
8876                     case R_PPC64_TPREL64:
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 (ok_tprel)
8883                         {
8884                           /* IE -> LE */
8885                           tls_set = TLS_EXPLICIT;
8886                           tls_clear = TLS_TPREL;
8887                           break;
8888                         }
8889                       continue;
8890
8891                     case R_PPC64_DTPMOD64:
8892                       if (pass == 0
8893                           || sec != toc
8894                           || toc_ref == NULL
8895                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8896                         continue;
8897                       if (rel + 1 < relend
8898                           && (rel[1].r_info
8899                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8900                           && rel[1].r_offset == rel->r_offset + 8)
8901                         {
8902                           if (ok_tprel)
8903                             /* GD -> LE */
8904                             tls_set = TLS_EXPLICIT | TLS_GD;
8905                           else
8906                             /* GD -> IE */
8907                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8908                           tls_clear = TLS_GD;
8909                         }
8910                       else
8911                         {
8912                           if (!is_local)
8913                             continue;
8914
8915                           /* LD -> LE */
8916                           tls_set = TLS_EXPLICIT;
8917                           tls_clear = TLS_LD;
8918                         }
8919                       break;
8920
8921                     default:
8922                       continue;
8923                     }
8924
8925                   if (pass == 0)
8926                     {
8927                       if (!expecting_tls_get_addr
8928                           || !sec->has_tls_get_addr_call)
8929                         continue;
8930
8931                       if (rel + 1 < relend
8932                           && branch_reloc_hash_match (ibfd, rel + 1,
8933                                                       htab->tls_get_addr,
8934                                                       htab->tls_get_addr_fd))
8935                         {
8936                           if (expecting_tls_get_addr == 2)
8937                             {
8938                               /* Check for toc tls entries.  */
8939                               unsigned char *toc_tls;
8940                               int retval;
8941
8942                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8943                                                      &locsyms,
8944                                                      rel, ibfd);
8945                               if (retval == 0)
8946                                 goto err_free_rel;
8947                               if (toc_tls != NULL)
8948                                 {
8949                                   if ((*toc_tls & TLS_TLS) != 0
8950                                       && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
8951                                     found_tls_get_addr_arg = 1;
8952                                   if (retval > 1)
8953                                     toc_ref[toc_ref_index] = 1;
8954                                 }
8955                             }
8956                           continue;
8957                         }
8958
8959                       /* Uh oh, we didn't find the expected call.  We
8960                          could just mark this symbol to exclude it
8961                          from tls optimization but it's safer to skip
8962                          the entire optimization.  */
8963                       /* xgettext:c-format */
8964                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8965                                                 "TLS optimization disabled\n"),
8966                                               ibfd, sec, rel->r_offset);
8967                       ret = TRUE;
8968                       goto err_free_rel;
8969                     }
8970
8971                   /* If we don't have old-style __tls_get_addr calls
8972                      without TLSGD/TLSLD marker relocs, and we haven't
8973                      found a new-style __tls_get_addr call with a
8974                      marker for this symbol, then we either have a
8975                      broken object file or an -mlongcall style
8976                      indirect call to __tls_get_addr without a marker.
8977                      Disable optimization in this case.  */
8978                   if ((tls_clear & (TLS_GD | TLS_LD)) != 0
8979                       && (tls_set & TLS_EXPLICIT) == 0
8980                       && !sec->has_tls_get_addr_call
8981                       && ((*tls_mask & (TLS_TLS | TLS_MARK))
8982                           != (TLS_TLS | TLS_MARK)))
8983                     continue;
8984
8985                   if (expecting_tls_get_addr)
8986                     {
8987                       struct plt_entry *ent = NULL;
8988
8989                       if (htab->tls_get_addr != NULL)
8990                         for (ent = htab->tls_get_addr->elf.plt.plist;
8991                              ent != NULL;
8992                              ent = ent->next)
8993                           if (ent->addend == 0)
8994                             break;
8995
8996                       if (ent == NULL && htab->tls_get_addr_fd != NULL)
8997                         for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8998                              ent != NULL;
8999                              ent = ent->next)
9000                           if (ent->addend == 0)
9001                             break;
9002
9003                       if (ent != NULL
9004                           && ent->plt.refcount > 0)
9005                         ent->plt.refcount -= 1;
9006                     }
9007
9008                   if (tls_clear == 0)
9009                     continue;
9010
9011                   if ((tls_set & TLS_EXPLICIT) == 0)
9012                     {
9013                       struct got_entry *ent;
9014
9015                       /* Adjust got entry for this reloc.  */
9016                       if (h != NULL)
9017                         ent = h->got.glist;
9018                       else
9019                         ent = elf_local_got_ents (ibfd)[r_symndx];
9020
9021                       for (; ent != NULL; ent = ent->next)
9022                         if (ent->addend == rel->r_addend
9023                             && ent->owner == ibfd
9024                             && ent->tls_type == tls_type)
9025                           break;
9026                       if (ent == NULL)
9027                         abort ();
9028
9029                       if (tls_set == 0)
9030                         {
9031                           /* We managed to get rid of a got entry.  */
9032                           if (ent->got.refcount > 0)
9033                             ent->got.refcount -= 1;
9034                         }
9035                     }
9036                   else
9037                     {
9038                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
9039                          we'll lose one or two dyn relocs.  */
9040                       if (!dec_dynrel_count (rel->r_info, sec, info,
9041                                              NULL, h, sym))
9042                         return FALSE;
9043
9044                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
9045                         {
9046                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9047                                                  NULL, h, sym))
9048                             return FALSE;
9049                         }
9050                     }
9051
9052                   *tls_mask |= tls_set;
9053                   *tls_mask &= ~tls_clear;
9054                 }
9055
9056               if (elf_section_data (sec)->relocs != relstart)
9057                 free (relstart);
9058             }
9059
9060         if (locsyms != NULL
9061             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9062           {
9063             if (!info->keep_memory)
9064               free (locsyms);
9065             else
9066               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9067           }
9068       }
9069
9070   if (toc_ref != NULL)
9071     free (toc_ref);
9072   htab->do_tls_opt = 1;
9073   return TRUE;
9074 }
9075
9076 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9077    the values of any global symbols in a toc section that has been
9078    edited.  Globals in toc sections should be a rarity, so this function
9079    sets a flag if any are found in toc sections other than the one just
9080    edited, so that further hash table traversals can be avoided.  */
9081
9082 struct adjust_toc_info
9083 {
9084   asection *toc;
9085   unsigned long *skip;
9086   bfd_boolean global_toc_syms;
9087 };
9088
9089 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9090
9091 static bfd_boolean
9092 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9093 {
9094   struct ppc_link_hash_entry *eh;
9095   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9096   unsigned long i;
9097
9098   if (h->root.type != bfd_link_hash_defined
9099       && h->root.type != bfd_link_hash_defweak)
9100     return TRUE;
9101
9102   eh = (struct ppc_link_hash_entry *) h;
9103   if (eh->adjust_done)
9104     return TRUE;
9105
9106   if (eh->elf.root.u.def.section == toc_inf->toc)
9107     {
9108       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9109         i = toc_inf->toc->rawsize >> 3;
9110       else
9111         i = eh->elf.root.u.def.value >> 3;
9112
9113       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9114         {
9115           _bfd_error_handler
9116             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9117           do
9118             ++i;
9119           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9120           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9121         }
9122
9123       eh->elf.root.u.def.value -= toc_inf->skip[i];
9124       eh->adjust_done = 1;
9125     }
9126   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9127     toc_inf->global_toc_syms = TRUE;
9128
9129   return TRUE;
9130 }
9131
9132 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9133    on a _LO variety toc/got reloc.  */
9134
9135 static bfd_boolean
9136 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9137 {
9138   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9139           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9140           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9141           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9142           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9143           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9144           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9145           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9146           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9147           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9148           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9149           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9150           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9151           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9152           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9153           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9154           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9155               /* Exclude lfqu by testing reloc.  If relocs are ever
9156                  defined for the reduced D field in psq_lu then those
9157                  will need testing too.  */
9158               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9159           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9160               && (insn & 1) == 0)
9161           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9162           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9163               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9164               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9165           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9166               && (insn & 1) == 0));
9167 }
9168
9169 /* Examine all relocs referencing .toc sections in order to remove
9170    unused .toc entries.  */
9171
9172 bfd_boolean
9173 ppc64_elf_edit_toc (struct bfd_link_info *info)
9174 {
9175   bfd *ibfd;
9176   struct adjust_toc_info toc_inf;
9177   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9178
9179   htab->do_toc_opt = 1;
9180   toc_inf.global_toc_syms = TRUE;
9181   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9182     {
9183       asection *toc, *sec;
9184       Elf_Internal_Shdr *symtab_hdr;
9185       Elf_Internal_Sym *local_syms;
9186       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9187       unsigned long *skip, *drop;
9188       unsigned char *used;
9189       unsigned char *keep, last, some_unused;
9190
9191       if (!is_ppc64_elf (ibfd))
9192         continue;
9193
9194       toc = bfd_get_section_by_name (ibfd, ".toc");
9195       if (toc == NULL
9196           || toc->size == 0
9197           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9198           || discarded_section (toc))
9199         continue;
9200
9201       toc_relocs = NULL;
9202       local_syms = NULL;
9203       symtab_hdr = &elf_symtab_hdr (ibfd);
9204
9205       /* Look at sections dropped from the final link.  */
9206       skip = NULL;
9207       relstart = NULL;
9208       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9209         {
9210           if (sec->reloc_count == 0
9211               || !discarded_section (sec)
9212               || get_opd_info (sec)
9213               || (sec->flags & SEC_ALLOC) == 0
9214               || (sec->flags & SEC_DEBUGGING) != 0)
9215             continue;
9216
9217           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9218           if (relstart == NULL)
9219             goto error_ret;
9220
9221           /* Run through the relocs to see which toc entries might be
9222              unused.  */
9223           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9224             {
9225               enum elf_ppc64_reloc_type r_type;
9226               unsigned long r_symndx;
9227               asection *sym_sec;
9228               struct elf_link_hash_entry *h;
9229               Elf_Internal_Sym *sym;
9230               bfd_vma val;
9231
9232               r_type = ELF64_R_TYPE (rel->r_info);
9233               switch (r_type)
9234                 {
9235                 default:
9236                   continue;
9237
9238                 case R_PPC64_TOC16:
9239                 case R_PPC64_TOC16_LO:
9240                 case R_PPC64_TOC16_HI:
9241                 case R_PPC64_TOC16_HA:
9242                 case R_PPC64_TOC16_DS:
9243                 case R_PPC64_TOC16_LO_DS:
9244                   break;
9245                 }
9246
9247               r_symndx = ELF64_R_SYM (rel->r_info);
9248               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9249                               r_symndx, ibfd))
9250                 goto error_ret;
9251
9252               if (sym_sec != toc)
9253                 continue;
9254
9255               if (h != NULL)
9256                 val = h->root.u.def.value;
9257               else
9258                 val = sym->st_value;
9259               val += rel->r_addend;
9260
9261               if (val >= toc->size)
9262                 continue;
9263
9264               /* Anything in the toc ought to be aligned to 8 bytes.
9265                  If not, don't mark as unused.  */
9266               if (val & 7)
9267                 continue;
9268
9269               if (skip == NULL)
9270                 {
9271                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9272                   if (skip == NULL)
9273                     goto error_ret;
9274                 }
9275
9276               skip[val >> 3] = ref_from_discarded;
9277             }
9278
9279           if (elf_section_data (sec)->relocs != relstart)
9280             free (relstart);
9281         }
9282
9283       /* For largetoc loads of address constants, we can convert
9284          .  addis rx,2,addr@got@ha
9285          .  ld ry,addr@got@l(rx)
9286          to
9287          .  addis rx,2,addr@toc@ha
9288          .  addi ry,rx,addr@toc@l
9289          when addr is within 2G of the toc pointer.  This then means
9290          that the word storing "addr" in the toc is no longer needed.  */
9291
9292       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9293           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9294           && toc->reloc_count != 0)
9295         {
9296           /* Read toc relocs.  */
9297           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9298                                                   info->keep_memory);
9299           if (toc_relocs == NULL)
9300             goto error_ret;
9301
9302           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9303             {
9304               enum elf_ppc64_reloc_type r_type;
9305               unsigned long r_symndx;
9306               asection *sym_sec;
9307               struct elf_link_hash_entry *h;
9308               Elf_Internal_Sym *sym;
9309               bfd_vma val, addr;
9310
9311               r_type = ELF64_R_TYPE (rel->r_info);
9312               if (r_type != R_PPC64_ADDR64)
9313                 continue;
9314
9315               r_symndx = ELF64_R_SYM (rel->r_info);
9316               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9317                               r_symndx, ibfd))
9318                 goto error_ret;
9319
9320               if (sym_sec == NULL
9321                   || sym_sec->output_section == NULL
9322                   || discarded_section (sym_sec))
9323                 continue;
9324
9325               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9326                 continue;
9327
9328               if (h != NULL)
9329                 {
9330                   if (h->type == STT_GNU_IFUNC)
9331                     continue;
9332                   val = h->root.u.def.value;
9333                 }
9334               else
9335                 {
9336                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9337                     continue;
9338                   val = sym->st_value;
9339                 }
9340               val += rel->r_addend;
9341               val += sym_sec->output_section->vma + sym_sec->output_offset;
9342
9343               /* We don't yet know the exact toc pointer value, but we
9344                  know it will be somewhere in the toc section.  Don't
9345                  optimize if the difference from any possible toc
9346                  pointer is outside [ff..f80008000, 7fff7fff].  */
9347               addr = toc->output_section->vma + TOC_BASE_OFF;
9348               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9349                 continue;
9350
9351               addr = toc->output_section->vma + toc->output_section->rawsize;
9352               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9353                 continue;
9354
9355               if (skip == NULL)
9356                 {
9357                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9358                   if (skip == NULL)
9359                     goto error_ret;
9360                 }
9361
9362               skip[rel->r_offset >> 3]
9363                 |= can_optimize | ((rel - toc_relocs) << 2);
9364             }
9365         }
9366
9367       if (skip == NULL)
9368         continue;
9369
9370       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9371       if (used == NULL)
9372         {
9373         error_ret:
9374           if (local_syms != NULL
9375               && symtab_hdr->contents != (unsigned char *) local_syms)
9376             free (local_syms);
9377           if (sec != NULL
9378               && relstart != NULL
9379               && elf_section_data (sec)->relocs != relstart)
9380             free (relstart);
9381           if (toc_relocs != NULL
9382               && elf_section_data (toc)->relocs != toc_relocs)
9383             free (toc_relocs);
9384           if (skip != NULL)
9385             free (skip);
9386           return FALSE;
9387         }
9388
9389       /* Now check all kept sections that might reference the toc.
9390          Check the toc itself last.  */
9391       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9392                   : ibfd->sections);
9393            sec != NULL;
9394            sec = (sec == toc ? NULL
9395                   : sec->next == NULL ? toc
9396                   : sec->next == toc && toc->next ? toc->next
9397                   : sec->next))
9398         {
9399           int repeat;
9400
9401           if (sec->reloc_count == 0
9402               || discarded_section (sec)
9403               || get_opd_info (sec)
9404               || (sec->flags & SEC_ALLOC) == 0
9405               || (sec->flags & SEC_DEBUGGING) != 0)
9406             continue;
9407
9408           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9409                                                 info->keep_memory);
9410           if (relstart == NULL)
9411             {
9412               free (used);
9413               goto error_ret;
9414             }
9415
9416           /* Mark toc entries referenced as used.  */
9417           do
9418             {
9419               repeat = 0;
9420               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9421                 {
9422                   enum elf_ppc64_reloc_type r_type;
9423                   unsigned long r_symndx;
9424                   asection *sym_sec;
9425                   struct elf_link_hash_entry *h;
9426                   Elf_Internal_Sym *sym;
9427                   bfd_vma val;
9428                   enum {no_check, check_lo, check_ha} insn_check;
9429
9430                   r_type = ELF64_R_TYPE (rel->r_info);
9431                   switch (r_type)
9432                     {
9433                     default:
9434                       insn_check = no_check;
9435                       break;
9436
9437                     case R_PPC64_GOT_TLSLD16_HA:
9438                     case R_PPC64_GOT_TLSGD16_HA:
9439                     case R_PPC64_GOT_TPREL16_HA:
9440                     case R_PPC64_GOT_DTPREL16_HA:
9441                     case R_PPC64_GOT16_HA:
9442                     case R_PPC64_TOC16_HA:
9443                       insn_check = check_ha;
9444                       break;
9445
9446                     case R_PPC64_GOT_TLSLD16_LO:
9447                     case R_PPC64_GOT_TLSGD16_LO:
9448                     case R_PPC64_GOT_TPREL16_LO_DS:
9449                     case R_PPC64_GOT_DTPREL16_LO_DS:
9450                     case R_PPC64_GOT16_LO:
9451                     case R_PPC64_GOT16_LO_DS:
9452                     case R_PPC64_TOC16_LO:
9453                     case R_PPC64_TOC16_LO_DS:
9454                       insn_check = check_lo;
9455                       break;
9456                     }
9457
9458                   if (insn_check != no_check)
9459                     {
9460                       bfd_vma off = rel->r_offset & ~3;
9461                       unsigned char buf[4];
9462                       unsigned int insn;
9463
9464                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9465                         {
9466                           free (used);
9467                           goto error_ret;
9468                         }
9469                       insn = bfd_get_32 (ibfd, buf);
9470                       if (insn_check == check_lo
9471                           ? !ok_lo_toc_insn (insn, r_type)
9472                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9473                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9474                         {
9475                           char str[12];
9476
9477                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9478                           sprintf (str, "%#08x", insn);
9479                           info->callbacks->einfo
9480                             /* xgettext:c-format */
9481                             (_("%H: toc optimization is not supported for"
9482                                " %s instruction\n"),
9483                              ibfd, sec, rel->r_offset & ~3, str);
9484                         }
9485                     }
9486
9487                   switch (r_type)
9488                     {
9489                     case R_PPC64_TOC16:
9490                     case R_PPC64_TOC16_LO:
9491                     case R_PPC64_TOC16_HI:
9492                     case R_PPC64_TOC16_HA:
9493                     case R_PPC64_TOC16_DS:
9494                     case R_PPC64_TOC16_LO_DS:
9495                       /* In case we're taking addresses of toc entries.  */
9496                     case R_PPC64_ADDR64:
9497                       break;
9498
9499                     default:
9500                       continue;
9501                     }
9502
9503                   r_symndx = ELF64_R_SYM (rel->r_info);
9504                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9505                                   r_symndx, ibfd))
9506                     {
9507                       free (used);
9508                       goto error_ret;
9509                     }
9510
9511                   if (sym_sec != toc)
9512                     continue;
9513
9514                   if (h != NULL)
9515                     val = h->root.u.def.value;
9516                   else
9517                     val = sym->st_value;
9518                   val += rel->r_addend;
9519
9520                   if (val >= toc->size)
9521                     continue;
9522
9523                   if ((skip[val >> 3] & can_optimize) != 0)
9524                     {
9525                       bfd_vma off;
9526                       unsigned char opc;
9527
9528                       switch (r_type)
9529                         {
9530                         case R_PPC64_TOC16_HA:
9531                           break;
9532
9533                         case R_PPC64_TOC16_LO_DS:
9534                           off = rel->r_offset;
9535                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9536                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9537                                                          off, 1))
9538                             {
9539                               free (used);
9540                               goto error_ret;
9541                             }
9542                           if ((opc & (0x3f << 2)) == (58u << 2))
9543                             break;
9544                           /* Fall through.  */
9545
9546                         default:
9547                           /* Wrong sort of reloc, or not a ld.  We may
9548                              as well clear ref_from_discarded too.  */
9549                           skip[val >> 3] = 0;
9550                         }
9551                     }
9552
9553                   if (sec != toc)
9554                     used[val >> 3] = 1;
9555                   /* For the toc section, we only mark as used if this
9556                      entry itself isn't unused.  */
9557                   else if ((used[rel->r_offset >> 3]
9558                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9559                            && !used[val >> 3])
9560                     {
9561                       /* Do all the relocs again, to catch reference
9562                          chains.  */
9563                       repeat = 1;
9564                       used[val >> 3] = 1;
9565                     }
9566                 }
9567             }
9568           while (repeat);
9569
9570           if (elf_section_data (sec)->relocs != relstart)
9571             free (relstart);
9572         }
9573
9574       /* Merge the used and skip arrays.  Assume that TOC
9575          doublewords not appearing as either used or unused belong
9576          to an entry more than one doubleword in size.  */
9577       for (drop = skip, keep = used, last = 0, some_unused = 0;
9578            drop < skip + (toc->size + 7) / 8;
9579            ++drop, ++keep)
9580         {
9581           if (*keep)
9582             {
9583               *drop &= ~ref_from_discarded;
9584               if ((*drop & can_optimize) != 0)
9585                 some_unused = 1;
9586               last = 0;
9587             }
9588           else if ((*drop & ref_from_discarded) != 0)
9589             {
9590               some_unused = 1;
9591               last = ref_from_discarded;
9592             }
9593           else
9594             *drop = last;
9595         }
9596
9597       free (used);
9598
9599       if (some_unused)
9600         {
9601           bfd_byte *contents, *src;
9602           unsigned long off;
9603           Elf_Internal_Sym *sym;
9604           bfd_boolean local_toc_syms = FALSE;
9605
9606           /* Shuffle the toc contents, and at the same time convert the
9607              skip array from booleans into offsets.  */
9608           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9609             goto error_ret;
9610
9611           elf_section_data (toc)->this_hdr.contents = contents;
9612
9613           for (src = contents, off = 0, drop = skip;
9614                src < contents + toc->size;
9615                src += 8, ++drop)
9616             {
9617               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9618                 off += 8;
9619               else if (off != 0)
9620                 {
9621                   *drop = off;
9622                   memcpy (src - off, src, 8);
9623                 }
9624             }
9625           *drop = off;
9626           toc->rawsize = toc->size;
9627           toc->size = src - contents - off;
9628
9629           /* Adjust addends for relocs against the toc section sym,
9630              and optimize any accesses we can.  */
9631           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9632             {
9633               if (sec->reloc_count == 0
9634                   || discarded_section (sec))
9635                 continue;
9636
9637               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9638                                                     info->keep_memory);
9639               if (relstart == NULL)
9640                 goto error_ret;
9641
9642               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9643                 {
9644                   enum elf_ppc64_reloc_type r_type;
9645                   unsigned long r_symndx;
9646                   asection *sym_sec;
9647                   struct elf_link_hash_entry *h;
9648                   bfd_vma val;
9649
9650                   r_type = ELF64_R_TYPE (rel->r_info);
9651                   switch (r_type)
9652                     {
9653                     default:
9654                       continue;
9655
9656                     case R_PPC64_TOC16:
9657                     case R_PPC64_TOC16_LO:
9658                     case R_PPC64_TOC16_HI:
9659                     case R_PPC64_TOC16_HA:
9660                     case R_PPC64_TOC16_DS:
9661                     case R_PPC64_TOC16_LO_DS:
9662                     case R_PPC64_ADDR64:
9663                       break;
9664                     }
9665
9666                   r_symndx = ELF64_R_SYM (rel->r_info);
9667                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9668                                   r_symndx, ibfd))
9669                     goto error_ret;
9670
9671                   if (sym_sec != toc)
9672                     continue;
9673
9674                   if (h != NULL)
9675                     val = h->root.u.def.value;
9676                   else
9677                     {
9678                       val = sym->st_value;
9679                       if (val != 0)
9680                         local_toc_syms = TRUE;
9681                     }
9682
9683                   val += rel->r_addend;
9684
9685                   if (val > toc->rawsize)
9686                     val = toc->rawsize;
9687                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9688                     continue;
9689                   else if ((skip[val >> 3] & can_optimize) != 0)
9690                     {
9691                       Elf_Internal_Rela *tocrel
9692                         = toc_relocs + (skip[val >> 3] >> 2);
9693                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9694
9695                       switch (r_type)
9696                         {
9697                         case R_PPC64_TOC16_HA:
9698                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9699                           break;
9700
9701                         case R_PPC64_TOC16_LO_DS:
9702                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9703                           break;
9704
9705                         default:
9706                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9707                             ppc_howto_init ();
9708                           info->callbacks->einfo
9709                             /* xgettext:c-format */
9710                             (_("%H: %s references "
9711                                "optimized away TOC entry\n"),
9712                              ibfd, sec, rel->r_offset,
9713                              ppc64_elf_howto_table[r_type]->name);
9714                           bfd_set_error (bfd_error_bad_value);
9715                           goto error_ret;
9716                         }
9717                       rel->r_addend = tocrel->r_addend;
9718                       elf_section_data (sec)->relocs = relstart;
9719                       continue;
9720                     }
9721
9722                   if (h != NULL || sym->st_value != 0)
9723                     continue;
9724
9725                   rel->r_addend -= skip[val >> 3];
9726                   elf_section_data (sec)->relocs = relstart;
9727                 }
9728
9729               if (elf_section_data (sec)->relocs != relstart)
9730                 free (relstart);
9731             }
9732
9733           /* We shouldn't have local or global symbols defined in the TOC,
9734              but handle them anyway.  */
9735           if (local_syms != NULL)
9736             for (sym = local_syms;
9737                  sym < local_syms + symtab_hdr->sh_info;
9738                  ++sym)
9739               if (sym->st_value != 0
9740                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9741                 {
9742                   unsigned long i;
9743
9744                   if (sym->st_value > toc->rawsize)
9745                     i = toc->rawsize >> 3;
9746                   else
9747                     i = sym->st_value >> 3;
9748
9749                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9750                     {
9751                       if (local_toc_syms)
9752                         _bfd_error_handler
9753                           (_("%s defined on removed toc entry"),
9754                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9755                       do
9756                         ++i;
9757                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9758                       sym->st_value = (bfd_vma) i << 3;
9759                     }
9760
9761                   sym->st_value -= skip[i];
9762                   symtab_hdr->contents = (unsigned char *) local_syms;
9763                 }
9764
9765           /* Adjust any global syms defined in this toc input section.  */
9766           if (toc_inf.global_toc_syms)
9767             {
9768               toc_inf.toc = toc;
9769               toc_inf.skip = skip;
9770               toc_inf.global_toc_syms = FALSE;
9771               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9772                                       &toc_inf);
9773             }
9774
9775           if (toc->reloc_count != 0)
9776             {
9777               Elf_Internal_Shdr *rel_hdr;
9778               Elf_Internal_Rela *wrel;
9779               bfd_size_type sz;
9780
9781               /* Remove unused toc relocs, and adjust those we keep.  */
9782               if (toc_relocs == NULL)
9783                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9784                                                         info->keep_memory);
9785               if (toc_relocs == NULL)
9786                 goto error_ret;
9787
9788               wrel = toc_relocs;
9789               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9790                 if ((skip[rel->r_offset >> 3]
9791                      & (ref_from_discarded | can_optimize)) == 0)
9792                   {
9793                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9794                     wrel->r_info = rel->r_info;
9795                     wrel->r_addend = rel->r_addend;
9796                     ++wrel;
9797                   }
9798                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9799                                             &local_syms, NULL, NULL))
9800                   goto error_ret;
9801
9802               elf_section_data (toc)->relocs = toc_relocs;
9803               toc->reloc_count = wrel - toc_relocs;
9804               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9805               sz = rel_hdr->sh_entsize;
9806               rel_hdr->sh_size = toc->reloc_count * sz;
9807             }
9808         }
9809       else if (toc_relocs != NULL
9810                && elf_section_data (toc)->relocs != toc_relocs)
9811         free (toc_relocs);
9812
9813       if (local_syms != NULL
9814           && symtab_hdr->contents != (unsigned char *) local_syms)
9815         {
9816           if (!info->keep_memory)
9817             free (local_syms);
9818           else
9819             symtab_hdr->contents = (unsigned char *) local_syms;
9820         }
9821       free (skip);
9822     }
9823
9824   return TRUE;
9825 }
9826
9827 /* Return true iff input section I references the TOC using
9828    instructions limited to +/-32k offsets.  */
9829
9830 bfd_boolean
9831 ppc64_elf_has_small_toc_reloc (asection *i)
9832 {
9833   return (is_ppc64_elf (i->owner)
9834           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9835 }
9836
9837 /* Allocate space for one GOT entry.  */
9838
9839 static void
9840 allocate_got (struct elf_link_hash_entry *h,
9841               struct bfd_link_info *info,
9842               struct got_entry *gent)
9843 {
9844   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9845   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9846   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9847                  ? 16 : 8);
9848   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9849                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9850   asection *got = ppc64_elf_tdata (gent->owner)->got;
9851
9852   gent->got.offset = got->size;
9853   got->size += entsize;
9854
9855   if (h->type == STT_GNU_IFUNC)
9856     {
9857       htab->elf.irelplt->size += rentsize;
9858       htab->got_reli_size += rentsize;
9859     }
9860   else if (((bfd_link_pic (info)
9861              && !((gent->tls_type & TLS_TPREL) != 0
9862                   && bfd_link_executable (info)
9863                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9864             || (htab->elf.dynamic_sections_created
9865                 && h->dynindx != -1
9866                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9867            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9868     {
9869       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9870       relgot->size += rentsize;
9871     }
9872 }
9873
9874 /* This function merges got entries in the same toc group.  */
9875
9876 static void
9877 merge_got_entries (struct got_entry **pent)
9878 {
9879   struct got_entry *ent, *ent2;
9880
9881   for (ent = *pent; ent != NULL; ent = ent->next)
9882     if (!ent->is_indirect)
9883       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9884         if (!ent2->is_indirect
9885             && ent2->addend == ent->addend
9886             && ent2->tls_type == ent->tls_type
9887             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9888           {
9889             ent2->is_indirect = TRUE;
9890             ent2->got.ent = ent;
9891           }
9892 }
9893
9894 /* If H is undefined, make it dynamic if that makes sense.  */
9895
9896 static bfd_boolean
9897 ensure_undef_dynamic (struct bfd_link_info *info,
9898                       struct elf_link_hash_entry *h)
9899 {
9900   struct elf_link_hash_table *htab = elf_hash_table (info);
9901
9902   if (htab->dynamic_sections_created
9903       && ((info->dynamic_undefined_weak != 0
9904            && h->root.type == bfd_link_hash_undefweak)
9905           || h->root.type == bfd_link_hash_undefined)
9906       && h->dynindx == -1
9907       && !h->forced_local
9908       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9909     return bfd_elf_link_record_dynamic_symbol (info, h);
9910   return TRUE;
9911 }
9912
9913 /* Allocate space in .plt, .got and associated reloc sections for
9914    dynamic relocs.  */
9915
9916 static bfd_boolean
9917 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9918 {
9919   struct bfd_link_info *info;
9920   struct ppc_link_hash_table *htab;
9921   asection *s;
9922   struct ppc_link_hash_entry *eh;
9923   struct got_entry **pgent, *gent;
9924
9925   if (h->root.type == bfd_link_hash_indirect)
9926     return TRUE;
9927
9928   info = (struct bfd_link_info *) inf;
9929   htab = ppc_hash_table (info);
9930   if (htab == NULL)
9931     return FALSE;
9932
9933   eh = (struct ppc_link_hash_entry *) h;
9934   /* Run through the TLS GD got entries first if we're changing them
9935      to TPREL.  */
9936   if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
9937     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9938       if (gent->got.refcount > 0
9939           && (gent->tls_type & TLS_GD) != 0)
9940         {
9941           /* This was a GD entry that has been converted to TPREL.  If
9942              there happens to be a TPREL entry we can use that one.  */
9943           struct got_entry *ent;
9944           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9945             if (ent->got.refcount > 0
9946                 && (ent->tls_type & TLS_TPREL) != 0
9947                 && ent->addend == gent->addend
9948                 && ent->owner == gent->owner)
9949               {
9950                 gent->got.refcount = 0;
9951                 break;
9952               }
9953
9954           /* If not, then we'll be using our own TPREL entry.  */
9955           if (gent->got.refcount != 0)
9956             gent->tls_type = TLS_TLS | TLS_TPREL;
9957         }
9958
9959   /* Remove any list entry that won't generate a word in the GOT before
9960      we call merge_got_entries.  Otherwise we risk merging to empty
9961      entries.  */
9962   pgent = &h->got.glist;
9963   while ((gent = *pgent) != NULL)
9964     if (gent->got.refcount > 0)
9965       {
9966         if ((gent->tls_type & TLS_LD) != 0
9967             && !h->def_dynamic)
9968           {
9969             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9970             *pgent = gent->next;
9971           }
9972         else
9973           pgent = &gent->next;
9974       }
9975     else
9976       *pgent = gent->next;
9977
9978   if (!htab->do_multi_toc)
9979     merge_got_entries (&h->got.glist);
9980
9981   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9982     if (!gent->is_indirect)
9983       {
9984         /* Make sure this symbol is output as a dynamic symbol.  */
9985         if (!ensure_undef_dynamic (info, h))
9986           return FALSE;
9987
9988         if (!is_ppc64_elf (gent->owner))
9989           abort ();
9990
9991         allocate_got (h, info, gent);
9992       }
9993
9994   /* If no dynamic sections we can't have dynamic relocs, except for
9995      IFUNCs which are handled even in static executables.  */
9996   if (!htab->elf.dynamic_sections_created
9997       && h->type != STT_GNU_IFUNC)
9998     eh->dyn_relocs = NULL;
9999
10000   /* Discard relocs on undefined symbols that must be local.  */
10001   else if (h->root.type == bfd_link_hash_undefined
10002            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10003     eh->dyn_relocs = NULL;
10004
10005   /* Also discard relocs on undefined weak syms with non-default
10006      visibility, or when dynamic_undefined_weak says so.  */
10007   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10008     eh->dyn_relocs = NULL;
10009
10010   if (eh->dyn_relocs != NULL)
10011     {
10012       struct elf_dyn_relocs *p, **pp;
10013
10014       /* In the shared -Bsymbolic case, discard space allocated for
10015          dynamic pc-relative relocs against symbols which turn out to
10016          be defined in regular objects.  For the normal shared case,
10017          discard space for relocs that have become local due to symbol
10018          visibility changes.  */
10019
10020       if (bfd_link_pic (info))
10021         {
10022           /* Relocs that use pc_count are those that appear on a call
10023              insn, or certain REL relocs (see must_be_dyn_reloc) that
10024              can be generated via assembly.  We want calls to
10025              protected symbols to resolve directly to the function
10026              rather than going via the plt.  If people want function
10027              pointer comparisons to work as expected then they should
10028              avoid writing weird assembly.  */
10029           if (SYMBOL_CALLS_LOCAL (info, h))
10030             {
10031               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10032                 {
10033                   p->count -= p->pc_count;
10034                   p->pc_count = 0;
10035                   if (p->count == 0)
10036                     *pp = p->next;
10037                   else
10038                     pp = &p->next;
10039                 }
10040             }
10041
10042           if (eh->dyn_relocs != NULL)
10043             {
10044               /* Make sure this symbol is output as a dynamic symbol.  */
10045               if (!ensure_undef_dynamic (info, h))
10046                 return FALSE;
10047             }
10048         }
10049       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10050         {
10051           /* For the non-pic case, discard space for relocs against
10052              symbols which turn out to need copy relocs or are not
10053              dynamic.  */
10054           if (h->dynamic_adjusted
10055               && !h->def_regular
10056               && !ELF_COMMON_DEF_P (h))
10057             {
10058               /* Make sure this symbol is output as a dynamic symbol.  */
10059               if (!ensure_undef_dynamic (info, h))
10060                 return FALSE;
10061
10062               if (h->dynindx == -1)
10063                 eh->dyn_relocs = NULL;
10064             }
10065           else
10066             eh->dyn_relocs = NULL;
10067         }
10068
10069       /* Finally, allocate space.  */
10070       for (p = eh->dyn_relocs; p != NULL; p = p->next)
10071         {
10072           asection *sreloc = elf_section_data (p->sec)->sreloc;
10073           if (eh->elf.type == STT_GNU_IFUNC)
10074             sreloc = htab->elf.irelplt;
10075           sreloc->size += p->count * sizeof (Elf64_External_Rela);
10076         }
10077     }
10078
10079   /* We might need a PLT entry when the symbol
10080      a) is dynamic, or
10081      b) is an ifunc, or
10082      c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10083      d) has plt16 relocs and we are linking statically.  */
10084   if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10085       || h->type == STT_GNU_IFUNC
10086       || (h->needs_plt && h->dynamic_adjusted)
10087       || (h->needs_plt
10088           && h->def_regular
10089           && !htab->elf.dynamic_sections_created
10090           && !htab->can_convert_all_inline_plt
10091           && (((struct ppc_link_hash_entry *) h)->tls_mask
10092               & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10093     {
10094       struct plt_entry *pent;
10095       bfd_boolean doneone = FALSE;
10096       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10097         if (pent->plt.refcount > 0)
10098           {
10099             if (!htab->elf.dynamic_sections_created
10100                 || h->dynindx == -1)
10101               {
10102                 if (h->type == STT_GNU_IFUNC)
10103                   {
10104                     s = htab->elf.iplt;
10105                     pent->plt.offset = s->size;
10106                     s->size += PLT_ENTRY_SIZE (htab);
10107                     s = htab->elf.irelplt;
10108                   }
10109                 else
10110                   {
10111                     s = htab->pltlocal;
10112                     pent->plt.offset = s->size;
10113                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10114                     s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10115                   }
10116               }
10117             else
10118               {
10119                 /* If this is the first .plt entry, make room for the special
10120                    first entry.  */
10121                 s = htab->elf.splt;
10122                 if (s->size == 0)
10123                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10124
10125                 pent->plt.offset = s->size;
10126
10127                 /* Make room for this entry.  */
10128                 s->size += PLT_ENTRY_SIZE (htab);
10129
10130                 /* Make room for the .glink code.  */
10131                 s = htab->glink;
10132                 if (s->size == 0)
10133                   s->size += GLINK_PLTRESOLVE_SIZE (htab);
10134                 if (htab->opd_abi)
10135                   {
10136                     /* We need bigger stubs past index 32767.  */
10137                     if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10138                       s->size += 4;
10139                     s->size += 2*4;
10140                   }
10141                 else
10142                   s->size += 4;
10143
10144                 /* We also need to make an entry in the .rela.plt section.  */
10145                 s = htab->elf.srelplt;
10146               }
10147             if (s != NULL)
10148               s->size += sizeof (Elf64_External_Rela);
10149             doneone = TRUE;
10150           }
10151         else
10152           pent->plt.offset = (bfd_vma) -1;
10153       if (!doneone)
10154         {
10155           h->plt.plist = NULL;
10156           h->needs_plt = 0;
10157         }
10158     }
10159   else
10160     {
10161       h->plt.plist = NULL;
10162       h->needs_plt = 0;
10163     }
10164
10165   return TRUE;
10166 }
10167
10168 #define PPC_LO(v) ((v) & 0xffff)
10169 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10170 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10171
10172 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10173    to set up space for global entry stubs.  These are put in glink,
10174    after the branch table.  */
10175
10176 static bfd_boolean
10177 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10178 {
10179   struct bfd_link_info *info;
10180   struct ppc_link_hash_table *htab;
10181   struct plt_entry *pent;
10182   asection *s, *plt;
10183
10184   if (h->root.type == bfd_link_hash_indirect)
10185     return TRUE;
10186
10187   if (!h->pointer_equality_needed)
10188     return TRUE;
10189
10190   if (h->def_regular)
10191     return TRUE;
10192
10193   info = inf;
10194   htab = ppc_hash_table (info);
10195   if (htab == NULL)
10196     return FALSE;
10197
10198   s = htab->global_entry;
10199   plt = htab->elf.splt;
10200   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10201     if (pent->plt.offset != (bfd_vma) -1
10202         && pent->addend == 0)
10203       {
10204         /* For ELFv2, if this symbol is not defined in a regular file
10205            and we are not generating a shared library or pie, then we
10206            need to define the symbol in the executable on a call stub.
10207            This is to avoid text relocations.  */
10208         bfd_vma off, stub_align, stub_off, stub_size;
10209         unsigned int align_power;
10210
10211         stub_size = 16;
10212         stub_off = s->size;
10213         if (htab->params->plt_stub_align >= 0)
10214           align_power = htab->params->plt_stub_align;
10215         else
10216           align_power = -htab->params->plt_stub_align;
10217         /* Setting section alignment is delayed until we know it is
10218            non-empty.  Otherwise the .text output section will be
10219            aligned at least to plt_stub_align even when no global
10220            entry stubs are needed.  */
10221         if (s->alignment_power < align_power)
10222           s->alignment_power = align_power;
10223         stub_align = (bfd_vma) 1 << align_power;
10224         if (htab->params->plt_stub_align >= 0
10225             || ((((stub_off + stub_size - 1) & -stub_align)
10226                  - (stub_off & -stub_align))
10227                 > ((stub_size - 1) & -stub_align)))
10228           stub_off = (stub_off + stub_align - 1) & -stub_align;
10229         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10230         off -= stub_off + s->output_offset + s->output_section->vma;
10231         /* Note that for --plt-stub-align negative we have a possible
10232            dependency between stub offset and size.  Break that
10233            dependency by assuming the max stub size when calculating
10234            the stub offset.  */
10235         if (PPC_HA (off) == 0)
10236           stub_size -= 4;
10237         h->root.type = bfd_link_hash_defined;
10238         h->root.u.def.section = s;
10239         h->root.u.def.value = stub_off;
10240         s->size = stub_off + stub_size;
10241         break;
10242       }
10243   return TRUE;
10244 }
10245
10246 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10247    read-only sections.  */
10248
10249 static bfd_boolean
10250 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10251 {
10252   asection *sec;
10253
10254   if (h->root.type == bfd_link_hash_indirect)
10255     return TRUE;
10256
10257   sec = readonly_dynrelocs (h);
10258   if (sec != NULL)
10259     {
10260       struct bfd_link_info *info = (struct bfd_link_info *) inf;
10261
10262       info->flags |= DF_TEXTREL;
10263       info->callbacks->minfo
10264         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10265          sec->owner, h->root.root.string, sec);
10266
10267       /* Not an error, just cut short the traversal.  */
10268       return FALSE;
10269     }
10270   return TRUE;
10271 }
10272
10273 /* Set the sizes of the dynamic sections.  */
10274
10275 static bfd_boolean
10276 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10277                                  struct bfd_link_info *info)
10278 {
10279   struct ppc_link_hash_table *htab;
10280   bfd *dynobj;
10281   asection *s;
10282   bfd_boolean relocs;
10283   bfd *ibfd;
10284   struct got_entry *first_tlsld;
10285
10286   htab = ppc_hash_table (info);
10287   if (htab == NULL)
10288     return FALSE;
10289
10290   dynobj = htab->elf.dynobj;
10291   if (dynobj == NULL)
10292     abort ();
10293
10294   if (htab->elf.dynamic_sections_created)
10295     {
10296       /* Set the contents of the .interp section to the interpreter.  */
10297       if (bfd_link_executable (info) && !info->nointerp)
10298         {
10299           s = bfd_get_linker_section (dynobj, ".interp");
10300           if (s == NULL)
10301             abort ();
10302           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10303           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10304         }
10305     }
10306
10307   /* Set up .got offsets for local syms, and space for local dynamic
10308      relocs.  */
10309   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10310     {
10311       struct got_entry **lgot_ents;
10312       struct got_entry **end_lgot_ents;
10313       struct plt_entry **local_plt;
10314       struct plt_entry **end_local_plt;
10315       unsigned char *lgot_masks;
10316       bfd_size_type locsymcount;
10317       Elf_Internal_Shdr *symtab_hdr;
10318
10319       if (!is_ppc64_elf (ibfd))
10320         continue;
10321
10322       for (s = ibfd->sections; s != NULL; s = s->next)
10323         {
10324           struct ppc_dyn_relocs *p;
10325
10326           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10327             {
10328               if (!bfd_is_abs_section (p->sec)
10329                   && bfd_is_abs_section (p->sec->output_section))
10330                 {
10331                   /* Input section has been discarded, either because
10332                      it is a copy of a linkonce section or due to
10333                      linker script /DISCARD/, so we'll be discarding
10334                      the relocs too.  */
10335                 }
10336               else if (p->count != 0)
10337                 {
10338                   asection *srel = elf_section_data (p->sec)->sreloc;
10339                   if (p->ifunc)
10340                     srel = htab->elf.irelplt;
10341                   srel->size += p->count * sizeof (Elf64_External_Rela);
10342                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10343                     info->flags |= DF_TEXTREL;
10344                 }
10345             }
10346         }
10347
10348       lgot_ents = elf_local_got_ents (ibfd);
10349       if (!lgot_ents)
10350         continue;
10351
10352       symtab_hdr = &elf_symtab_hdr (ibfd);
10353       locsymcount = symtab_hdr->sh_info;
10354       end_lgot_ents = lgot_ents + locsymcount;
10355       local_plt = (struct plt_entry **) end_lgot_ents;
10356       end_local_plt = local_plt + locsymcount;
10357       lgot_masks = (unsigned char *) end_local_plt;
10358       s = ppc64_elf_tdata (ibfd)->got;
10359       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10360         {
10361           struct got_entry **pent, *ent;
10362
10363           pent = lgot_ents;
10364           while ((ent = *pent) != NULL)
10365             if (ent->got.refcount > 0)
10366               {
10367                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10368                   {
10369                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10370                     *pent = ent->next;
10371                   }
10372                 else
10373                   {
10374                     unsigned int ent_size = 8;
10375                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10376
10377                     ent->got.offset = s->size;
10378                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10379                       {
10380                         ent_size *= 2;
10381                         rel_size *= 2;
10382                       }
10383                     s->size += ent_size;
10384                     if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10385                       {
10386                         htab->elf.irelplt->size += rel_size;
10387                         htab->got_reli_size += rel_size;
10388                       }
10389                     else if (bfd_link_pic (info)
10390                              && !((ent->tls_type & TLS_TPREL) != 0
10391                                   && bfd_link_executable (info)))
10392                       {
10393                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10394                         srel->size += rel_size;
10395                       }
10396                     pent = &ent->next;
10397                   }
10398               }
10399             else
10400               *pent = ent->next;
10401         }
10402
10403       /* Allocate space for plt calls to local syms.  */
10404       lgot_masks = (unsigned char *) end_local_plt;
10405       for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10406         {
10407           struct plt_entry *ent;
10408
10409           for (ent = *local_plt; ent != NULL; ent = ent->next)
10410             if (ent->plt.refcount > 0)
10411               {
10412                 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10413                   {
10414                     s = htab->elf.iplt;
10415                     ent->plt.offset = s->size;
10416                     s->size += PLT_ENTRY_SIZE (htab);
10417                     htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10418                   }
10419                 else if (htab->can_convert_all_inline_plt
10420                          || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10421                   ent->plt.offset = (bfd_vma) -1;
10422                 else
10423                   {
10424                     s = htab->pltlocal;
10425                     ent->plt.offset = s->size;
10426                     s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10427                     if (bfd_link_pic (info))
10428                       htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10429                   }
10430               }
10431             else
10432               ent->plt.offset = (bfd_vma) -1;
10433         }
10434     }
10435
10436   /* Allocate global sym .plt and .got entries, and space for global
10437      sym dynamic relocs.  */
10438   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10439
10440   if (!htab->opd_abi && !bfd_link_pic (info))
10441     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10442
10443   first_tlsld = NULL;
10444   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10445     {
10446       struct got_entry *ent;
10447
10448       if (!is_ppc64_elf (ibfd))
10449         continue;
10450
10451       ent = ppc64_tlsld_got (ibfd);
10452       if (ent->got.refcount > 0)
10453         {
10454           if (!htab->do_multi_toc && first_tlsld != NULL)
10455             {
10456               ent->is_indirect = TRUE;
10457               ent->got.ent = first_tlsld;
10458             }
10459           else
10460             {
10461               if (first_tlsld == NULL)
10462                 first_tlsld = ent;
10463               s = ppc64_elf_tdata (ibfd)->got;
10464               ent->got.offset = s->size;
10465               ent->owner = ibfd;
10466               s->size += 16;
10467               if (bfd_link_pic (info))
10468                 {
10469                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10470                   srel->size += sizeof (Elf64_External_Rela);
10471                 }
10472             }
10473         }
10474       else
10475         ent->got.offset = (bfd_vma) -1;
10476     }
10477
10478   /* We now have determined the sizes of the various dynamic sections.
10479      Allocate memory for them.  */
10480   relocs = FALSE;
10481   for (s = dynobj->sections; s != NULL; s = s->next)
10482     {
10483       if ((s->flags & SEC_LINKER_CREATED) == 0)
10484         continue;
10485
10486       if (s == htab->brlt || s == htab->relbrlt)
10487         /* These haven't been allocated yet;  don't strip.  */
10488         continue;
10489       else if (s == htab->elf.sgot
10490                || s == htab->elf.splt
10491                || s == htab->elf.iplt
10492                || s == htab->pltlocal
10493                || s == htab->glink
10494                || s == htab->global_entry
10495                || s == htab->elf.sdynbss
10496                || s == htab->elf.sdynrelro)
10497         {
10498           /* Strip this section if we don't need it; see the
10499              comment below.  */
10500         }
10501       else if (s == htab->glink_eh_frame)
10502         {
10503           if (!bfd_is_abs_section (s->output_section))
10504             /* Not sized yet.  */
10505             continue;
10506         }
10507       else if (CONST_STRNEQ (s->name, ".rela"))
10508         {
10509           if (s->size != 0)
10510             {
10511               if (s != htab->elf.srelplt)
10512                 relocs = TRUE;
10513
10514               /* We use the reloc_count field as a counter if we need
10515                  to copy relocs into the output file.  */
10516               s->reloc_count = 0;
10517             }
10518         }
10519       else
10520         {
10521           /* It's not one of our sections, so don't allocate space.  */
10522           continue;
10523         }
10524
10525       if (s->size == 0)
10526         {
10527           /* If we don't need this section, strip it from the
10528              output file.  This is mostly to handle .rela.bss and
10529              .rela.plt.  We must create both sections in
10530              create_dynamic_sections, because they must be created
10531              before the linker maps input sections to output
10532              sections.  The linker does that before
10533              adjust_dynamic_symbol is called, and it is that
10534              function which decides whether anything needs to go
10535              into these sections.  */
10536           s->flags |= SEC_EXCLUDE;
10537           continue;
10538         }
10539
10540       if (bfd_is_abs_section (s->output_section))
10541         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10542                             s->name);
10543
10544       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10545         continue;
10546
10547       /* Allocate memory for the section contents.  We use bfd_zalloc
10548          here in case unused entries are not reclaimed before the
10549          section's contents are written out.  This should not happen,
10550          but this way if it does we get a R_PPC64_NONE reloc in .rela
10551          sections instead of garbage.
10552          We also rely on the section contents being zero when writing
10553          the GOT and .dynrelro.  */
10554       s->contents = bfd_zalloc (dynobj, s->size);
10555       if (s->contents == NULL)
10556         return FALSE;
10557     }
10558
10559   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10560     {
10561       if (!is_ppc64_elf (ibfd))
10562         continue;
10563
10564       s = ppc64_elf_tdata (ibfd)->got;
10565       if (s != NULL && s != htab->elf.sgot)
10566         {
10567           if (s->size == 0)
10568             s->flags |= SEC_EXCLUDE;
10569           else
10570             {
10571               s->contents = bfd_zalloc (ibfd, s->size);
10572               if (s->contents == NULL)
10573                 return FALSE;
10574             }
10575         }
10576       s = ppc64_elf_tdata (ibfd)->relgot;
10577       if (s != NULL)
10578         {
10579           if (s->size == 0)
10580             s->flags |= SEC_EXCLUDE;
10581           else
10582             {
10583               s->contents = bfd_zalloc (ibfd, s->size);
10584               if (s->contents == NULL)
10585                 return FALSE;
10586               relocs = TRUE;
10587               s->reloc_count = 0;
10588             }
10589         }
10590     }
10591
10592   if (htab->elf.dynamic_sections_created)
10593     {
10594       bfd_boolean tls_opt;
10595
10596       /* Add some entries to the .dynamic section.  We fill in the
10597          values later, in ppc64_elf_finish_dynamic_sections, but we
10598          must add the entries now so that we get the correct size for
10599          the .dynamic section.  The DT_DEBUG entry is filled in by the
10600          dynamic linker and used by the debugger.  */
10601 #define add_dynamic_entry(TAG, VAL) \
10602   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10603
10604       if (bfd_link_executable (info))
10605         {
10606           if (!add_dynamic_entry (DT_DEBUG, 0))
10607             return FALSE;
10608         }
10609
10610       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10611         {
10612           if (!add_dynamic_entry (DT_PLTGOT, 0)
10613               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10614               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10615               || !add_dynamic_entry (DT_JMPREL, 0)
10616               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10617             return FALSE;
10618         }
10619
10620       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10621         {
10622           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10623               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10624             return FALSE;
10625         }
10626
10627       tls_opt = (htab->params->tls_get_addr_opt
10628                  && htab->tls_get_addr_fd != NULL
10629                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10630       if (tls_opt || !htab->opd_abi)
10631         {
10632           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10633             return FALSE;
10634         }
10635
10636       if (relocs)
10637         {
10638           if (!add_dynamic_entry (DT_RELA, 0)
10639               || !add_dynamic_entry (DT_RELASZ, 0)
10640               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10641             return FALSE;
10642
10643           /* If any dynamic relocs apply to a read-only section,
10644              then we need a DT_TEXTREL entry.  */
10645           if ((info->flags & DF_TEXTREL) == 0)
10646             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10647
10648           if ((info->flags & DF_TEXTREL) != 0)
10649             {
10650               if (!add_dynamic_entry (DT_TEXTREL, 0))
10651                 return FALSE;
10652             }
10653         }
10654     }
10655 #undef add_dynamic_entry
10656
10657   return TRUE;
10658 }
10659
10660 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10661
10662 static bfd_boolean
10663 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10664 {
10665   if (h->plt.plist != NULL
10666       && !h->def_regular
10667       && !h->pointer_equality_needed)
10668     return FALSE;
10669
10670   return _bfd_elf_hash_symbol (h);
10671 }
10672
10673 /* Determine the type of stub needed, if any, for a call.  */
10674
10675 static inline enum ppc_stub_type
10676 ppc_type_of_stub (asection *input_sec,
10677                   const Elf_Internal_Rela *rel,
10678                   struct ppc_link_hash_entry **hash,
10679                   struct plt_entry **plt_ent,
10680                   bfd_vma destination,
10681                   unsigned long local_off)
10682 {
10683   struct ppc_link_hash_entry *h = *hash;
10684   bfd_vma location;
10685   bfd_vma branch_offset;
10686   bfd_vma max_branch_offset;
10687   enum elf_ppc64_reloc_type r_type;
10688
10689   if (h != NULL)
10690     {
10691       struct plt_entry *ent;
10692       struct ppc_link_hash_entry *fdh = h;
10693       if (h->oh != NULL
10694           && h->oh->is_func_descriptor)
10695         {
10696           fdh = ppc_follow_link (h->oh);
10697           *hash = fdh;
10698         }
10699
10700       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10701         if (ent->addend == rel->r_addend
10702             && ent->plt.offset != (bfd_vma) -1)
10703           {
10704             *plt_ent = ent;
10705             return ppc_stub_plt_call;
10706           }
10707
10708       /* Here, we know we don't have a plt entry.  If we don't have a
10709          either a defined function descriptor or a defined entry symbol
10710          in a regular object file, then it is pointless trying to make
10711          any other type of stub.  */
10712       if (!is_static_defined (&fdh->elf)
10713           && !is_static_defined (&h->elf))
10714         return ppc_stub_none;
10715     }
10716   else if (elf_local_got_ents (input_sec->owner) != NULL)
10717     {
10718       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10719       struct plt_entry **local_plt = (struct plt_entry **)
10720         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10721       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10722
10723       if (local_plt[r_symndx] != NULL)
10724         {
10725           struct plt_entry *ent;
10726
10727           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10728             if (ent->addend == rel->r_addend
10729                 && ent->plt.offset != (bfd_vma) -1)
10730               {
10731                 *plt_ent = ent;
10732                 return ppc_stub_plt_call;
10733               }
10734         }
10735     }
10736
10737   /* Determine where the call point is.  */
10738   location = (input_sec->output_offset
10739               + input_sec->output_section->vma
10740               + rel->r_offset);
10741
10742   branch_offset = destination - location;
10743   r_type = ELF64_R_TYPE (rel->r_info);
10744
10745   /* Determine if a long branch stub is needed.  */
10746   max_branch_offset = 1 << 25;
10747   if (r_type == R_PPC64_REL14
10748       || r_type == R_PPC64_REL14_BRTAKEN
10749       || r_type == R_PPC64_REL14_BRNTAKEN)
10750     max_branch_offset = 1 << 15;
10751
10752   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10753     /* We need a stub.  Figure out whether a long_branch or plt_branch
10754        is needed later.  */
10755     return ppc_stub_long_branch;
10756
10757   return ppc_stub_none;
10758 }
10759
10760 /* With power7 weakly ordered memory model, it is possible for ld.so
10761    to update a plt entry in one thread and have another thread see a
10762    stale zero toc entry.  To avoid this we need some sort of acquire
10763    barrier in the call stub.  One solution is to make the load of the
10764    toc word seem to appear to depend on the load of the function entry
10765    word.  Another solution is to test for r2 being zero, and branch to
10766    the appropriate glink entry if so.
10767
10768    .    fake dep barrier        compare
10769    .    ld 12,xxx(2)            ld 12,xxx(2)
10770    .    mtctr 12                mtctr 12
10771    .    xor 11,12,12            ld 2,xxx+8(2)
10772    .    add 2,2,11              cmpldi 2,0
10773    .    ld 2,xxx+8(2)           bnectr+
10774    .    bctr                    b <glink_entry>
10775
10776    The solution involving the compare turns out to be faster, so
10777    that's what we use unless the branch won't reach.  */
10778
10779 #define ALWAYS_USE_FAKE_DEP 0
10780 #define ALWAYS_EMIT_R2SAVE 0
10781
10782 static inline unsigned int
10783 plt_stub_size (struct ppc_link_hash_table *htab,
10784                struct ppc_stub_hash_entry *stub_entry,
10785                bfd_vma off)
10786 {
10787   unsigned size = 12;
10788
10789   if (ALWAYS_EMIT_R2SAVE
10790       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10791     size += 4;
10792   if (PPC_HA (off) != 0)
10793     size += 4;
10794   if (htab->opd_abi)
10795     {
10796       size += 4;
10797       if (htab->params->plt_static_chain)
10798         size += 4;
10799       if (htab->params->plt_thread_safe
10800           && htab->elf.dynamic_sections_created
10801           && stub_entry->h != NULL
10802           && stub_entry->h->elf.dynindx != -1)
10803         size += 8;
10804       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10805         size += 4;
10806     }
10807   if (stub_entry->h != NULL
10808       && (stub_entry->h == htab->tls_get_addr_fd
10809           || stub_entry->h == htab->tls_get_addr)
10810       && htab->params->tls_get_addr_opt)
10811     {
10812       size += 7 * 4;
10813       if (ALWAYS_EMIT_R2SAVE
10814           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10815         size += 6 * 4;
10816     }
10817   return size;
10818 }
10819
10820 /* Depending on the sign of plt_stub_align:
10821    If positive, return the padding to align to a 2**plt_stub_align
10822    boundary.
10823    If negative, if this stub would cross fewer 2**plt_stub_align
10824    boundaries if we align, then return the padding needed to do so.  */
10825
10826 static inline unsigned int
10827 plt_stub_pad (struct ppc_link_hash_table *htab,
10828               struct ppc_stub_hash_entry *stub_entry,
10829               bfd_vma plt_off)
10830 {
10831   int stub_align;
10832   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10833   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10834
10835   if (htab->params->plt_stub_align >= 0)
10836     {
10837       stub_align = 1 << htab->params->plt_stub_align;
10838       if ((stub_off & (stub_align - 1)) != 0)
10839         return stub_align - (stub_off & (stub_align - 1));
10840       return 0;
10841     }
10842
10843   stub_align = 1 << -htab->params->plt_stub_align;
10844   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10845       > ((stub_size - 1) & -stub_align))
10846     return stub_align - (stub_off & (stub_align - 1));
10847   return 0;
10848 }
10849
10850 /* Build a .plt call stub.  */
10851
10852 static inline bfd_byte *
10853 build_plt_stub (struct ppc_link_hash_table *htab,
10854                 struct ppc_stub_hash_entry *stub_entry,
10855                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10856 {
10857   bfd *obfd = htab->params->stub_bfd;
10858   bfd_boolean plt_load_toc = htab->opd_abi;
10859   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10860   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10861                                  && htab->elf.dynamic_sections_created
10862                                  && stub_entry->h != NULL
10863                                  && stub_entry->h->elf.dynindx != -1);
10864   bfd_boolean use_fake_dep = plt_thread_safe;
10865   bfd_vma cmp_branch_off = 0;
10866
10867   if (!ALWAYS_USE_FAKE_DEP
10868       && plt_load_toc
10869       && plt_thread_safe
10870       && !((stub_entry->h == htab->tls_get_addr_fd
10871             || stub_entry->h == htab->tls_get_addr)
10872            && htab->params->tls_get_addr_opt))
10873     {
10874       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10875       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10876                           / PLT_ENTRY_SIZE (htab));
10877       bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10878       bfd_vma to, from;
10879
10880       if (pltindex > 32768)
10881         glinkoff += (pltindex - 32768) * 4;
10882       to = (glinkoff
10883             + htab->glink->output_offset
10884             + htab->glink->output_section->vma);
10885       from = (p - stub_entry->group->stub_sec->contents
10886               + 4 * (ALWAYS_EMIT_R2SAVE
10887                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10888               + 4 * (PPC_HA (offset) != 0)
10889               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10890                      != PPC_HA (offset))
10891               + 4 * (plt_static_chain != 0)
10892               + 20
10893               + stub_entry->group->stub_sec->output_offset
10894               + stub_entry->group->stub_sec->output_section->vma);
10895       cmp_branch_off = to - from;
10896       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10897     }
10898
10899   if (PPC_HA (offset) != 0)
10900     {
10901       if (r != NULL)
10902         {
10903           if (ALWAYS_EMIT_R2SAVE
10904               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10905             r[0].r_offset += 4;
10906           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10907           r[1].r_offset = r[0].r_offset + 4;
10908           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10909           r[1].r_addend = r[0].r_addend;
10910           if (plt_load_toc)
10911             {
10912               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10913                 {
10914                   r[2].r_offset = r[1].r_offset + 4;
10915                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10916                   r[2].r_addend = r[0].r_addend;
10917                 }
10918               else
10919                 {
10920                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10921                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10922                   r[2].r_addend = r[0].r_addend + 8;
10923                   if (plt_static_chain)
10924                     {
10925                       r[3].r_offset = r[2].r_offset + 4;
10926                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10927                       r[3].r_addend = r[0].r_addend + 16;
10928                     }
10929                 }
10930             }
10931         }
10932       if (ALWAYS_EMIT_R2SAVE
10933           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10934         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10935       if (plt_load_toc)
10936         {
10937           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10938           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10939         }
10940       else
10941         {
10942           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10943           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10944         }
10945       if (plt_load_toc
10946           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10947         {
10948           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10949           offset = 0;
10950         }
10951       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10952       if (plt_load_toc)
10953         {
10954           if (use_fake_dep)
10955             {
10956               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10957               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10958             }
10959           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10960           if (plt_static_chain)
10961             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10962         }
10963     }
10964   else
10965     {
10966       if (r != NULL)
10967         {
10968           if (ALWAYS_EMIT_R2SAVE
10969               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10970             r[0].r_offset += 4;
10971           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10972           if (plt_load_toc)
10973             {
10974               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10975                 {
10976                   r[1].r_offset = r[0].r_offset + 4;
10977                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10978                   r[1].r_addend = r[0].r_addend;
10979                 }
10980               else
10981                 {
10982                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10983                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10984                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10985                   if (plt_static_chain)
10986                     {
10987                       r[2].r_offset = r[1].r_offset + 4;
10988                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10989                       r[2].r_addend = r[0].r_addend + 8;
10990                     }
10991                 }
10992             }
10993         }
10994       if (ALWAYS_EMIT_R2SAVE
10995           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10996         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10997       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10998       if (plt_load_toc
10999           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11000         {
11001           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
11002           offset = 0;
11003         }
11004       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
11005       if (plt_load_toc)
11006         {
11007           if (use_fake_dep)
11008             {
11009               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
11010               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
11011             }
11012           if (plt_static_chain)
11013             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11014           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11015         }
11016     }
11017   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11018     {
11019       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
11020       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
11021       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11022     }
11023   else
11024     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
11025   return p;
11026 }
11027
11028 /* Build a special .plt call stub for __tls_get_addr.  */
11029
11030 #define LD_R11_0R3      0xe9630000
11031 #define LD_R12_0R3      0xe9830000
11032 #define MR_R0_R3        0x7c601b78
11033 #define CMPDI_R11_0     0x2c2b0000
11034 #define ADD_R3_R12_R13  0x7c6c6a14
11035 #define BEQLR           0x4d820020
11036 #define MR_R3_R0        0x7c030378
11037 #define STD_R11_0R1     0xf9610000
11038 #define BCTRL           0x4e800421
11039 #define LD_R11_0R1      0xe9610000
11040 #define MTLR_R11        0x7d6803a6
11041
11042 static inline bfd_byte *
11043 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11044                          struct ppc_stub_hash_entry *stub_entry,
11045                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11046 {
11047   bfd *obfd = htab->params->stub_bfd;
11048
11049   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
11050   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
11051   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
11052   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
11053   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
11054   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
11055   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
11056   if (r != NULL)
11057     r[0].r_offset += 7 * 4;
11058   if (!ALWAYS_EMIT_R2SAVE
11059       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
11060     return build_plt_stub (htab, stub_entry, p, offset, r);
11061
11062   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
11063   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11064
11065   if (r != NULL)
11066     r[0].r_offset += 2 * 4;
11067   p = build_plt_stub (htab, stub_entry, p, offset, r);
11068   bfd_put_32 (obfd, BCTRL, p - 4);
11069
11070   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
11071   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11072   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
11073   bfd_put_32 (obfd, BLR, p),                    p += 4;
11074
11075   return p;
11076 }
11077
11078 static Elf_Internal_Rela *
11079 get_relocs (asection *sec, int count)
11080 {
11081   Elf_Internal_Rela *relocs;
11082   struct bfd_elf_section_data *elfsec_data;
11083
11084   elfsec_data = elf_section_data (sec);
11085   relocs = elfsec_data->relocs;
11086   if (relocs == NULL)
11087     {
11088       bfd_size_type relsize;
11089       relsize = sec->reloc_count * sizeof (*relocs);
11090       relocs = bfd_alloc (sec->owner, relsize);
11091       if (relocs == NULL)
11092         return NULL;
11093       elfsec_data->relocs = relocs;
11094       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11095                                           sizeof (Elf_Internal_Shdr));
11096       if (elfsec_data->rela.hdr == NULL)
11097         return NULL;
11098       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11099                                         * sizeof (Elf64_External_Rela));
11100       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11101       sec->reloc_count = 0;
11102     }
11103   relocs += sec->reloc_count;
11104   sec->reloc_count += count;
11105   return relocs;
11106 }
11107
11108 static bfd_vma
11109 get_r2off (struct bfd_link_info *info,
11110            struct ppc_stub_hash_entry *stub_entry)
11111 {
11112   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11113   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11114
11115   if (r2off == 0)
11116     {
11117       /* Support linking -R objects.  Get the toc pointer from the
11118          opd entry.  */
11119       char buf[8];
11120       if (!htab->opd_abi)
11121         return r2off;
11122       asection *opd = stub_entry->h->elf.root.u.def.section;
11123       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11124
11125       if (strcmp (opd->name, ".opd") != 0
11126           || opd->reloc_count != 0)
11127         {
11128           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11129                                   stub_entry->h->elf.root.root.string);
11130           bfd_set_error (bfd_error_bad_value);
11131           return (bfd_vma) -1;
11132         }
11133       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11134         return (bfd_vma) -1;
11135       r2off = bfd_get_64 (opd->owner, buf);
11136       r2off -= elf_gp (info->output_bfd);
11137     }
11138   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11139   return r2off;
11140 }
11141
11142 static bfd_boolean
11143 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11144 {
11145   struct ppc_stub_hash_entry *stub_entry;
11146   struct ppc_branch_hash_entry *br_entry;
11147   struct bfd_link_info *info;
11148   struct ppc_link_hash_table *htab;
11149   bfd_byte *loc;
11150   bfd_byte *p;
11151   bfd_vma dest, off;
11152   Elf_Internal_Rela *r;
11153   asection *plt;
11154
11155   /* Massage our args to the form they really have.  */
11156   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11157   info = in_arg;
11158
11159   htab = ppc_hash_table (info);
11160   if (htab == NULL)
11161     return FALSE;
11162
11163   /* Make a note of the offset within the stubs for this entry.  */
11164   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11165   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11166
11167   htab->stub_count[stub_entry->stub_type - 1] += 1;
11168   switch (stub_entry->stub_type)
11169     {
11170     case ppc_stub_long_branch:
11171     case ppc_stub_long_branch_r2off:
11172       /* Branches are relative.  This is where we are going to.  */
11173       dest = (stub_entry->target_value
11174               + stub_entry->target_section->output_offset
11175               + stub_entry->target_section->output_section->vma);
11176       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11177       off = dest;
11178
11179       /* And this is where we are coming from.  */
11180       off -= (stub_entry->stub_offset
11181               + stub_entry->group->stub_sec->output_offset
11182               + stub_entry->group->stub_sec->output_section->vma);
11183
11184       p = loc;
11185       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11186         {
11187           bfd_vma r2off = get_r2off (info, stub_entry);
11188
11189           if (r2off == (bfd_vma) -1)
11190             {
11191               htab->stub_error = TRUE;
11192               return FALSE;
11193             }
11194           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11195           p += 4;
11196           if (PPC_HA (r2off) != 0)
11197             {
11198               bfd_put_32 (htab->params->stub_bfd,
11199                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11200               p += 4;
11201             }
11202           if (PPC_LO (r2off) != 0)
11203             {
11204               bfd_put_32 (htab->params->stub_bfd,
11205                           ADDI_R2_R2 | PPC_LO (r2off), p);
11206               p += 4;
11207             }
11208           off -= p - loc;
11209         }
11210       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11211       p += 4;
11212
11213       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11214         {
11215           _bfd_error_handler
11216             (_("long branch stub `%s' offset overflow"),
11217              stub_entry->root.string);
11218           htab->stub_error = TRUE;
11219           return FALSE;
11220         }
11221
11222       if (info->emitrelocations)
11223         {
11224           r = get_relocs (stub_entry->group->stub_sec, 1);
11225           if (r == NULL)
11226             return FALSE;
11227           r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11228           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11229           r->r_addend = dest;
11230           if (stub_entry->h != NULL)
11231             {
11232               struct elf_link_hash_entry **hashes;
11233               unsigned long symndx;
11234               struct ppc_link_hash_entry *h;
11235
11236               hashes = elf_sym_hashes (htab->params->stub_bfd);
11237               if (hashes == NULL)
11238                 {
11239                   bfd_size_type hsize;
11240
11241                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11242                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11243                   if (hashes == NULL)
11244                     return FALSE;
11245                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11246                   htab->stub_globals = 1;
11247                 }
11248               symndx = htab->stub_globals++;
11249               h = stub_entry->h;
11250               hashes[symndx] = &h->elf;
11251               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11252               if (h->oh != NULL && h->oh->is_func)
11253                 h = ppc_follow_link (h->oh);
11254               if (h->elf.root.u.def.section != stub_entry->target_section)
11255                 /* H is an opd symbol.  The addend must be zero.  */
11256                 r->r_addend = 0;
11257               else
11258                 {
11259                   off = (h->elf.root.u.def.value
11260                          + h->elf.root.u.def.section->output_offset
11261                          + h->elf.root.u.def.section->output_section->vma);
11262                   r->r_addend -= off;
11263                 }
11264             }
11265         }
11266       break;
11267
11268     case ppc_stub_plt_branch:
11269     case ppc_stub_plt_branch_r2off:
11270       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11271                                          stub_entry->root.string + 9,
11272                                          FALSE, FALSE);
11273       if (br_entry == NULL)
11274         {
11275           _bfd_error_handler (_("can't find branch stub `%s'"),
11276                               stub_entry->root.string);
11277           htab->stub_error = TRUE;
11278           return FALSE;
11279         }
11280
11281       dest = (stub_entry->target_value
11282               + stub_entry->target_section->output_offset
11283               + stub_entry->target_section->output_section->vma);
11284       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11285         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11286
11287       bfd_put_64 (htab->brlt->owner, dest,
11288                   htab->brlt->contents + br_entry->offset);
11289
11290       if (br_entry->iter == htab->stub_iteration)
11291         {
11292           br_entry->iter = 0;
11293
11294           if (htab->relbrlt != NULL)
11295             {
11296               /* Create a reloc for the branch lookup table entry.  */
11297               Elf_Internal_Rela rela;
11298               bfd_byte *rl;
11299
11300               rela.r_offset = (br_entry->offset
11301                                + htab->brlt->output_offset
11302                                + htab->brlt->output_section->vma);
11303               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11304               rela.r_addend = dest;
11305
11306               rl = htab->relbrlt->contents;
11307               rl += (htab->relbrlt->reloc_count++
11308                      * sizeof (Elf64_External_Rela));
11309               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11310             }
11311           else if (info->emitrelocations)
11312             {
11313               r = get_relocs (htab->brlt, 1);
11314               if (r == NULL)
11315                 return FALSE;
11316               /* brlt, being SEC_LINKER_CREATED does not go through the
11317                  normal reloc processing.  Symbols and offsets are not
11318                  translated from input file to output file form, so
11319                  set up the offset per the output file.  */
11320               r->r_offset = (br_entry->offset
11321                              + htab->brlt->output_offset
11322                              + htab->brlt->output_section->vma);
11323               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11324               r->r_addend = dest;
11325             }
11326         }
11327
11328       dest = (br_entry->offset
11329               + htab->brlt->output_offset
11330               + htab->brlt->output_section->vma);
11331
11332       off = (dest
11333              - elf_gp (info->output_bfd)
11334              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11335
11336       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11337         {
11338           info->callbacks->einfo
11339             (_("%P: linkage table error against `%pT'\n"),
11340              stub_entry->root.string);
11341           bfd_set_error (bfd_error_bad_value);
11342           htab->stub_error = TRUE;
11343           return FALSE;
11344         }
11345
11346       if (info->emitrelocations)
11347         {
11348           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11349           if (r == NULL)
11350             return FALSE;
11351           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11352           if (bfd_big_endian (info->output_bfd))
11353             r[0].r_offset += 2;
11354           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11355             r[0].r_offset += 4;
11356           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11357           r[0].r_addend = dest;
11358           if (PPC_HA (off) != 0)
11359             {
11360               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11361               r[1].r_offset = r[0].r_offset + 4;
11362               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11363               r[1].r_addend = r[0].r_addend;
11364             }
11365         }
11366
11367       p = loc;
11368       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11369         {
11370           if (PPC_HA (off) != 0)
11371             {
11372               bfd_put_32 (htab->params->stub_bfd,
11373                           ADDIS_R12_R2 | PPC_HA (off), p);
11374               p += 4;
11375               bfd_put_32 (htab->params->stub_bfd,
11376                           LD_R12_0R12 | PPC_LO (off), p);
11377             }
11378           else
11379             bfd_put_32 (htab->params->stub_bfd,
11380                         LD_R12_0R2 | PPC_LO (off), p);
11381         }
11382       else
11383         {
11384           bfd_vma r2off = get_r2off (info, stub_entry);
11385
11386           if (r2off == (bfd_vma) -1)
11387             {
11388               htab->stub_error = TRUE;
11389               return FALSE;
11390             }
11391
11392           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11393           p += 4;
11394           if (PPC_HA (off) != 0)
11395             {
11396               bfd_put_32 (htab->params->stub_bfd,
11397                           ADDIS_R12_R2 | PPC_HA (off), p);
11398               p += 4;
11399               bfd_put_32 (htab->params->stub_bfd,
11400                           LD_R12_0R12 | PPC_LO (off), p);
11401             }
11402           else
11403             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11404
11405           if (PPC_HA (r2off) != 0)
11406             {
11407               p += 4;
11408               bfd_put_32 (htab->params->stub_bfd,
11409                           ADDIS_R2_R2 | PPC_HA (r2off), p);
11410             }
11411           if (PPC_LO (r2off) != 0)
11412             {
11413               p += 4;
11414               bfd_put_32 (htab->params->stub_bfd,
11415                           ADDI_R2_R2 | PPC_LO (r2off), p);
11416             }
11417         }
11418       p += 4;
11419       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11420       p += 4;
11421       bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11422       p += 4;
11423       break;
11424
11425     case ppc_stub_plt_call:
11426     case ppc_stub_plt_call_r2save:
11427       if (stub_entry->h != NULL
11428           && stub_entry->h->is_func_descriptor
11429           && stub_entry->h->oh != NULL)
11430         {
11431           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11432
11433           /* If the old-ABI "dot-symbol" is undefined make it weak so
11434              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11435           if (fh->elf.root.type == bfd_link_hash_undefined
11436               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11437                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11438             fh->elf.root.type = bfd_link_hash_undefweak;
11439         }
11440
11441       /* Now build the stub.  */
11442       dest = stub_entry->plt_ent->plt.offset & ~1;
11443       if (dest >= (bfd_vma) -2)
11444         abort ();
11445
11446       plt = htab->elf.splt;
11447       if (!htab->elf.dynamic_sections_created
11448           || stub_entry->h == NULL
11449           || stub_entry->h->elf.dynindx == -1)
11450         {
11451           if (stub_entry->symtype == STT_GNU_IFUNC)
11452             plt = htab->elf.iplt;
11453           else
11454             plt = htab->pltlocal;
11455         }
11456
11457       dest += plt->output_offset + plt->output_section->vma;
11458
11459       off = (dest
11460              - elf_gp (info->output_bfd)
11461              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11462
11463       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11464         {
11465           info->callbacks->einfo
11466             /* xgettext:c-format */
11467             (_("%P: linkage table error against `%pT'\n"),
11468              stub_entry->h != NULL
11469              ? stub_entry->h->elf.root.root.string
11470              : "<local sym>");
11471           bfd_set_error (bfd_error_bad_value);
11472           htab->stub_error = TRUE;
11473           return FALSE;
11474         }
11475
11476       if (htab->params->plt_stub_align != 0)
11477         {
11478           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11479
11480           stub_entry->group->stub_sec->size += pad;
11481           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11482           loc += pad;
11483         }
11484
11485       r = NULL;
11486       if (info->emitrelocations)
11487         {
11488           r = get_relocs (stub_entry->group->stub_sec,
11489                           ((PPC_HA (off) != 0)
11490                            + (htab->opd_abi
11491                               ? 2 + (htab->params->plt_static_chain
11492                                      && PPC_HA (off + 16) == PPC_HA (off))
11493                               : 1)));
11494           if (r == NULL)
11495             return FALSE;
11496           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11497           if (bfd_big_endian (info->output_bfd))
11498             r[0].r_offset += 2;
11499           r[0].r_addend = dest;
11500         }
11501       if (stub_entry->h != NULL
11502           && (stub_entry->h == htab->tls_get_addr_fd
11503               || stub_entry->h == htab->tls_get_addr)
11504           && htab->params->tls_get_addr_opt)
11505         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11506       else
11507         p = build_plt_stub (htab, stub_entry, loc, off, r);
11508       break;
11509
11510     case ppc_stub_save_res:
11511       return TRUE;
11512
11513     default:
11514       BFD_FAIL ();
11515       return FALSE;
11516     }
11517
11518   stub_entry->group->stub_sec->size += p - loc;
11519
11520   if (htab->params->emit_stub_syms)
11521     {
11522       struct elf_link_hash_entry *h;
11523       size_t len1, len2;
11524       char *name;
11525       const char *const stub_str[] = { "long_branch",
11526                                        "long_branch_r2off",
11527                                        "plt_branch",
11528                                        "plt_branch_r2off",
11529                                        "plt_call",
11530                                        "plt_call" };
11531
11532       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11533       len2 = strlen (stub_entry->root.string);
11534       name = bfd_malloc (len1 + len2 + 2);
11535       if (name == NULL)
11536         return FALSE;
11537       memcpy (name, stub_entry->root.string, 9);
11538       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11539       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11540       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11541       if (h == NULL)
11542         return FALSE;
11543       if (h->root.type == bfd_link_hash_new)
11544         {
11545           h->root.type = bfd_link_hash_defined;
11546           h->root.u.def.section = stub_entry->group->stub_sec;
11547           h->root.u.def.value = stub_entry->stub_offset;
11548           h->ref_regular = 1;
11549           h->def_regular = 1;
11550           h->ref_regular_nonweak = 1;
11551           h->forced_local = 1;
11552           h->non_elf = 0;
11553           h->root.linker_def = 1;
11554         }
11555     }
11556
11557   return TRUE;
11558 }
11559
11560 /* As above, but don't actually build the stub.  Just bump offset so
11561    we know stub section sizes, and select plt_branch stubs where
11562    long_branch stubs won't do.  */
11563
11564 static bfd_boolean
11565 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11566 {
11567   struct ppc_stub_hash_entry *stub_entry;
11568   struct bfd_link_info *info;
11569   struct ppc_link_hash_table *htab;
11570   bfd_vma off;
11571   int size;
11572
11573   /* Massage our args to the form they really have.  */
11574   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11575   info = in_arg;
11576
11577   htab = ppc_hash_table (info);
11578   if (htab == NULL)
11579     return FALSE;
11580
11581   if (stub_entry->h != NULL
11582       && stub_entry->h->save_res
11583       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11584       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11585     {
11586       /* Don't make stubs to out-of-line register save/restore
11587          functions.  Instead, emit copies of the functions.  */
11588       stub_entry->group->needs_save_res = 1;
11589       stub_entry->stub_type = ppc_stub_save_res;
11590       return TRUE;
11591     }
11592
11593   if (stub_entry->stub_type == ppc_stub_plt_call
11594       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11595     {
11596       asection *plt;
11597       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11598       if (off >= (bfd_vma) -2)
11599         abort ();
11600       plt = htab->elf.splt;
11601       if (!htab->elf.dynamic_sections_created
11602           || stub_entry->h == NULL
11603           || stub_entry->h->elf.dynindx == -1)
11604         {
11605           if (stub_entry->symtype == STT_GNU_IFUNC)
11606             plt = htab->elf.iplt;
11607           else
11608             plt = htab->pltlocal;
11609         }
11610       off += (plt->output_offset
11611               + plt->output_section->vma
11612               - elf_gp (info->output_bfd)
11613               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11614
11615       size = plt_stub_size (htab, stub_entry, off);
11616       if (stub_entry->h != NULL
11617           && (stub_entry->h == htab->tls_get_addr_fd
11618               || stub_entry->h == htab->tls_get_addr)
11619           && htab->params->tls_get_addr_opt
11620           && (ALWAYS_EMIT_R2SAVE
11621               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11622         stub_entry->group->tls_get_addr_opt_bctrl
11623           = stub_entry->group->stub_sec->size + size - 5 * 4;
11624
11625       if (htab->params->plt_stub_align)
11626         size += plt_stub_pad (htab, stub_entry, off);
11627       if (info->emitrelocations)
11628         {
11629           stub_entry->group->stub_sec->reloc_count
11630             += ((PPC_HA (off) != 0)
11631                 + (htab->opd_abi
11632                    ? 2 + (htab->params->plt_static_chain
11633                           && PPC_HA (off + 16) == PPC_HA (off))
11634                    : 1));
11635           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11636         }
11637     }
11638   else
11639     {
11640       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11641          variants.  */
11642       bfd_vma r2off = 0;
11643       bfd_vma local_off = 0;
11644
11645       off = (stub_entry->target_value
11646              + stub_entry->target_section->output_offset
11647              + stub_entry->target_section->output_section->vma);
11648       off -= (stub_entry->group->stub_sec->size
11649               + stub_entry->group->stub_sec->output_offset
11650               + stub_entry->group->stub_sec->output_section->vma);
11651
11652       /* Reset the stub type from the plt variant in case we now
11653          can reach with a shorter stub.  */
11654       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11655         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11656
11657       size = 4;
11658       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11659         {
11660           r2off = get_r2off (info, stub_entry);
11661           if (r2off == (bfd_vma) -1)
11662             {
11663               htab->stub_error = TRUE;
11664               return FALSE;
11665             }
11666           size = 8;
11667           if (PPC_HA (r2off) != 0)
11668             size += 4;
11669           if (PPC_LO (r2off) != 0)
11670             size += 4;
11671           off -= size - 4;
11672         }
11673
11674       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11675
11676       /* If the branch offset is too big, use a ppc_stub_plt_branch.
11677          Do the same for -R objects without function descriptors.  */
11678       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11679           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11680               && r2off == 0
11681               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11682         {
11683           struct ppc_branch_hash_entry *br_entry;
11684
11685           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11686                                              stub_entry->root.string + 9,
11687                                              TRUE, FALSE);
11688           if (br_entry == NULL)
11689             {
11690               _bfd_error_handler (_("can't build branch stub `%s'"),
11691                                   stub_entry->root.string);
11692               htab->stub_error = TRUE;
11693               return FALSE;
11694             }
11695
11696           if (br_entry->iter != htab->stub_iteration)
11697             {
11698               br_entry->iter = htab->stub_iteration;
11699               br_entry->offset = htab->brlt->size;
11700               htab->brlt->size += 8;
11701
11702               if (htab->relbrlt != NULL)
11703                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11704               else if (info->emitrelocations)
11705                 {
11706                   htab->brlt->reloc_count += 1;
11707                   htab->brlt->flags |= SEC_RELOC;
11708                 }
11709             }
11710
11711           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11712           off = (br_entry->offset
11713                  + htab->brlt->output_offset
11714                  + htab->brlt->output_section->vma
11715                  - elf_gp (info->output_bfd)
11716                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11717
11718           if (info->emitrelocations)
11719             {
11720               stub_entry->group->stub_sec->reloc_count
11721                 += 1 + (PPC_HA (off) != 0);
11722               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11723             }
11724
11725           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11726             {
11727               size = 12;
11728               if (PPC_HA (off) != 0)
11729                 size = 16;
11730             }
11731           else
11732             {
11733               size = 16;
11734               if (PPC_HA (off) != 0)
11735                 size += 4;
11736
11737               if (PPC_HA (r2off) != 0)
11738                 size += 4;
11739               if (PPC_LO (r2off) != 0)
11740                 size += 4;
11741             }
11742         }
11743       else if (info->emitrelocations)
11744         {
11745           stub_entry->group->stub_sec->reloc_count += 1;
11746           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11747         }
11748     }
11749
11750   stub_entry->group->stub_sec->size += size;
11751   return TRUE;
11752 }
11753
11754 /* Set up various things so that we can make a list of input sections
11755    for each output section included in the link.  Returns -1 on error,
11756    0 when no stubs will be needed, and 1 on success.  */
11757
11758 int
11759 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11760 {
11761   unsigned int id;
11762   bfd_size_type amt;
11763   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11764
11765   if (htab == NULL)
11766     return -1;
11767
11768   htab->sec_info_arr_size = _bfd_section_id;
11769   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11770   htab->sec_info = bfd_zmalloc (amt);
11771   if (htab->sec_info == NULL)
11772     return -1;
11773
11774   /* Set toc_off for com, und, abs and ind sections.  */
11775   for (id = 0; id < 3; id++)
11776     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11777
11778   return 1;
11779 }
11780
11781 /* Set up for first pass at multitoc partitioning.  */
11782
11783 void
11784 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11785 {
11786   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11787
11788   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11789   htab->toc_bfd = NULL;
11790   htab->toc_first_sec = NULL;
11791 }
11792
11793 /* The linker repeatedly calls this function for each TOC input section
11794    and linker generated GOT section.  Group input bfds such that the toc
11795    within a group is less than 64k in size.  */
11796
11797 bfd_boolean
11798 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11799 {
11800   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11801   bfd_vma addr, off, limit;
11802
11803   if (htab == NULL)
11804     return FALSE;
11805
11806   if (!htab->second_toc_pass)
11807     {
11808       /* Keep track of the first .toc or .got section for this input bfd.  */
11809       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11810
11811       if (new_bfd)
11812         {
11813           htab->toc_bfd = isec->owner;
11814           htab->toc_first_sec = isec;
11815         }
11816
11817       addr = isec->output_offset + isec->output_section->vma;
11818       off = addr - htab->toc_curr;
11819       limit = 0x80008000;
11820       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11821         limit = 0x10000;
11822       if (off + isec->size > limit)
11823         {
11824           addr = (htab->toc_first_sec->output_offset
11825                   + htab->toc_first_sec->output_section->vma);
11826           htab->toc_curr = addr;
11827           htab->toc_curr &= -TOC_BASE_ALIGN;
11828         }
11829
11830       /* toc_curr is the base address of this toc group.  Set elf_gp
11831          for the input section to be the offset relative to the
11832          output toc base plus 0x8000.  Making the input elf_gp an
11833          offset allows us to move the toc as a whole without
11834          recalculating input elf_gp.  */
11835       off = htab->toc_curr - elf_gp (info->output_bfd);
11836       off += TOC_BASE_OFF;
11837
11838       /* Die if someone uses a linker script that doesn't keep input
11839          file .toc and .got together.  */
11840       if (new_bfd
11841           && elf_gp (isec->owner) != 0
11842           && elf_gp (isec->owner) != off)
11843         return FALSE;
11844
11845       elf_gp (isec->owner) = off;
11846       return TRUE;
11847     }
11848
11849   /* During the second pass toc_first_sec points to the start of
11850      a toc group, and toc_curr is used to track the old elf_gp.
11851      We use toc_bfd to ensure we only look at each bfd once.  */
11852   if (htab->toc_bfd == isec->owner)
11853     return TRUE;
11854   htab->toc_bfd = isec->owner;
11855
11856   if (htab->toc_first_sec == NULL
11857       || htab->toc_curr != elf_gp (isec->owner))
11858     {
11859       htab->toc_curr = elf_gp (isec->owner);
11860       htab->toc_first_sec = isec;
11861     }
11862   addr = (htab->toc_first_sec->output_offset
11863           + htab->toc_first_sec->output_section->vma);
11864   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11865   elf_gp (isec->owner) = off;
11866
11867   return TRUE;
11868 }
11869
11870 /* Called via elf_link_hash_traverse to merge GOT entries for global
11871    symbol H.  */
11872
11873 static bfd_boolean
11874 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11875 {
11876   if (h->root.type == bfd_link_hash_indirect)
11877     return TRUE;
11878
11879   merge_got_entries (&h->got.glist);
11880
11881   return TRUE;
11882 }
11883
11884 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11885    symbol H.  */
11886
11887 static bfd_boolean
11888 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11889 {
11890   struct got_entry *gent;
11891
11892   if (h->root.type == bfd_link_hash_indirect)
11893     return TRUE;
11894
11895   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11896     if (!gent->is_indirect)
11897       allocate_got (h, (struct bfd_link_info *) inf, gent);
11898   return TRUE;
11899 }
11900
11901 /* Called on the first multitoc pass after the last call to
11902    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11903    entries.  */
11904
11905 bfd_boolean
11906 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11907 {
11908   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11909   struct bfd *ibfd, *ibfd2;
11910   bfd_boolean done_something;
11911
11912   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11913
11914   if (!htab->do_multi_toc)
11915     return FALSE;
11916
11917   /* Merge global sym got entries within a toc group.  */
11918   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11919
11920   /* And tlsld_got.  */
11921   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11922     {
11923       struct got_entry *ent, *ent2;
11924
11925       if (!is_ppc64_elf (ibfd))
11926         continue;
11927
11928       ent = ppc64_tlsld_got (ibfd);
11929       if (!ent->is_indirect
11930           && ent->got.offset != (bfd_vma) -1)
11931         {
11932           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11933             {
11934               if (!is_ppc64_elf (ibfd2))
11935                 continue;
11936
11937               ent2 = ppc64_tlsld_got (ibfd2);
11938               if (!ent2->is_indirect
11939                   && ent2->got.offset != (bfd_vma) -1
11940                   && elf_gp (ibfd2) == elf_gp (ibfd))
11941                 {
11942                   ent2->is_indirect = TRUE;
11943                   ent2->got.ent = ent;
11944                 }
11945             }
11946         }
11947     }
11948
11949   /* Zap sizes of got sections.  */
11950   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11951   htab->elf.irelplt->size -= htab->got_reli_size;
11952   htab->got_reli_size = 0;
11953
11954   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11955     {
11956       asection *got, *relgot;
11957
11958       if (!is_ppc64_elf (ibfd))
11959         continue;
11960
11961       got = ppc64_elf_tdata (ibfd)->got;
11962       if (got != NULL)
11963         {
11964           got->rawsize = got->size;
11965           got->size = 0;
11966           relgot = ppc64_elf_tdata (ibfd)->relgot;
11967           relgot->rawsize = relgot->size;
11968           relgot->size = 0;
11969         }
11970     }
11971
11972   /* Now reallocate the got, local syms first.  We don't need to
11973      allocate section contents again since we never increase size.  */
11974   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11975     {
11976       struct got_entry **lgot_ents;
11977       struct got_entry **end_lgot_ents;
11978       struct plt_entry **local_plt;
11979       struct plt_entry **end_local_plt;
11980       unsigned char *lgot_masks;
11981       bfd_size_type locsymcount;
11982       Elf_Internal_Shdr *symtab_hdr;
11983       asection *s;
11984
11985       if (!is_ppc64_elf (ibfd))
11986         continue;
11987
11988       lgot_ents = elf_local_got_ents (ibfd);
11989       if (!lgot_ents)
11990         continue;
11991
11992       symtab_hdr = &elf_symtab_hdr (ibfd);
11993       locsymcount = symtab_hdr->sh_info;
11994       end_lgot_ents = lgot_ents + locsymcount;
11995       local_plt = (struct plt_entry **) end_lgot_ents;
11996       end_local_plt = local_plt + locsymcount;
11997       lgot_masks = (unsigned char *) end_local_plt;
11998       s = ppc64_elf_tdata (ibfd)->got;
11999       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12000         {
12001           struct got_entry *ent;
12002
12003           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12004             {
12005               unsigned int ent_size = 8;
12006               unsigned int rel_size = sizeof (Elf64_External_Rela);
12007
12008               ent->got.offset = s->size;
12009               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12010                 {
12011                   ent_size *= 2;
12012                   rel_size *= 2;
12013                 }
12014               s->size += ent_size;
12015               if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12016                 {
12017                   htab->elf.irelplt->size += rel_size;
12018                   htab->got_reli_size += rel_size;
12019                 }
12020               else if (bfd_link_pic (info)
12021                        && !((ent->tls_type & TLS_TPREL) != 0
12022                             && bfd_link_executable (info)))
12023                 {
12024                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12025                   srel->size += rel_size;
12026                 }
12027             }
12028         }
12029     }
12030
12031   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12032
12033   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12034     {
12035       struct got_entry *ent;
12036
12037       if (!is_ppc64_elf (ibfd))
12038         continue;
12039
12040       ent = ppc64_tlsld_got (ibfd);
12041       if (!ent->is_indirect
12042           && ent->got.offset != (bfd_vma) -1)
12043         {
12044           asection *s = ppc64_elf_tdata (ibfd)->got;
12045           ent->got.offset = s->size;
12046           s->size += 16;
12047           if (bfd_link_pic (info))
12048             {
12049               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12050               srel->size += sizeof (Elf64_External_Rela);
12051             }
12052         }
12053     }
12054
12055   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12056   if (!done_something)
12057     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12058       {
12059         asection *got;
12060
12061         if (!is_ppc64_elf (ibfd))
12062           continue;
12063
12064         got = ppc64_elf_tdata (ibfd)->got;
12065         if (got != NULL)
12066           {
12067             done_something = got->rawsize != got->size;
12068             if (done_something)
12069               break;
12070           }
12071       }
12072
12073   if (done_something)
12074     (*htab->params->layout_sections_again) ();
12075
12076   /* Set up for second pass over toc sections to recalculate elf_gp
12077      on input sections.  */
12078   htab->toc_bfd = NULL;
12079   htab->toc_first_sec = NULL;
12080   htab->second_toc_pass = TRUE;
12081   return done_something;
12082 }
12083
12084 /* Called after second pass of multitoc partitioning.  */
12085
12086 void
12087 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12088 {
12089   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12090
12091   /* After the second pass, toc_curr tracks the TOC offset used
12092      for code sections below in ppc64_elf_next_input_section.  */
12093   htab->toc_curr = TOC_BASE_OFF;
12094 }
12095
12096 /* No toc references were found in ISEC.  If the code in ISEC makes no
12097    calls, then there's no need to use toc adjusting stubs when branching
12098    into ISEC.  Actually, indirect calls from ISEC are OK as they will
12099    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
12100    needed, and 2 if a cyclical call-graph was found but no other reason
12101    for a stub was detected.  If called from the top level, a return of
12102    2 means the same as a return of 0.  */
12103
12104 static int
12105 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12106 {
12107   int ret;
12108
12109   /* Mark this section as checked.  */
12110   isec->call_check_done = 1;
12111
12112   /* We know none of our code bearing sections will need toc stubs.  */
12113   if ((isec->flags & SEC_LINKER_CREATED) != 0)
12114     return 0;
12115
12116   if (isec->size == 0)
12117     return 0;
12118
12119   if (isec->output_section == NULL)
12120     return 0;
12121
12122   ret = 0;
12123   if (isec->reloc_count != 0)
12124     {
12125       Elf_Internal_Rela *relstart, *rel;
12126       Elf_Internal_Sym *local_syms;
12127       struct ppc_link_hash_table *htab;
12128
12129       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12130                                             info->keep_memory);
12131       if (relstart == NULL)
12132         return -1;
12133
12134       /* Look for branches to outside of this section.  */
12135       local_syms = NULL;
12136       htab = ppc_hash_table (info);
12137       if (htab == NULL)
12138         return -1;
12139
12140       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12141         {
12142           enum elf_ppc64_reloc_type r_type;
12143           unsigned long r_symndx;
12144           struct elf_link_hash_entry *h;
12145           struct ppc_link_hash_entry *eh;
12146           Elf_Internal_Sym *sym;
12147           asection *sym_sec;
12148           struct _opd_sec_data *opd;
12149           bfd_vma sym_value;
12150           bfd_vma dest;
12151
12152           r_type = ELF64_R_TYPE (rel->r_info);
12153           if (r_type != R_PPC64_REL24
12154               && r_type != R_PPC64_REL14
12155               && r_type != R_PPC64_REL14_BRTAKEN
12156               && r_type != R_PPC64_REL14_BRNTAKEN
12157               && r_type != R_PPC64_PLTCALL)
12158             continue;
12159
12160           r_symndx = ELF64_R_SYM (rel->r_info);
12161           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12162                           isec->owner))
12163             {
12164               ret = -1;
12165               break;
12166             }
12167
12168           /* Calls to dynamic lib functions go through a plt call stub
12169              that uses r2.  */
12170           eh = (struct ppc_link_hash_entry *) h;
12171           if (eh != NULL
12172               && (eh->elf.plt.plist != NULL
12173                   || (eh->oh != NULL
12174                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12175             {
12176               ret = 1;
12177               break;
12178             }
12179
12180           if (sym_sec == NULL)
12181             /* Ignore other undefined symbols.  */
12182             continue;
12183
12184           /* Assume branches to other sections not included in the
12185              link need stubs too, to cover -R and absolute syms.  */
12186           if (sym_sec->output_section == NULL)
12187             {
12188               ret = 1;
12189               break;
12190             }
12191
12192           if (h == NULL)
12193             sym_value = sym->st_value;
12194           else
12195             {
12196               if (h->root.type != bfd_link_hash_defined
12197                   && h->root.type != bfd_link_hash_defweak)
12198                 abort ();
12199               sym_value = h->root.u.def.value;
12200             }
12201           sym_value += rel->r_addend;
12202
12203           /* If this branch reloc uses an opd sym, find the code section.  */
12204           opd = get_opd_info (sym_sec);
12205           if (opd != NULL)
12206             {
12207               if (h == NULL && opd->adjust != NULL)
12208                 {
12209                   long adjust;
12210
12211                   adjust = opd->adjust[OPD_NDX (sym_value)];
12212                   if (adjust == -1)
12213                     /* Assume deleted functions won't ever be called.  */
12214                     continue;
12215                   sym_value += adjust;
12216                 }
12217
12218               dest = opd_entry_value (sym_sec, sym_value,
12219                                       &sym_sec, NULL, FALSE);
12220               if (dest == (bfd_vma) -1)
12221                 continue;
12222             }
12223           else
12224             dest = (sym_value
12225                     + sym_sec->output_offset
12226                     + sym_sec->output_section->vma);
12227
12228           /* Ignore branch to self.  */
12229           if (sym_sec == isec)
12230             continue;
12231
12232           /* If the called function uses the toc, we need a stub.  */
12233           if (sym_sec->has_toc_reloc
12234               || sym_sec->makes_toc_func_call)
12235             {
12236               ret = 1;
12237               break;
12238             }
12239
12240           /* Assume any branch that needs a long branch stub might in fact
12241              need a plt_branch stub.  A plt_branch stub uses r2.  */
12242           else if (dest - (isec->output_offset
12243                            + isec->output_section->vma
12244                            + rel->r_offset) + (1 << 25)
12245                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12246                                                              ? h->other
12247                                                              : sym->st_other))
12248             {
12249               ret = 1;
12250               break;
12251             }
12252
12253           /* If calling back to a section in the process of being
12254              tested, we can't say for sure that no toc adjusting stubs
12255              are needed, so don't return zero.  */
12256           else if (sym_sec->call_check_in_progress)
12257             ret = 2;
12258
12259           /* Branches to another section that itself doesn't have any TOC
12260              references are OK.  Recursively call ourselves to check.  */
12261           else if (!sym_sec->call_check_done)
12262             {
12263               int recur;
12264
12265               /* Mark current section as indeterminate, so that other
12266                  sections that call back to current won't be marked as
12267                  known.  */
12268               isec->call_check_in_progress = 1;
12269               recur = toc_adjusting_stub_needed (info, sym_sec);
12270               isec->call_check_in_progress = 0;
12271
12272               if (recur != 0)
12273                 {
12274                   ret = recur;
12275                   if (recur != 2)
12276                     break;
12277                 }
12278             }
12279         }
12280
12281       if (local_syms != NULL
12282           && (elf_symtab_hdr (isec->owner).contents
12283               != (unsigned char *) local_syms))
12284         free (local_syms);
12285       if (elf_section_data (isec)->relocs != relstart)
12286         free (relstart);
12287     }
12288
12289   if ((ret & 1) == 0
12290       && isec->map_head.s != NULL
12291       && (strcmp (isec->output_section->name, ".init") == 0
12292           || strcmp (isec->output_section->name, ".fini") == 0))
12293     {
12294       if (isec->map_head.s->has_toc_reloc
12295           || isec->map_head.s->makes_toc_func_call)
12296         ret = 1;
12297       else if (!isec->map_head.s->call_check_done)
12298         {
12299           int recur;
12300           isec->call_check_in_progress = 1;
12301           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12302           isec->call_check_in_progress = 0;
12303           if (recur != 0)
12304             ret = recur;
12305         }
12306     }
12307
12308   if (ret == 1)
12309     isec->makes_toc_func_call = 1;
12310
12311   return ret;
12312 }
12313
12314 /* The linker repeatedly calls this function for each input section,
12315    in the order that input sections are linked into output sections.
12316    Build lists of input sections to determine groupings between which
12317    we may insert linker stubs.  */
12318
12319 bfd_boolean
12320 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12321 {
12322   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12323
12324   if (htab == NULL)
12325     return FALSE;
12326
12327   if ((isec->output_section->flags & SEC_CODE) != 0
12328       && isec->output_section->id < htab->sec_info_arr_size)
12329     {
12330       /* This happens to make the list in reverse order,
12331          which is what we want.  */
12332       htab->sec_info[isec->id].u.list
12333         = htab->sec_info[isec->output_section->id].u.list;
12334       htab->sec_info[isec->output_section->id].u.list = isec;
12335     }
12336
12337   if (htab->multi_toc_needed)
12338     {
12339       /* Analyse sections that aren't already flagged as needing a
12340          valid toc pointer.  Exclude .fixup for the linux kernel.
12341          .fixup contains branches, but only back to the function that
12342          hit an exception.  */
12343       if (!(isec->has_toc_reloc
12344             || (isec->flags & SEC_CODE) == 0
12345             || strcmp (isec->name, ".fixup") == 0
12346             || isec->call_check_done))
12347         {
12348           if (toc_adjusting_stub_needed (info, isec) < 0)
12349             return FALSE;
12350         }
12351       /* Make all sections use the TOC assigned for this object file.
12352          This will be wrong for pasted sections;  We fix that in
12353          check_pasted_section().  */
12354       if (elf_gp (isec->owner) != 0)
12355         htab->toc_curr = elf_gp (isec->owner);
12356     }
12357
12358   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12359   return TRUE;
12360 }
12361
12362 /* Check that all .init and .fini sections use the same toc, if they
12363    have toc relocs.  */
12364
12365 static bfd_boolean
12366 check_pasted_section (struct bfd_link_info *info, const char *name)
12367 {
12368   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12369
12370   if (o != NULL)
12371     {
12372       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12373       bfd_vma toc_off = 0;
12374       asection *i;
12375
12376       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12377         if (i->has_toc_reloc)
12378           {
12379             if (toc_off == 0)
12380               toc_off = htab->sec_info[i->id].toc_off;
12381             else if (toc_off != htab->sec_info[i->id].toc_off)
12382               return FALSE;
12383           }
12384
12385       if (toc_off == 0)
12386         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12387           if (i->makes_toc_func_call)
12388             {
12389               toc_off = htab->sec_info[i->id].toc_off;
12390               break;
12391             }
12392
12393       /* Make sure the whole pasted function uses the same toc offset.  */
12394       if (toc_off != 0)
12395         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12396           htab->sec_info[i->id].toc_off = toc_off;
12397     }
12398   return TRUE;
12399 }
12400
12401 bfd_boolean
12402 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12403 {
12404   return (check_pasted_section (info, ".init")
12405           & check_pasted_section (info, ".fini"));
12406 }
12407
12408 /* See whether we can group stub sections together.  Grouping stub
12409    sections may result in fewer stubs.  More importantly, we need to
12410    put all .init* and .fini* stubs at the beginning of the .init or
12411    .fini output sections respectively, because glibc splits the
12412    _init and _fini functions into multiple parts.  Putting a stub in
12413    the middle of a function is not a good idea.  */
12414
12415 static bfd_boolean
12416 group_sections (struct bfd_link_info *info,
12417                 bfd_size_type stub_group_size,
12418                 bfd_boolean stubs_always_before_branch)
12419 {
12420   struct ppc_link_hash_table *htab;
12421   asection *osec;
12422   bfd_boolean suppress_size_errors;
12423
12424   htab = ppc_hash_table (info);
12425   if (htab == NULL)
12426     return FALSE;
12427
12428   suppress_size_errors = FALSE;
12429   if (stub_group_size == 1)
12430     {
12431       /* Default values.  */
12432       if (stubs_always_before_branch)
12433         stub_group_size = 0x1e00000;
12434       else
12435         stub_group_size = 0x1c00000;
12436       suppress_size_errors = TRUE;
12437     }
12438
12439   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12440     {
12441       asection *tail;
12442
12443       if (osec->id >= htab->sec_info_arr_size)
12444         continue;
12445
12446       tail = htab->sec_info[osec->id].u.list;
12447       while (tail != NULL)
12448         {
12449           asection *curr;
12450           asection *prev;
12451           bfd_size_type total;
12452           bfd_boolean big_sec;
12453           bfd_vma curr_toc;
12454           struct map_stub *group;
12455           bfd_size_type group_size;
12456
12457           curr = tail;
12458           total = tail->size;
12459           group_size = (ppc64_elf_section_data (tail) != NULL
12460                         && ppc64_elf_section_data (tail)->has_14bit_branch
12461                         ? stub_group_size >> 10 : stub_group_size);
12462
12463           big_sec = total > group_size;
12464           if (big_sec && !suppress_size_errors)
12465             /* xgettext:c-format */
12466             _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12467                                 tail->owner, tail);
12468           curr_toc = htab->sec_info[tail->id].toc_off;
12469
12470           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12471                  && ((total += curr->output_offset - prev->output_offset)
12472                      < (ppc64_elf_section_data (prev) != NULL
12473                         && ppc64_elf_section_data (prev)->has_14bit_branch
12474                         ? (group_size = stub_group_size >> 10) : group_size))
12475                  && htab->sec_info[prev->id].toc_off == curr_toc)
12476             curr = prev;
12477
12478           /* OK, the size from the start of CURR to the end is less
12479              than group_size and thus can be handled by one stub
12480              section.  (or the tail section is itself larger than
12481              group_size, in which case we may be toast.)  We should
12482              really be keeping track of the total size of stubs added
12483              here, as stubs contribute to the final output section
12484              size.  That's a little tricky, and this way will only
12485              break if stubs added make the total size more than 2^25,
12486              ie. for the default stub_group_size, if stubs total more
12487              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12488           group = bfd_alloc (curr->owner, sizeof (*group));
12489           if (group == NULL)
12490             return FALSE;
12491           group->link_sec = curr;
12492           group->stub_sec = NULL;
12493           group->needs_save_res = 0;
12494           group->tls_get_addr_opt_bctrl = -1u;
12495           group->next = htab->group;
12496           htab->group = group;
12497           do
12498             {
12499               prev = htab->sec_info[tail->id].u.list;
12500               /* Set up this stub group.  */
12501               htab->sec_info[tail->id].u.group = group;
12502             }
12503           while (tail != curr && (tail = prev) != NULL);
12504
12505           /* But wait, there's more!  Input sections up to group_size
12506              bytes before the stub section can be handled by it too.
12507              Don't do this if we have a really large section after the
12508              stubs, as adding more stubs increases the chance that
12509              branches may not reach into the stub section.  */
12510           if (!stubs_always_before_branch && !big_sec)
12511             {
12512               total = 0;
12513               while (prev != NULL
12514                      && ((total += tail->output_offset - prev->output_offset)
12515                          < (ppc64_elf_section_data (prev) != NULL
12516                             && ppc64_elf_section_data (prev)->has_14bit_branch
12517                             ? (group_size = stub_group_size >> 10) : group_size))
12518                      && htab->sec_info[prev->id].toc_off == curr_toc)
12519                 {
12520                   tail = prev;
12521                   prev = htab->sec_info[tail->id].u.list;
12522                   htab->sec_info[tail->id].u.group = group;
12523                 }
12524             }
12525           tail = prev;
12526         }
12527     }
12528   return TRUE;
12529 }
12530
12531 static const unsigned char glink_eh_frame_cie[] =
12532 {
12533   0, 0, 0, 16,                          /* length.  */
12534   0, 0, 0, 0,                           /* id.  */
12535   1,                                    /* CIE version.  */
12536   'z', 'R', 0,                          /* Augmentation string.  */
12537   4,                                    /* Code alignment.  */
12538   0x78,                                 /* Data alignment.  */
12539   65,                                   /* RA reg.  */
12540   1,                                    /* Augmentation size.  */
12541   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12542   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12543 };
12544
12545 static size_t
12546 stub_eh_frame_size (struct map_stub *group, size_t align)
12547 {
12548   size_t this_size = 17;
12549   if (group->tls_get_addr_opt_bctrl != -1u)
12550     {
12551       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12552       if (to_bctrl < 64)
12553         this_size += 1;
12554       else if (to_bctrl < 256)
12555         this_size += 2;
12556       else if (to_bctrl < 65536)
12557         this_size += 3;
12558       else
12559         this_size += 5;
12560       this_size += 6;
12561     }
12562   this_size = (this_size + align - 1) & -align;
12563   return this_size;
12564 }
12565
12566 /* Stripping output sections is normally done before dynamic section
12567    symbols have been allocated.  This function is called later, and
12568    handles cases like htab->brlt which is mapped to its own output
12569    section.  */
12570
12571 static void
12572 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12573 {
12574   if (isec->size == 0
12575       && isec->output_section->size == 0
12576       && !(isec->output_section->flags & SEC_KEEP)
12577       && !bfd_section_removed_from_list (info->output_bfd,
12578                                          isec->output_section)
12579       && elf_section_data (isec->output_section)->dynindx == 0)
12580     {
12581       isec->output_section->flags |= SEC_EXCLUDE;
12582       bfd_section_list_remove (info->output_bfd, isec->output_section);
12583       info->output_bfd->section_count--;
12584     }
12585 }
12586
12587 /* Determine and set the size of the stub section for a final link.
12588
12589    The basic idea here is to examine all the relocations looking for
12590    PC-relative calls to a target that is unreachable with a "bl"
12591    instruction.  */
12592
12593 bfd_boolean
12594 ppc64_elf_size_stubs (struct bfd_link_info *info)
12595 {
12596   bfd_size_type stub_group_size;
12597   bfd_boolean stubs_always_before_branch;
12598   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12599
12600   if (htab == NULL)
12601     return FALSE;
12602
12603   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12604     htab->params->plt_thread_safe = 1;
12605   if (!htab->opd_abi)
12606     htab->params->plt_thread_safe = 0;
12607   else if (htab->params->plt_thread_safe == -1)
12608     {
12609       static const char *const thread_starter[] =
12610         {
12611           "pthread_create",
12612           /* libstdc++ */
12613           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12614           /* librt */
12615           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12616           "mq_notify", "create_timer",
12617           /* libanl */
12618           "getaddrinfo_a",
12619           /* libgomp */
12620           "GOMP_parallel",
12621           "GOMP_parallel_start",
12622           "GOMP_parallel_loop_static",
12623           "GOMP_parallel_loop_static_start",
12624           "GOMP_parallel_loop_dynamic",
12625           "GOMP_parallel_loop_dynamic_start",
12626           "GOMP_parallel_loop_guided",
12627           "GOMP_parallel_loop_guided_start",
12628           "GOMP_parallel_loop_runtime",
12629           "GOMP_parallel_loop_runtime_start",
12630           "GOMP_parallel_sections",
12631           "GOMP_parallel_sections_start",
12632           /* libgo */
12633           "__go_go",
12634         };
12635       unsigned i;
12636
12637       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12638         {
12639           struct elf_link_hash_entry *h;
12640           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12641                                     FALSE, FALSE, TRUE);
12642           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12643           if (htab->params->plt_thread_safe)
12644             break;
12645         }
12646     }
12647   stubs_always_before_branch = htab->params->group_size < 0;
12648   if (htab->params->group_size < 0)
12649     stub_group_size = -htab->params->group_size;
12650   else
12651     stub_group_size = htab->params->group_size;
12652
12653   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12654     return FALSE;
12655
12656 #define STUB_SHRINK_ITER 20
12657   /* Loop until no stubs added.  After iteration 20 of this loop we may
12658      exit on a stub section shrinking.  This is to break out of a
12659      pathological case where adding stubs on one iteration decreases
12660      section gaps (perhaps due to alignment), which then requires
12661      fewer or smaller stubs on the next iteration.  */
12662
12663   while (1)
12664     {
12665       bfd *input_bfd;
12666       unsigned int bfd_indx;
12667       struct map_stub *group;
12668
12669       htab->stub_iteration += 1;
12670
12671       for (input_bfd = info->input_bfds, bfd_indx = 0;
12672            input_bfd != NULL;
12673            input_bfd = input_bfd->link.next, bfd_indx++)
12674         {
12675           Elf_Internal_Shdr *symtab_hdr;
12676           asection *section;
12677           Elf_Internal_Sym *local_syms = NULL;
12678
12679           if (!is_ppc64_elf (input_bfd))
12680             continue;
12681
12682           /* We'll need the symbol table in a second.  */
12683           symtab_hdr = &elf_symtab_hdr (input_bfd);
12684           if (symtab_hdr->sh_info == 0)
12685             continue;
12686
12687           /* Walk over each section attached to the input bfd.  */
12688           for (section = input_bfd->sections;
12689                section != NULL;
12690                section = section->next)
12691             {
12692               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12693
12694               /* If there aren't any relocs, then there's nothing more
12695                  to do.  */
12696               if ((section->flags & SEC_RELOC) == 0
12697                   || (section->flags & SEC_ALLOC) == 0
12698                   || (section->flags & SEC_LOAD) == 0
12699                   || (section->flags & SEC_CODE) == 0
12700                   || section->reloc_count == 0)
12701                 continue;
12702
12703               /* If this section is a link-once section that will be
12704                  discarded, then don't create any stubs.  */
12705               if (section->output_section == NULL
12706                   || section->output_section->owner != info->output_bfd)
12707                 continue;
12708
12709               /* Get the relocs.  */
12710               internal_relocs
12711                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12712                                              info->keep_memory);
12713               if (internal_relocs == NULL)
12714                 goto error_ret_free_local;
12715
12716               /* Now examine each relocation.  */
12717               irela = internal_relocs;
12718               irelaend = irela + section->reloc_count;
12719               for (; irela < irelaend; irela++)
12720                 {
12721                   enum elf_ppc64_reloc_type r_type;
12722                   unsigned int r_indx;
12723                   enum ppc_stub_type stub_type;
12724                   struct ppc_stub_hash_entry *stub_entry;
12725                   asection *sym_sec, *code_sec;
12726                   bfd_vma sym_value, code_value;
12727                   bfd_vma destination;
12728                   unsigned long local_off;
12729                   bfd_boolean ok_dest;
12730                   struct ppc_link_hash_entry *hash;
12731                   struct ppc_link_hash_entry *fdh;
12732                   struct elf_link_hash_entry *h;
12733                   Elf_Internal_Sym *sym;
12734                   char *stub_name;
12735                   const asection *id_sec;
12736                   struct _opd_sec_data *opd;
12737                   struct plt_entry *plt_ent;
12738
12739                   r_type = ELF64_R_TYPE (irela->r_info);
12740                   r_indx = ELF64_R_SYM (irela->r_info);
12741
12742                   if (r_type >= R_PPC64_max)
12743                     {
12744                       bfd_set_error (bfd_error_bad_value);
12745                       goto error_ret_free_internal;
12746                     }
12747
12748                   /* Only look for stubs on branch instructions.  */
12749                   if (r_type != R_PPC64_REL24
12750                       && r_type != R_PPC64_REL14
12751                       && r_type != R_PPC64_REL14_BRTAKEN
12752                       && r_type != R_PPC64_REL14_BRNTAKEN)
12753                     continue;
12754
12755                   /* Now determine the call target, its name, value,
12756                      section.  */
12757                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12758                                   r_indx, input_bfd))
12759                     goto error_ret_free_internal;
12760                   hash = (struct ppc_link_hash_entry *) h;
12761
12762                   ok_dest = FALSE;
12763                   fdh = NULL;
12764                   sym_value = 0;
12765                   if (hash == NULL)
12766                     {
12767                       sym_value = sym->st_value;
12768                       if (sym_sec != NULL
12769                           && sym_sec->output_section != NULL)
12770                         ok_dest = TRUE;
12771                     }
12772                   else if (hash->elf.root.type == bfd_link_hash_defined
12773                            || hash->elf.root.type == bfd_link_hash_defweak)
12774                     {
12775                       sym_value = hash->elf.root.u.def.value;
12776                       if (sym_sec->output_section != NULL)
12777                         ok_dest = TRUE;
12778                     }
12779                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12780                            || hash->elf.root.type == bfd_link_hash_undefined)
12781                     {
12782                       /* Recognise an old ABI func code entry sym, and
12783                          use the func descriptor sym instead if it is
12784                          defined.  */
12785                       if (hash->elf.root.root.string[0] == '.'
12786                           && hash->oh != NULL)
12787                         {
12788                           fdh = ppc_follow_link (hash->oh);
12789                           if (fdh->elf.root.type == bfd_link_hash_defined
12790                               || fdh->elf.root.type == bfd_link_hash_defweak)
12791                             {
12792                               sym_sec = fdh->elf.root.u.def.section;
12793                               sym_value = fdh->elf.root.u.def.value;
12794                               if (sym_sec->output_section != NULL)
12795                                 ok_dest = TRUE;
12796                             }
12797                           else
12798                             fdh = NULL;
12799                         }
12800                     }
12801                   else
12802                     {
12803                       bfd_set_error (bfd_error_bad_value);
12804                       goto error_ret_free_internal;
12805                     }
12806
12807                   destination = 0;
12808                   local_off = 0;
12809                   if (ok_dest)
12810                     {
12811                       sym_value += irela->r_addend;
12812                       destination = (sym_value
12813                                      + sym_sec->output_offset
12814                                      + sym_sec->output_section->vma);
12815                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12816                                                             ? hash->elf.other
12817                                                             : sym->st_other);
12818                     }
12819
12820                   code_sec = sym_sec;
12821                   code_value = sym_value;
12822                   opd = get_opd_info (sym_sec);
12823                   if (opd != NULL)
12824                     {
12825                       bfd_vma dest;
12826
12827                       if (hash == NULL && opd->adjust != NULL)
12828                         {
12829                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12830                           if (adjust == -1)
12831                             continue;
12832                           code_value += adjust;
12833                           sym_value += adjust;
12834                         }
12835                       dest = opd_entry_value (sym_sec, sym_value,
12836                                               &code_sec, &code_value, FALSE);
12837                       if (dest != (bfd_vma) -1)
12838                         {
12839                           destination = dest;
12840                           if (fdh != NULL)
12841                             {
12842                               /* Fixup old ABI sym to point at code
12843                                  entry.  */
12844                               hash->elf.root.type = bfd_link_hash_defweak;
12845                               hash->elf.root.u.def.section = code_sec;
12846                               hash->elf.root.u.def.value = code_value;
12847                             }
12848                         }
12849                     }
12850
12851                   /* Determine what (if any) linker stub is needed.  */
12852                   plt_ent = NULL;
12853                   stub_type = ppc_type_of_stub (section, irela, &hash,
12854                                                 &plt_ent, destination,
12855                                                 local_off);
12856
12857                   if (stub_type != ppc_stub_plt_call)
12858                     {
12859                       /* Check whether we need a TOC adjusting stub.
12860                          Since the linker pastes together pieces from
12861                          different object files when creating the
12862                          _init and _fini functions, it may be that a
12863                          call to what looks like a local sym is in
12864                          fact a call needing a TOC adjustment.  */
12865                       if (code_sec != NULL
12866                           && code_sec->output_section != NULL
12867                           && (htab->sec_info[code_sec->id].toc_off
12868                               != htab->sec_info[section->id].toc_off)
12869                           && (code_sec->has_toc_reloc
12870                               || code_sec->makes_toc_func_call))
12871                         stub_type = ppc_stub_long_branch_r2off;
12872                     }
12873
12874                   if (stub_type == ppc_stub_none)
12875                     continue;
12876
12877                   /* __tls_get_addr calls might be eliminated.  */
12878                   if (stub_type != ppc_stub_plt_call
12879                       && hash != NULL
12880                       && (hash == htab->tls_get_addr
12881                           || hash == htab->tls_get_addr_fd)
12882                       && section->has_tls_reloc
12883                       && irela != internal_relocs)
12884                     {
12885                       /* Get tls info.  */
12886                       unsigned char *tls_mask;
12887
12888                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12889                                          irela - 1, input_bfd))
12890                         goto error_ret_free_internal;
12891                       if ((*tls_mask & TLS_TLS) != 0)
12892                         continue;
12893                     }
12894
12895                   if (stub_type == ppc_stub_plt_call)
12896                     {
12897                       if (!htab->opd_abi
12898                           && htab->params->plt_localentry0 != 0
12899                           && is_elfv2_localentry0 (&hash->elf))
12900                         htab->has_plt_localentry0 = 1;
12901                       else if (irela + 1 < irelaend
12902                                && irela[1].r_offset == irela->r_offset + 4
12903                                && (ELF64_R_TYPE (irela[1].r_info)
12904                                    == R_PPC64_TOCSAVE))
12905                         {
12906                           if (!tocsave_find (htab, INSERT,
12907                                              &local_syms, irela + 1, input_bfd))
12908                             goto error_ret_free_internal;
12909                         }
12910                       else
12911                         stub_type = ppc_stub_plt_call_r2save;
12912                     }
12913
12914                   /* Support for grouping stub sections.  */
12915                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12916
12917                   /* Get the name of this stub.  */
12918                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12919                   if (!stub_name)
12920                     goto error_ret_free_internal;
12921
12922                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12923                                                      stub_name, FALSE, FALSE);
12924                   if (stub_entry != NULL)
12925                     {
12926                       /* The proper stub has already been created.  */
12927                       free (stub_name);
12928                       if (stub_type == ppc_stub_plt_call_r2save)
12929                         stub_entry->stub_type = stub_type;
12930                       continue;
12931                     }
12932
12933                   stub_entry = ppc_add_stub (stub_name, section, info);
12934                   if (stub_entry == NULL)
12935                     {
12936                       free (stub_name);
12937                     error_ret_free_internal:
12938                       if (elf_section_data (section)->relocs == NULL)
12939                         free (internal_relocs);
12940                     error_ret_free_local:
12941                       if (local_syms != NULL
12942                           && (symtab_hdr->contents
12943                               != (unsigned char *) local_syms))
12944                         free (local_syms);
12945                       return FALSE;
12946                     }
12947
12948                   stub_entry->stub_type = stub_type;
12949                   if (stub_type != ppc_stub_plt_call
12950                       && stub_type != ppc_stub_plt_call_r2save)
12951                     {
12952                       stub_entry->target_value = code_value;
12953                       stub_entry->target_section = code_sec;
12954                     }
12955                   else
12956                     {
12957                       stub_entry->target_value = sym_value;
12958                       stub_entry->target_section = sym_sec;
12959                     }
12960                   stub_entry->h = hash;
12961                   stub_entry->plt_ent = plt_ent;
12962                   stub_entry->symtype
12963                     = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
12964                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12965
12966                   if (stub_entry->h != NULL)
12967                     htab->stub_globals += 1;
12968                 }
12969
12970               /* We're done with the internal relocs, free them.  */
12971               if (elf_section_data (section)->relocs != internal_relocs)
12972                 free (internal_relocs);
12973             }
12974
12975           if (local_syms != NULL
12976               && symtab_hdr->contents != (unsigned char *) local_syms)
12977             {
12978               if (!info->keep_memory)
12979                 free (local_syms);
12980               else
12981                 symtab_hdr->contents = (unsigned char *) local_syms;
12982             }
12983         }
12984
12985       /* We may have added some stubs.  Find out the new size of the
12986          stub sections.  */
12987       for (group = htab->group; group != NULL; group = group->next)
12988         if (group->stub_sec != NULL)
12989           {
12990             asection *stub_sec = group->stub_sec;
12991
12992             if (htab->stub_iteration <= STUB_SHRINK_ITER
12993                 || stub_sec->rawsize < stub_sec->size)
12994               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12995               stub_sec->rawsize = stub_sec->size;
12996             stub_sec->size = 0;
12997             stub_sec->reloc_count = 0;
12998             stub_sec->flags &= ~SEC_RELOC;
12999           }
13000
13001       if (htab->stub_iteration <= STUB_SHRINK_ITER
13002           || htab->brlt->rawsize < htab->brlt->size)
13003         htab->brlt->rawsize = htab->brlt->size;
13004       htab->brlt->size = 0;
13005       htab->brlt->reloc_count = 0;
13006       htab->brlt->flags &= ~SEC_RELOC;
13007       if (htab->relbrlt != NULL)
13008         htab->relbrlt->size = 0;
13009
13010       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13011
13012       for (group = htab->group; group != NULL; group = group->next)
13013         if (group->needs_save_res)
13014           group->stub_sec->size += htab->sfpr->size;
13015
13016       if (info->emitrelocations
13017           && htab->glink != NULL && htab->glink->size != 0)
13018         {
13019           htab->glink->reloc_count = 1;
13020           htab->glink->flags |= SEC_RELOC;
13021         }
13022
13023       if (htab->glink_eh_frame != NULL
13024           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13025           && htab->glink_eh_frame->output_section->size > 8)
13026         {
13027           size_t size = 0, align = 4;
13028
13029           for (group = htab->group; group != NULL; group = group->next)
13030             if (group->stub_sec != NULL)
13031               size += stub_eh_frame_size (group, align);
13032           if (htab->glink != NULL && htab->glink->size != 0)
13033             size += (24 + align - 1) & -align;
13034           if (size != 0)
13035             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13036           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13037           size = (size + align - 1) & -align;
13038           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13039           htab->glink_eh_frame->size = size;
13040         }
13041
13042       if (htab->params->plt_stub_align != 0)
13043         for (group = htab->group; group != NULL; group = group->next)
13044           if (group->stub_sec != NULL)
13045             {
13046               int align = abs (htab->params->plt_stub_align);
13047               group->stub_sec->size
13048                 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13049             }
13050
13051       for (group = htab->group; group != NULL; group = group->next)
13052         if (group->stub_sec != NULL
13053             && group->stub_sec->rawsize != group->stub_sec->size
13054             && (htab->stub_iteration <= STUB_SHRINK_ITER
13055                 || group->stub_sec->rawsize < group->stub_sec->size))
13056           break;
13057
13058       if (group == NULL
13059           && (htab->brlt->rawsize == htab->brlt->size
13060               || (htab->stub_iteration > STUB_SHRINK_ITER
13061                   && htab->brlt->rawsize > htab->brlt->size))
13062           && (htab->glink_eh_frame == NULL
13063               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13064         break;
13065
13066       /* Ask the linker to do its stuff.  */
13067       (*htab->params->layout_sections_again) ();
13068     }
13069
13070   if (htab->glink_eh_frame != NULL
13071       && htab->glink_eh_frame->size != 0)
13072     {
13073       bfd_vma val;
13074       bfd_byte *p, *last_fde;
13075       size_t last_fde_len, size, align, pad;
13076       struct map_stub *group;
13077
13078       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13079       if (p == NULL)
13080         return FALSE;
13081       htab->glink_eh_frame->contents = p;
13082       last_fde = p;
13083       align = 4;
13084
13085       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13086       /* CIE length (rewrite in case little-endian).  */
13087       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13088       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13089       p += last_fde_len + 4;
13090
13091       for (group = htab->group; group != NULL; group = group->next)
13092         if (group->stub_sec != NULL)
13093           {
13094             last_fde = p;
13095             last_fde_len = stub_eh_frame_size (group, align) - 4;
13096             /* FDE length.  */
13097             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13098             p += 4;
13099             /* CIE pointer.  */
13100             val = p - htab->glink_eh_frame->contents;
13101             bfd_put_32 (htab->elf.dynobj, val, p);
13102             p += 4;
13103             /* Offset to stub section, written later.  */
13104             p += 4;
13105             /* stub section size.  */
13106             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13107             p += 4;
13108             /* Augmentation.  */
13109             p += 1;
13110             if (group->tls_get_addr_opt_bctrl != -1u)
13111               {
13112                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
13113
13114                 /* This FDE needs more than just the default.
13115                    Describe __tls_get_addr_opt stub LR.  */
13116                 if (to_bctrl < 64)
13117                   *p++ = DW_CFA_advance_loc + to_bctrl;
13118                 else if (to_bctrl < 256)
13119                   {
13120                     *p++ = DW_CFA_advance_loc1;
13121                     *p++ = to_bctrl;
13122                   }
13123                 else if (to_bctrl < 65536)
13124                   {
13125                     *p++ = DW_CFA_advance_loc2;
13126                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
13127                     p += 2;
13128                   }
13129                 else
13130                   {
13131                     *p++ = DW_CFA_advance_loc4;
13132                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
13133                     p += 4;
13134                   }
13135                 *p++ = DW_CFA_offset_extended_sf;
13136                 *p++ = 65;
13137                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
13138                 *p++ = DW_CFA_advance_loc + 4;
13139                 *p++ = DW_CFA_restore_extended;
13140                 *p++ = 65;
13141               }
13142             /* Pad.  */
13143             p = last_fde + last_fde_len + 4;
13144           }
13145       if (htab->glink != NULL && htab->glink->size != 0)
13146         {
13147           last_fde = p;
13148           last_fde_len = ((24 + align - 1) & -align) - 4;
13149           /* FDE length.  */
13150           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13151           p += 4;
13152           /* CIE pointer.  */
13153           val = p - htab->glink_eh_frame->contents;
13154           bfd_put_32 (htab->elf.dynobj, val, p);
13155           p += 4;
13156           /* Offset to .glink, written later.  */
13157           p += 4;
13158           /* .glink size.  */
13159           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13160           p += 4;
13161           /* Augmentation.  */
13162           p += 1;
13163
13164           *p++ = DW_CFA_advance_loc + 1;
13165           *p++ = DW_CFA_register;
13166           *p++ = 65;
13167           *p++ = htab->opd_abi ? 12 : 0;
13168           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13169           *p++ = DW_CFA_restore_extended;
13170           *p++ = 65;
13171           p += ((24 + align - 1) & -align) - 24;
13172         }
13173       /* Subsume any padding into the last FDE if user .eh_frame
13174          sections are aligned more than glink_eh_frame.  Otherwise any
13175          zero padding will be seen as a terminator.  */
13176       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13177       size = p - htab->glink_eh_frame->contents;
13178       pad = ((size + align - 1) & -align) - size;
13179       htab->glink_eh_frame->size = size + pad;
13180       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13181     }
13182
13183   maybe_strip_output (info, htab->brlt);
13184   if (htab->glink_eh_frame != NULL)
13185     maybe_strip_output (info, htab->glink_eh_frame);
13186
13187   return TRUE;
13188 }
13189
13190 /* Called after we have determined section placement.  If sections
13191    move, we'll be called again.  Provide a value for TOCstart.  */
13192
13193 bfd_vma
13194 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13195 {
13196   asection *s;
13197   bfd_vma TOCstart, adjust;
13198
13199   if (info != NULL)
13200     {
13201       struct elf_link_hash_entry *h;
13202       struct elf_link_hash_table *htab = elf_hash_table (info);
13203
13204       if (is_elf_hash_table (htab)
13205           && htab->hgot != NULL)
13206         h = htab->hgot;
13207       else
13208         {
13209           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13210           if (is_elf_hash_table (htab))
13211             htab->hgot = h;
13212         }
13213       if (h != NULL
13214           && h->root.type == bfd_link_hash_defined
13215           && !h->root.linker_def
13216           && (!is_elf_hash_table (htab)
13217               || h->def_regular))
13218         {
13219           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13220                       + h->root.u.def.section->output_offset
13221                       + h->root.u.def.section->output_section->vma);
13222           _bfd_set_gp_value (obfd, TOCstart);
13223           return TOCstart;
13224         }
13225     }
13226
13227   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13228      order.  The TOC starts where the first of these sections starts.  */
13229   s = bfd_get_section_by_name (obfd, ".got");
13230   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13231     s = bfd_get_section_by_name (obfd, ".toc");
13232   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13233     s = bfd_get_section_by_name (obfd, ".tocbss");
13234   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13235     s = bfd_get_section_by_name (obfd, ".plt");
13236   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13237     {
13238       /* This may happen for
13239          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13240          .toc directive
13241          o  bad linker script
13242          o --gc-sections and empty TOC sections
13243
13244          FIXME: Warn user?  */
13245
13246       /* Look for a likely section.  We probably won't even be
13247          using TOCstart.  */
13248       for (s = obfd->sections; s != NULL; s = s->next)
13249         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13250                          | SEC_EXCLUDE))
13251             == (SEC_ALLOC | SEC_SMALL_DATA))
13252           break;
13253       if (s == NULL)
13254         for (s = obfd->sections; s != NULL; s = s->next)
13255           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13256               == (SEC_ALLOC | SEC_SMALL_DATA))
13257             break;
13258       if (s == NULL)
13259         for (s = obfd->sections; s != NULL; s = s->next)
13260           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13261               == SEC_ALLOC)
13262             break;
13263       if (s == NULL)
13264         for (s = obfd->sections; s != NULL; s = s->next)
13265           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13266             break;
13267     }
13268
13269   TOCstart = 0;
13270   if (s != NULL)
13271     TOCstart = s->output_section->vma + s->output_offset;
13272
13273   /* Force alignment.  */
13274   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13275   TOCstart -= adjust;
13276   _bfd_set_gp_value (obfd, TOCstart);
13277
13278   if (info != NULL && s != NULL)
13279     {
13280       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13281
13282       if (htab != NULL)
13283         {
13284           if (htab->elf.hgot != NULL)
13285             {
13286               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13287               htab->elf.hgot->root.u.def.section = s;
13288             }
13289         }
13290       else
13291         {
13292           struct bfd_link_hash_entry *bh = NULL;
13293           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13294                                             s, TOC_BASE_OFF - adjust,
13295                                             NULL, FALSE, FALSE, &bh);
13296         }
13297     }
13298   return TOCstart;
13299 }
13300
13301 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13302    write out any global entry stubs, and PLT relocations.  */
13303
13304 static bfd_boolean
13305 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13306 {
13307   struct bfd_link_info *info;
13308   struct ppc_link_hash_table *htab;
13309   struct plt_entry *ent;
13310   asection *s;
13311
13312   if (h->root.type == bfd_link_hash_indirect)
13313     return TRUE;
13314
13315   info = inf;
13316   htab = ppc_hash_table (info);
13317   if (htab == NULL)
13318     return FALSE;
13319
13320   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13321     if (ent->plt.offset != (bfd_vma) -1)
13322       {
13323         /* This symbol has an entry in the procedure linkage
13324            table.  Set it up.  */
13325         Elf_Internal_Rela rela;
13326         asection *plt, *relplt;
13327         bfd_byte *loc;
13328
13329         if (!htab->elf.dynamic_sections_created
13330             || h->dynindx == -1)
13331           {
13332             if (!(h->def_regular
13333                   && (h->root.type == bfd_link_hash_defined
13334                       || h->root.type == bfd_link_hash_defweak)))
13335               continue;
13336             if (h->type == STT_GNU_IFUNC)
13337               {
13338                 plt = htab->elf.iplt;
13339                 relplt = htab->elf.irelplt;
13340                 htab->local_ifunc_resolver = 1;
13341                 if (htab->opd_abi)
13342                   rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13343                 else
13344                   rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13345               }
13346             else
13347               {
13348                 plt = htab->pltlocal;
13349                 if (bfd_link_pic (info))
13350                   {
13351                     relplt = htab->relpltlocal;
13352                     if (htab->opd_abi)
13353                       rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13354                     else
13355                       rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13356                   }
13357                 else
13358                   relplt = NULL;
13359               }
13360             rela.r_addend = (h->root.u.def.value
13361                              + h->root.u.def.section->output_offset
13362                              + h->root.u.def.section->output_section->vma
13363                              + ent->addend);
13364
13365             if (relplt == NULL)
13366               {
13367                 loc = plt->contents + ent->plt.offset;
13368                 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13369                 if (htab->opd_abi)
13370                   {
13371                     bfd_vma toc = elf_gp (info->output_bfd);
13372                     toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13373                     bfd_put_64 (info->output_bfd, toc, loc + 8);
13374                   }
13375               }
13376             else
13377               {
13378                 rela.r_offset = (plt->output_section->vma
13379                                  + plt->output_offset
13380                                  + ent->plt.offset);
13381                 loc = relplt->contents + (relplt->reloc_count++
13382                                           * sizeof (Elf64_External_Rela));
13383                 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13384               }
13385           }
13386         else
13387           {
13388             rela.r_offset = (htab->elf.splt->output_section->vma
13389                              + htab->elf.splt->output_offset
13390                              + ent->plt.offset);
13391             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13392             rela.r_addend = ent->addend;
13393             loc = (htab->elf.srelplt->contents
13394                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13395                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13396             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13397               htab->maybe_local_ifunc_resolver = 1;
13398             bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13399           }
13400       }
13401
13402   if (!h->pointer_equality_needed)
13403     return TRUE;
13404
13405   if (h->def_regular)
13406     return TRUE;
13407
13408   s = htab->global_entry;
13409   if (s == NULL || s->size == 0)
13410     return TRUE;
13411
13412   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13413     if (ent->plt.offset != (bfd_vma) -1
13414         && ent->addend == 0)
13415       {
13416         bfd_byte *p;
13417         asection *plt;
13418         bfd_vma off;
13419
13420         p = s->contents + h->root.u.def.value;
13421         plt = htab->elf.splt;
13422         if (!htab->elf.dynamic_sections_created
13423             || h->dynindx == -1)
13424           {
13425             if (h->type == STT_GNU_IFUNC)
13426               plt = htab->elf.iplt;
13427             else
13428               plt = htab->pltlocal;
13429           }
13430         off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13431         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13432
13433         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13434           {
13435             info->callbacks->einfo
13436               (_("%P: linkage table error against `%pT'\n"),
13437                h->root.root.string);
13438             bfd_set_error (bfd_error_bad_value);
13439             htab->stub_error = TRUE;
13440           }
13441
13442         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13443         if (htab->params->emit_stub_syms)
13444           {
13445             size_t len = strlen (h->root.root.string);
13446             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13447
13448             if (name == NULL)
13449               return FALSE;
13450
13451             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13452             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13453             if (h == NULL)
13454               return FALSE;
13455             if (h->root.type == bfd_link_hash_new)
13456               {
13457                 h->root.type = bfd_link_hash_defined;
13458                 h->root.u.def.section = s;
13459                 h->root.u.def.value = p - s->contents;
13460                 h->ref_regular = 1;
13461                 h->def_regular = 1;
13462                 h->ref_regular_nonweak = 1;
13463                 h->forced_local = 1;
13464                 h->non_elf = 0;
13465                 h->root.linker_def = 1;
13466               }
13467           }
13468
13469         if (PPC_HA (off) != 0)
13470           {
13471             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13472             p += 4;
13473           }
13474         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13475         p += 4;
13476         bfd_put_32 (s->owner, MTCTR_R12, p);
13477         p += 4;
13478         bfd_put_32 (s->owner, BCTR, p);
13479         break;
13480       }
13481   return TRUE;
13482 }
13483
13484 /* Write PLT relocs for locals.  */
13485
13486 static bfd_boolean
13487 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13488 {
13489   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13490   bfd *ibfd;
13491
13492   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
13493     {
13494       struct got_entry **lgot_ents, **end_lgot_ents;
13495       struct plt_entry **local_plt, **lplt, **end_local_plt;
13496       Elf_Internal_Shdr *symtab_hdr;
13497       bfd_size_type locsymcount;
13498       Elf_Internal_Sym *local_syms = NULL;
13499       struct plt_entry *ent;
13500
13501       if (!is_ppc64_elf (ibfd))
13502         continue;
13503
13504       lgot_ents = elf_local_got_ents (ibfd);
13505       if (!lgot_ents)
13506         continue;
13507
13508       symtab_hdr = &elf_symtab_hdr (ibfd);
13509       locsymcount = symtab_hdr->sh_info;
13510       end_lgot_ents = lgot_ents + locsymcount;
13511       local_plt = (struct plt_entry **) end_lgot_ents;
13512       end_local_plt = local_plt + locsymcount;
13513       for (lplt = local_plt; lplt < end_local_plt; ++lplt)
13514         for (ent = *lplt; ent != NULL; ent = ent->next)
13515           if (ent->plt.offset != (bfd_vma) -1)
13516             {
13517               Elf_Internal_Sym *sym;
13518               asection *sym_sec;
13519               asection *plt, *relplt;
13520               bfd_byte *loc;
13521               bfd_vma val;
13522
13523               if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
13524                               lplt - local_plt, ibfd))
13525                 {
13526                   if (local_syms != NULL
13527                       && symtab_hdr->contents != (unsigned char *) local_syms)
13528                     free (local_syms);
13529                   return FALSE;
13530                 }
13531
13532               val = sym->st_value + ent->addend;
13533               val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
13534               if (sym_sec != NULL && sym_sec->output_section != NULL)
13535                 val += sym_sec->output_offset + sym_sec->output_section->vma;
13536
13537               if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13538                 {
13539                   htab->local_ifunc_resolver = 1;
13540                   plt = htab->elf.iplt;
13541                   relplt = htab->elf.irelplt;
13542                 }
13543               else
13544                 {
13545                   plt = htab->pltlocal;
13546                   relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
13547                 }
13548
13549               if (relplt == NULL)
13550                 {
13551                   loc = plt->contents + ent->plt.offset;
13552                   bfd_put_64 (info->output_bfd, val, loc);
13553                   if (htab->opd_abi)
13554                     {
13555                       bfd_vma toc = elf_gp (ibfd);
13556                       bfd_put_64 (info->output_bfd, toc, loc + 8);
13557                     }
13558                 }
13559               else
13560                 {
13561                   Elf_Internal_Rela rela;
13562                   rela.r_offset = (ent->plt.offset
13563                                    + plt->output_offset
13564                                    + plt->output_section->vma);
13565                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13566                     {
13567                       if (htab->opd_abi)
13568                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13569                       else
13570                         rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13571                     }
13572                   else
13573                     {
13574                       if (htab->opd_abi)
13575                         rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13576                       else
13577                         rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13578                     }
13579                   rela.r_addend = val;
13580                   loc = relplt->contents + (relplt->reloc_count++
13581                                             * sizeof (Elf64_External_Rela));
13582                   bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13583                 }
13584             }
13585
13586       if (local_syms != NULL
13587           && symtab_hdr->contents != (unsigned char *) local_syms)
13588         {
13589           if (!info->keep_memory)
13590             free (local_syms);
13591           else
13592             symtab_hdr->contents = (unsigned char *) local_syms;
13593         }
13594     }
13595   return TRUE;
13596 }
13597
13598 /* Build all the stubs associated with the current output file.
13599    The stubs are kept in a hash table attached to the main linker
13600    hash table.  This function is called via gldelf64ppc_finish.  */
13601
13602 bfd_boolean
13603 ppc64_elf_build_stubs (struct bfd_link_info *info,
13604                        char **stats)
13605 {
13606   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13607   struct map_stub *group;
13608   asection *stub_sec;
13609   bfd_byte *p;
13610   int stub_sec_count = 0;
13611
13612   if (htab == NULL)
13613     return FALSE;
13614
13615   /* Allocate memory to hold the linker stubs.  */
13616   for (group = htab->group; group != NULL; group = group->next)
13617     if ((stub_sec = group->stub_sec) != NULL
13618         && stub_sec->size != 0)
13619       {
13620         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13621         if (stub_sec->contents == NULL)
13622           return FALSE;
13623         stub_sec->size = 0;
13624       }
13625
13626   if (htab->glink != NULL && htab->glink->size != 0)
13627     {
13628       unsigned int indx;
13629       bfd_vma plt0;
13630
13631       /* Build the .glink plt call stub.  */
13632       if (htab->params->emit_stub_syms)
13633         {
13634           struct elf_link_hash_entry *h;
13635           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13636                                     TRUE, FALSE, FALSE);
13637           if (h == NULL)
13638             return FALSE;
13639           if (h->root.type == bfd_link_hash_new)
13640             {
13641               h->root.type = bfd_link_hash_defined;
13642               h->root.u.def.section = htab->glink;
13643               h->root.u.def.value = 8;
13644               h->ref_regular = 1;
13645               h->def_regular = 1;
13646               h->ref_regular_nonweak = 1;
13647               h->forced_local = 1;
13648               h->non_elf = 0;
13649               h->root.linker_def = 1;
13650             }
13651         }
13652       plt0 = (htab->elf.splt->output_section->vma
13653               + htab->elf.splt->output_offset
13654               - 16);
13655       if (info->emitrelocations)
13656         {
13657           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13658           if (r == NULL)
13659             return FALSE;
13660           r->r_offset = (htab->glink->output_offset
13661                          + htab->glink->output_section->vma);
13662           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13663           r->r_addend = plt0;
13664         }
13665       p = htab->glink->contents;
13666       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13667       bfd_put_64 (htab->glink->owner, plt0, p);
13668       p += 8;
13669       if (htab->opd_abi)
13670         {
13671           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13672           p += 4;
13673           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13674           p += 4;
13675           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13676           p += 4;
13677           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13678           p += 4;
13679           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13680           p += 4;
13681           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13682           p += 4;
13683           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13684           p += 4;
13685           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13686           p += 4;
13687           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13688           p += 4;
13689           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13690           p += 4;
13691         }
13692       else
13693         {
13694           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13695           p += 4;
13696           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13697           p += 4;
13698           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13699           p += 4;
13700           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13701           p += 4;
13702           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13703           p += 4;
13704           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13705           p += 4;
13706           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13707           p += 4;
13708           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13709           p += 4;
13710           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13711           p += 4;
13712           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13713           p += 4;
13714           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13715           p += 4;
13716           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13717           p += 4;
13718           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13719           p += 4;
13720         }
13721       bfd_put_32 (htab->glink->owner, BCTR, p);
13722       p += 4;
13723       BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13724
13725       /* Build the .glink lazy link call stubs.  */
13726       indx = 0;
13727       while (p < htab->glink->contents + htab->glink->size)
13728         {
13729           if (htab->opd_abi)
13730             {
13731               if (indx < 0x8000)
13732                 {
13733                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13734                   p += 4;
13735                 }
13736               else
13737                 {
13738                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13739                   p += 4;
13740                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13741                               p);
13742                   p += 4;
13743                 }
13744             }
13745           bfd_put_32 (htab->glink->owner,
13746                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13747           indx++;
13748           p += 4;
13749         }
13750     }
13751
13752   /* Build .glink global entry stubs, and PLT relocs for globals.  */
13753   elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
13754
13755   if (!write_plt_relocs_for_local_syms (info))
13756     return FALSE;
13757
13758   if (htab->brlt != NULL && htab->brlt->size != 0)
13759     {
13760       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13761                                          htab->brlt->size);
13762       if (htab->brlt->contents == NULL)
13763         return FALSE;
13764     }
13765   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13766     {
13767       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13768                                             htab->relbrlt->size);
13769       if (htab->relbrlt->contents == NULL)
13770         return FALSE;
13771     }
13772
13773   /* Build the stubs as directed by the stub hash table.  */
13774   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13775
13776   for (group = htab->group; group != NULL; group = group->next)
13777     if (group->needs_save_res)
13778       group->stub_sec->size += htab->sfpr->size;
13779
13780   if (htab->relbrlt != NULL)
13781     htab->relbrlt->reloc_count = 0;
13782
13783   if (htab->params->plt_stub_align != 0)
13784     for (group = htab->group; group != NULL; group = group->next)
13785       if ((stub_sec = group->stub_sec) != NULL)
13786         {
13787           int align = abs (htab->params->plt_stub_align);
13788           stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13789         }
13790
13791   for (group = htab->group; group != NULL; group = group->next)
13792     if (group->needs_save_res)
13793       {
13794         stub_sec = group->stub_sec;
13795         memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
13796                 htab->sfpr->contents, htab->sfpr->size);
13797         if (htab->params->emit_stub_syms)
13798           {
13799             unsigned int i;
13800
13801             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13802               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13803                 return FALSE;
13804           }
13805       }
13806
13807   for (group = htab->group; group != NULL; group = group->next)
13808     if ((stub_sec = group->stub_sec) != NULL)
13809       {
13810         stub_sec_count += 1;
13811         if (stub_sec->rawsize != stub_sec->size
13812             && (htab->stub_iteration <= STUB_SHRINK_ITER
13813                 || stub_sec->rawsize < stub_sec->size))
13814           break;
13815       }
13816
13817   if (group != NULL)
13818     {
13819       htab->stub_error = TRUE;
13820       _bfd_error_handler (_("stubs don't match calculated size"));
13821     }
13822
13823   if (htab->stub_error)
13824     return FALSE;
13825
13826   if (stats != NULL)
13827     {
13828       size_t len;
13829       *stats = bfd_malloc (500);
13830       if (*stats == NULL)
13831         return FALSE;
13832
13833       len = sprintf (*stats,
13834                      ngettext ("linker stubs in %u group\n",
13835                                "linker stubs in %u groups\n",
13836                                stub_sec_count),
13837                      stub_sec_count);
13838       sprintf (*stats + len, _("  branch       %lu\n"
13839                                "  toc adjust   %lu\n"
13840                                "  long branch  %lu\n"
13841                                "  long toc adj %lu\n"
13842                                "  plt call     %lu\n"
13843                                "  plt call toc %lu\n"
13844                                "  global entry %lu"),
13845                htab->stub_count[ppc_stub_long_branch - 1],
13846                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13847                htab->stub_count[ppc_stub_plt_branch - 1],
13848                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13849                htab->stub_count[ppc_stub_plt_call - 1],
13850                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13851                htab->stub_count[ppc_stub_global_entry - 1]);
13852     }
13853   return TRUE;
13854 }
13855
13856 /* What to do when ld finds relocations against symbols defined in
13857    discarded sections.  */
13858
13859 static unsigned int
13860 ppc64_elf_action_discarded (asection *sec)
13861 {
13862   if (strcmp (".opd", sec->name) == 0)
13863     return 0;
13864
13865   if (strcmp (".toc", sec->name) == 0)
13866     return 0;
13867
13868   if (strcmp (".toc1", sec->name) == 0)
13869     return 0;
13870
13871   return _bfd_elf_default_action_discarded (sec);
13872 }
13873
13874 /* The RELOCATE_SECTION function is called by the ELF backend linker
13875    to handle the relocations for a section.
13876
13877    The relocs are always passed as Rela structures; if the section
13878    actually uses Rel structures, the r_addend field will always be
13879    zero.
13880
13881    This function is responsible for adjust the section contents as
13882    necessary, and (if using Rela relocs and generating a
13883    relocatable output file) adjusting the reloc addend as
13884    necessary.
13885
13886    This function does not have to worry about setting the reloc
13887    address or the reloc symbol index.
13888
13889    LOCAL_SYMS is a pointer to the swapped in local symbols.
13890
13891    LOCAL_SECTIONS is an array giving the section in the input file
13892    corresponding to the st_shndx field of each local symbol.
13893
13894    The global hash table entry for the global symbols can be found
13895    via elf_sym_hashes (input_bfd).
13896
13897    When generating relocatable output, this function must handle
13898    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13899    going to be the section symbol corresponding to the output
13900    section, which means that the addend must be adjusted
13901    accordingly.  */
13902
13903 static bfd_boolean
13904 ppc64_elf_relocate_section (bfd *output_bfd,
13905                             struct bfd_link_info *info,
13906                             bfd *input_bfd,
13907                             asection *input_section,
13908                             bfd_byte *contents,
13909                             Elf_Internal_Rela *relocs,
13910                             Elf_Internal_Sym *local_syms,
13911                             asection **local_sections)
13912 {
13913   struct ppc_link_hash_table *htab;
13914   Elf_Internal_Shdr *symtab_hdr;
13915   struct elf_link_hash_entry **sym_hashes;
13916   Elf_Internal_Rela *rel;
13917   Elf_Internal_Rela *wrel;
13918   Elf_Internal_Rela *relend;
13919   Elf_Internal_Rela outrel;
13920   bfd_byte *loc;
13921   struct got_entry **local_got_ents;
13922   bfd_vma TOCstart;
13923   bfd_boolean ret = TRUE;
13924   bfd_boolean is_opd;
13925   /* Assume 'at' branch hints.  */
13926   bfd_boolean is_isa_v2 = TRUE;
13927   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13928
13929   /* Initialize howto table if needed.  */
13930   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13931     ppc_howto_init ();
13932
13933   htab = ppc_hash_table (info);
13934   if (htab == NULL)
13935     return FALSE;
13936
13937   /* Don't relocate stub sections.  */
13938   if (input_section->owner == htab->params->stub_bfd)
13939     return TRUE;
13940
13941   BFD_ASSERT (is_ppc64_elf (input_bfd));
13942
13943   local_got_ents = elf_local_got_ents (input_bfd);
13944   TOCstart = elf_gp (output_bfd);
13945   symtab_hdr = &elf_symtab_hdr (input_bfd);
13946   sym_hashes = elf_sym_hashes (input_bfd);
13947   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13948
13949   rel = wrel = relocs;
13950   relend = relocs + input_section->reloc_count;
13951   for (; rel < relend; wrel++, rel++)
13952     {
13953       enum elf_ppc64_reloc_type r_type;
13954       bfd_vma addend;
13955       bfd_reloc_status_type r;
13956       Elf_Internal_Sym *sym;
13957       asection *sec;
13958       struct elf_link_hash_entry *h_elf;
13959       struct ppc_link_hash_entry *h;
13960       struct ppc_link_hash_entry *fdh;
13961       const char *sym_name;
13962       unsigned long r_symndx, toc_symndx;
13963       bfd_vma toc_addend;
13964       unsigned char tls_mask, tls_gd, tls_type;
13965       unsigned char sym_type;
13966       bfd_vma relocation;
13967       bfd_boolean unresolved_reloc, save_unresolved_reloc;
13968       bfd_boolean warned;
13969       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13970       unsigned int insn;
13971       unsigned int mask;
13972       struct ppc_stub_hash_entry *stub_entry;
13973       bfd_vma max_br_offset;
13974       bfd_vma from;
13975       Elf_Internal_Rela orig_rel;
13976       reloc_howto_type *howto;
13977       struct reloc_howto_struct alt_howto;
13978
13979     again:
13980       orig_rel = *rel;
13981
13982       r_type = ELF64_R_TYPE (rel->r_info);
13983       r_symndx = ELF64_R_SYM (rel->r_info);
13984
13985       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13986          symbol of the previous ADDR64 reloc.  The symbol gives us the
13987          proper TOC base to use.  */
13988       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13989           && wrel != relocs
13990           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13991           && is_opd)
13992         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13993
13994       sym = NULL;
13995       sec = NULL;
13996       h_elf = NULL;
13997       sym_name = NULL;
13998       unresolved_reloc = FALSE;
13999       warned = FALSE;
14000
14001       if (r_symndx < symtab_hdr->sh_info)
14002         {
14003           /* It's a local symbol.  */
14004           struct _opd_sec_data *opd;
14005
14006           sym = local_syms + r_symndx;
14007           sec = local_sections[r_symndx];
14008           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14009           sym_type = ELF64_ST_TYPE (sym->st_info);
14010           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14011           opd = get_opd_info (sec);
14012           if (opd != NULL && opd->adjust != NULL)
14013             {
14014               long adjust = opd->adjust[OPD_NDX (sym->st_value
14015                                                  + rel->r_addend)];
14016               if (adjust == -1)
14017                 relocation = 0;
14018               else
14019                 {
14020                   /* If this is a relocation against the opd section sym
14021                      and we have edited .opd, adjust the reloc addend so
14022                      that ld -r and ld --emit-relocs output is correct.
14023                      If it is a reloc against some other .opd symbol,
14024                      then the symbol value will be adjusted later.  */
14025                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14026                     rel->r_addend += adjust;
14027                   else
14028                     relocation += adjust;
14029                 }
14030             }
14031         }
14032       else
14033         {
14034           bfd_boolean ignored;
14035
14036           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14037                                    r_symndx, symtab_hdr, sym_hashes,
14038                                    h_elf, sec, relocation,
14039                                    unresolved_reloc, warned, ignored);
14040           sym_name = h_elf->root.root.string;
14041           sym_type = h_elf->type;
14042           if (sec != NULL
14043               && sec->owner == output_bfd
14044               && strcmp (sec->name, ".opd") == 0)
14045             {
14046               /* This is a symbol defined in a linker script.  All
14047                  such are defined in output sections, even those
14048                  defined by simple assignment from a symbol defined in
14049                  an input section.  Transfer the symbol to an
14050                  appropriate input .opd section, so that a branch to
14051                  this symbol will be mapped to the location specified
14052                  by the opd entry.  */
14053               struct bfd_link_order *lo;
14054               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14055                 if (lo->type == bfd_indirect_link_order)
14056                   {
14057                     asection *isec = lo->u.indirect.section;
14058                     if (h_elf->root.u.def.value >= isec->output_offset
14059                         && h_elf->root.u.def.value < (isec->output_offset
14060                                                       + isec->size))
14061                       {
14062                         h_elf->root.u.def.value -= isec->output_offset;
14063                         h_elf->root.u.def.section = isec;
14064                         sec = isec;
14065                         break;
14066                       }
14067                   }
14068             }
14069         }
14070       h = (struct ppc_link_hash_entry *) h_elf;
14071
14072       if (sec != NULL && discarded_section (sec))
14073         {
14074           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14075                                input_bfd, input_section,
14076                                contents + rel->r_offset);
14077           wrel->r_offset = rel->r_offset;
14078           wrel->r_info = 0;
14079           wrel->r_addend = 0;
14080
14081           /* For ld -r, remove relocations in debug sections against
14082              symbols defined in discarded sections.  Not done for
14083              non-debug to preserve relocs in .eh_frame which the
14084              eh_frame editing code expects to be present.  */
14085           if (bfd_link_relocatable (info)
14086               && (input_section->flags & SEC_DEBUGGING))
14087             wrel--;
14088
14089           continue;
14090         }
14091
14092       if (bfd_link_relocatable (info))
14093         goto copy_reloc;
14094
14095       if (h != NULL && &h->elf == htab->elf.hgot)
14096         {
14097           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14098           sec = bfd_abs_section_ptr;
14099           unresolved_reloc = FALSE;
14100         }
14101
14102       /* TLS optimizations.  Replace instruction sequences and relocs
14103          based on information we collected in tls_optimize.  We edit
14104          RELOCS so that --emit-relocs will output something sensible
14105          for the final instruction stream.  */
14106       tls_mask = 0;
14107       tls_gd = 0;
14108       toc_symndx = 0;
14109       if (h != NULL)
14110         tls_mask = h->tls_mask;
14111       else if (local_got_ents != NULL)
14112         {
14113           struct plt_entry **local_plt = (struct plt_entry **)
14114             (local_got_ents + symtab_hdr->sh_info);
14115           unsigned char *lgot_masks = (unsigned char *)
14116             (local_plt + symtab_hdr->sh_info);
14117           tls_mask = lgot_masks[r_symndx];
14118         }
14119       if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14120           && (r_type == R_PPC64_TLS
14121               || r_type == R_PPC64_TLSGD
14122               || r_type == R_PPC64_TLSLD))
14123         {
14124           /* Check for toc tls entries.  */
14125           unsigned char *toc_tls;
14126
14127           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14128                              &local_syms, rel, input_bfd))
14129             return FALSE;
14130
14131           if (toc_tls)
14132             tls_mask = *toc_tls;
14133         }
14134
14135       /* Check that tls relocs are used with tls syms, and non-tls
14136          relocs are used with non-tls syms.  */
14137       if (r_symndx != STN_UNDEF
14138           && r_type != R_PPC64_NONE
14139           && (h == NULL
14140               || h->elf.root.type == bfd_link_hash_defined
14141               || h->elf.root.type == bfd_link_hash_defweak)
14142           && (IS_PPC64_TLS_RELOC (r_type)
14143               != (sym_type == STT_TLS
14144                   || (sym_type == STT_SECTION
14145                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14146         {
14147           if ((tls_mask & TLS_TLS) != 0
14148               && (r_type == R_PPC64_TLS
14149                   || r_type == R_PPC64_TLSGD
14150                   || r_type == R_PPC64_TLSLD))
14151             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
14152             ;
14153           else
14154             info->callbacks->einfo
14155               (!IS_PPC64_TLS_RELOC (r_type)
14156                /* xgettext:c-format */
14157                ? _("%H: %s used with TLS symbol `%pT'\n")
14158                /* xgettext:c-format */
14159                : _("%H: %s used with non-TLS symbol `%pT'\n"),
14160                input_bfd, input_section, rel->r_offset,
14161                ppc64_elf_howto_table[r_type]->name,
14162                sym_name);
14163         }
14164
14165       /* Ensure reloc mapping code below stays sane.  */
14166       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14167           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14168           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
14169           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14170           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14171           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14172           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
14173           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14174           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14175           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14176         abort ();
14177
14178       switch (r_type)
14179         {
14180         default:
14181           break;
14182
14183         case R_PPC64_LO_DS_OPT:
14184           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14185           if ((insn & (0x3f << 26)) != 58u << 26)
14186             abort ();
14187           insn += (14u << 26) - (58u << 26);
14188           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14189           r_type = R_PPC64_TOC16_LO;
14190           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14191           break;
14192
14193         case R_PPC64_TOC16:
14194         case R_PPC64_TOC16_LO:
14195         case R_PPC64_TOC16_DS:
14196         case R_PPC64_TOC16_LO_DS:
14197           {
14198             /* Check for toc tls entries.  */
14199             unsigned char *toc_tls;
14200             int retval;
14201
14202             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14203                                    &local_syms, rel, input_bfd);
14204             if (retval == 0)
14205               return FALSE;
14206
14207             if (toc_tls)
14208               {
14209                 tls_mask = *toc_tls;
14210                 if (r_type == R_PPC64_TOC16_DS
14211                     || r_type == R_PPC64_TOC16_LO_DS)
14212                   {
14213                     if ((tls_mask & TLS_TLS) != 0
14214                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14215                       goto toctprel;
14216                   }
14217                 else
14218                   {
14219                     /* If we found a GD reloc pair, then we might be
14220                        doing a GD->IE transition.  */
14221                     if (retval == 2)
14222                       {
14223                         tls_gd = TLS_TPRELGD;
14224                         if ((tls_mask & TLS_TLS) != 0
14225                             && (tls_mask & TLS_GD) == 0)
14226                           goto tls_ldgd_opt;
14227                       }
14228                     else if (retval == 3)
14229                       {
14230                         if ((tls_mask & TLS_TLS) != 0
14231                             && (tls_mask & TLS_LD) == 0)
14232                           goto tls_ldgd_opt;
14233                       }
14234                   }
14235               }
14236           }
14237           break;
14238
14239         case R_PPC64_GOT_TPREL16_HI:
14240         case R_PPC64_GOT_TPREL16_HA:
14241           if ((tls_mask & TLS_TLS) != 0
14242               && (tls_mask & TLS_TPREL) == 0)
14243             {
14244               rel->r_offset -= d_offset;
14245               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14246               r_type = R_PPC64_NONE;
14247               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14248             }
14249           break;
14250
14251         case R_PPC64_GOT_TPREL16_DS:
14252         case R_PPC64_GOT_TPREL16_LO_DS:
14253           if ((tls_mask & TLS_TLS) != 0
14254               && (tls_mask & TLS_TPREL) == 0)
14255             {
14256             toctprel:
14257               insn = bfd_get_32 (input_bfd,
14258                                  contents + rel->r_offset - d_offset);
14259               insn &= 31 << 21;
14260               insn |= 0x3c0d0000;       /* addis 0,13,0 */
14261               bfd_put_32 (input_bfd, insn,
14262                           contents + rel->r_offset - d_offset);
14263               r_type = R_PPC64_TPREL16_HA;
14264               if (toc_symndx != 0)
14265                 {
14266                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14267                   rel->r_addend = toc_addend;
14268                   /* We changed the symbol.  Start over in order to
14269                      get h, sym, sec etc. right.  */
14270                   goto again;
14271                 }
14272               else
14273                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14274             }
14275           break;
14276
14277         case R_PPC64_TLS:
14278           if ((tls_mask & TLS_TLS) != 0
14279               && (tls_mask & TLS_TPREL) == 0)
14280             {
14281               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14282               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14283               if (insn == 0)
14284                 abort ();
14285               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14286               /* Was PPC64_TLS which sits on insn boundary, now
14287                  PPC64_TPREL16_LO which is at low-order half-word.  */
14288               rel->r_offset += d_offset;
14289               r_type = R_PPC64_TPREL16_LO;
14290               if (toc_symndx != 0)
14291                 {
14292                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14293                   rel->r_addend = toc_addend;
14294                   /* We changed the symbol.  Start over in order to
14295                      get h, sym, sec etc. right.  */
14296                   goto again;
14297                 }
14298               else
14299                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14300             }
14301           break;
14302
14303         case R_PPC64_GOT_TLSGD16_HI:
14304         case R_PPC64_GOT_TLSGD16_HA:
14305           tls_gd = TLS_TPRELGD;
14306           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14307             goto tls_gdld_hi;
14308           break;
14309
14310         case R_PPC64_GOT_TLSLD16_HI:
14311         case R_PPC64_GOT_TLSLD16_HA:
14312           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14313             {
14314             tls_gdld_hi:
14315               if ((tls_mask & tls_gd) != 0)
14316                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14317                           + R_PPC64_GOT_TPREL16_DS);
14318               else
14319                 {
14320                   rel->r_offset -= d_offset;
14321                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14322                   r_type = R_PPC64_NONE;
14323                 }
14324               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14325             }
14326           break;
14327
14328         case R_PPC64_GOT_TLSGD16:
14329         case R_PPC64_GOT_TLSGD16_LO:
14330           tls_gd = TLS_TPRELGD;
14331           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14332             goto tls_ldgd_opt;
14333           break;
14334
14335         case R_PPC64_GOT_TLSLD16:
14336         case R_PPC64_GOT_TLSLD16_LO:
14337           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14338             {
14339               unsigned int insn1, insn2;
14340               bfd_vma offset;
14341
14342             tls_ldgd_opt:
14343               offset = (bfd_vma) -1;
14344               /* If not using the newer R_PPC64_TLSGD/LD to mark
14345                  __tls_get_addr calls, we must trust that the call
14346                  stays with its arg setup insns, ie. that the next
14347                  reloc is the __tls_get_addr call associated with
14348                  the current reloc.  Edit both insns.  */
14349               if (input_section->has_tls_get_addr_call
14350                   && rel + 1 < relend
14351                   && branch_reloc_hash_match (input_bfd, rel + 1,
14352                                               htab->tls_get_addr,
14353                                               htab->tls_get_addr_fd))
14354                 offset = rel[1].r_offset;
14355               /* We read the low GOT_TLS (or TOC16) insn because we
14356                  need to keep the destination reg.  It may be
14357                  something other than the usual r3, and moved to r3
14358                  before the call by intervening code.  */
14359               insn1 = bfd_get_32 (input_bfd,
14360                                   contents + rel->r_offset - d_offset);
14361               if ((tls_mask & tls_gd) != 0)
14362                 {
14363                   /* IE */
14364                   insn1 &= (0x1f << 21) | (0x1f << 16);
14365                   insn1 |= 58 << 26;    /* ld */
14366                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14367                   if (offset != (bfd_vma) -1)
14368                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14369                   if ((tls_mask & TLS_EXPLICIT) == 0)
14370                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14371                               + R_PPC64_GOT_TPREL16_DS);
14372                   else
14373                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14374                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14375                 }
14376               else
14377                 {
14378                   /* LE */
14379                   insn1 &= 0x1f << 21;
14380                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14381                   insn2 = 0x38630000;   /* addi 3,3,0 */
14382                   if (tls_gd == 0)
14383                     {
14384                       /* Was an LD reloc.  */
14385                       if (toc_symndx)
14386                         sec = local_sections[toc_symndx];
14387                       for (r_symndx = 0;
14388                            r_symndx < symtab_hdr->sh_info;
14389                            r_symndx++)
14390                         if (local_sections[r_symndx] == sec)
14391                           break;
14392                       if (r_symndx >= symtab_hdr->sh_info)
14393                         r_symndx = STN_UNDEF;
14394                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14395                       if (r_symndx != STN_UNDEF)
14396                         rel->r_addend -= (local_syms[r_symndx].st_value
14397                                           + sec->output_offset
14398                                           + sec->output_section->vma);
14399                     }
14400                   else if (toc_symndx != 0)
14401                     {
14402                       r_symndx = toc_symndx;
14403                       rel->r_addend = toc_addend;
14404                     }
14405                   r_type = R_PPC64_TPREL16_HA;
14406                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14407                   if (offset != (bfd_vma) -1)
14408                     {
14409                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14410                                                     R_PPC64_TPREL16_LO);
14411                       rel[1].r_offset = offset + d_offset;
14412                       rel[1].r_addend = rel->r_addend;
14413                     }
14414                 }
14415               bfd_put_32 (input_bfd, insn1,
14416                           contents + rel->r_offset - d_offset);
14417               if (offset != (bfd_vma) -1)
14418                 bfd_put_32 (input_bfd, insn2, contents + offset);
14419               if ((tls_mask & tls_gd) == 0
14420                   && (tls_gd == 0 || toc_symndx != 0))
14421                 {
14422                   /* We changed the symbol.  Start over in order
14423                      to get h, sym, sec etc. right.  */
14424                   goto again;
14425                 }
14426             }
14427           break;
14428
14429         case R_PPC64_TLSGD:
14430           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
14431               && rel + 1 < relend)
14432             {
14433               unsigned int insn2;
14434               bfd_vma offset = rel->r_offset;
14435
14436               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14437                 {
14438                   bfd_put_32 (output_bfd, NOP, contents + offset);
14439                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14440                   break;
14441                 }
14442
14443               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14444                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14445
14446               if ((tls_mask & TLS_TPRELGD) != 0)
14447                 {
14448                   /* IE */
14449                   r_type = R_PPC64_NONE;
14450                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14451                 }
14452               else
14453                 {
14454                   /* LE */
14455                   if (toc_symndx != 0)
14456                     {
14457                       r_symndx = toc_symndx;
14458                       rel->r_addend = toc_addend;
14459                     }
14460                   r_type = R_PPC64_TPREL16_LO;
14461                   rel->r_offset = offset + d_offset;
14462                   insn2 = 0x38630000;   /* addi 3,3,0 */
14463                 }
14464               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14465               /* Zap the reloc on the _tls_get_addr call too.  */
14466               BFD_ASSERT (offset == rel[1].r_offset);
14467               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14468               bfd_put_32 (input_bfd, insn2, contents + offset);
14469               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14470                 goto again;
14471             }
14472           break;
14473
14474         case R_PPC64_TLSLD:
14475           if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
14476               && rel + 1 < relend)
14477             {
14478               unsigned int insn2;
14479               bfd_vma offset = rel->r_offset;
14480
14481               if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
14482                 {
14483                   bfd_put_32 (output_bfd, NOP, contents + offset);
14484                   rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14485                   break;
14486                 }
14487
14488               if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
14489                 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
14490
14491               if (toc_symndx)
14492                 sec = local_sections[toc_symndx];
14493               for (r_symndx = 0;
14494                    r_symndx < symtab_hdr->sh_info;
14495                    r_symndx++)
14496                 if (local_sections[r_symndx] == sec)
14497                   break;
14498               if (r_symndx >= symtab_hdr->sh_info)
14499                 r_symndx = STN_UNDEF;
14500               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14501               if (r_symndx != STN_UNDEF)
14502                 rel->r_addend -= (local_syms[r_symndx].st_value
14503                                   + sec->output_offset
14504                                   + sec->output_section->vma);
14505
14506               r_type = R_PPC64_TPREL16_LO;
14507               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14508               rel->r_offset = offset + d_offset;
14509               /* Zap the reloc on the _tls_get_addr call too.  */
14510               BFD_ASSERT (offset == rel[1].r_offset);
14511               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14512               insn2 = 0x38630000;       /* addi 3,3,0 */
14513               bfd_put_32 (input_bfd, insn2, contents + offset);
14514               goto again;
14515             }
14516           break;
14517
14518         case R_PPC64_DTPMOD64:
14519           if (rel + 1 < relend
14520               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14521               && rel[1].r_offset == rel->r_offset + 8)
14522             {
14523               if ((tls_mask & TLS_GD) == 0)
14524                 {
14525                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14526                   if ((tls_mask & TLS_TPRELGD) != 0)
14527                     r_type = R_PPC64_TPREL64;
14528                   else
14529                     {
14530                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14531                       r_type = R_PPC64_NONE;
14532                     }
14533                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14534                 }
14535             }
14536           else
14537             {
14538               if ((tls_mask & TLS_LD) == 0)
14539                 {
14540                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14541                   r_type = R_PPC64_NONE;
14542                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14543                 }
14544             }
14545           break;
14546
14547         case R_PPC64_TPREL64:
14548           if ((tls_mask & TLS_TPREL) == 0)
14549             {
14550               r_type = R_PPC64_NONE;
14551               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14552             }
14553           break;
14554
14555         case R_PPC64_ENTRY:
14556           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14557           if (!bfd_link_pic (info)
14558               && !info->traditional_format
14559               && relocation + 0x80008000 <= 0xffffffff)
14560             {
14561               unsigned int insn1, insn2;
14562
14563               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14564               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14565               if ((insn1 & ~0xfffc) == LD_R2_0R12
14566                   && insn2 == ADD_R2_R2_R12)
14567                 {
14568                   bfd_put_32 (input_bfd,
14569                               LIS_R2 + PPC_HA (relocation),
14570                               contents + rel->r_offset);
14571                   bfd_put_32 (input_bfd,
14572                               ADDI_R2_R2 + PPC_LO (relocation),
14573                               contents + rel->r_offset + 4);
14574                 }
14575             }
14576           else
14577             {
14578               relocation -= (rel->r_offset
14579                              + input_section->output_offset
14580                              + input_section->output_section->vma);
14581               if (relocation + 0x80008000 <= 0xffffffff)
14582                 {
14583                   unsigned int insn1, insn2;
14584
14585                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14586                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14587                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14588                       && insn2 == ADD_R2_R2_R12)
14589                     {
14590                       bfd_put_32 (input_bfd,
14591                                   ADDIS_R2_R12 + PPC_HA (relocation),
14592                                   contents + rel->r_offset);
14593                       bfd_put_32 (input_bfd,
14594                                   ADDI_R2_R2 + PPC_LO (relocation),
14595                                   contents + rel->r_offset + 4);
14596                     }
14597                 }
14598             }
14599           break;
14600
14601         case R_PPC64_REL16_HA:
14602           /* If we are generating a non-PIC executable, edit
14603              .  0:      addis 2,12,.TOC.-0b@ha
14604              .          addi 2,2,.TOC.-0b@l
14605              used by ELFv2 global entry points to set up r2, to
14606              .          lis 2,.TOC.@ha
14607              .          addi 2,2,.TOC.@l
14608              if .TOC. is in range.  */
14609           if (!bfd_link_pic (info)
14610               && !info->traditional_format
14611               && !htab->opd_abi
14612               && rel->r_addend == d_offset
14613               && h != NULL && &h->elf == htab->elf.hgot
14614               && rel + 1 < relend
14615               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14616               && rel[1].r_offset == rel->r_offset + 4
14617               && rel[1].r_addend == rel->r_addend + 4
14618               && relocation + 0x80008000 <= 0xffffffff)
14619             {
14620               unsigned int insn1, insn2;
14621               bfd_vma offset = rel->r_offset - d_offset;
14622               insn1 = bfd_get_32 (input_bfd, contents + offset);
14623               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14624               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14625                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14626                 {
14627                   r_type = R_PPC64_ADDR16_HA;
14628                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14629                   rel->r_addend -= d_offset;
14630                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14631                   rel[1].r_addend -= d_offset + 4;
14632                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14633                 }
14634             }
14635           break;
14636         }
14637
14638       /* Handle other relocations that tweak non-addend part of insn.  */
14639       insn = 0;
14640       max_br_offset = 1 << 25;
14641       addend = rel->r_addend;
14642       reloc_dest = DEST_NORMAL;
14643       switch (r_type)
14644         {
14645         default:
14646           break;
14647
14648         case R_PPC64_TOCSAVE:
14649           if (relocation + addend == (rel->r_offset
14650                                       + input_section->output_offset
14651                                       + input_section->output_section->vma)
14652               && tocsave_find (htab, NO_INSERT,
14653                                &local_syms, rel, input_bfd))
14654             {
14655               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14656               if (insn == NOP
14657                   || insn == CROR_151515 || insn == CROR_313131)
14658                 bfd_put_32 (input_bfd,
14659                             STD_R2_0R1 + STK_TOC (htab),
14660                             contents + rel->r_offset);
14661             }
14662           break;
14663
14664           /* Branch taken prediction relocations.  */
14665         case R_PPC64_ADDR14_BRTAKEN:
14666         case R_PPC64_REL14_BRTAKEN:
14667           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14668           /* Fall through.  */
14669
14670           /* Branch not taken prediction relocations.  */
14671         case R_PPC64_ADDR14_BRNTAKEN:
14672         case R_PPC64_REL14_BRNTAKEN:
14673           insn |= bfd_get_32 (input_bfd,
14674                               contents + rel->r_offset) & ~(0x01 << 21);
14675           /* Fall through.  */
14676
14677         case R_PPC64_REL14:
14678           max_br_offset = 1 << 15;
14679           /* Fall through.  */
14680
14681         case R_PPC64_REL24:
14682         case R_PPC64_PLTCALL:
14683           /* Calls to functions with a different TOC, such as calls to
14684              shared objects, need to alter the TOC pointer.  This is
14685              done using a linkage stub.  A REL24 branching to these
14686              linkage stubs needs to be followed by a nop, as the nop
14687              will be replaced with an instruction to restore the TOC
14688              base pointer.  */
14689           fdh = h;
14690           if (h != NULL
14691               && h->oh != NULL
14692               && h->oh->is_func_descriptor)
14693             fdh = ppc_follow_link (h->oh);
14694           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14695                                            htab);
14696           if (r_type == R_PPC64_PLTCALL
14697               && stub_entry != NULL
14698               && (stub_entry->stub_type == ppc_stub_plt_call
14699                   || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14700             stub_entry = NULL;
14701
14702           if (stub_entry != NULL
14703               && (stub_entry->stub_type == ppc_stub_plt_call
14704                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14705                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14706                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14707             {
14708               bfd_boolean can_plt_call = FALSE;
14709
14710               if (stub_entry->stub_type == ppc_stub_plt_call
14711                   && !htab->opd_abi
14712                   && htab->params->plt_localentry0 != 0
14713                   && is_elfv2_localentry0 (&h->elf))
14714                 {
14715                   /* The function doesn't use or change r2.  */
14716                   can_plt_call = TRUE;
14717                 }
14718
14719               /* All of these stubs may modify r2, so there must be a
14720                  branch and link followed by a nop.  The nop is
14721                  replaced by an insn to restore r2.  */
14722               else if (rel->r_offset + 8 <= input_section->size)
14723                 {
14724                   unsigned long br;
14725
14726                   br = bfd_get_32 (input_bfd,
14727                                    contents + rel->r_offset);
14728                   if ((br & 1) != 0)
14729                     {
14730                       unsigned long nop;
14731
14732                       nop = bfd_get_32 (input_bfd,
14733                                         contents + rel->r_offset + 4);
14734                       if (nop == LD_R2_0R1 + STK_TOC (htab))
14735                         can_plt_call = TRUE;
14736                       else if (nop == NOP
14737                                || nop == CROR_151515
14738                                || nop == CROR_313131)
14739                         {
14740                           if (h != NULL
14741                               && (h == htab->tls_get_addr_fd
14742                                   || h == htab->tls_get_addr)
14743                               && htab->params->tls_get_addr_opt)
14744                             {
14745                               /* Special stub used, leave nop alone.  */
14746                             }
14747                           else
14748                             bfd_put_32 (input_bfd,
14749                                         LD_R2_0R1 + STK_TOC (htab),
14750                                         contents + rel->r_offset + 4);
14751                           can_plt_call = TRUE;
14752                         }
14753                     }
14754                 }
14755
14756               if (!can_plt_call && h != NULL)
14757                 {
14758                   const char *name = h->elf.root.root.string;
14759
14760                   if (*name == '.')
14761                     ++name;
14762
14763                   if (strncmp (name, "__libc_start_main", 17) == 0
14764                       && (name[17] == 0 || name[17] == '@'))
14765                     {
14766                       /* Allow crt1 branch to go via a toc adjusting
14767                          stub.  Other calls that never return could do
14768                          the same, if we could detect such.  */
14769                       can_plt_call = TRUE;
14770                     }
14771                 }
14772
14773               if (!can_plt_call)
14774                 {
14775                   /* g++ as of 20130507 emits self-calls without a
14776                      following nop.  This is arguably wrong since we
14777                      have conflicting information.  On the one hand a
14778                      global symbol and on the other a local call
14779                      sequence, but don't error for this special case.
14780                      It isn't possible to cheaply verify we have
14781                      exactly such a call.  Allow all calls to the same
14782                      section.  */
14783                   asection *code_sec = sec;
14784
14785                   if (get_opd_info (sec) != NULL)
14786                     {
14787                       bfd_vma off = (relocation + addend
14788                                      - sec->output_section->vma
14789                                      - sec->output_offset);
14790
14791                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14792                     }
14793                   if (code_sec == input_section)
14794                     can_plt_call = TRUE;
14795                 }
14796
14797               if (!can_plt_call)
14798                 {
14799                   if (stub_entry->stub_type == ppc_stub_plt_call
14800                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14801                     info->callbacks->einfo
14802                       /* xgettext:c-format */
14803                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14804                          "recompile with -fPIC\n"),
14805                        input_bfd, input_section, rel->r_offset, sym_name);
14806                   else
14807                     info->callbacks->einfo
14808                       /* xgettext:c-format */
14809                       (_("%H: call to `%pT' lacks nop, can't restore toc; "
14810                          "(-mcmodel=small toc adjust stub)\n"),
14811                        input_bfd, input_section, rel->r_offset, sym_name);
14812
14813                   bfd_set_error (bfd_error_bad_value);
14814                   ret = FALSE;
14815                 }
14816
14817               if (can_plt_call
14818                   && (stub_entry->stub_type == ppc_stub_plt_call
14819                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14820                 unresolved_reloc = FALSE;
14821             }
14822
14823           if ((stub_entry == NULL
14824                || stub_entry->stub_type == ppc_stub_long_branch
14825                || stub_entry->stub_type == ppc_stub_plt_branch)
14826               && get_opd_info (sec) != NULL)
14827             {
14828               /* The branch destination is the value of the opd entry. */
14829               bfd_vma off = (relocation + addend
14830                              - sec->output_section->vma
14831                              - sec->output_offset);
14832               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14833               if (dest != (bfd_vma) -1)
14834                 {
14835                   relocation = dest;
14836                   addend = 0;
14837                   reloc_dest = DEST_OPD;
14838                 }
14839             }
14840
14841           /* If the branch is out of reach we ought to have a long
14842              branch stub.  */
14843           from = (rel->r_offset
14844                   + input_section->output_offset
14845                   + input_section->output_section->vma);
14846
14847           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14848                                                   ? fdh->elf.other
14849                                                   : sym->st_other);
14850
14851           if (stub_entry != NULL
14852               && (stub_entry->stub_type == ppc_stub_long_branch
14853                   || stub_entry->stub_type == ppc_stub_plt_branch)
14854               && (r_type == R_PPC64_ADDR14_BRTAKEN
14855                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14856                   || (relocation + addend - from + max_br_offset
14857                       < 2 * max_br_offset)))
14858             /* Don't use the stub if this branch is in range.  */
14859             stub_entry = NULL;
14860
14861           if (stub_entry != NULL)
14862             {
14863               /* Munge up the value and addend so that we call the stub
14864                  rather than the procedure directly.  */
14865               asection *stub_sec = stub_entry->group->stub_sec;
14866
14867               if (stub_entry->stub_type == ppc_stub_save_res)
14868                 relocation += (stub_sec->output_offset
14869                                + stub_sec->output_section->vma
14870                                + stub_sec->size - htab->sfpr->size
14871                                - htab->sfpr->output_offset
14872                                - htab->sfpr->output_section->vma);
14873               else
14874                 relocation = (stub_entry->stub_offset
14875                               + stub_sec->output_offset
14876                               + stub_sec->output_section->vma);
14877               addend = 0;
14878               reloc_dest = DEST_STUB;
14879
14880               if ((stub_entry->stub_type == ppc_stub_plt_call
14881                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14882                   && (ALWAYS_EMIT_R2SAVE
14883                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14884                   && rel + 1 < relend
14885                   && rel[1].r_offset == rel->r_offset + 4
14886                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14887                 relocation += 4;
14888             }
14889
14890           if (insn != 0)
14891             {
14892               if (is_isa_v2)
14893                 {
14894                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14895                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14896                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14897                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14898                     insn |= 0x02 << 21;
14899                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14900                     insn |= 0x08 << 21;
14901                   else
14902                     break;
14903                 }
14904               else
14905                 {
14906                   /* Invert 'y' bit if not the default.  */
14907                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14908                     insn ^= 0x01 << 21;
14909                 }
14910
14911               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14912             }
14913
14914           /* NOP out calls to undefined weak functions.
14915              We can thus call a weak function without first
14916              checking whether the function is defined.  */
14917           else if (h != NULL
14918                    && h->elf.root.type == bfd_link_hash_undefweak
14919                    && h->elf.dynindx == -1
14920                    && r_type == R_PPC64_REL24
14921                    && relocation == 0
14922                    && addend == 0)
14923             {
14924               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14925               goto copy_reloc;
14926             }
14927           break;
14928         }
14929
14930       /* Set `addend'.  */
14931       tls_type = 0;
14932       save_unresolved_reloc = unresolved_reloc;
14933       switch (r_type)
14934         {
14935         default:
14936           /* xgettext:c-format */
14937           _bfd_error_handler (_("%pB: %s unsupported"),
14938                               input_bfd, ppc64_elf_howto_table[r_type]->name);
14939
14940           bfd_set_error (bfd_error_bad_value);
14941           ret = FALSE;
14942           goto copy_reloc;
14943
14944         case R_PPC64_NONE:
14945         case R_PPC64_TLS:
14946         case R_PPC64_TLSGD:
14947         case R_PPC64_TLSLD:
14948         case R_PPC64_TOCSAVE:
14949         case R_PPC64_GNU_VTINHERIT:
14950         case R_PPC64_GNU_VTENTRY:
14951         case R_PPC64_ENTRY:
14952           goto copy_reloc;
14953
14954           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14955              address in the GOT as relocation value instead of the
14956              symbol's value itself.  Also, create a GOT entry for the
14957              symbol and put the symbol value there.  */
14958         case R_PPC64_GOT_TLSGD16:
14959         case R_PPC64_GOT_TLSGD16_LO:
14960         case R_PPC64_GOT_TLSGD16_HI:
14961         case R_PPC64_GOT_TLSGD16_HA:
14962           tls_type = TLS_TLS | TLS_GD;
14963           goto dogot;
14964
14965         case R_PPC64_GOT_TLSLD16:
14966         case R_PPC64_GOT_TLSLD16_LO:
14967         case R_PPC64_GOT_TLSLD16_HI:
14968         case R_PPC64_GOT_TLSLD16_HA:
14969           tls_type = TLS_TLS | TLS_LD;
14970           goto dogot;
14971
14972         case R_PPC64_GOT_TPREL16_DS:
14973         case R_PPC64_GOT_TPREL16_LO_DS:
14974         case R_PPC64_GOT_TPREL16_HI:
14975         case R_PPC64_GOT_TPREL16_HA:
14976           tls_type = TLS_TLS | TLS_TPREL;
14977           goto dogot;
14978
14979         case R_PPC64_GOT_DTPREL16_DS:
14980         case R_PPC64_GOT_DTPREL16_LO_DS:
14981         case R_PPC64_GOT_DTPREL16_HI:
14982         case R_PPC64_GOT_DTPREL16_HA:
14983           tls_type = TLS_TLS | TLS_DTPREL;
14984           goto dogot;
14985
14986         case R_PPC64_GOT16:
14987         case R_PPC64_GOT16_LO:
14988         case R_PPC64_GOT16_HI:
14989         case R_PPC64_GOT16_HA:
14990         case R_PPC64_GOT16_DS:
14991         case R_PPC64_GOT16_LO_DS:
14992         dogot:
14993           {
14994             /* Relocation is to the entry for this symbol in the global
14995                offset table.  */
14996             asection *got;
14997             bfd_vma *offp;
14998             bfd_vma off;
14999             unsigned long indx = 0;
15000             struct got_entry *ent;
15001
15002             if (tls_type == (TLS_TLS | TLS_LD)
15003                 && (h == NULL
15004                     || !h->elf.def_dynamic))
15005               ent = ppc64_tlsld_got (input_bfd);
15006             else
15007               {
15008                 if (h != NULL)
15009                   {
15010                     if (!htab->elf.dynamic_sections_created
15011                         || h->elf.dynindx == -1
15012                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15013                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15014                       /* This is actually a static link, or it is a
15015                          -Bsymbolic link and the symbol is defined
15016                          locally, or the symbol was forced to be local
15017                          because of a version file.  */
15018                       ;
15019                     else
15020                       {
15021                         indx = h->elf.dynindx;
15022                         unresolved_reloc = FALSE;
15023                       }
15024                     ent = h->elf.got.glist;
15025                   }
15026                 else
15027                   {
15028                     if (local_got_ents == NULL)
15029                       abort ();
15030                     ent = local_got_ents[r_symndx];
15031                   }
15032
15033                 for (; ent != NULL; ent = ent->next)
15034                   if (ent->addend == orig_rel.r_addend
15035                       && ent->owner == input_bfd
15036                       && ent->tls_type == tls_type)
15037                     break;
15038               }
15039
15040             if (ent == NULL)
15041               abort ();
15042             if (ent->is_indirect)
15043               ent = ent->got.ent;
15044             offp = &ent->got.offset;
15045             got = ppc64_elf_tdata (ent->owner)->got;
15046             if (got == NULL)
15047               abort ();
15048
15049             /* The offset must always be a multiple of 8.  We use the
15050                least significant bit to record whether we have already
15051                processed this entry.  */
15052             off = *offp;
15053             if ((off & 1) != 0)
15054               off &= ~1;
15055             else
15056               {
15057                 /* Generate relocs for the dynamic linker, except in
15058                    the case of TLSLD where we'll use one entry per
15059                    module.  */
15060                 asection *relgot;
15061                 bfd_boolean ifunc;
15062
15063                 *offp = off | 1;
15064                 relgot = NULL;
15065                 ifunc = (h != NULL
15066                          ? h->elf.type == STT_GNU_IFUNC
15067                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15068                 if (ifunc)
15069                   {
15070                     relgot = htab->elf.irelplt;
15071                     if (indx == 0)
15072                       htab->local_ifunc_resolver = 1;
15073                     else if (is_static_defined (&h->elf))
15074                       htab->maybe_local_ifunc_resolver = 1;
15075                   }
15076                 else if (indx != 0
15077                          || (bfd_link_pic (info)
15078                              && (h == NULL
15079                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15080                                  || (tls_type == (TLS_TLS | TLS_LD)
15081                                      && !h->elf.def_dynamic))
15082                              && !(tls_type == (TLS_TLS | TLS_TPREL)
15083                                   && bfd_link_executable (info)
15084                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15085                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
15086                 if (relgot != NULL)
15087                   {
15088                     outrel.r_offset = (got->output_section->vma
15089                                        + got->output_offset
15090                                        + off);
15091                     outrel.r_addend = addend;
15092                     if (tls_type & (TLS_LD | TLS_GD))
15093                       {
15094                         outrel.r_addend = 0;
15095                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15096                         if (tls_type == (TLS_TLS | TLS_GD))
15097                           {
15098                             loc = relgot->contents;
15099                             loc += (relgot->reloc_count++
15100                                     * sizeof (Elf64_External_Rela));
15101                             bfd_elf64_swap_reloca_out (output_bfd,
15102                                                        &outrel, loc);
15103                             outrel.r_offset += 8;
15104                             outrel.r_addend = addend;
15105                             outrel.r_info
15106                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15107                           }
15108                       }
15109                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
15110                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15111                     else if (tls_type == (TLS_TLS | TLS_TPREL))
15112                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15113                     else if (indx != 0)
15114                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15115                     else
15116                       {
15117                         if (ifunc)
15118                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15119                         else
15120                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15121
15122                         /* Write the .got section contents for the sake
15123                            of prelink.  */
15124                         loc = got->contents + off;
15125                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15126                                     loc);
15127                       }
15128
15129                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15130                       {
15131                         outrel.r_addend += relocation;
15132                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15133                           {
15134                             if (htab->elf.tls_sec == NULL)
15135                               outrel.r_addend = 0;
15136                             else
15137                               outrel.r_addend -= htab->elf.tls_sec->vma;
15138                           }
15139                       }
15140                     loc = relgot->contents;
15141                     loc += (relgot->reloc_count++
15142                             * sizeof (Elf64_External_Rela));
15143                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15144                   }
15145
15146                 /* Init the .got section contents here if we're not
15147                    emitting a reloc.  */
15148                 else
15149                   {
15150                     relocation += addend;
15151                     if (tls_type != 0)
15152                       {
15153                         if (htab->elf.tls_sec == NULL)
15154                           relocation = 0;
15155                         else
15156                           {
15157                             if (tls_type & TLS_LD)
15158                               relocation = 0;
15159                             else
15160                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15161                             if (tls_type & TLS_TPREL)
15162                               relocation += DTP_OFFSET - TP_OFFSET;
15163                           }
15164
15165                         if (tls_type & (TLS_GD | TLS_LD))
15166                           {
15167                             bfd_put_64 (output_bfd, relocation,
15168                                         got->contents + off + 8);
15169                             relocation = 1;
15170                           }
15171                       }
15172                     bfd_put_64 (output_bfd, relocation,
15173                                 got->contents + off);
15174                   }
15175               }
15176
15177             if (off >= (bfd_vma) -2)
15178               abort ();
15179
15180             relocation = got->output_section->vma + got->output_offset + off;
15181             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15182           }
15183           break;
15184
15185         case R_PPC64_PLT16_HA:
15186         case R_PPC64_PLT16_HI:
15187         case R_PPC64_PLT16_LO:
15188         case R_PPC64_PLT16_LO_DS:
15189         case R_PPC64_PLT32:
15190         case R_PPC64_PLT64:
15191         case R_PPC64_PLTSEQ:
15192         case R_PPC64_PLTCALL:
15193           /* Relocation is to the entry for this symbol in the
15194              procedure linkage table.  */
15195           unresolved_reloc = TRUE;
15196           {
15197             struct plt_entry **plt_list = NULL;
15198             if (h != NULL)
15199               plt_list = &h->elf.plt.plist;
15200             else if (local_got_ents != NULL)
15201               {
15202                 struct plt_entry **local_plt = (struct plt_entry **)
15203                   (local_got_ents + symtab_hdr->sh_info);
15204                 plt_list = local_plt + r_symndx;
15205               }
15206             if (plt_list)
15207               {
15208                 struct plt_entry *ent;
15209
15210                 for (ent = *plt_list; ent != NULL; ent = ent->next)
15211                   if (ent->plt.offset != (bfd_vma) -1
15212                       && ent->addend == orig_rel.r_addend)
15213                     {
15214                       asection *plt;
15215                       bfd_vma got;
15216
15217                       plt = htab->elf.splt;
15218                       if (!htab->elf.dynamic_sections_created
15219                           || h == NULL
15220                           || h->elf.dynindx == -1)
15221                         {
15222                           if (h != NULL
15223                               ? h->elf.type == STT_GNU_IFUNC
15224                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15225                             plt = htab->elf.iplt;
15226                           else
15227                             plt = htab->pltlocal;
15228                         }
15229                       relocation = (plt->output_section->vma
15230                                     + plt->output_offset
15231                                     + ent->plt.offset);
15232                       if (r_type == R_PPC64_PLT16_HA
15233                           || r_type ==R_PPC64_PLT16_HI
15234                           || r_type ==R_PPC64_PLT16_LO
15235                           || r_type ==R_PPC64_PLT16_LO_DS)
15236                         {
15237                           got = (elf_gp (output_bfd)
15238                                  + htab->sec_info[input_section->id].toc_off);
15239                           relocation -= got;
15240                         }
15241                       addend = 0;
15242                       unresolved_reloc = FALSE;
15243                       break;
15244                     }
15245               }
15246           }
15247           break;
15248
15249         case R_PPC64_TOC:
15250           /* Relocation value is TOC base.  */
15251           relocation = TOCstart;
15252           if (r_symndx == STN_UNDEF)
15253             relocation += htab->sec_info[input_section->id].toc_off;
15254           else if (unresolved_reloc)
15255             ;
15256           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15257             relocation += htab->sec_info[sec->id].toc_off;
15258           else
15259             unresolved_reloc = TRUE;
15260           goto dodyn;
15261
15262           /* TOC16 relocs.  We want the offset relative to the TOC base,
15263              which is the address of the start of the TOC plus 0x8000.
15264              The TOC consists of sections .got, .toc, .tocbss, and .plt,
15265              in this order.  */
15266         case R_PPC64_TOC16:
15267         case R_PPC64_TOC16_LO:
15268         case R_PPC64_TOC16_HI:
15269         case R_PPC64_TOC16_DS:
15270         case R_PPC64_TOC16_LO_DS:
15271         case R_PPC64_TOC16_HA:
15272           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15273           break;
15274
15275           /* Relocate against the beginning of the section.  */
15276         case R_PPC64_SECTOFF:
15277         case R_PPC64_SECTOFF_LO:
15278         case R_PPC64_SECTOFF_HI:
15279         case R_PPC64_SECTOFF_DS:
15280         case R_PPC64_SECTOFF_LO_DS:
15281         case R_PPC64_SECTOFF_HA:
15282           if (sec != NULL)
15283             addend -= sec->output_section->vma;
15284           break;
15285
15286         case R_PPC64_REL16:
15287         case R_PPC64_REL16_LO:
15288         case R_PPC64_REL16_HI:
15289         case R_PPC64_REL16_HA:
15290         case R_PPC64_REL16DX_HA:
15291           break;
15292
15293         case R_PPC64_REL14:
15294         case R_PPC64_REL14_BRNTAKEN:
15295         case R_PPC64_REL14_BRTAKEN:
15296         case R_PPC64_REL24:
15297           break;
15298
15299         case R_PPC64_TPREL16:
15300         case R_PPC64_TPREL16_LO:
15301         case R_PPC64_TPREL16_HI:
15302         case R_PPC64_TPREL16_HA:
15303         case R_PPC64_TPREL16_DS:
15304         case R_PPC64_TPREL16_LO_DS:
15305         case R_PPC64_TPREL16_HIGH:
15306         case R_PPC64_TPREL16_HIGHA:
15307         case R_PPC64_TPREL16_HIGHER:
15308         case R_PPC64_TPREL16_HIGHERA:
15309         case R_PPC64_TPREL16_HIGHEST:
15310         case R_PPC64_TPREL16_HIGHESTA:
15311           if (h != NULL
15312               && h->elf.root.type == bfd_link_hash_undefweak
15313               && h->elf.dynindx == -1)
15314             {
15315               /* Make this relocation against an undefined weak symbol
15316                  resolve to zero.  This is really just a tweak, since
15317                  code using weak externs ought to check that they are
15318                  defined before using them.  */
15319               bfd_byte *p = contents + rel->r_offset - d_offset;
15320
15321               insn = bfd_get_32 (input_bfd, p);
15322               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15323               if (insn != 0)
15324                 bfd_put_32 (input_bfd, insn, p);
15325               break;
15326             }
15327           if (htab->elf.tls_sec != NULL)
15328             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15329           /* The TPREL16 relocs shouldn't really be used in shared
15330              libs or with non-local symbols as that will result in
15331              DT_TEXTREL being set, but support them anyway.  */
15332           goto dodyn;
15333
15334         case R_PPC64_DTPREL16:
15335         case R_PPC64_DTPREL16_LO:
15336         case R_PPC64_DTPREL16_HI:
15337         case R_PPC64_DTPREL16_HA:
15338         case R_PPC64_DTPREL16_DS:
15339         case R_PPC64_DTPREL16_LO_DS:
15340         case R_PPC64_DTPREL16_HIGH:
15341         case R_PPC64_DTPREL16_HIGHA:
15342         case R_PPC64_DTPREL16_HIGHER:
15343         case R_PPC64_DTPREL16_HIGHERA:
15344         case R_PPC64_DTPREL16_HIGHEST:
15345         case R_PPC64_DTPREL16_HIGHESTA:
15346           if (htab->elf.tls_sec != NULL)
15347             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15348           break;
15349
15350         case R_PPC64_ADDR64_LOCAL:
15351           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15352                                               ? h->elf.other
15353                                               : sym->st_other);
15354           break;
15355
15356         case R_PPC64_DTPMOD64:
15357           relocation = 1;
15358           addend = 0;
15359           goto dodyn;
15360
15361         case R_PPC64_TPREL64:
15362           if (htab->elf.tls_sec != NULL)
15363             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15364           goto dodyn;
15365
15366         case R_PPC64_DTPREL64:
15367           if (htab->elf.tls_sec != NULL)
15368             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15369           /* Fall through.  */
15370
15371           /* Relocations that may need to be propagated if this is a
15372              dynamic object.  */
15373         case R_PPC64_REL30:
15374         case R_PPC64_REL32:
15375         case R_PPC64_REL64:
15376         case R_PPC64_ADDR14:
15377         case R_PPC64_ADDR14_BRNTAKEN:
15378         case R_PPC64_ADDR14_BRTAKEN:
15379         case R_PPC64_ADDR16:
15380         case R_PPC64_ADDR16_DS:
15381         case R_PPC64_ADDR16_HA:
15382         case R_PPC64_ADDR16_HI:
15383         case R_PPC64_ADDR16_HIGH:
15384         case R_PPC64_ADDR16_HIGHA:
15385         case R_PPC64_ADDR16_HIGHER:
15386         case R_PPC64_ADDR16_HIGHERA:
15387         case R_PPC64_ADDR16_HIGHEST:
15388         case R_PPC64_ADDR16_HIGHESTA:
15389         case R_PPC64_ADDR16_LO:
15390         case R_PPC64_ADDR16_LO_DS:
15391         case R_PPC64_ADDR24:
15392         case R_PPC64_ADDR32:
15393         case R_PPC64_ADDR64:
15394         case R_PPC64_UADDR16:
15395         case R_PPC64_UADDR32:
15396         case R_PPC64_UADDR64:
15397         dodyn:
15398           if ((input_section->flags & SEC_ALLOC) == 0)
15399             break;
15400
15401           if (NO_OPD_RELOCS && is_opd)
15402             break;
15403
15404           if (bfd_link_pic (info)
15405               ? ((h == NULL
15406                   || h->dyn_relocs != NULL)
15407                  && ((h != NULL && pc_dynrelocs (h))
15408                      || must_be_dyn_reloc (info, r_type)))
15409               : (h != NULL
15410                  ? h->dyn_relocs != NULL
15411                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15412             {
15413               bfd_boolean skip, relocate;
15414               asection *sreloc;
15415               bfd_vma out_off;
15416               long indx = 0;
15417
15418               /* When generating a dynamic object, these relocations
15419                  are copied into the output file to be resolved at run
15420                  time.  */
15421
15422               skip = FALSE;
15423               relocate = FALSE;
15424
15425               out_off = _bfd_elf_section_offset (output_bfd, info,
15426                                                  input_section, rel->r_offset);
15427               if (out_off == (bfd_vma) -1)
15428                 skip = TRUE;
15429               else if (out_off == (bfd_vma) -2)
15430                 skip = TRUE, relocate = TRUE;
15431               out_off += (input_section->output_section->vma
15432                           + input_section->output_offset);
15433               outrel.r_offset = out_off;
15434               outrel.r_addend = rel->r_addend;
15435
15436               /* Optimize unaligned reloc use.  */
15437               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15438                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15439                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15440               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15441                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15442                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15443               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15444                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15445                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15446
15447               if (skip)
15448                 memset (&outrel, 0, sizeof outrel);
15449               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15450                        && !is_opd
15451                        && r_type != R_PPC64_TOC)
15452                 {
15453                   indx = h->elf.dynindx;
15454                   BFD_ASSERT (indx != -1);
15455                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15456                 }
15457               else
15458                 {
15459                   /* This symbol is local, or marked to become local,
15460                      or this is an opd section reloc which must point
15461                      at a local function.  */
15462                   outrel.r_addend += relocation;
15463                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15464                     {
15465                       if (is_opd && h != NULL)
15466                         {
15467                           /* Lie about opd entries.  This case occurs
15468                              when building shared libraries and we
15469                              reference a function in another shared
15470                              lib.  The same thing happens for a weak
15471                              definition in an application that's
15472                              overridden by a strong definition in a
15473                              shared lib.  (I believe this is a generic
15474                              bug in binutils handling of weak syms.)
15475                              In these cases we won't use the opd
15476                              entry in this lib.  */
15477                           unresolved_reloc = FALSE;
15478                         }
15479                       if (!is_opd
15480                           && r_type == R_PPC64_ADDR64
15481                           && (h != NULL
15482                               ? h->elf.type == STT_GNU_IFUNC
15483                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15484                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15485                       else
15486                         {
15487                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15488
15489                           /* We need to relocate .opd contents for ld.so.
15490                              Prelink also wants simple and consistent rules
15491                              for relocs.  This make all RELATIVE relocs have
15492                              *r_offset equal to r_addend.  */
15493                           relocate = TRUE;
15494                         }
15495                     }
15496                   else
15497                     {
15498                       if (h != NULL
15499                           ? h->elf.type == STT_GNU_IFUNC
15500                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15501                         {
15502                           info->callbacks->einfo
15503                             /* xgettext:c-format */
15504                             (_("%H: %s for indirect "
15505                                "function `%pT' unsupported\n"),
15506                              input_bfd, input_section, rel->r_offset,
15507                              ppc64_elf_howto_table[r_type]->name,
15508                              sym_name);
15509                           ret = FALSE;
15510                         }
15511                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15512                         ;
15513                       else if (sec == NULL || sec->owner == NULL)
15514                         {
15515                           bfd_set_error (bfd_error_bad_value);
15516                           return FALSE;
15517                         }
15518                       else
15519                         {
15520                           asection *osec;
15521
15522                           osec = sec->output_section;
15523                           indx = elf_section_data (osec)->dynindx;
15524
15525                           if (indx == 0)
15526                             {
15527                               if ((osec->flags & SEC_READONLY) == 0
15528                                   && htab->elf.data_index_section != NULL)
15529                                 osec = htab->elf.data_index_section;
15530                               else
15531                                 osec = htab->elf.text_index_section;
15532                               indx = elf_section_data (osec)->dynindx;
15533                             }
15534                           BFD_ASSERT (indx != 0);
15535
15536                           /* We are turning this relocation into one
15537                              against a section symbol, so subtract out
15538                              the output section's address but not the
15539                              offset of the input section in the output
15540                              section.  */
15541                           outrel.r_addend -= osec->vma;
15542                         }
15543
15544                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15545                     }
15546                 }
15547
15548               sreloc = elf_section_data (input_section)->sreloc;
15549               if (h != NULL
15550                   ? h->elf.type == STT_GNU_IFUNC
15551                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15552                 {
15553                   sreloc = htab->elf.irelplt;
15554                   if (indx == 0)
15555                     htab->local_ifunc_resolver = 1;
15556                   else if (is_static_defined (&h->elf))
15557                     htab->maybe_local_ifunc_resolver = 1;
15558                 }
15559               if (sreloc == NULL)
15560                 abort ();
15561
15562               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15563                   >= sreloc->size)
15564                 abort ();
15565               loc = sreloc->contents;
15566               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15567               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15568
15569               /* If this reloc is against an external symbol, it will
15570                  be computed at runtime, so there's no need to do
15571                  anything now.  However, for the sake of prelink ensure
15572                  that the section contents are a known value.  */
15573               if (! relocate)
15574                 {
15575                   unresolved_reloc = FALSE;
15576                   /* The value chosen here is quite arbitrary as ld.so
15577                      ignores section contents except for the special
15578                      case of .opd where the contents might be accessed
15579                      before relocation.  Choose zero, as that won't
15580                      cause reloc overflow.  */
15581                   relocation = 0;
15582                   addend = 0;
15583                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15584                      to improve backward compatibility with older
15585                      versions of ld.  */
15586                   if (r_type == R_PPC64_ADDR64)
15587                     addend = outrel.r_addend;
15588                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15589                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15590                     addend = outrel.r_offset;
15591                 }
15592             }
15593           break;
15594
15595         case R_PPC64_COPY:
15596         case R_PPC64_GLOB_DAT:
15597         case R_PPC64_JMP_SLOT:
15598         case R_PPC64_JMP_IREL:
15599         case R_PPC64_RELATIVE:
15600           /* We shouldn't ever see these dynamic relocs in relocatable
15601              files.  */
15602           /* Fall through.  */
15603
15604         case R_PPC64_PLTGOT16:
15605         case R_PPC64_PLTGOT16_DS:
15606         case R_PPC64_PLTGOT16_HA:
15607         case R_PPC64_PLTGOT16_HI:
15608         case R_PPC64_PLTGOT16_LO:
15609         case R_PPC64_PLTGOT16_LO_DS:
15610         case R_PPC64_PLTREL32:
15611         case R_PPC64_PLTREL64:
15612           /* These ones haven't been implemented yet.  */
15613
15614           info->callbacks->einfo
15615             /* xgettext:c-format */
15616             (_("%P: %pB: %s is not supported for `%pT'\n"),
15617              input_bfd,
15618              ppc64_elf_howto_table[r_type]->name, sym_name);
15619
15620           bfd_set_error (bfd_error_invalid_operation);
15621           ret = FALSE;
15622           goto copy_reloc;
15623         }
15624
15625       /* Multi-instruction sequences that access the TOC can be
15626          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15627          to             nop;           addi rb,r2,x;  */
15628       switch (r_type)
15629         {
15630         default:
15631           break;
15632
15633         case R_PPC64_GOT_TLSLD16_HI:
15634         case R_PPC64_GOT_TLSGD16_HI:
15635         case R_PPC64_GOT_TPREL16_HI:
15636         case R_PPC64_GOT_DTPREL16_HI:
15637         case R_PPC64_GOT16_HI:
15638         case R_PPC64_TOC16_HI:
15639           /* These relocs would only be useful if building up an
15640              offset to later add to r2, perhaps in an indexed
15641              addressing mode instruction.  Don't try to optimize.
15642              Unfortunately, the possibility of someone building up an
15643              offset like this or even with the HA relocs, means that
15644              we need to check the high insn when optimizing the low
15645              insn.  */
15646           break;
15647
15648         case R_PPC64_PLTCALL:
15649           if (unresolved_reloc)
15650             {
15651               /* No plt entry.  Make this into a direct call.  */
15652               bfd_byte *p = contents + rel->r_offset;
15653               insn = bfd_get_32 (input_bfd, p);
15654               insn &= 1;
15655               bfd_put_32 (input_bfd, B_DOT | insn, p);
15656               bfd_put_32 (input_bfd, NOP, p + 4);
15657               unresolved_reloc = save_unresolved_reloc;
15658               r_type = R_PPC64_REL24;
15659             }
15660           break;
15661
15662         case R_PPC64_PLTSEQ:
15663           if (unresolved_reloc)
15664             {
15665               unresolved_reloc = FALSE;
15666               goto nop_it;
15667             }
15668           break;
15669
15670         case R_PPC64_PLT16_HA:
15671           if (unresolved_reloc)
15672             {
15673               unresolved_reloc = FALSE;
15674               goto nop_it;
15675             }
15676           /* Fall through.  */
15677         case R_PPC64_GOT_TLSLD16_HA:
15678         case R_PPC64_GOT_TLSGD16_HA:
15679         case R_PPC64_GOT_TPREL16_HA:
15680         case R_PPC64_GOT_DTPREL16_HA:
15681         case R_PPC64_GOT16_HA:
15682         case R_PPC64_TOC16_HA:
15683           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15684               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15685             {
15686               bfd_byte *p;
15687             nop_it:
15688               p = contents + (rel->r_offset & ~3);
15689               bfd_put_32 (input_bfd, NOP, p);
15690               goto copy_reloc;
15691             }
15692           break;
15693
15694         case R_PPC64_PLT16_LO:
15695         case R_PPC64_PLT16_LO_DS:
15696           if (unresolved_reloc)
15697             {
15698               unresolved_reloc = FALSE;
15699               goto nop_it;
15700             }
15701           /* Fall through.  */
15702         case R_PPC64_GOT_TLSLD16_LO:
15703         case R_PPC64_GOT_TLSGD16_LO:
15704         case R_PPC64_GOT_TPREL16_LO_DS:
15705         case R_PPC64_GOT_DTPREL16_LO_DS:
15706         case R_PPC64_GOT16_LO:
15707         case R_PPC64_GOT16_LO_DS:
15708         case R_PPC64_TOC16_LO:
15709         case R_PPC64_TOC16_LO_DS:
15710           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15711               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15712             {
15713               bfd_byte *p = contents + (rel->r_offset & ~3);
15714               insn = bfd_get_32 (input_bfd, p);
15715               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15716                 {
15717                   /* Transform addic to addi when we change reg.  */
15718                   insn &= ~((0x3f << 26) | (0x1f << 16));
15719                   insn |= (14u << 26) | (2 << 16);
15720                 }
15721               else
15722                 {
15723                   insn &= ~(0x1f << 16);
15724                   insn |= 2 << 16;
15725                 }
15726               bfd_put_32 (input_bfd, insn, p);
15727             }
15728           break;
15729
15730         case R_PPC64_TPREL16_HA:
15731           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15732             {
15733               bfd_byte *p = contents + (rel->r_offset & ~3);
15734               insn = bfd_get_32 (input_bfd, p);
15735               if ((insn & ((0x3f << 26) | 0x1f << 16))
15736                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15737                 /* xgettext:c-format */
15738                 info->callbacks->minfo
15739                   (_("%H: warning: %s unexpected insn %#x.\n"),
15740                    input_bfd, input_section, rel->r_offset,
15741                    ppc64_elf_howto_table[r_type]->name, insn);
15742               else
15743                 {
15744                   bfd_put_32 (input_bfd, NOP, p);
15745                   goto copy_reloc;
15746                 }
15747             }
15748           break;
15749
15750         case R_PPC64_TPREL16_LO:
15751         case R_PPC64_TPREL16_LO_DS:
15752           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15753             {
15754               bfd_byte *p = contents + (rel->r_offset & ~3);
15755               insn = bfd_get_32 (input_bfd, p);
15756               insn &= ~(0x1f << 16);
15757               insn |= 13 << 16;
15758               bfd_put_32 (input_bfd, insn, p);
15759             }
15760           break;
15761         }
15762
15763       /* Do any further special processing.  */
15764       switch (r_type)
15765         {
15766         default:
15767           break;
15768
15769         case R_PPC64_REL16_HA:
15770         case R_PPC64_REL16DX_HA:
15771         case R_PPC64_ADDR16_HA:
15772         case R_PPC64_ADDR16_HIGHA:
15773         case R_PPC64_ADDR16_HIGHERA:
15774         case R_PPC64_ADDR16_HIGHESTA:
15775         case R_PPC64_TOC16_HA:
15776         case R_PPC64_SECTOFF_HA:
15777         case R_PPC64_TPREL16_HA:
15778         case R_PPC64_TPREL16_HIGHA:
15779         case R_PPC64_TPREL16_HIGHERA:
15780         case R_PPC64_TPREL16_HIGHESTA:
15781         case R_PPC64_DTPREL16_HA:
15782         case R_PPC64_DTPREL16_HIGHA:
15783         case R_PPC64_DTPREL16_HIGHERA:
15784         case R_PPC64_DTPREL16_HIGHESTA:
15785           /* It's just possible that this symbol is a weak symbol
15786              that's not actually defined anywhere. In that case,
15787              'sec' would be NULL, and we should leave the symbol
15788              alone (it will be set to zero elsewhere in the link).  */
15789           if (sec == NULL)
15790             break;
15791           /* Fall through.  */
15792
15793         case R_PPC64_GOT16_HA:
15794         case R_PPC64_PLTGOT16_HA:
15795         case R_PPC64_PLT16_HA:
15796         case R_PPC64_GOT_TLSGD16_HA:
15797         case R_PPC64_GOT_TLSLD16_HA:
15798         case R_PPC64_GOT_TPREL16_HA:
15799         case R_PPC64_GOT_DTPREL16_HA:
15800           /* Add 0x10000 if sign bit in 0:15 is set.
15801              Bits 0:15 are not used.  */
15802           addend += 0x8000;
15803           break;
15804
15805         case R_PPC64_ADDR16_DS:
15806         case R_PPC64_ADDR16_LO_DS:
15807         case R_PPC64_GOT16_DS:
15808         case R_PPC64_GOT16_LO_DS:
15809         case R_PPC64_PLT16_LO_DS:
15810         case R_PPC64_SECTOFF_DS:
15811         case R_PPC64_SECTOFF_LO_DS:
15812         case R_PPC64_TOC16_DS:
15813         case R_PPC64_TOC16_LO_DS:
15814         case R_PPC64_PLTGOT16_DS:
15815         case R_PPC64_PLTGOT16_LO_DS:
15816         case R_PPC64_GOT_TPREL16_DS:
15817         case R_PPC64_GOT_TPREL16_LO_DS:
15818         case R_PPC64_GOT_DTPREL16_DS:
15819         case R_PPC64_GOT_DTPREL16_LO_DS:
15820         case R_PPC64_TPREL16_DS:
15821         case R_PPC64_TPREL16_LO_DS:
15822         case R_PPC64_DTPREL16_DS:
15823         case R_PPC64_DTPREL16_LO_DS:
15824           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15825           mask = 3;
15826           /* If this reloc is against an lq, lxv, or stxv insn, then
15827              the value must be a multiple of 16.  This is somewhat of
15828              a hack, but the "correct" way to do this by defining _DQ
15829              forms of all the _DS relocs bloats all reloc switches in
15830              this file.  It doesn't make much sense to use these
15831              relocs in data, so testing the insn should be safe.  */
15832           if ((insn & (0x3f << 26)) == (56u << 26)
15833               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15834             mask = 15;
15835           relocation += addend;
15836           addend = insn & (mask ^ 3);
15837           if ((relocation & mask) != 0)
15838             {
15839               relocation ^= relocation & mask;
15840               info->callbacks->einfo
15841                 /* xgettext:c-format */
15842                 (_("%H: error: %s not a multiple of %u\n"),
15843                  input_bfd, input_section, rel->r_offset,
15844                  ppc64_elf_howto_table[r_type]->name,
15845                  mask + 1);
15846               bfd_set_error (bfd_error_bad_value);
15847               ret = FALSE;
15848               goto copy_reloc;
15849             }
15850           break;
15851         }
15852
15853       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15854          because such sections are not SEC_ALLOC and thus ld.so will
15855          not process them.  */
15856       howto = ppc64_elf_howto_table[(int) r_type];
15857       if (unresolved_reloc
15858           && !((input_section->flags & SEC_DEBUGGING) != 0
15859                && h->elf.def_dynamic)
15860           && _bfd_elf_section_offset (output_bfd, info, input_section,
15861                                       rel->r_offset) != (bfd_vma) -1)
15862         {
15863           info->callbacks->einfo
15864             /* xgettext:c-format */
15865             (_("%H: unresolvable %s against `%pT'\n"),
15866              input_bfd, input_section, rel->r_offset,
15867              howto->name,
15868              h->elf.root.root.string);
15869           ret = FALSE;
15870         }
15871
15872       /* 16-bit fields in insns mostly have signed values, but a
15873          few insns have 16-bit unsigned values.  Really, we should
15874          have different reloc types.  */
15875       if (howto->complain_on_overflow != complain_overflow_dont
15876           && howto->dst_mask == 0xffff
15877           && (input_section->flags & SEC_CODE) != 0)
15878         {
15879           enum complain_overflow complain = complain_overflow_signed;
15880
15881           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15882           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15883             complain = complain_overflow_bitfield;
15884           else if (howto->rightshift == 0
15885                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15886                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15887                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15888                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15889                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15890                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15891             complain = complain_overflow_unsigned;
15892           if (howto->complain_on_overflow != complain)
15893             {
15894               alt_howto = *howto;
15895               alt_howto.complain_on_overflow = complain;
15896               howto = &alt_howto;
15897             }
15898         }
15899
15900       if (r_type == R_PPC64_REL16DX_HA)
15901         {
15902           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15903           if (rel->r_offset + 4 > input_section->size)
15904             r = bfd_reloc_outofrange;
15905           else
15906             {
15907               relocation += addend;
15908               relocation -= (rel->r_offset
15909                              + input_section->output_offset
15910                              + input_section->output_section->vma);
15911               relocation = (bfd_signed_vma) relocation >> 16;
15912               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15913               insn &= ~0x1fffc1;
15914               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15915               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15916               r = bfd_reloc_ok;
15917               if (relocation + 0x8000 > 0xffff)
15918                 r = bfd_reloc_overflow;
15919             }
15920         }
15921       else
15922         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15923                                       rel->r_offset, relocation, addend);
15924
15925       if (r != bfd_reloc_ok)
15926         {
15927           char *more_info = NULL;
15928           const char *reloc_name = howto->name;
15929
15930           if (reloc_dest != DEST_NORMAL)
15931             {
15932               more_info = bfd_malloc (strlen (reloc_name) + 8);
15933               if (more_info != NULL)
15934                 {
15935                   strcpy (more_info, reloc_name);
15936                   strcat (more_info, (reloc_dest == DEST_OPD
15937                                       ? " (OPD)" : " (stub)"));
15938                   reloc_name = more_info;
15939                 }
15940             }
15941
15942           if (r == bfd_reloc_overflow)
15943             {
15944               /* On code like "if (foo) foo();" don't report overflow
15945                  on a branch to zero when foo is undefined.  */
15946               if (!warned
15947                   && (reloc_dest == DEST_STUB
15948                       || !(h != NULL
15949                            && (h->elf.root.type == bfd_link_hash_undefweak
15950                                || h->elf.root.type == bfd_link_hash_undefined)
15951                            && is_branch_reloc (r_type))))
15952                 info->callbacks->reloc_overflow (info, &h->elf.root,
15953                                                  sym_name, reloc_name,
15954                                                  orig_rel.r_addend,
15955                                                  input_bfd, input_section,
15956                                                  rel->r_offset);
15957             }
15958           else
15959             {
15960               info->callbacks->einfo
15961                 /* xgettext:c-format */
15962                 (_("%H: %s against `%pT': error %d\n"),
15963                  input_bfd, input_section, rel->r_offset,
15964                  reloc_name, sym_name, (int) r);
15965               ret = FALSE;
15966             }
15967           if (more_info != NULL)
15968             free (more_info);
15969         }
15970     copy_reloc:
15971       if (wrel != rel)
15972         *wrel = *rel;
15973     }
15974
15975   if (wrel != rel)
15976     {
15977       Elf_Internal_Shdr *rel_hdr;
15978       size_t deleted = rel - wrel;
15979
15980       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15981       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15982       if (rel_hdr->sh_size == 0)
15983         {
15984           /* It is too late to remove an empty reloc section.  Leave
15985              one NONE reloc.
15986              ??? What is wrong with an empty section???  */
15987           rel_hdr->sh_size = rel_hdr->sh_entsize;
15988           deleted -= 1;
15989         }
15990       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15991       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15992       input_section->reloc_count -= deleted;
15993     }
15994
15995   /* If we're emitting relocations, then shortly after this function
15996      returns, reloc offsets and addends for this section will be
15997      adjusted.  Worse, reloc symbol indices will be for the output
15998      file rather than the input.  Save a copy of the relocs for
15999      opd_entry_value.  */
16000   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16001     {
16002       bfd_size_type amt;
16003       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16004       rel = bfd_alloc (input_bfd, amt);
16005       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16006       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16007       if (rel == NULL)
16008         return FALSE;
16009       memcpy (rel, relocs, amt);
16010     }
16011   return ret;
16012 }
16013
16014 /* Adjust the value of any local symbols in opd sections.  */
16015
16016 static int
16017 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16018                               const char *name ATTRIBUTE_UNUSED,
16019                               Elf_Internal_Sym *elfsym,
16020                               asection *input_sec,
16021                               struct elf_link_hash_entry *h)
16022 {
16023   struct _opd_sec_data *opd;
16024   long adjust;
16025   bfd_vma value;
16026
16027   if (h != NULL)
16028     return 1;
16029
16030   opd = get_opd_info (input_sec);
16031   if (opd == NULL || opd->adjust == NULL)
16032     return 1;
16033
16034   value = elfsym->st_value - input_sec->output_offset;
16035   if (!bfd_link_relocatable (info))
16036     value -= input_sec->output_section->vma;
16037
16038   adjust = opd->adjust[OPD_NDX (value)];
16039   if (adjust == -1)
16040     return 2;
16041
16042   elfsym->st_value += adjust;
16043   return 1;
16044 }
16045
16046 /* Finish up dynamic symbol handling.  We set the contents of various
16047    dynamic sections here.  */
16048
16049 static bfd_boolean
16050 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16051                                  struct bfd_link_info *info,
16052                                  struct elf_link_hash_entry *h,
16053                                  Elf_Internal_Sym *sym)
16054 {
16055   struct ppc_link_hash_table *htab;
16056   struct plt_entry *ent;
16057
16058   htab = ppc_hash_table (info);
16059   if (htab == NULL)
16060     return FALSE;
16061
16062   if (!htab->opd_abi && !h->def_regular)
16063     for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16064       if (ent->plt.offset != (bfd_vma) -1)
16065         {
16066           /* Mark the symbol as undefined, rather than as
16067              defined in glink.  Leave the value if there were
16068              any relocations where pointer equality matters
16069              (this is a clue for the dynamic linker, to make
16070              function pointer comparisons work between an
16071              application and shared library), otherwise set it
16072              to zero.  */
16073           sym->st_shndx = SHN_UNDEF;
16074           if (!h->pointer_equality_needed)
16075             sym->st_value = 0;
16076           else if (!h->ref_regular_nonweak)
16077             {
16078               /* This breaks function pointer comparisons, but
16079                  that is better than breaking tests for a NULL
16080                  function pointer.  */
16081               sym->st_value = 0;
16082             }
16083           break;
16084         }
16085
16086   if (h->needs_copy)
16087     {
16088       /* This symbol needs a copy reloc.  Set it up.  */
16089       Elf_Internal_Rela rela;
16090       asection *srel;
16091       bfd_byte *loc;
16092
16093       if (h->dynindx == -1
16094           || (h->root.type != bfd_link_hash_defined
16095               && h->root.type != bfd_link_hash_defweak)
16096           || htab->elf.srelbss == NULL
16097           || htab->elf.sreldynrelro == NULL)
16098         abort ();
16099
16100       rela.r_offset = (h->root.u.def.value
16101                        + h->root.u.def.section->output_section->vma
16102                        + h->root.u.def.section->output_offset);
16103       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16104       rela.r_addend = 0;
16105       if (h->root.u.def.section == htab->elf.sdynrelro)
16106         srel = htab->elf.sreldynrelro;
16107       else
16108         srel = htab->elf.srelbss;
16109       loc = srel->contents;
16110       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16111       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16112     }
16113
16114   return TRUE;
16115 }
16116
16117 /* Used to decide how to sort relocs in an optimal manner for the
16118    dynamic linker, before writing them out.  */
16119
16120 static enum elf_reloc_type_class
16121 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16122                             const asection *rel_sec,
16123                             const Elf_Internal_Rela *rela)
16124 {
16125   enum elf_ppc64_reloc_type r_type;
16126   struct ppc_link_hash_table *htab = ppc_hash_table (info);
16127
16128   if (rel_sec == htab->elf.irelplt)
16129     return reloc_class_ifunc;
16130
16131   r_type = ELF64_R_TYPE (rela->r_info);
16132   switch (r_type)
16133     {
16134     case R_PPC64_RELATIVE:
16135       return reloc_class_relative;
16136     case R_PPC64_JMP_SLOT:
16137       return reloc_class_plt;
16138     case R_PPC64_COPY:
16139       return reloc_class_copy;
16140     default:
16141       return reloc_class_normal;
16142     }
16143 }
16144
16145 /* Finish up the dynamic sections.  */
16146
16147 static bfd_boolean
16148 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16149                                    struct bfd_link_info *info)
16150 {
16151   struct ppc_link_hash_table *htab;
16152   bfd *dynobj;
16153   asection *sdyn;
16154
16155   htab = ppc_hash_table (info);
16156   if (htab == NULL)
16157     return FALSE;
16158
16159   dynobj = htab->elf.dynobj;
16160   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16161
16162   if (htab->elf.dynamic_sections_created)
16163     {
16164       Elf64_External_Dyn *dyncon, *dynconend;
16165
16166       if (sdyn == NULL || htab->elf.sgot == NULL)
16167         abort ();
16168
16169       dyncon = (Elf64_External_Dyn *) sdyn->contents;
16170       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16171       for (; dyncon < dynconend; dyncon++)
16172         {
16173           Elf_Internal_Dyn dyn;
16174           asection *s;
16175
16176           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16177
16178           switch (dyn.d_tag)
16179             {
16180             default:
16181               continue;
16182
16183             case DT_PPC64_GLINK:
16184               s = htab->glink;
16185               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16186               /* We stupidly defined DT_PPC64_GLINK to be the start
16187                  of glink rather than the first entry point, which is
16188                  what ld.so needs, and now have a bigger stub to
16189                  support automatic multiple TOCs.  */
16190               dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16191               break;
16192
16193             case DT_PPC64_OPD:
16194               s = bfd_get_section_by_name (output_bfd, ".opd");
16195               if (s == NULL)
16196                 continue;
16197               dyn.d_un.d_ptr = s->vma;
16198               break;
16199
16200             case DT_PPC64_OPT:
16201               if (htab->do_multi_toc && htab->multi_toc_needed)
16202                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16203               if (htab->has_plt_localentry0)
16204                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16205               break;
16206
16207             case DT_PPC64_OPDSZ:
16208               s = bfd_get_section_by_name (output_bfd, ".opd");
16209               if (s == NULL)
16210                 continue;
16211               dyn.d_un.d_val = s->size;
16212               break;
16213
16214             case DT_PLTGOT:
16215               s = htab->elf.splt;
16216               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16217               break;
16218
16219             case DT_JMPREL:
16220               s = htab->elf.srelplt;
16221               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16222               break;
16223
16224             case DT_PLTRELSZ:
16225               dyn.d_un.d_val = htab->elf.srelplt->size;
16226               break;
16227
16228             case DT_TEXTREL:
16229               if (htab->local_ifunc_resolver)
16230                 info->callbacks->einfo
16231                   (_("%X%P: text relocations and GNU indirect "
16232                      "functions will result in a segfault at runtime\n"));
16233               else if (htab->maybe_local_ifunc_resolver)
16234                 info->callbacks->einfo
16235                   (_("%P: warning: text relocations and GNU indirect "
16236                      "functions may result in a segfault at runtime\n"));
16237               continue;
16238             }
16239
16240           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16241         }
16242     }
16243
16244   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16245       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16246     {
16247       /* Fill in the first entry in the global offset table.
16248          We use it to hold the link-time TOCbase.  */
16249       bfd_put_64 (output_bfd,
16250                   elf_gp (output_bfd) + TOC_BASE_OFF,
16251                   htab->elf.sgot->contents);
16252
16253       /* Set .got entry size.  */
16254       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16255     }
16256
16257   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16258       && htab->elf.splt->output_section != bfd_abs_section_ptr)
16259     {
16260       /* Set .plt entry size.  */
16261       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16262         = PLT_ENTRY_SIZE (htab);
16263     }
16264
16265   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16266      brlt ourselves if emitrelocations.  */
16267   if (htab->brlt != NULL
16268       && htab->brlt->reloc_count != 0
16269       && !_bfd_elf_link_output_relocs (output_bfd,
16270                                        htab->brlt,
16271                                        elf_section_data (htab->brlt)->rela.hdr,
16272                                        elf_section_data (htab->brlt)->relocs,
16273                                        NULL))
16274     return FALSE;
16275
16276   if (htab->glink != NULL
16277       && htab->glink->reloc_count != 0
16278       && !_bfd_elf_link_output_relocs (output_bfd,
16279                                        htab->glink,
16280                                        elf_section_data (htab->glink)->rela.hdr,
16281                                        elf_section_data (htab->glink)->relocs,
16282                                        NULL))
16283     return FALSE;
16284
16285   if (htab->glink_eh_frame != NULL
16286       && htab->glink_eh_frame->size != 0)
16287     {
16288       bfd_vma val;
16289       bfd_byte *p;
16290       struct map_stub *group;
16291       size_t align = 4;
16292
16293       p = htab->glink_eh_frame->contents;
16294       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
16295
16296       for (group = htab->group; group != NULL; group = group->next)
16297         if (group->stub_sec != NULL)
16298           {
16299             /* Offset to stub section.  */
16300             val = (group->stub_sec->output_section->vma
16301                    + group->stub_sec->output_offset);
16302             val -= (htab->glink_eh_frame->output_section->vma
16303                     + htab->glink_eh_frame->output_offset
16304                     + (p + 8 - htab->glink_eh_frame->contents));
16305             if (val + 0x80000000 > 0xffffffff)
16306               {
16307                 _bfd_error_handler
16308                   (_("%s offset too large for .eh_frame sdata4 encoding"),
16309                    group->stub_sec->name);
16310                 return FALSE;
16311               }
16312             bfd_put_32 (dynobj, val, p + 8);
16313             p += stub_eh_frame_size (group, align);
16314           }
16315       if (htab->glink != NULL && htab->glink->size != 0)
16316         {
16317           /* Offset to .glink.  */
16318           val = (htab->glink->output_section->vma
16319                  + htab->glink->output_offset
16320                  + 8);
16321           val -= (htab->glink_eh_frame->output_section->vma
16322                   + htab->glink_eh_frame->output_offset
16323                   + (p + 8 - htab->glink_eh_frame->contents));
16324           if (val + 0x80000000 > 0xffffffff)
16325             {
16326               _bfd_error_handler
16327                 (_("%s offset too large for .eh_frame sdata4 encoding"),
16328                  htab->glink->name);
16329               return FALSE;
16330             }
16331           bfd_put_32 (dynobj, val, p + 8);
16332           p += (24 + align - 1) & -align;
16333         }
16334
16335       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16336           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16337                                                htab->glink_eh_frame,
16338                                                htab->glink_eh_frame->contents))
16339         return FALSE;
16340     }
16341
16342   /* We need to handle writing out multiple GOT sections ourselves,
16343      since we didn't add them to DYNOBJ.  We know dynobj is the first
16344      bfd.  */
16345   while ((dynobj = dynobj->link.next) != NULL)
16346     {
16347       asection *s;
16348
16349       if (!is_ppc64_elf (dynobj))
16350         continue;
16351
16352       s = ppc64_elf_tdata (dynobj)->got;
16353       if (s != NULL
16354           && s->size != 0
16355           && s->output_section != bfd_abs_section_ptr
16356           && !bfd_set_section_contents (output_bfd, s->output_section,
16357                                         s->contents, s->output_offset,
16358                                         s->size))
16359         return FALSE;
16360       s = ppc64_elf_tdata (dynobj)->relgot;
16361       if (s != NULL
16362           && s->size != 0
16363           && s->output_section != bfd_abs_section_ptr
16364           && !bfd_set_section_contents (output_bfd, s->output_section,
16365                                         s->contents, s->output_offset,
16366                                         s->size))
16367         return FALSE;
16368     }
16369
16370   return TRUE;
16371 }
16372
16373 #include "elf64-target.h"
16374
16375 /* FreeBSD support */
16376
16377 #undef  TARGET_LITTLE_SYM
16378 #undef  TARGET_LITTLE_NAME
16379
16380 #undef  TARGET_BIG_SYM
16381 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
16382 #undef  TARGET_BIG_NAME
16383 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16384
16385 #undef  ELF_OSABI
16386 #define ELF_OSABI       ELFOSABI_FREEBSD
16387
16388 #undef  elf64_bed
16389 #define elf64_bed       elf64_powerpc_fbsd_bed
16390
16391 #include "elf64-target.h"