bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2017 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      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_want_dynrelro 1
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_dtrel_excludes_plt 1
  80 #define elf_backend_default_execstack 0
  81
  82 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  83 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  84 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  87 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  92
  93 #define elf_backend_object_p                  ppc64_elf_object_p
  94 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  95 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  96 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  99 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 100 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 101 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 103 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 104 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 105 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 106 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 107 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 108 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 109 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 110 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 111 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 112 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 113 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 114 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 115 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 116 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 117 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 118 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 119 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 120 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 121 #define elf_backend_special_sections          ppc64_elf_special_sections
 122 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 123 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 124 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 125
 126 /* The name of the dynamic interpreter.  This is put in the .interp
 127    section.  */
 128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 129
 130 /* The size in bytes of an entry in the procedure linkage table.  */
 131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 132
 133 /* The initial size of the plt reserved for the dynamic linker.  */
 134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 135
 136 /* Offsets to some stack save slots.  */
 137 #define STK_LR 16
 138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 139 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 140    CR save slot.  Used only by optimised __tls_get_addr call stub,
 141    relying on __tls_get_addr_opt not saving CR..  */
 142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 143
 144 /* TOC base pointers offset from start of TOC.  */
 145 #define TOC_BASE_OFF    0x8000
 146 /* TOC base alignment.  */
 147 #define TOC_BASE_ALIGN  256
 148
 149 /* Offset of tp and dtp pointers from start of TLS block.  */
 150 #define TP_OFFSET       0x7000
 151 #define DTP_OFFSET      0x8000
 152
 153 /* .plt call stub instructions.  The normal stub is like this, but
 154    sometimes the .plt entry crosses a 64k boundary and we need to
 155    insert an addi to adjust r11.  */
 156 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 157 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 158 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 159 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 160 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 161 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 162 #define BCTR            0x4e800420      /* bctr                      */
 163
 164 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 165 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 166 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 167
 168 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 169 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 170 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 171 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 172 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 173 #define BNECTR          0x4ca20420      /* bnectr+               */
 174 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 175
 176 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 177 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 178 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 179
 180 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 181 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 182 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 183
 184 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 185 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 186 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 187 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 188 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 189
 190 /* glink call stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_CALL_STUB_SIZE (16*4)
 192                                         /* 0:                           */
 193                                         /*  .quad plt0-1f               */
 194                                         /* __glink:                     */
 195 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 196 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 197                                         /* 1:                           */
 198 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 199                                         /*  ld %2,(0b-1b)(%11)          */
 200 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 201 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 202                                         /*  ld %12,0(%11)               */
 203                                         /*  ld %2,8(%11)                */
 204                                         /*  mtctr %12                   */
 205                                         /*  ld %11,16(%11)              */
 206                                         /*  bctr                        */
 207 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 208 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 209 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 210 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 211 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 212
 213 /* Pad with this.  */
 214 #define NOP             0x60000000
 215
 216 /* Some other nops.  */
 217 #define CROR_151515     0x4def7b82
 218 #define CROR_313131     0x4ffffb82
 219
 220 /* .glink entries for the first 32k functions are two instructions.  */
 221 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 222 #define B_DOT           0x48000000      /* b     .              */
 223
 224 /* After that, we need two instructions to load the index, followed by
 225    a branch.  */
 226 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 227 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 228
 229 /* Instructions used by the save and restore reg functions.  */
 230 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 231 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 232 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 233 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 234 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 235 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 236 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 237 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 238 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 239 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 240 #define BLR             0x4e800020      /* blr                  */
 241
 242 /* Since .opd is an array of descriptors and each entry will end up
 243    with identical R_PPC64_RELATIVE relocs, there is really no need to
 244    propagate .opd relocs;  The dynamic linker should be taught to
 245    relocate .opd without reloc entries.  */
 246 #ifndef NO_OPD_RELOCS
 247 #define NO_OPD_RELOCS 0
 248 #endif
 249
 250 #ifndef ARRAY_SIZE
 251 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 252 #endif
 253
 254 static inline int
 255 abiversion (bfd *abfd)
 256 {
 257   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 258 }
 259
 260 static inline void
 261 set_abiversion (bfd *abfd, int ver)
 262 {
 263   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 264   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 265 }
 266 \f
 267 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 268
 269 /* Relocation HOWTO's.  */
 270 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 271
 272 static reloc_howto_type ppc64_elf_howto_raw[] = {
 273   /* This reloc does nothing.  */
 274   HOWTO (R_PPC64_NONE,          /* type */
 275          0,                     /* rightshift */
 276          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          0,                     /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_dont, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_NONE",        /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0,                     /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* A standard 32 bit relocation.  */
 289   HOWTO (R_PPC64_ADDR32,        /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          32,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_bitfield, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_PPC64_ADDR32",      /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0xffffffff,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   /* An absolute 26 bit branch; the lower two bits must be zero.
 304      FIXME: we don't check that, we just clear them.  */
 305   HOWTO (R_PPC64_ADDR24,        /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          26,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR24",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0x03fffffc,            /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A standard 16 bit relocation.  */
 320   HOWTO (R_PPC64_ADDR16,        /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_bitfield, /* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16",      /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* A 16 bit relocation without overflow.  */
 335   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 336          0,                     /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_dont,/* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_LO",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address.  */
 350   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 351          16,                    /* rightshift */
 352          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          FALSE,                 /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC64_ADDR16_HI",   /* name */
 359          FALSE,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xffff,                /* dst_mask */
 362          FALSE),                /* pcrel_offset */
 363
 364   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 365      bits, treated as a signed number, is negative.  */
 366   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 367          16,                    /* rightshift */
 368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          ppc64_elf_ha_reloc,    /* special_function */
 374          "R_PPC64_ADDR16_HA",   /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 16 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC64_ADDR14,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          16,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_signed, /* complain_on_overflow */
 389          ppc64_elf_branch_reloc, /* special_function */
 390          "R_PPC64_ADDR14",      /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x0000fffc,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* An absolute 16 bit branch, for which bit 10 should be set to
 397      indicate that the branch is expected to be taken.  The lower two
 398      bits must be zero.  */
 399   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 400          0,                     /* rightshift */
 401          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          FALSE,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          ppc64_elf_brtaken_reloc, /* special_function */
 407          "R_PPC64_ADDR14_BRTAKEN",/* name */
 408          FALSE,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0x0000fffc,            /* dst_mask */
 411          FALSE),                /* pcrel_offset */
 412
 413   /* An absolute 16 bit branch, for which bit 10 should be set to
 414      indicate that the branch is not expected to be taken.  The lower
 415      two bits must be zero.  */
 416   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          16,                    /* bitsize */
 420          FALSE,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_brtaken_reloc, /* special_function */
 424          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x0000fffc,            /* dst_mask */
 428          FALSE),                /* pcrel_offset */
 429
 430   /* A relative 26 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL24,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          26,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL24",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x03fffffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch; the lower two bits must be zero.  */
 446   HOWTO (R_PPC64_REL14,         /* type */
 447          0,                     /* rightshift */
 448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          16,                    /* bitsize */
 450          TRUE,                  /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          ppc64_elf_branch_reloc, /* special_function */
 454          "R_PPC64_REL14",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0,                     /* src_mask */
 457          0x0000fffc,            /* dst_mask */
 458          TRUE),                 /* pcrel_offset */
 459
 460   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 461      the branch is expected to be taken.  The lower two bits must be
 462      zero.  */
 463   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 464          0,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          16,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed, /* complain_on_overflow */
 470          ppc64_elf_brtaken_reloc, /* special_function */
 471          "R_PPC64_REL14_BRTAKEN", /* name */
 472          FALSE,                 /* partial_inplace */
 473          0,                     /* src_mask */
 474          0x0000fffc,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 478      the branch is not expected to be taken.  The lower two bits must
 479      be zero.  */
 480   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 481          0,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          16,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed, /* complain_on_overflow */
 487          ppc64_elf_brtaken_reloc, /* special_function */
 488          "R_PPC64_REL14_BRNTAKEN",/* name */
 489          FALSE,                 /* partial_inplace */
 490          0,                     /* src_mask */
 491          0x0000fffc,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 495      symbol.  */
 496   HOWTO (R_PPC64_GOT16,         /* type */
 497          0,                     /* rightshift */
 498          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_GOT16",       /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0xffff,                /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 511      the symbol.  */
 512   HOWTO (R_PPC64_GOT16_LO,      /* type */
 513          0,                     /* rightshift */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          16,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc, /* special_function */
 520          "R_PPC64_GOT16_LO",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          0xffff,                /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 527      the symbol.  */
 528   HOWTO (R_PPC64_GOT16_HI,      /* type */
 529          16,                    /* rightshift */
 530          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          16,                    /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed,/* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_GOT16_HI",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0xffff,                /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 543      the symbol.  */
 544   HOWTO (R_PPC64_GOT16_HA,      /* type */
 545          16,                    /* rightshift */
 546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          16,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,/* complain_on_overflow */
 551          ppc64_elf_unhandled_reloc, /* special_function */
 552          "R_PPC64_GOT16_HA",    /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0xffff,                /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* This is used only by the dynamic linker.  The symbol should exist
 559      both in the object being run and in some shared library.  The
 560      dynamic linker copies the data addressed by the symbol from the
 561      shared library into the object, because the object being
 562      run has to have the data at some particular address.  */
 563   HOWTO (R_PPC64_COPY,          /* type */
 564          0,                     /* rightshift */
 565          0,                     /* this one is variable size */
 566          0,                     /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          ppc64_elf_unhandled_reloc, /* special_function */
 571          "R_PPC64_COPY",        /* name */
 572          FALSE,                 /* partial_inplace */
 573          0,                     /* src_mask */
 574          0,                     /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* Like R_PPC64_ADDR64, but used when setting global offset table
 578      entries.  */
 579   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 580          0,                     /* rightshift */
 581          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 582          64,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          ppc64_elf_unhandled_reloc,  /* special_function */
 587          "R_PPC64_GLOB_DAT",    /* name */
 588          FALSE,                 /* partial_inplace */
 589          0,                     /* src_mask */
 590          ONES (64),             /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* Created by the link editor.  Marks a procedure linkage table
 594      entry for a symbol.  */
 595   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 596          0,                     /* rightshift */
 597          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          0,                     /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_dont, /* complain_on_overflow */
 602          ppc64_elf_unhandled_reloc, /* special_function */
 603          "R_PPC64_JMP_SLOT",    /* name */
 604          FALSE,                 /* partial_inplace */
 605          0,                     /* src_mask */
 606          0,                     /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* Used only by the dynamic linker.  When the object is run, this
 610      doubleword64 is set to the load address of the object, plus the
 611      addend.  */
 612   HOWTO (R_PPC64_RELATIVE,      /* type */
 613          0,                     /* rightshift */
 614          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 615          64,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_dont, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_RELATIVE",    /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          ONES (64),             /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR32,       /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          32,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR32",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffffffff,            /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 642   HOWTO (R_PPC64_UADDR16,       /* type */
 643          0,                     /* rightshift */
 644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          16,                    /* bitsize */
 646          FALSE,                 /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_bitfield, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_UADDR16",     /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffff,                /* dst_mask */
 654          FALSE),                /* pcrel_offset */
 655
 656   /* 32-bit PC relative.  */
 657   HOWTO (R_PPC64_REL32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_REL32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          TRUE),                 /* pcrel_offset */
 670
 671   /* 32-bit relocation to the symbol's procedure linkage table.  */
 672   HOWTO (R_PPC64_PLT32,         /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          ppc64_elf_unhandled_reloc, /* special_function */
 680          "R_PPC64_PLT32",       /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 687      FIXME: R_PPC64_PLTREL32 not supported.  */
 688   HOWTO (R_PPC64_PLTREL32,      /* type */
 689          0,                     /* rightshift */
 690          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 691          32,                    /* bitsize */
 692          TRUE,                  /* pc_relative */
 693          0,                     /* bitpos */
 694          complain_overflow_signed, /* complain_on_overflow */
 695          ppc64_elf_unhandled_reloc, /* special_function */
 696          "R_PPC64_PLTREL32",    /* name */
 697          FALSE,                 /* partial_inplace */
 698          0,                     /* src_mask */
 699          0xffffffff,            /* dst_mask */
 700          TRUE),                 /* pcrel_offset */
 701
 702   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 703      the symbol.  */
 704   HOWTO (R_PPC64_PLT16_LO,      /* type */
 705          0,                     /* rightshift */
 706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_dont, /* complain_on_overflow */
 711          ppc64_elf_unhandled_reloc, /* special_function */
 712          "R_PPC64_PLT16_LO",    /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffff,                /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 719      the symbol.  */
 720   HOWTO (R_PPC64_PLT16_HI,      /* type */
 721          16,                    /* rightshift */
 722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          FALSE,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_signed, /* complain_on_overflow */
 727          ppc64_elf_unhandled_reloc, /* special_function */
 728          "R_PPC64_PLT16_HI",    /* name */
 729          FALSE,                 /* partial_inplace */
 730          0,                     /* src_mask */
 731          0xffff,                /* dst_mask */
 732          FALSE),                /* pcrel_offset */
 733
 734   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 735      the symbol.  */
 736   HOWTO (R_PPC64_PLT16_HA,      /* type */
 737          16,                    /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_unhandled_reloc, /* special_function */
 744          "R_PPC64_PLT16_HA",    /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit section relative relocation.  */
 751   HOWTO (R_PPC64_SECTOFF,       /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF",     /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 766   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 767          0,                     /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_dont, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_LO",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HI",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* 16-bit upper half adjusted section relative relocation.  */
 796   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 797          16,                    /* rightshift */
 798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          FALSE,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          ppc64_elf_sectoff_ha_reloc, /* special_function */
 804          "R_PPC64_SECTOFF_HA",  /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xffff,                /* dst_mask */
 808          FALSE),                /* pcrel_offset */
 809
 810   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 811   HOWTO (R_PPC64_REL30,         /* type */
 812          2,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          30,                    /* bitsize */
 815          TRUE,                  /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_PPC64_REL30",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xfffffffc,            /* dst_mask */
 823          TRUE),                 /* pcrel_offset */
 824
 825   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 826
 827   /* A standard 64-bit relocation.  */
 828   HOWTO (R_PPC64_ADDR64,        /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR64",      /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          ONES (64),             /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address.  */
 843   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 844          32,                    /* rightshift */
 845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          16,                    /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_ADDR16_HIGHER", /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0xffff,                /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   /* The bits 32-47 of an address, plus 1 if the contents of the low
 858      16 bits, treated as a signed number, is negative.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 860          32,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          ppc64_elf_ha_reloc,    /* special_function */
 867          "R_PPC64_ADDR16_HIGHERA", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address.  */
 874   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 875          48,                    /* rightshift */
 876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          16,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          0,                     /* bitpos */
 880          complain_overflow_dont, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_PPC64_ADDR16_HIGHEST", /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffff,                /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* The bits 48-63 of an address, plus 1 if the contents of the low
 889      16 bits, treated as a signed number, is negative.  */
 890   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 891          48,                    /* rightshift */
 892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          ppc64_elf_ha_reloc,    /* special_function */
 898          "R_PPC64_ADDR16_HIGHESTA", /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0xffff,                /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* Like ADDR64, but may be unaligned.  */
 905   HOWTO (R_PPC64_UADDR64,       /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          FALSE,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_UADDR64",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          FALSE),                /* pcrel_offset */
 918
 919   /* 64-bit relative relocation.  */
 920   HOWTO (R_PPC64_REL64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          TRUE,                  /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_PPC64_REL64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          TRUE),                 /* pcrel_offset */
 933
 934   /* 64-bit relocation to the symbol's procedure linkage table.  */
 935   HOWTO (R_PPC64_PLT64,         /* type */
 936          0,                     /* rightshift */
 937          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 938          64,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_unhandled_reloc, /* special_function */
 943          "R_PPC64_PLT64",       /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          ONES (64),             /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 64-bit PC relative relocation to the symbol's procedure linkage
 950      table.  */
 951   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 952   HOWTO (R_PPC64_PLTREL64,      /* type */
 953          0,                     /* rightshift */
 954          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 955          64,                    /* bitsize */
 956          TRUE,                  /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_unhandled_reloc, /* special_function */
 960          "R_PPC64_PLTREL64",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          ONES (64),             /* dst_mask */
 964          TRUE),                 /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation.  */
 967
 968   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 969   HOWTO (R_PPC64_TOC16,         /* type */
 970          0,                     /* rightshift */
 971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 972          16,                    /* bitsize */
 973          FALSE,                 /* pc_relative */
 974          0,                     /* bitpos */
 975          complain_overflow_signed, /* complain_on_overflow */
 976          ppc64_elf_toc_reloc,   /* special_function */
 977          "R_PPC64_TOC16",       /* name */
 978          FALSE,                 /* partial_inplace */
 979          0,                     /* src_mask */
 980          0xffff,                /* dst_mask */
 981          FALSE),                /* pcrel_offset */
 982
 983   /* 16 bit TOC-relative relocation without overflow.  */
 984
 985   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 986   HOWTO (R_PPC64_TOC16_LO,      /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          FALSE,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          ppc64_elf_toc_reloc,   /* special_function */
 994          "R_PPC64_TOC16_LO",    /* name */
 995          FALSE,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          FALSE),                /* pcrel_offset */
 999
1000   /* 16 bit TOC-relative relocation, high 16 bits.  */
1001
1002   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1003   HOWTO (R_PPC64_TOC16_HI,      /* type */
1004          16,                    /* rightshift */
1005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          16,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_signed, /* complain_on_overflow */
1010          ppc64_elf_toc_reloc,   /* special_function */
1011          "R_PPC64_TOC16_HI",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0,                     /* src_mask */
1014          0xffff,                /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016
1017   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018      contents of the low 16 bits, treated as a signed number, is
1019      negative.  */
1020
1021   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1022   HOWTO (R_PPC64_TOC16_HA,      /* type */
1023          16,                    /* rightshift */
1024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1025          16,                    /* bitsize */
1026          FALSE,                 /* pc_relative */
1027          0,                     /* bitpos */
1028          complain_overflow_signed, /* complain_on_overflow */
1029          ppc64_elf_toc_ha_reloc, /* special_function */
1030          "R_PPC64_TOC16_HA",    /* name */
1031          FALSE,                 /* partial_inplace */
1032          0,                     /* src_mask */
1033          0xffff,                /* dst_mask */
1034          FALSE),                /* pcrel_offset */
1035
1036   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1037
1038   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1039   HOWTO (R_PPC64_TOC,           /* type */
1040          0,                     /* rightshift */
1041          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042          64,                    /* bitsize */
1043          FALSE,                 /* pc_relative */
1044          0,                     /* bitpos */
1045          complain_overflow_dont, /* complain_on_overflow */
1046          ppc64_elf_toc64_reloc, /* special_function */
1047          "R_PPC64_TOC",         /* name */
1048          FALSE,                 /* partial_inplace */
1049          0,                     /* src_mask */
1050          ONES (64),             /* dst_mask */
1051          FALSE),                /* pcrel_offset */
1052
1053   /* Like R_PPC64_GOT16, but also informs the link editor that the
1054      value to relocate may (!) refer to a PLT entry which the link
1055      editor (a) may replace with the symbol value.  If the link editor
1056      is unable to fully resolve the symbol, it may (b) create a PLT
1057      entry and store the address to the new PLT entry in the GOT.
1058      This permits lazy resolution of function symbols at run time.
1059      The link editor may also skip all of this and just (c) emit a
1060      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1061   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1062     HOWTO (R_PPC64_PLTGOT16,    /* type */
1063          0,                     /* rightshift */
1064          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_signed, /* complain_on_overflow */
1069          ppc64_elf_unhandled_reloc, /* special_function */
1070          "R_PPC64_PLTGOT16",    /* name */
1071          FALSE,                 /* partial_inplace */
1072          0,                     /* src_mask */
1073          0xffff,                /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1077   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1078   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1079          0,                     /* rightshift */
1080          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1081          16,                    /* bitsize */
1082          FALSE,                 /* pc_relative */
1083          0,                     /* bitpos */
1084          complain_overflow_dont, /* complain_on_overflow */
1085          ppc64_elf_unhandled_reloc, /* special_function */
1086          "R_PPC64_PLTGOT16_LO", /* name */
1087          FALSE,                 /* partial_inplace */
1088          0,                     /* src_mask */
1089          0xffff,                /* dst_mask */
1090          FALSE),                /* pcrel_offset */
1091
1092   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1093   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1094   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1095          16,                    /* rightshift */
1096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1097          16,                    /* bitsize */
1098          FALSE,                 /* pc_relative */
1099          0,                     /* bitpos */
1100          complain_overflow_signed, /* complain_on_overflow */
1101          ppc64_elf_unhandled_reloc, /* special_function */
1102          "R_PPC64_PLTGOT16_HI", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109      1 if the contents of the low 16 bits, treated as a signed number,
1110      is negative.  */
1111   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1112   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1113          16,                    /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          ppc64_elf_unhandled_reloc, /* special_function */
1120          "R_PPC64_PLTGOT16_HA", /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xffff,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_signed, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_DS",   /* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_dont,/* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_ADDR16_LO_DS",/* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_DS,      /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_signed, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_DS",    /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_GOT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont, /* complain_on_overflow */
1194          ppc64_elf_unhandled_reloc, /* special_function */
1195          "R_PPC64_PLT16_LO_DS", /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_signed, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_DS",  /* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont, /* complain_on_overflow */
1224          ppc64_elf_sectoff_reloc, /* special_function */
1225          "R_PPC64_SECTOFF_LO_DS",/* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_DS,      /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_signed, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_DS",    /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1247   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1248          0,                     /* rightshift */
1249          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          16,                    /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont, /* complain_on_overflow */
1254          ppc64_elf_toc_reloc,   /* special_function */
1255          "R_PPC64_TOC16_LO_DS", /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0xfffc,                /* dst_mask */
1259          FALSE),                /* pcrel_offset */
1260
1261   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1262   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1263   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1264          0,                     /* rightshift */
1265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          16,                    /* bitsize */
1267          FALSE,                 /* pc_relative */
1268          0,                     /* bitpos */
1269          complain_overflow_signed, /* complain_on_overflow */
1270          ppc64_elf_unhandled_reloc, /* special_function */
1271          "R_PPC64_PLTGOT16_DS", /* name */
1272          FALSE,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0xfffc,                /* dst_mask */
1275          FALSE),                /* pcrel_offset */
1276
1277   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1278   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1279   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280          0,                     /* rightshift */
1281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          16,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          ppc64_elf_unhandled_reloc, /* special_function */
1287          "R_PPC64_PLTGOT16_LO_DS",/* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xfffc,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* Marker relocs for TLS.  */
1294   HOWTO (R_PPC64_TLS,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLS",         /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TLSGD,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TLSGD",       /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   HOWTO (R_PPC64_TLSLD,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLSLD",       /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TOCSAVE,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TOCSAVE",     /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Computes the load module index of the load module that contains the
1351      definition of its TLS sym.  */
1352   HOWTO (R_PPC64_DTPMOD64,
1353          0,                     /* rightshift */
1354          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          64,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc64_elf_unhandled_reloc, /* special_function */
1360          "R_PPC64_DTPMOD64",    /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          ONES (64),             /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* Computes a dtv-relative displacement, the difference between the value
1367      of sym+add and the base address of the thread-local storage block that
1368      contains the definition of sym, minus 0x8000.  */
1369   HOWTO (R_PPC64_DTPREL64,
1370          0,                     /* rightshift */
1371          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          64,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL64",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          ONES (64),             /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* A 16 bit dtprel reloc.  */
1384   HOWTO (R_PPC64_DTPREL16,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16",    /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16, but no overflow.  */
1399   HOWTO (R_PPC64_DTPREL16_LO,
1400          0,                     /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_dont, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_LO", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HI,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HI", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HA,
1430          16,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_signed, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HA", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHER,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHER", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460          32,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHERA", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHEST", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1489   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490          48,                    /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_dont, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xffff,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16, but for insns with a DS field.  */
1504   HOWTO (R_PPC64_DTPREL16_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_signed, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Like DTPREL16_DS, but no overflow.  */
1519   HOWTO (R_PPC64_DTPREL16_LO_DS,
1520          0,                     /* rightshift */
1521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          16,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_dont, /* complain_on_overflow */
1526          ppc64_elf_unhandled_reloc, /* special_function */
1527          "R_PPC64_DTPREL16_LO_DS", /* name */
1528          FALSE,                 /* partial_inplace */
1529          0,                     /* src_mask */
1530          0xfffc,                /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   /* Computes a tp-relative displacement, the difference between the value of
1534      sym+add and the value of the thread pointer (r13).  */
1535   HOWTO (R_PPC64_TPREL64,
1536          0,                     /* rightshift */
1537          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          64,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_dont, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL64",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          ONES (64),             /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* A 16 bit tprel reloc.  */
1550   HOWTO (R_PPC64_TPREL16,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_signed, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16",     /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16, but no overflow.  */
1565   HOWTO (R_PPC64_TPREL16_LO,
1566          0,                     /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_dont, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_LO",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HI,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HI",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HA,
1596          16,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_signed, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HA",  /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHER,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHER",      /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHERA,
1626          32,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHERA", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHEST,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHEST", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1655   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656          48,                    /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_dont, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_HIGHESTA", /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xffff,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16, but for insns with a DS field.  */
1670   HOWTO (R_PPC64_TPREL16_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_signed, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_DS",  /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Like TPREL16_DS, but no overflow.  */
1685   HOWTO (R_PPC64_TPREL16_LO_DS,
1686          0,                     /* rightshift */
1687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1688          16,                    /* bitsize */
1689          FALSE,                 /* pc_relative */
1690          0,                     /* bitpos */
1691          complain_overflow_dont, /* complain_on_overflow */
1692          ppc64_elf_unhandled_reloc, /* special_function */
1693          "R_PPC64_TPREL16_LO_DS", /* name */
1694          FALSE,                 /* partial_inplace */
1695          0,                     /* src_mask */
1696          0xfffc,                /* dst_mask */
1697          FALSE),                /* pcrel_offset */
1698
1699   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701      to the first entry relative to the TOC base (r2).  */
1702   HOWTO (R_PPC64_GOT_TLSGD16,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_signed, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16, but no overflow.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_dont, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_LO", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HI", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1747   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_signed, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_TLSGD16_HA", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762      with values (sym+add)@dtpmod and zero, and computes the offset to the
1763      first entry relative to the TOC base (r2).  */
1764   HOWTO (R_PPC64_GOT_TLSLD16,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_signed, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16, but no overflow.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_dont, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_LO", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HI", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1809   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810          16,                    /* rightshift */
1811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1812          16,                    /* bitsize */
1813          FALSE,                 /* pc_relative */
1814          0,                     /* bitpos */
1815          complain_overflow_signed, /* complain_on_overflow */
1816          ppc64_elf_unhandled_reloc, /* special_function */
1817          "R_PPC64_GOT_TLSLD16_HA", /* name */
1818          FALSE,                 /* partial_inplace */
1819          0,                     /* src_mask */
1820          0xffff,                /* dst_mask */
1821          FALSE),                /* pcrel_offset */
1822
1823   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824      the offset to the entry relative to the TOC base (r2).  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_signed, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_DS, but no overflow.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841          0,                     /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_dont, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xfffc,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HI", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1870   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871          16,                    /* rightshift */
1872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1873          16,                    /* bitsize */
1874          FALSE,                 /* pc_relative */
1875          0,                     /* bitpos */
1876          complain_overflow_signed, /* complain_on_overflow */
1877          ppc64_elf_unhandled_reloc, /* special_function */
1878          "R_PPC64_GOT_DTPREL16_HA", /* name */
1879          FALSE,                 /* partial_inplace */
1880          0,                     /* src_mask */
1881          0xffff,                /* dst_mask */
1882          FALSE),                /* pcrel_offset */
1883
1884   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885      offset to the entry relative to the TOC base (r2).  */
1886   HOWTO (R_PPC64_GOT_TPREL16_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_signed, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_DS, but no overflow.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902          0,                     /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_dont, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xfffc,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HI,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HI", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1931   HOWTO (R_PPC64_GOT_TPREL16_HA,
1932          16,                    /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_signed, /* complain_on_overflow */
1938          ppc64_elf_unhandled_reloc, /* special_function */
1939          "R_PPC64_GOT_TPREL16_HA", /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   HOWTO (R_PPC64_JMP_IREL,      /* type */
1946          0,                     /* rightshift */
1947          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948          0,                     /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_dont, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_JMP_IREL",    /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0,                     /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   HOWTO (R_PPC64_IRELATIVE,     /* type */
1960          0,                     /* rightshift */
1961          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962          64,                    /* bitsize */
1963          FALSE,                 /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_dont, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_IRELATIVE",   /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          ONES (64),             /* dst_mask */
1971          FALSE),                /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation.  */
1974   HOWTO (R_PPC64_REL16,         /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_signed, /* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16",       /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* A 16 bit relative relocation without overflow.  */
1989   HOWTO (R_PPC64_REL16_LO,      /* type */
1990          0,                     /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_dont,/* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_LO",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address.  */
2004   HOWTO (R_PPC64_REL16_HI,      /* type */
2005          16,                    /* rightshift */
2006          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2007          16,                    /* bitsize */
2008          TRUE,                  /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_signed, /* complain_on_overflow */
2011          bfd_elf_generic_reloc, /* special_function */
2012          "R_PPC64_REL16_HI",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0xffff,                /* dst_mask */
2016          TRUE),                 /* pcrel_offset */
2017
2018   /* The high order 16 bits of a relative address, plus 1 if the contents of
2019      the low 16 bits, treated as a signed number, is negative.  */
2020   HOWTO (R_PPC64_REL16_HA,      /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          TRUE,                  /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_signed, /* complain_on_overflow */
2027          ppc64_elf_ha_reloc,    /* special_function */
2028          "R_PPC64_REL16_HA",    /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          TRUE),                 /* pcrel_offset */
2033
2034   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2035   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2036          16,                    /* rightshift */
2037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          TRUE,                  /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_signed, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_REL16DX_HA",  /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0x1fffc1,              /* dst_mask */
2047          TRUE),                 /* pcrel_offset */
2048
2049   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2050   HOWTO (R_PPC64_16DX_HA,       /* type */
2051          16,                    /* rightshift */
2052          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_signed, /* complain_on_overflow */
2057          ppc64_elf_ha_reloc,    /* special_function */
2058          "R_PPC64_16DX_HA",     /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0x1fffc1,              /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2065   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          bfd_elf_generic_reloc, /* special_function */
2073          "R_PPC64_ADDR16_HIGH", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2080   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_ha_reloc,    /* special_function */
2088          "R_PPC64_ADDR16_HIGHA",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2095   HOWTO (R_PPC64_DTPREL16_HIGH,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_DTPREL16_HIGH", /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2110   HOWTO (R_PPC64_DTPREL16_HIGHA,
2111          16,                    /* rightshift */
2112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2113          16,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          ppc64_elf_unhandled_reloc, /* special_function */
2118          "R_PPC64_DTPREL16_HIGHA", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          0xffff,                /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2125   HOWTO (R_PPC64_TPREL16_HIGH,
2126          16,                    /* rightshift */
2127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          16,                    /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          ppc64_elf_unhandled_reloc, /* special_function */
2133          "R_PPC64_TPREL16_HIGH",        /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0xffff,                /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2140   HOWTO (R_PPC64_TPREL16_HIGHA,
2141          16,                    /* rightshift */
2142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          16,                    /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          ppc64_elf_unhandled_reloc, /* special_function */
2148          "R_PPC64_TPREL16_HIGHA",       /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0xffff,                /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153
2154   /* Marker reloc on ELFv2 large-model function entry.  */
2155   HOWTO (R_PPC64_ENTRY,
2156          0,                     /* rightshift */
2157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2158          32,                    /* bitsize */
2159          FALSE,                 /* pc_relative */
2160          0,                     /* bitpos */
2161          complain_overflow_dont, /* complain_on_overflow */
2162          bfd_elf_generic_reloc, /* special_function */
2163          "R_PPC64_ENTRY",       /* name */
2164          FALSE,                 /* partial_inplace */
2165          0,                     /* src_mask */
2166          0,                     /* dst_mask */
2167          FALSE),                /* pcrel_offset */
2168
2169   /* Like ADDR64, but use local entry point of function.  */
2170   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2171          0,                     /* rightshift */
2172          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173          64,                    /* bitsize */
2174          FALSE,                 /* pc_relative */
2175          0,                     /* bitpos */
2176          complain_overflow_dont, /* complain_on_overflow */
2177          bfd_elf_generic_reloc, /* special_function */
2178          "R_PPC64_ADDR64_LOCAL", /* name */
2179          FALSE,                 /* partial_inplace */
2180          0,                     /* src_mask */
2181          ONES (64),             /* dst_mask */
2182          FALSE),                /* pcrel_offset */
2183
2184   /* GNU extension to record C++ vtable hierarchy.  */
2185   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186          0,                     /* rightshift */
2187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2188          0,                     /* bitsize */
2189          FALSE,                 /* pc_relative */
2190          0,                     /* bitpos */
2191          complain_overflow_dont, /* complain_on_overflow */
2192          NULL,                  /* special_function */
2193          "R_PPC64_GNU_VTINHERIT", /* name */
2194          FALSE,                 /* partial_inplace */
2195          0,                     /* src_mask */
2196          0,                     /* dst_mask */
2197          FALSE),                /* pcrel_offset */
2198
2199   /* GNU extension to record C++ vtable member usage.  */
2200   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2201          0,                     /* rightshift */
2202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          0,                     /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont, /* complain_on_overflow */
2207          NULL,                  /* special_function */
2208          "R_PPC64_GNU_VTENTRY", /* name */
2209          FALSE,                 /* partial_inplace */
2210          0,                     /* src_mask */
2211          0,                     /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213 };
2214
2215 \f
2216 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217    be done.  */
2218
2219 static void
2220 ppc_howto_init (void)
2221 {
2222   unsigned int i, type;
2223
2224   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225     {
2226       type = ppc64_elf_howto_raw[i].type;
2227       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2228       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229     }
2230 }
2231
2232 static reloc_howto_type *
2233 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234                              bfd_reloc_code_real_type code)
2235 {
2236   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237
2238   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239     /* Initialize howto table if needed.  */
2240     ppc_howto_init ();
2241
2242   switch (code)
2243     {
2244     default:
2245       return NULL;
2246
2247     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2248       break;
2249     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2250       break;
2251     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2252       break;
2253     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2254       break;
2255     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2256       break;
2257     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2258       break;
2259     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2260       break;
2261     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2262       break;
2263     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2264       break;
2265     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2266       break;
2267     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2268       break;
2269     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2270       break;
2271     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2272       break;
2273     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2274       break;
2275     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2278       break;
2279     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2280       break;
2281     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2282       break;
2283     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2284       break;
2285     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2286       break;
2287     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2288       break;
2289     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2290       break;
2291     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2292       break;
2293     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2294       break;
2295     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2296       break;
2297     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2298       break;
2299     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2300       break;
2301     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2302       break;
2303     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2304       break;
2305     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2306       break;
2307     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2308       break;
2309     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2310       break;
2311     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2312       break;
2313     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2314       break;
2315     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2316       break;
2317     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2318       break;
2319     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2322       break;
2323     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2324       break;
2325     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2326       break;
2327     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2328       break;
2329     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2330       break;
2331     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2332       break;
2333     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2334       break;
2335     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2336       break;
2337     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2338       break;
2339     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2340       break;
2341     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2342       break;
2343     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2348       break;
2349     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2350       break;
2351     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2352       break;
2353     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2358       break;
2359     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2362       break;
2363     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2364       break;
2365     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2366       break;
2367     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2368       break;
2369     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2370       break;
2371     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2372       break;
2373     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2374       break;
2375     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2376       break;
2377     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2378       break;
2379     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2380       break;
2381     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2388       break;
2389     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2390       break;
2391     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2392       break;
2393     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2394       break;
2395     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2402       break;
2403     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2408       break;
2409     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2428       break;
2429     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2436       break;
2437     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2438       break;
2439     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2440       break;
2441     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2448       break;
2449     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2450       break;
2451     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2452       break;
2453     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2460       break;
2461     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2462       break;
2463     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2464       break;
2465     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2466       break;
2467     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2468       break;
2469     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2470       break;
2471     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2472       break;
2473     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2474       break;
2475     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2476       break;
2477     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2478       break;
2479     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2480       break;
2481     }
2482
2483   return ppc64_elf_howto_table[r];
2484 };
2485
2486 static reloc_howto_type *
2487 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488                              const char *r_name)
2489 {
2490   unsigned int i;
2491
2492   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2493     if (ppc64_elf_howto_raw[i].name != NULL
2494         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495       return &ppc64_elf_howto_raw[i];
2496
2497   return NULL;
2498 }
2499
2500 /* Set the howto pointer for a PowerPC ELF reloc.  */
2501
2502 static void
2503 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2504                          Elf_Internal_Rela *dst)
2505 {
2506   unsigned int type;
2507
2508   /* Initialize howto table if needed.  */
2509   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2510     ppc_howto_init ();
2511
2512   type = ELF64_R_TYPE (dst->r_info);
2513   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514     {
2515       /* xgettext:c-format */
2516       _bfd_error_handler (_("%B: invalid relocation type %d"),
2517                           abfd, (int) type);
2518       type = R_PPC64_NONE;
2519     }
2520   cache_ptr->howto = ppc64_elf_howto_table[type];
2521 }
2522
2523 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                     void *data, asection *input_section,
2528                     bfd *output_bfd, char **error_message)
2529 {
2530   enum elf_ppc64_reloc_type r_type;
2531   long insn;
2532   bfd_size_type octets;
2533   bfd_vma value;
2534
2535   /* If this is a relocatable link (output_bfd test tells us), just
2536      call the generic function.  Any adjustment will be done at final
2537      link time.  */
2538   if (output_bfd != NULL)
2539     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540                                   input_section, output_bfd, error_message);
2541
2542   /* Adjust the addend for sign extension of the low 16 bits.
2543      We won't actually be using the low 16 bits, so trashing them
2544      doesn't matter.  */
2545   reloc_entry->addend += 0x8000;
2546   r_type = reloc_entry->howto->type;
2547   if (r_type != R_PPC64_REL16DX_HA)
2548     return bfd_reloc_continue;
2549
2550   value = 0;
2551   if (!bfd_is_com_section (symbol->section))
2552     value = symbol->value;
2553   value += (reloc_entry->addend
2554             + symbol->section->output_offset
2555             + symbol->section->output_section->vma);
2556   value -= (reloc_entry->address
2557             + input_section->output_offset
2558             + input_section->output_section->vma);
2559   value = (bfd_signed_vma) value >> 16;
2560
2561   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563   insn &= ~0x1fffc1;
2564   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2565   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2566   if (value + 0x8000 > 0xffff)
2567     return bfd_reloc_overflow;
2568   return bfd_reloc_ok;
2569 }
2570
2571 static bfd_reloc_status_type
2572 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573                         void *data, asection *input_section,
2574                         bfd *output_bfd, char **error_message)
2575 {
2576   if (output_bfd != NULL)
2577     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578                                   input_section, output_bfd, error_message);
2579
2580   if (strcmp (symbol->section->name, ".opd") == 0
2581       && (symbol->section->owner->flags & DYNAMIC) == 0)
2582     {
2583       bfd_vma dest = opd_entry_value (symbol->section,
2584                                       symbol->value + reloc_entry->addend,
2585                                       NULL, NULL, FALSE);
2586       if (dest != (bfd_vma) -1)
2587         reloc_entry->addend = dest - (symbol->value
2588                                       + symbol->section->output_section->vma
2589                                       + symbol->section->output_offset);
2590     }
2591   else
2592     {
2593       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595       if (symbol->section->owner != abfd
2596           && symbol->section->owner != NULL
2597           && abiversion (symbol->section->owner) >= 2)
2598         {
2599           unsigned int i;
2600
2601           for (i = 0; i < symbol->section->owner->symcount; ++i)
2602             {
2603               asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605               if (strcmp (symdef->name, symbol->name) == 0)
2606                 {
2607                   elfsym = (elf_symbol_type *) symdef;
2608                   break;
2609                 }
2610             }
2611         }
2612       reloc_entry->addend
2613         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614     }
2615   return bfd_reloc_continue;
2616 }
2617
2618 static bfd_reloc_status_type
2619 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620                          void *data, asection *input_section,
2621                          bfd *output_bfd, char **error_message)
2622 {
2623   long insn;
2624   enum elf_ppc64_reloc_type r_type;
2625   bfd_size_type octets;
2626   /* Assume 'at' branch hints.  */
2627   bfd_boolean is_isa_v2 = TRUE;
2628
2629   /* If this is a relocatable link (output_bfd test tells us), just
2630      call the generic function.  Any adjustment will be done at final
2631      link time.  */
2632   if (output_bfd != NULL)
2633     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2634                                   input_section, output_bfd, error_message);
2635
2636   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638   insn &= ~(0x01 << 21);
2639   r_type = reloc_entry->howto->type;
2640   if (r_type == R_PPC64_ADDR14_BRTAKEN
2641       || r_type == R_PPC64_REL14_BRTAKEN)
2642     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2643
2644   if (is_isa_v2)
2645     {
2646       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2647          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2649       if ((insn & (0x14 << 21)) == (0x04 << 21))
2650         insn |= 0x02 << 21;
2651       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652         insn |= 0x08 << 21;
2653       else
2654         goto out;
2655     }
2656   else
2657     {
2658       bfd_vma target = 0;
2659       bfd_vma from;
2660
2661       if (!bfd_is_com_section (symbol->section))
2662         target = symbol->value;
2663       target += symbol->section->output_section->vma;
2664       target += symbol->section->output_offset;
2665       target += reloc_entry->addend;
2666
2667       from = (reloc_entry->address
2668               + input_section->output_offset
2669               + input_section->output_section->vma);
2670
2671       /* Invert 'y' bit if not the default.  */
2672       if ((bfd_signed_vma) (target - from) < 0)
2673         insn ^= 0x01 << 21;
2674     }
2675   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676  out:
2677   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678                                  input_section, output_bfd, error_message);
2679 }
2680
2681 static bfd_reloc_status_type
2682 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683                          void *data, asection *input_section,
2684                          bfd *output_bfd, char **error_message)
2685 {
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   /* Subtract the symbol section base address.  */
2694   reloc_entry->addend -= symbol->section->output_section->vma;
2695   return bfd_reloc_continue;
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700                             void *data, asection *input_section,
2701                             bfd *output_bfd, char **error_message)
2702 {
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   /* Subtract the symbol section base address.  */
2711   reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713   /* Adjust the addend for sign extension of the low 16 bits.  */
2714   reloc_entry->addend += 0x8000;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                      void *data, asection *input_section,
2721                      bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738   return bfd_reloc_continue;
2739 }
2740
2741 static bfd_reloc_status_type
2742 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743                         void *data, asection *input_section,
2744                         bfd *output_bfd, char **error_message)
2745 {
2746   bfd_vma TOCstart;
2747
2748   /* If this is a relocatable link (output_bfd test tells us), just
2749      call the generic function.  Any adjustment will be done at final
2750      link time.  */
2751   if (output_bfd != NULL)
2752     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2753                                   input_section, output_bfd, error_message);
2754
2755   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756   if (TOCstart == 0)
2757     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758
2759   /* Subtract the TOC base address.  */
2760   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                        void *data, asection *input_section,
2770                        bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773   bfd_size_type octets;
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   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788   return bfd_reloc_ok;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                            void *data, asection *input_section,
2794                            bfd *output_bfd, char **error_message)
2795 {
2796   /* If this is a relocatable link (output_bfd test tells us), just
2797      call the generic function.  Any adjustment will be done at final
2798      link time.  */
2799   if (output_bfd != NULL)
2800     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2801                                   input_section, output_bfd, error_message);
2802
2803   if (error_message != NULL)
2804     {
2805       static char buf[60];
2806       sprintf (buf, "generic linker can't handle %s",
2807                reloc_entry->howto->name);
2808       *error_message = buf;
2809     }
2810   return bfd_reloc_dangerous;
2811 }
2812
2813 /* Track GOT entries needed for a given symbol.  We might need more
2814    than one got entry per symbol.  */
2815 struct got_entry
2816 {
2817   struct got_entry *next;
2818
2819   /* The symbol addend that we'll be placing in the GOT.  */
2820   bfd_vma addend;
2821
2822   /* Unlike other ELF targets, we use separate GOT entries for the same
2823      symbol referenced from different input files.  This is to support
2824      automatic multiple TOC/GOT sections, where the TOC base can vary
2825      from one input file to another.  After partitioning into TOC groups
2826      we merge entries within the group.
2827
2828      Point to the BFD owning this GOT entry.  */
2829   bfd *owner;
2830
2831   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832      TLS_TPREL or TLS_DTPREL for tls entries.  */
2833   unsigned char tls_type;
2834
2835   /* Non-zero if got.ent points to real entry.  */
2836   unsigned char is_indirect;
2837
2838   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2839   union
2840     {
2841       bfd_signed_vma refcount;
2842       bfd_vma offset;
2843       struct got_entry *ent;
2844     } got;
2845 };
2846
2847 /* The same for PLT.  */
2848 struct plt_entry
2849 {
2850   struct plt_entry *next;
2851
2852   bfd_vma addend;
2853
2854   union
2855     {
2856       bfd_signed_vma refcount;
2857       bfd_vma offset;
2858     } plt;
2859 };
2860
2861 struct ppc64_elf_obj_tdata
2862 {
2863   struct elf_obj_tdata elf;
2864
2865   /* Shortcuts to dynamic linker sections.  */
2866   asection *got;
2867   asection *relgot;
2868
2869   /* Used during garbage collection.  We attach global symbols defined
2870      on removed .opd entries to this section so that the sym is removed.  */
2871   asection *deleted_section;
2872
2873   /* TLS local dynamic got entry handling.  Support for multiple GOT
2874      sections means we potentially need one of these for each input bfd.  */
2875   struct got_entry tlsld_got;
2876
2877   union {
2878     /* A copy of relocs before they are modified for --emit-relocs.  */
2879     Elf_Internal_Rela *relocs;
2880
2881     /* Section contents.  */
2882     bfd_byte *contents;
2883   } opd;
2884
2885   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886      the reloc to be in the range -32768 to 32767.  */
2887   unsigned int has_small_toc_reloc : 1;
2888
2889   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890      instruction not one we handle.  */
2891   unsigned int unexpected_toc_insn : 1;
2892 };
2893
2894 #define ppc64_elf_tdata(bfd) \
2895   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897 #define ppc64_tlsld_got(bfd) \
2898   (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
2900 #define is_ppc64_elf(bfd) \
2901   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2902    && elf_object_id (bfd) == PPC64_ELF_DATA)
2903
2904 /* Override the generic function because we store some extras.  */
2905
2906 static bfd_boolean
2907 ppc64_elf_mkobject (bfd *abfd)
2908 {
2909   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2910                                   PPC64_ELF_DATA);
2911 }
2912
2913 /* Fix bad default arch selected for a 64 bit input bfd when the
2914    default is 32 bit.  Also select arch based on apuinfo.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_object_p (bfd *abfd)
2918 {
2919   if (!abfd->arch_info->the_default)
2920     return TRUE;
2921
2922   if (abfd->arch_info->bits_per_word == 32)
2923     {
2924       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927         {
2928           /* Relies on arch after 32 bit default being 64 bit default.  */
2929           abfd->arch_info = abfd->arch_info->next;
2930           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931         }
2932     }
2933   return _bfd_elf_ppc_set_arch (abfd);
2934 }
2935
2936 /* Support for core dump NOTE sections.  */
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   size_t offset, size;
2942
2943   if (note->descsz != 504)
2944     return FALSE;
2945
2946   /* pr_cursig */
2947   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2948
2949   /* pr_pid */
2950   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2951
2952   /* pr_reg */
2953   offset = 112;
2954   size = 384;
2955
2956   /* Make a ".reg/999" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   if (note->descsz != 136)
2965     return FALSE;
2966
2967   elf_tdata (abfd)->core->pid
2968     = bfd_get_32 (abfd, note->descdata + 24);
2969   elf_tdata (abfd)->core->program
2970     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2971   elf_tdata (abfd)->core->command
2972     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974   return TRUE;
2975 }
2976
2977 static char *
2978 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979                            ...)
2980 {
2981   switch (note_type)
2982     {
2983     default:
2984       return NULL;
2985
2986     case NT_PRPSINFO:
2987       {
2988         char data[136];
2989         va_list ap;
2990
2991         va_start (ap, note_type);
2992         memset (data, 0, sizeof (data));
2993         strncpy (data + 40, va_arg (ap, const char *), 16);
2994         strncpy (data + 56, va_arg (ap, const char *), 80);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999
3000     case NT_PRSTATUS:
3001       {
3002         char data[504];
3003         va_list ap;
3004         long pid;
3005         int cursig;
3006         const void *greg;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, 112);
3010         pid = va_arg (ap, long);
3011         bfd_put_32 (abfd, pid, data + 32);
3012         cursig = va_arg (ap, int);
3013         bfd_put_16 (abfd, cursig, data + 12);
3014         greg = va_arg (ap, const void *);
3015         memcpy (data + 112, greg, 384);
3016         memset (data + 496, 0, 8);
3017         va_end (ap);
3018         return elfcore_write_note (abfd, buf, bufsiz,
3019                                    "CORE", note_type, data, sizeof (data));
3020       }
3021     }
3022 }
3023
3024 /* Add extra PPC sections.  */
3025
3026 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 {
3028   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3029   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3034   { NULL,                     0,  0, 0,            0 }
3035 };
3036
3037 enum _ppc64_sec_type {
3038   sec_normal = 0,
3039   sec_opd = 1,
3040   sec_toc = 2
3041 };
3042
3043 struct _ppc64_elf_section_data
3044 {
3045   struct bfd_elf_section_data elf;
3046
3047   union
3048   {
3049     /* An array with one entry for each opd function descriptor,
3050        and some spares since opd entries may be either 16 or 24 bytes.  */
3051 #define OPD_NDX(OFF) ((OFF) >> 4)
3052     struct _opd_sec_data
3053     {
3054       /* Points to the function code section for local opd entries.  */
3055       asection **func_sec;
3056
3057       /* After editing .opd, adjust references to opd local syms.  */
3058       long *adjust;
3059     } opd;
3060
3061     /* An array for toc sections, indexed by offset/8.  */
3062     struct _toc_sec_data
3063     {
3064       /* Specifies the relocation symbol index used at a given toc offset.  */
3065       unsigned *symndx;
3066
3067       /* And the relocation addend.  */
3068       bfd_vma *add;
3069     } toc;
3070   } u;
3071
3072   enum _ppc64_sec_type sec_type:2;
3073
3074   /* Flag set when small branches are detected.  Used to
3075      select suitable defaults for the stub group size.  */
3076   unsigned int has_14bit_branch:1;
3077 };
3078
3079 #define ppc64_elf_section_data(sec) \
3080   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3081
3082 static bfd_boolean
3083 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 {
3085   if (!sec->used_by_bfd)
3086     {
3087       struct _ppc64_elf_section_data *sdata;
3088       bfd_size_type amt = sizeof (*sdata);
3089
3090       sdata = bfd_zalloc (abfd, amt);
3091       if (sdata == NULL)
3092         return FALSE;
3093       sec->used_by_bfd = sdata;
3094     }
3095
3096   return _bfd_elf_new_section_hook (abfd, sec);
3097 }
3098
3099 static struct _opd_sec_data *
3100 get_opd_info (asection * sec)
3101 {
3102   if (sec != NULL
3103       && ppc64_elf_section_data (sec) != NULL
3104       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3105     return &ppc64_elf_section_data (sec)->u.opd;
3106   return NULL;
3107 }
3108 \f
3109 /* Parameters for the qsort hook.  */
3110 static bfd_boolean synthetic_relocatable;
3111 static asection *synthetic_opd;
3112
3113 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3114
3115 static int
3116 compare_symbols (const void *ap, const void *bp)
3117 {
3118   const asymbol *a = * (const asymbol **) ap;
3119   const asymbol *b = * (const asymbol **) bp;
3120
3121   /* Section symbols first.  */
3122   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123     return -1;
3124   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3125     return 1;
3126
3127   /* then .opd symbols.  */
3128   if (synthetic_opd != NULL)
3129     {
3130       if (strcmp (a->section->name, ".opd") == 0
3131           && strcmp (b->section->name, ".opd") != 0)
3132         return -1;
3133       if (strcmp (a->section->name, ".opd") != 0
3134           && strcmp (b->section->name, ".opd") == 0)
3135         return 1;
3136     }
3137
3138   /* then other code symbols.  */
3139   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140       == (SEC_CODE | SEC_ALLOC)
3141       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142          != (SEC_CODE | SEC_ALLOC))
3143     return -1;
3144
3145   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146       != (SEC_CODE | SEC_ALLOC)
3147       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148          == (SEC_CODE | SEC_ALLOC))
3149     return 1;
3150
3151   if (synthetic_relocatable)
3152     {
3153       if (a->section->id < b->section->id)
3154         return -1;
3155
3156       if (a->section->id > b->section->id)
3157         return 1;
3158     }
3159
3160   if (a->value + a->section->vma < b->value + b->section->vma)
3161     return -1;
3162
3163   if (a->value + a->section->vma > b->value + b->section->vma)
3164     return 1;
3165
3166   /* For syms with the same value, prefer strong dynamic global function
3167      syms over other syms.  */
3168   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169     return -1;
3170
3171   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172     return 1;
3173
3174   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175     return -1;
3176
3177   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178     return 1;
3179
3180   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181     return -1;
3182
3183   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184     return 1;
3185
3186   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190     return 1;
3191
3192   return a > b;
3193 }
3194
3195 /* Search SYMS for a symbol of the given VALUE.  */
3196
3197 static asymbol *
3198 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3199 {
3200   long mid;
3201
3202   if (id == (unsigned) -1)
3203     {
3204       while (lo < hi)
3205         {
3206           mid = (lo + hi) >> 1;
3207           if (syms[mid]->value + syms[mid]->section->vma < value)
3208             lo = mid + 1;
3209           else if (syms[mid]->value + syms[mid]->section->vma > value)
3210             hi = mid;
3211           else
3212             return syms[mid];
3213         }
3214     }
3215   else
3216     {
3217       while (lo < hi)
3218         {
3219           mid = (lo + hi) >> 1;
3220           if (syms[mid]->section->id < id)
3221             lo = mid + 1;
3222           else if (syms[mid]->section->id > id)
3223             hi = mid;
3224           else if (syms[mid]->value < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   return NULL;
3233 }
3234
3235 static bfd_boolean
3236 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 {
3238   bfd_vma vma = *(bfd_vma *) ptr;
3239   return ((section->flags & SEC_ALLOC) != 0
3240           && section->vma <= vma
3241           && vma < section->vma + section->size);
3242 }
3243
3244 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3245    entry syms.  Also generate @plt symbols for the glink branch table.
3246    Returns count of synthetic symbols in RET or -1 on error.  */
3247
3248 static long
3249 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250                                 long static_count, asymbol **static_syms,
3251                                 long dyn_count, asymbol **dyn_syms,
3252                                 asymbol **ret)
3253 {
3254   asymbol *s;
3255   long i;
3256   long count;
3257   char *names;
3258   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3259   asection *opd = NULL;
3260   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261   asymbol **syms;
3262   int abi = abiversion (abfd);
3263
3264   *ret = NULL;
3265
3266   if (abi < 2)
3267     {
3268       opd = bfd_get_section_by_name (abfd, ".opd");
3269       if (opd == NULL && abi == 1)
3270         return 0;
3271     }
3272
3273   symcount = static_count;
3274   if (!relocatable)
3275     symcount += dyn_count;
3276   if (symcount == 0)
3277     return 0;
3278
3279   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3280   if (syms == NULL)
3281     return -1;
3282
3283   if (!relocatable && static_count != 0 && dyn_count != 0)
3284     {
3285       /* Use both symbol tables.  */
3286       memcpy (syms, static_syms, static_count * sizeof (*syms));
3287       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288     }
3289   else if (!relocatable && static_count == 0)
3290     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291   else
3292     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293
3294   synthetic_relocatable = relocatable;
3295   synthetic_opd = opd;
3296   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3297
3298   if (!relocatable && symcount > 1)
3299     {
3300       long j;
3301       /* Trim duplicate syms, since we may have merged the normal and
3302          dynamic symbols.  Actually, we only care about syms that have
3303          different values, so trim any with the same value.  */
3304       for (i = 1, j = 1; i < symcount; ++i)
3305         if (syms[i - 1]->value + syms[i - 1]->section->vma
3306             != syms[i]->value + syms[i]->section->vma)
3307           syms[j++] = syms[i];
3308       symcount = j;
3309     }
3310
3311   i = 0;
3312   /* Note that here and in compare_symbols we can't compare opd and
3313      sym->section directly.  With separate debug info files, the
3314      symbols will be extracted from the debug file while abfd passed
3315      to this function is the real binary.  */
3316   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3317     ++i;
3318   codesecsym = i;
3319
3320   for (; i < symcount; ++i)
3321     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3322          != (SEC_CODE | SEC_ALLOC))
3323         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3324       break;
3325   codesecsymend = i;
3326
3327   for (; i < symcount; ++i)
3328     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3329       break;
3330   secsymend = i;
3331
3332   if (opd != NULL)
3333     for (; i < symcount; ++i)
3334       if (strcmp (syms[i]->section->name, ".opd") != 0)
3335         break;
3336   opdsymend = i;
3337
3338   for (; i < symcount; ++i)
3339     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3340         != (SEC_CODE | SEC_ALLOC))
3341       break;
3342   symcount = i;
3343
3344   count = 0;
3345
3346   if (relocatable)
3347     {
3348       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3349       arelent *r;
3350       size_t size;
3351       long relcount;
3352
3353       if (opdsymend == secsymend)
3354         goto done;
3355
3356       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3357       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3358       if (relcount == 0)
3359         goto done;
3360
3361       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       size = 0;
3368       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3369         {
3370           asymbol *sym;
3371
3372           while (r < opd->relocation + relcount
3373                  && r->address < syms[i]->value + opd->vma)
3374             ++r;
3375
3376           if (r == opd->relocation + relcount)
3377             break;
3378
3379           if (r->address != syms[i]->value + opd->vma)
3380             continue;
3381
3382           if (r->howto->type != R_PPC64_ADDR64)
3383             continue;
3384
3385           sym = *r->sym_ptr_ptr;
3386           if (!sym_exists_at (syms, opdsymend, symcount,
3387                               sym->section->id, sym->value + r->addend))
3388             {
3389               ++count;
3390               size += sizeof (asymbol);
3391               size += strlen (syms[i]->name) + 2;
3392             }
3393         }
3394
3395       if (size == 0)
3396         goto done;
3397       s = *ret = bfd_malloc (size);
3398       if (s == NULL)
3399         {
3400           count = -1;
3401           goto done;
3402         }
3403
3404       names = (char *) (s + count);
3405
3406       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3407         {
3408           asymbol *sym;
3409
3410           while (r < opd->relocation + relcount
3411                  && r->address < syms[i]->value + opd->vma)
3412             ++r;
3413
3414           if (r == opd->relocation + relcount)
3415             break;
3416
3417           if (r->address != syms[i]->value + opd->vma)
3418             continue;
3419
3420           if (r->howto->type != R_PPC64_ADDR64)
3421             continue;
3422
3423           sym = *r->sym_ptr_ptr;
3424           if (!sym_exists_at (syms, opdsymend, symcount,
3425                               sym->section->id, sym->value + r->addend))
3426             {
3427               size_t len;
3428
3429               *s = *syms[i];
3430               s->flags |= BSF_SYNTHETIC;
3431               s->section = sym->section;
3432               s->value = sym->value + r->addend;
3433               s->name = names;
3434               *names++ = '.';
3435               len = strlen (syms[i]->name);
3436               memcpy (names, syms[i]->name, len + 1);
3437               names += len + 1;
3438               /* Have udata.p point back to the original symbol this
3439                  synthetic symbol was derived from.  */
3440               s->udata.p = syms[i];
3441               s++;
3442             }
3443         }
3444     }
3445   else
3446     {
3447       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3448       bfd_byte *contents = NULL;
3449       size_t size;
3450       long plt_count = 0;
3451       bfd_vma glink_vma = 0, resolv_vma = 0;
3452       asection *dynamic, *glink = NULL, *relplt = NULL;
3453       arelent *p;
3454
3455       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3456         {
3457         free_contents_and_exit_err:
3458           count = -1;
3459         free_contents_and_exit:
3460           if (contents)
3461             free (contents);
3462           goto done;
3463         }
3464
3465       size = 0;
3466       for (i = secsymend; i < opdsymend; ++i)
3467         {
3468           bfd_vma ent;
3469
3470           /* Ignore bogus symbols.  */
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               ++count;
3478               size += sizeof (asymbol);
3479               size += strlen (syms[i]->name) + 2;
3480             }
3481         }
3482
3483       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3484       if (dyn_count != 0
3485           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3486         {
3487           bfd_byte *dynbuf, *extdyn, *extdynend;
3488           size_t extdynsize;
3489           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490
3491           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3492             goto free_contents_and_exit_err;
3493
3494           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3495           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3496
3497           extdyn = dynbuf;
3498           extdynend = extdyn + dynamic->size;
3499           for (; extdyn < extdynend; extdyn += extdynsize)
3500             {
3501               Elf_Internal_Dyn dyn;
3502               (*swap_dyn_in) (abfd, extdyn, &dyn);
3503
3504               if (dyn.d_tag == DT_NULL)
3505                 break;
3506
3507               if (dyn.d_tag == DT_PPC64_GLINK)
3508                 {
3509                   /* The first glink stub starts at offset 32; see
3510                      comment in ppc64_elf_finish_dynamic_sections. */
3511                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3512                   /* The .glink section usually does not survive the final
3513                      link; search for the section (usually .text) where the
3514                      glink stubs now reside.  */
3515                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3516                                                 &glink_vma);
3517                   break;
3518                 }
3519             }
3520
3521           free (dynbuf);
3522         }
3523
3524       if (glink != NULL)
3525         {
3526           /* Determine __glink trampoline by reading the relative branch
3527              from the first glink stub.  */
3528           bfd_byte buf[4];
3529           unsigned int off = 0;
3530
3531           while (bfd_get_section_contents (abfd, glink, buf,
3532                                            glink_vma + off - glink->vma, 4))
3533             {
3534               unsigned int insn = bfd_get_32 (abfd, buf);
3535               insn ^= B_DOT;
3536               if ((insn & ~0x3fffffc) == 0)
3537                 {
3538                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3539                   break;
3540                 }
3541               off += 4;
3542               if (off > 4)
3543                 break;
3544             }
3545
3546           if (resolv_vma)
3547             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3548
3549           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3550           if (relplt != NULL)
3551             {
3552               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3553               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3554                 goto free_contents_and_exit_err;
3555
3556               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3557               size += plt_count * sizeof (asymbol);
3558
3559               p = relplt->relocation;
3560               for (i = 0; i < plt_count; i++, p++)
3561                 {
3562                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563                   if (p->addend != 0)
3564                     size += sizeof ("+0x") - 1 + 16;
3565                 }
3566             }
3567         }
3568
3569       if (size == 0)
3570         goto free_contents_and_exit;
3571       s = *ret = bfd_malloc (size);
3572       if (s == NULL)
3573         goto free_contents_and_exit_err;
3574
3575       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3576
3577       for (i = secsymend; i < opdsymend; ++i)
3578         {
3579           bfd_vma ent;
3580
3581           if (syms[i]->value > opd->size - 8)
3582             continue;
3583
3584           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3585           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3586             {
3587               long lo, hi;
3588               size_t len;
3589               asection *sec = abfd->sections;
3590
3591               *s = *syms[i];
3592               lo = codesecsym;
3593               hi = codesecsymend;
3594               while (lo < hi)
3595                 {
3596                   long mid = (lo + hi) >> 1;
3597                   if (syms[mid]->section->vma < ent)
3598                     lo = mid + 1;
3599                   else if (syms[mid]->section->vma > ent)
3600                     hi = mid;
3601                   else
3602                     {
3603                       sec = syms[mid]->section;
3604                       break;
3605                     }
3606                 }
3607
3608               if (lo >= hi && lo > codesecsym)
3609                 sec = syms[lo - 1]->section;
3610
3611               for (; sec != NULL; sec = sec->next)
3612                 {
3613                   if (sec->vma > ent)
3614                     break;
3615                   /* SEC_LOAD may not be set if SEC is from a separate debug
3616                      info file.  */
3617                   if ((sec->flags & SEC_ALLOC) == 0)
3618                     break;
3619                   if ((sec->flags & SEC_CODE) != 0)
3620                     s->section = sec;
3621                 }
3622               s->flags |= BSF_SYNTHETIC;
3623               s->value = ent - s->section->vma;
3624               s->name = names;
3625               *names++ = '.';
3626               len = strlen (syms[i]->name);
3627               memcpy (names, syms[i]->name, len + 1);
3628               names += len + 1;
3629               /* Have udata.p point back to the original symbol this
3630                  synthetic symbol was derived from.  */
3631               s->udata.p = syms[i];
3632               s++;
3633             }
3634         }
3635       free (contents);
3636
3637       if (glink != NULL && relplt != NULL)
3638         {
3639           if (resolv_vma)
3640             {
3641               /* Add a symbol for the main glink trampoline.  */
3642               memset (s, 0, sizeof *s);
3643               s->the_bfd = abfd;
3644               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3645               s->section = glink;
3646               s->value = resolv_vma - glink->vma;
3647               s->name = names;
3648               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3649               names += sizeof ("__glink_PLTresolve");
3650               s++;
3651               count++;
3652             }
3653
3654           /* FIXME: It would be very much nicer to put sym@plt on the
3655              stub rather than on the glink branch table entry.  The
3656              objdump disassembler would then use a sensible symbol
3657              name on plt calls.  The difficulty in doing so is
3658              a) finding the stubs, and,
3659              b) matching stubs against plt entries, and,
3660              c) there can be multiple stubs for a given plt entry.
3661
3662              Solving (a) could be done by code scanning, but older
3663              ppc64 binaries used different stubs to current code.
3664              (b) is the tricky one since you need to known the toc
3665              pointer for at least one function that uses a pic stub to
3666              be able to calculate the plt address referenced.
3667              (c) means gdb would need to set multiple breakpoints (or
3668              find the glink branch itself) when setting breakpoints
3669              for pending shared library loads.  */
3670           p = relplt->relocation;
3671           for (i = 0; i < plt_count; i++, p++)
3672             {
3673               size_t len;
3674
3675               *s = **p->sym_ptr_ptr;
3676               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3677                  we are defining a symbol, ensure one of them is set.  */
3678               if ((s->flags & BSF_LOCAL) == 0)
3679                 s->flags |= BSF_GLOBAL;
3680               s->flags |= BSF_SYNTHETIC;
3681               s->section = glink;
3682               s->value = glink_vma - glink->vma;
3683               s->name = names;
3684               s->udata.p = NULL;
3685               len = strlen ((*p->sym_ptr_ptr)->name);
3686               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3687               names += len;
3688               if (p->addend != 0)
3689                 {
3690                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3691                   names += sizeof ("+0x") - 1;
3692                   bfd_sprintf_vma (abfd, names, p->addend);
3693                   names += strlen (names);
3694                 }
3695               memcpy (names, "@plt", sizeof ("@plt"));
3696               names += sizeof ("@plt");
3697               s++;
3698               if (abi < 2)
3699                 {
3700                   glink_vma += 8;
3701                   if (i >= 0x8000)
3702                     glink_vma += 4;
3703                 }
3704               else
3705                 glink_vma += 4;
3706             }
3707           count += plt_count;
3708         }
3709     }
3710
3711  done:
3712   free (syms);
3713   return count;
3714 }
3715 \f
3716 /* The following functions are specific to the ELF linker, while
3717    functions above are used generally.  Those named ppc64_elf_* are
3718    called by the main ELF linker code.  They appear in this file more
3719    or less in the order in which they are called.  eg.
3720    ppc64_elf_check_relocs is called early in the link process,
3721    ppc64_elf_finish_dynamic_sections is one of the last functions
3722    called.
3723
3724    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3725    functions have both a function code symbol and a function descriptor
3726    symbol.  A call to foo in a relocatable object file looks like:
3727
3728    .            .text
3729    .    x:
3730    .            bl      .foo
3731    .            nop
3732
3733    The function definition in another object file might be:
3734
3735    .            .section .opd
3736    .    foo:    .quad   .foo
3737    .            .quad   .TOC.@tocbase
3738    .            .quad   0
3739    .
3740    .            .text
3741    .    .foo:   blr
3742
3743    When the linker resolves the call during a static link, the branch
3744    unsurprisingly just goes to .foo and the .opd information is unused.
3745    If the function definition is in a shared library, things are a little
3746    different:  The call goes via a plt call stub, the opd information gets
3747    copied to the plt, and the linker patches the nop.
3748
3749    .    x:
3750    .            bl      .foo_stub
3751    .            ld      2,40(1)
3752    .
3753    .
3754    .    .foo_stub:
3755    .            std     2,40(1)                 # in practice, the call stub
3756    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3757    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3758    .            ld      12,0(11)
3759    .            ld      2,8(11)
3760    .            mtctr   12
3761    .            ld      11,16(11)
3762    .            bctr
3763    .
3764    .            .section .plt
3765    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3766
3767    The "reloc ()" notation is supposed to indicate that the linker emits
3768    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3769    copying.
3770
3771    What are the difficulties here?  Well, firstly, the relocations
3772    examined by the linker in check_relocs are against the function code
3773    sym .foo, while the dynamic relocation in the plt is emitted against
3774    the function descriptor symbol, foo.  Somewhere along the line, we need
3775    to carefully copy dynamic link information from one symbol to the other.
3776    Secondly, the generic part of the elf linker will make .foo a dynamic
3777    symbol as is normal for most other backends.  We need foo dynamic
3778    instead, at least for an application final link.  However, when
3779    creating a shared library containing foo, we need to have both symbols
3780    dynamic so that references to .foo are satisfied during the early
3781    stages of linking.  Otherwise the linker might decide to pull in a
3782    definition from some other object, eg. a static library.
3783
3784    Update: As of August 2004, we support a new convention.  Function
3785    calls may use the function descriptor symbol, ie. "bl foo".  This
3786    behaves exactly as "bl .foo".  */
3787
3788 /* Of those relocs that might be copied as dynamic relocs, this
3789    function selects those that must be copied when linking a shared
3790    library or PIE, even when the symbol is local.  */
3791
3792 static int
3793 must_be_dyn_reloc (struct bfd_link_info *info,
3794                    enum elf_ppc64_reloc_type r_type)
3795 {
3796   switch (r_type)
3797     {
3798     default:
3799       /* Only relative relocs can be resolved when the object load
3800          address isn't fixed.  DTPREL64 is excluded because the
3801          dynamic linker needs to differentiate global dynamic from
3802          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3803       return 1;
3804
3805     case R_PPC64_REL32:
3806     case R_PPC64_REL64:
3807     case R_PPC64_REL30:
3808       return 0;
3809
3810     case R_PPC64_TPREL16:
3811     case R_PPC64_TPREL16_LO:
3812     case R_PPC64_TPREL16_HI:
3813     case R_PPC64_TPREL16_HA:
3814     case R_PPC64_TPREL16_DS:
3815     case R_PPC64_TPREL16_LO_DS:
3816     case R_PPC64_TPREL16_HIGH:
3817     case R_PPC64_TPREL16_HIGHA:
3818     case R_PPC64_TPREL16_HIGHER:
3819     case R_PPC64_TPREL16_HIGHERA:
3820     case R_PPC64_TPREL16_HIGHEST:
3821     case R_PPC64_TPREL16_HIGHESTA:
3822     case R_PPC64_TPREL64:
3823       /* These relocations are relative but in a shared library the
3824          linker doesn't know the thread pointer base.  */
3825       return bfd_link_dll (info);
3826     }
3827 }
3828
3829 /* Whether an undefined weak symbol should resolve to its link-time
3830    value, even in PIC or PIE objects.  */
3831 #define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H)             \
3832   ((H)->root.type == bfd_link_hash_undefweak            \
3833    && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT    \
3834        || (INFO)->dynamic_undefined_weak == 0))
3835
3836 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3837    copying dynamic variables from a shared lib into an app's dynbss
3838    section, and instead use a dynamic relocation to point into the
3839    shared lib.  With code that gcc generates, it's vital that this be
3840    enabled;  In the PowerPC64 ABI, the address of a function is actually
3841    the address of a function descriptor, which resides in the .opd
3842    section.  gcc uses the descriptor directly rather than going via the
3843    GOT as some other ABI's do, which means that initialized function
3844    pointers must reference the descriptor.  Thus, a function pointer
3845    initialized to the address of a function in a shared library will
3846    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3847    redefines the function descriptor symbol to point to the copy.  This
3848    presents a problem as a plt entry for that function is also
3849    initialized from the function descriptor symbol and the copy reloc
3850    may not be initialized first.  */
3851 #define ELIMINATE_COPY_RELOCS 1
3852
3853 /* Section name for stubs is the associated section name plus this
3854    string.  */
3855 #define STUB_SUFFIX ".stub"
3856
3857 /* Linker stubs.
3858    ppc_stub_long_branch:
3859    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3860    destination, but a 24 bit branch in a stub section will reach.
3861    .    b       dest
3862
3863    ppc_stub_plt_branch:
3864    Similar to the above, but a 24 bit branch in the stub section won't
3865    reach its destination.
3866    .    addis   %r11,%r2,xxx@toc@ha
3867    .    ld      %r12,xxx@toc@l(%r11)
3868    .    mtctr   %r12
3869    .    bctr
3870
3871    ppc_stub_plt_call:
3872    Used to call a function in a shared library.  If it so happens that
3873    the plt entry referenced crosses a 64k boundary, then an extra
3874    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3875    .    std     %r2,40(%r1)
3876    .    addis   %r11,%r2,xxx@toc@ha
3877    .    ld      %r12,xxx+0@toc@l(%r11)
3878    .    mtctr   %r12
3879    .    ld      %r2,xxx+8@toc@l(%r11)
3880    .    ld      %r11,xxx+16@toc@l(%r11)
3881    .    bctr
3882
3883    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3884    code to adjust the value and save r2 to support multiple toc sections.
3885    A ppc_stub_long_branch with an r2 offset looks like:
3886    .    std     %r2,40(%r1)
3887    .    addis   %r2,%r2,off@ha
3888    .    addi    %r2,%r2,off@l
3889    .    b       dest
3890
3891    A ppc_stub_plt_branch with an r2 offset looks like:
3892    .    std     %r2,40(%r1)
3893    .    addis   %r11,%r2,xxx@toc@ha
3894    .    ld      %r12,xxx@toc@l(%r11)
3895    .    addis   %r2,%r2,off@ha
3896    .    addi    %r2,%r2,off@l
3897    .    mtctr   %r12
3898    .    bctr
3899
3900    In cases where the "addis" instruction would add zero, the "addis" is
3901    omitted and following instructions modified slightly in some cases.
3902 */
3903
3904 enum ppc_stub_type {
3905   ppc_stub_none,
3906   ppc_stub_long_branch,
3907   ppc_stub_long_branch_r2off,
3908   ppc_stub_plt_branch,
3909   ppc_stub_plt_branch_r2off,
3910   ppc_stub_plt_call,
3911   ppc_stub_plt_call_r2save,
3912   ppc_stub_global_entry,
3913   ppc_stub_save_res
3914 };
3915
3916 /* Information on stub grouping.  */
3917 struct map_stub
3918 {
3919   /* The stub section.  */
3920   asection *stub_sec;
3921   /* This is the section to which stubs in the group will be attached.  */
3922   asection *link_sec;
3923   /* Next group.  */
3924   struct map_stub *next;
3925   /* Whether to emit a copy of register save/restore functions in this
3926      group.  */
3927   int needs_save_res;
3928   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3929      or -1u if no such stub with bctrl exists.  */
3930   unsigned int tls_get_addr_opt_bctrl;
3931 };
3932
3933 struct ppc_stub_hash_entry {
3934
3935   /* Base hash table entry structure.  */
3936   struct bfd_hash_entry root;
3937
3938   enum ppc_stub_type stub_type;
3939
3940   /* Group information.  */
3941   struct map_stub *group;
3942
3943   /* Offset within stub_sec of the beginning of this stub.  */
3944   bfd_vma stub_offset;
3945
3946   /* Given the symbol's value and its section we can determine its final
3947      value when building the stubs (so the stub knows where to jump.  */
3948   bfd_vma target_value;
3949   asection *target_section;
3950
3951   /* The symbol table entry, if any, that this was derived from.  */
3952   struct ppc_link_hash_entry *h;
3953   struct plt_entry *plt_ent;
3954
3955   /* Symbol st_other.  */
3956   unsigned char other;
3957 };
3958
3959 struct ppc_branch_hash_entry {
3960
3961   /* Base hash table entry structure.  */
3962   struct bfd_hash_entry root;
3963
3964   /* Offset within branch lookup table.  */
3965   unsigned int offset;
3966
3967   /* Generation marker.  */
3968   unsigned int iter;
3969 };
3970
3971 /* Used to track dynamic relocations for local symbols.  */
3972 struct ppc_dyn_relocs
3973 {
3974   struct ppc_dyn_relocs *next;
3975
3976   /* The input section of the reloc.  */
3977   asection *sec;
3978
3979   /* Total number of relocs copied for the input section.  */
3980   unsigned int count : 31;
3981
3982   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3983   unsigned int ifunc : 1;
3984 };
3985
3986 struct ppc_link_hash_entry
3987 {
3988   struct elf_link_hash_entry elf;
3989
3990   union {
3991     /* A pointer to the most recently used stub hash entry against this
3992        symbol.  */
3993     struct ppc_stub_hash_entry *stub_cache;
3994
3995     /* A pointer to the next symbol starting with a '.'  */
3996     struct ppc_link_hash_entry *next_dot_sym;
3997   } u;
3998
3999   /* Track dynamic relocs copied for this symbol.  */
4000   struct elf_dyn_relocs *dyn_relocs;
4001
4002   /* Chain of aliases referring to a weakdef.  */
4003   struct ppc_link_hash_entry *weakref;
4004
4005   /* Link between function code and descriptor symbols.  */
4006   struct ppc_link_hash_entry *oh;
4007
4008   /* Flag function code and descriptor symbols.  */
4009   unsigned int is_func:1;
4010   unsigned int is_func_descriptor:1;
4011   unsigned int fake:1;
4012
4013   /* Whether global opd/toc sym has been adjusted or not.
4014      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4015      should be set for all globals defined in any opd/toc section.  */
4016   unsigned int adjust_done:1;
4017
4018   /* Set if this is an out-of-line register save/restore function,
4019      with non-standard calling convention.  */
4020   unsigned int save_res:1;
4021
4022   /* Set if a duplicate symbol with non-zero localentry is detected,
4023      even when the duplicate symbol does not provide a definition.  */
4024   unsigned int non_zero_localentry:1;
4025
4026   /* Contexts in which symbol is used in the GOT (or TOC).
4027      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4028      corresponding relocs are encountered during check_relocs.
4029      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4030      indicate the corresponding GOT entry type is not needed.
4031      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4032      a TPREL one.  We use a separate flag rather than setting TPREL
4033      just for convenience in distinguishing the two cases.  */
4034 #define TLS_GD           1      /* GD reloc. */
4035 #define TLS_LD           2      /* LD reloc. */
4036 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4037 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4038 #define TLS_TLS         16      /* Any TLS reloc.  */
4039 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4040 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4041 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4042   unsigned char tls_mask;
4043 };
4044
4045 /* ppc64 ELF linker hash table.  */
4046
4047 struct ppc_link_hash_table
4048 {
4049   struct elf_link_hash_table elf;
4050
4051   /* The stub hash table.  */
4052   struct bfd_hash_table stub_hash_table;
4053
4054   /* Another hash table for plt_branch stubs.  */
4055   struct bfd_hash_table branch_hash_table;
4056
4057   /* Hash table for function prologue tocsave.  */
4058   htab_t tocsave_htab;
4059
4060   /* Various options and other info passed from the linker.  */
4061   struct ppc64_elf_params *params;
4062
4063   /* The size of sec_info below.  */
4064   unsigned int sec_info_arr_size;
4065
4066   /* Per-section array of extra section info.  Done this way rather
4067      than as part of ppc64_elf_section_data so we have the info for
4068      non-ppc64 sections.  */
4069   struct
4070   {
4071     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4072     bfd_vma toc_off;
4073
4074     union
4075     {
4076       /* The section group that this section belongs to.  */
4077       struct map_stub *group;
4078       /* A temp section list pointer.  */
4079       asection *list;
4080     } u;
4081   } *sec_info;
4082
4083   /* Linked list of groups.  */
4084   struct map_stub *group;
4085
4086   /* Temp used when calculating TOC pointers.  */
4087   bfd_vma toc_curr;
4088   bfd *toc_bfd;
4089   asection *toc_first_sec;
4090
4091   /* Used when adding symbols.  */
4092   struct ppc_link_hash_entry *dot_syms;
4093
4094   /* Shortcuts to get to dynamic linker sections.  */
4095   asection *glink;
4096   asection *sfpr;
4097   asection *brlt;
4098   asection *relbrlt;
4099   asection *glink_eh_frame;
4100
4101   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4102   struct ppc_link_hash_entry *tls_get_addr;
4103   struct ppc_link_hash_entry *tls_get_addr_fd;
4104
4105   /* The size of reliplt used by got entry relocs.  */
4106   bfd_size_type got_reli_size;
4107
4108   /* Statistics.  */
4109   unsigned long stub_count[ppc_stub_global_entry];
4110
4111   /* Number of stubs against global syms.  */
4112   unsigned long stub_globals;
4113
4114   /* Set if we're linking code with function descriptors.  */
4115   unsigned int opd_abi:1;
4116
4117   /* Support for multiple toc sections.  */
4118   unsigned int do_multi_toc:1;
4119   unsigned int multi_toc_needed:1;
4120   unsigned int second_toc_pass:1;
4121   unsigned int do_toc_opt:1;
4122
4123   /* Set if tls optimization is enabled.  */
4124   unsigned int do_tls_opt:1;
4125
4126   /* Set on error.  */
4127   unsigned int stub_error:1;
4128
4129   /* Whether func_desc_adjust needs to be run over symbols.  */
4130   unsigned int need_func_desc_adj:1;
4131
4132   /* Whether there exist local gnu indirect function resolvers,
4133      referenced by dynamic relocations.  */
4134   unsigned int local_ifunc_resolver:1;
4135   unsigned int maybe_local_ifunc_resolver:1;
4136
4137   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4138   unsigned int has_plt_localentry0:1;
4139
4140   /* Incremented every time we size stubs.  */
4141   unsigned int stub_iteration;
4142
4143   /* Small local sym cache.  */
4144   struct sym_cache sym_cache;
4145 };
4146
4147 /* Rename some of the generic section flags to better document how they
4148    are used here.  */
4149
4150 /* Nonzero if this section has TLS related relocations.  */
4151 #define has_tls_reloc sec_flg0
4152
4153 /* Nonzero if this section has a call to __tls_get_addr.  */
4154 #define has_tls_get_addr_call sec_flg1
4155
4156 /* Nonzero if this section has any toc or got relocs.  */
4157 #define has_toc_reloc sec_flg2
4158
4159 /* Nonzero if this section has a call to another section that uses
4160    the toc or got.  */
4161 #define makes_toc_func_call sec_flg3
4162
4163 /* Recursion protection when determining above flag.  */
4164 #define call_check_in_progress sec_flg4
4165 #define call_check_done sec_flg5
4166
4167 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4168
4169 #define ppc_hash_table(p) \
4170   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4171   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4172
4173 #define ppc_stub_hash_lookup(table, string, create, copy) \
4174   ((struct ppc_stub_hash_entry *) \
4175    bfd_hash_lookup ((table), (string), (create), (copy)))
4176
4177 #define ppc_branch_hash_lookup(table, string, create, copy) \
4178   ((struct ppc_branch_hash_entry *) \
4179    bfd_hash_lookup ((table), (string), (create), (copy)))
4180
4181 /* Create an entry in the stub hash table.  */
4182
4183 static struct bfd_hash_entry *
4184 stub_hash_newfunc (struct bfd_hash_entry *entry,
4185                    struct bfd_hash_table *table,
4186                    const char *string)
4187 {
4188   /* Allocate the structure if it has not already been allocated by a
4189      subclass.  */
4190   if (entry == NULL)
4191     {
4192       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4193       if (entry == NULL)
4194         return entry;
4195     }
4196
4197   /* Call the allocation method of the superclass.  */
4198   entry = bfd_hash_newfunc (entry, table, string);
4199   if (entry != NULL)
4200     {
4201       struct ppc_stub_hash_entry *eh;
4202
4203       /* Initialize the local fields.  */
4204       eh = (struct ppc_stub_hash_entry *) entry;
4205       eh->stub_type = ppc_stub_none;
4206       eh->group = NULL;
4207       eh->stub_offset = 0;
4208       eh->target_value = 0;
4209       eh->target_section = NULL;
4210       eh->h = NULL;
4211       eh->plt_ent = NULL;
4212       eh->other = 0;
4213     }
4214
4215   return entry;
4216 }
4217
4218 /* Create an entry in the branch hash table.  */
4219
4220 static struct bfd_hash_entry *
4221 branch_hash_newfunc (struct bfd_hash_entry *entry,
4222                      struct bfd_hash_table *table,
4223                      const char *string)
4224 {
4225   /* Allocate the structure if it has not already been allocated by a
4226      subclass.  */
4227   if (entry == NULL)
4228     {
4229       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4230       if (entry == NULL)
4231         return entry;
4232     }
4233
4234   /* Call the allocation method of the superclass.  */
4235   entry = bfd_hash_newfunc (entry, table, string);
4236   if (entry != NULL)
4237     {
4238       struct ppc_branch_hash_entry *eh;
4239
4240       /* Initialize the local fields.  */
4241       eh = (struct ppc_branch_hash_entry *) entry;
4242       eh->offset = 0;
4243       eh->iter = 0;
4244     }
4245
4246   return entry;
4247 }
4248
4249 /* Create an entry in a ppc64 ELF linker hash table.  */
4250
4251 static struct bfd_hash_entry *
4252 link_hash_newfunc (struct bfd_hash_entry *entry,
4253                    struct bfd_hash_table *table,
4254                    const char *string)
4255 {
4256   /* Allocate the structure if it has not already been allocated by a
4257      subclass.  */
4258   if (entry == NULL)
4259     {
4260       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4261       if (entry == NULL)
4262         return entry;
4263     }
4264
4265   /* Call the allocation method of the superclass.  */
4266   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4267   if (entry != NULL)
4268     {
4269       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4270
4271       memset (&eh->u.stub_cache, 0,
4272               (sizeof (struct ppc_link_hash_entry)
4273                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4274
4275       /* When making function calls, old ABI code references function entry
4276          points (dot symbols), while new ABI code references the function
4277          descriptor symbol.  We need to make any combination of reference and
4278          definition work together, without breaking archive linking.
4279
4280          For a defined function "foo" and an undefined call to "bar":
4281          An old object defines "foo" and ".foo", references ".bar" (possibly
4282          "bar" too).
4283          A new object defines "foo" and references "bar".
4284
4285          A new object thus has no problem with its undefined symbols being
4286          satisfied by definitions in an old object.  On the other hand, the
4287          old object won't have ".bar" satisfied by a new object.
4288
4289          Keep a list of newly added dot-symbols.  */
4290
4291       if (string[0] == '.')
4292         {
4293           struct ppc_link_hash_table *htab;
4294
4295           htab = (struct ppc_link_hash_table *) table;
4296           eh->u.next_dot_sym = htab->dot_syms;
4297           htab->dot_syms = eh;
4298         }
4299     }
4300
4301   return entry;
4302 }
4303
4304 struct tocsave_entry {
4305   asection *sec;
4306   bfd_vma offset;
4307 };
4308
4309 static hashval_t
4310 tocsave_htab_hash (const void *p)
4311 {
4312   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4313   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4314 }
4315
4316 static int
4317 tocsave_htab_eq (const void *p1, const void *p2)
4318 {
4319   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4320   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4321   return e1->sec == e2->sec && e1->offset == e2->offset;
4322 }
4323
4324 /* Destroy a ppc64 ELF linker hash table.  */
4325
4326 static void
4327 ppc64_elf_link_hash_table_free (bfd *obfd)
4328 {
4329   struct ppc_link_hash_table *htab;
4330
4331   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4332   if (htab->tocsave_htab)
4333     htab_delete (htab->tocsave_htab);
4334   bfd_hash_table_free (&htab->branch_hash_table);
4335   bfd_hash_table_free (&htab->stub_hash_table);
4336   _bfd_elf_link_hash_table_free (obfd);
4337 }
4338
4339 /* Create a ppc64 ELF linker hash table.  */
4340
4341 static struct bfd_link_hash_table *
4342 ppc64_elf_link_hash_table_create (bfd *abfd)
4343 {
4344   struct ppc_link_hash_table *htab;
4345   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4346
4347   htab = bfd_zmalloc (amt);
4348   if (htab == NULL)
4349     return NULL;
4350
4351   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4352                                       sizeof (struct ppc_link_hash_entry),
4353                                       PPC64_ELF_DATA))
4354     {
4355       free (htab);
4356       return NULL;
4357     }
4358
4359   /* Init the stub hash table too.  */
4360   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4361                             sizeof (struct ppc_stub_hash_entry)))
4362     {
4363       _bfd_elf_link_hash_table_free (abfd);
4364       return NULL;
4365     }
4366
4367   /* And the branch hash table.  */
4368   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4369                             sizeof (struct ppc_branch_hash_entry)))
4370     {
4371       bfd_hash_table_free (&htab->stub_hash_table);
4372       _bfd_elf_link_hash_table_free (abfd);
4373       return NULL;
4374     }
4375
4376   htab->tocsave_htab = htab_try_create (1024,
4377                                         tocsave_htab_hash,
4378                                         tocsave_htab_eq,
4379                                         NULL);
4380   if (htab->tocsave_htab == NULL)
4381     {
4382       ppc64_elf_link_hash_table_free (abfd);
4383       return NULL;
4384     }
4385   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4386
4387   /* Initializing two fields of the union is just cosmetic.  We really
4388      only care about glist, but when compiled on a 32-bit host the
4389      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4390      debugger inspection of these fields look nicer.  */
4391   htab->elf.init_got_refcount.refcount = 0;
4392   htab->elf.init_got_refcount.glist = NULL;
4393   htab->elf.init_plt_refcount.refcount = 0;
4394   htab->elf.init_plt_refcount.glist = NULL;
4395   htab->elf.init_got_offset.offset = 0;
4396   htab->elf.init_got_offset.glist = NULL;
4397   htab->elf.init_plt_offset.offset = 0;
4398   htab->elf.init_plt_offset.glist = NULL;
4399
4400   return &htab->elf.root;
4401 }
4402
4403 /* Create sections for linker generated code.  */
4404
4405 static bfd_boolean
4406 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4407 {
4408   struct ppc_link_hash_table *htab;
4409   flagword flags;
4410
4411   htab = ppc_hash_table (info);
4412
4413   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4414            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4415   if (htab->params->save_restore_funcs)
4416     {
4417       /* Create .sfpr for code to save and restore fp regs.  */
4418       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4419                                                        flags);
4420       if (htab->sfpr == NULL
4421           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4422         return FALSE;
4423     }
4424
4425   if (bfd_link_relocatable (info))
4426     return TRUE;
4427
4428   /* Create .glink for lazy dynamic linking support.  */
4429   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4430                                                     flags);
4431   if (htab->glink == NULL
4432       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4433     return FALSE;
4434
4435   if (!info->no_ld_generated_unwind_info)
4436     {
4437       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4438                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4439       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4440                                                                  ".eh_frame",
4441                                                                  flags);
4442       if (htab->glink_eh_frame == NULL
4443           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4444         return FALSE;
4445     }
4446
4447   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4448   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4449   if (htab->elf.iplt == NULL
4450       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4451     return FALSE;
4452
4453   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4454            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4455   htab->elf.irelplt
4456     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4457   if (htab->elf.irelplt == NULL
4458       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4459     return FALSE;
4460
4461   /* Create branch lookup table for plt_branch stubs.  */
4462   flags = (SEC_ALLOC | SEC_LOAD
4463            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4464   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4465                                                    flags);
4466   if (htab->brlt == NULL
4467       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4468     return FALSE;
4469
4470   if (!bfd_link_pic (info))
4471     return TRUE;
4472
4473   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4474            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4475   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4476                                                       ".rela.branch_lt",
4477                                                       flags);
4478   if (htab->relbrlt == NULL
4479       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4480     return FALSE;
4481
4482   return TRUE;
4483 }
4484
4485 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4486
4487 bfd_boolean
4488 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4489                          struct ppc64_elf_params *params)
4490 {
4491   struct ppc_link_hash_table *htab;
4492
4493   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4494
4495 /* Always hook our dynamic sections into the first bfd, which is the
4496    linker created stub bfd.  This ensures that the GOT header is at
4497    the start of the output TOC section.  */
4498   htab = ppc_hash_table (info);
4499   htab->elf.dynobj = params->stub_bfd;
4500   htab->params = params;
4501
4502   return create_linkage_sections (htab->elf.dynobj, info);
4503 }
4504
4505 /* Build a name for an entry in the stub hash table.  */
4506
4507 static char *
4508 ppc_stub_name (const asection *input_section,
4509                const asection *sym_sec,
4510                const struct ppc_link_hash_entry *h,
4511                const Elf_Internal_Rela *rel)
4512 {
4513   char *stub_name;
4514   ssize_t len;
4515
4516   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4517      offsets from a sym as a branch target?  In fact, we could
4518      probably assume the addend is always zero.  */
4519   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4520
4521   if (h)
4522     {
4523       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4524       stub_name = bfd_malloc (len);
4525       if (stub_name == NULL)
4526         return stub_name;
4527
4528       len = sprintf (stub_name, "%08x.%s+%x",
4529                      input_section->id & 0xffffffff,
4530                      h->elf.root.root.string,
4531                      (int) rel->r_addend & 0xffffffff);
4532     }
4533   else
4534     {
4535       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4536       stub_name = bfd_malloc (len);
4537       if (stub_name == NULL)
4538         return stub_name;
4539
4540       len = sprintf (stub_name, "%08x.%x:%x+%x",
4541                      input_section->id & 0xffffffff,
4542                      sym_sec->id & 0xffffffff,
4543                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4544                      (int) rel->r_addend & 0xffffffff);
4545     }
4546   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4547     stub_name[len - 2] = 0;
4548   return stub_name;
4549 }
4550
4551 /* Look up an entry in the stub hash.  Stub entries are cached because
4552    creating the stub name takes a bit of time.  */
4553
4554 static struct ppc_stub_hash_entry *
4555 ppc_get_stub_entry (const asection *input_section,
4556                     const asection *sym_sec,
4557                     struct ppc_link_hash_entry *h,
4558                     const Elf_Internal_Rela *rel,
4559                     struct ppc_link_hash_table *htab)
4560 {
4561   struct ppc_stub_hash_entry *stub_entry;
4562   struct map_stub *group;
4563
4564   /* If this input section is part of a group of sections sharing one
4565      stub section, then use the id of the first section in the group.
4566      Stub names need to include a section id, as there may well be
4567      more than one stub used to reach say, printf, and we need to
4568      distinguish between them.  */
4569   group = htab->sec_info[input_section->id].u.group;
4570   if (group == NULL)
4571     return NULL;
4572
4573   if (h != NULL && h->u.stub_cache != NULL
4574       && h->u.stub_cache->h == h
4575       && h->u.stub_cache->group == group)
4576     {
4577       stub_entry = h->u.stub_cache;
4578     }
4579   else
4580     {
4581       char *stub_name;
4582
4583       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4584       if (stub_name == NULL)
4585         return NULL;
4586
4587       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4588                                          stub_name, FALSE, FALSE);
4589       if (h != NULL)
4590         h->u.stub_cache = stub_entry;
4591
4592       free (stub_name);
4593     }
4594
4595   return stub_entry;
4596 }
4597
4598 /* Add a new stub entry to the stub hash.  Not all fields of the new
4599    stub entry are initialised.  */
4600
4601 static struct ppc_stub_hash_entry *
4602 ppc_add_stub (const char *stub_name,
4603               asection *section,
4604               struct bfd_link_info *info)
4605 {
4606   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4607   struct map_stub *group;
4608   asection *link_sec;
4609   asection *stub_sec;
4610   struct ppc_stub_hash_entry *stub_entry;
4611
4612   group = htab->sec_info[section->id].u.group;
4613   link_sec = group->link_sec;
4614   stub_sec = group->stub_sec;
4615   if (stub_sec == NULL)
4616     {
4617       size_t namelen;
4618       bfd_size_type len;
4619       char *s_name;
4620
4621       namelen = strlen (link_sec->name);
4622       len = namelen + sizeof (STUB_SUFFIX);
4623       s_name = bfd_alloc (htab->params->stub_bfd, len);
4624       if (s_name == NULL)
4625         return NULL;
4626
4627       memcpy (s_name, link_sec->name, namelen);
4628       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4629       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4630       if (stub_sec == NULL)
4631         return NULL;
4632       group->stub_sec = stub_sec;
4633     }
4634
4635   /* Enter this entry into the linker stub hash table.  */
4636   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4637                                      TRUE, FALSE);
4638   if (stub_entry == NULL)
4639     {
4640       /* xgettext:c-format */
4641       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4642                               section->owner, stub_name);
4643       return NULL;
4644     }
4645
4646   stub_entry->group = group;
4647   stub_entry->stub_offset = 0;
4648   return stub_entry;
4649 }
4650
4651 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4652    not already done.  */
4653
4654 static bfd_boolean
4655 create_got_section (bfd *abfd, struct bfd_link_info *info)
4656 {
4657   asection *got, *relgot;
4658   flagword flags;
4659   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4660
4661   if (!is_ppc64_elf (abfd))
4662     return FALSE;
4663   if (htab == NULL)
4664     return FALSE;
4665
4666   if (!htab->elf.sgot
4667       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4668     return FALSE;
4669
4670   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4671            | SEC_LINKER_CREATED);
4672
4673   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4674   if (!got
4675       || !bfd_set_section_alignment (abfd, got, 3))
4676     return FALSE;
4677
4678   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4679                                                flags | SEC_READONLY);
4680   if (!relgot
4681       || ! bfd_set_section_alignment (abfd, relgot, 3))
4682     return FALSE;
4683
4684   ppc64_elf_tdata (abfd)->got = got;
4685   ppc64_elf_tdata (abfd)->relgot = relgot;
4686   return TRUE;
4687 }
4688
4689 /* Follow indirect and warning symbol links.  */
4690
4691 static inline struct bfd_link_hash_entry *
4692 follow_link (struct bfd_link_hash_entry *h)
4693 {
4694   while (h->type == bfd_link_hash_indirect
4695          || h->type == bfd_link_hash_warning)
4696     h = h->u.i.link;
4697   return h;
4698 }
4699
4700 static inline struct elf_link_hash_entry *
4701 elf_follow_link (struct elf_link_hash_entry *h)
4702 {
4703   return (struct elf_link_hash_entry *) follow_link (&h->root);
4704 }
4705
4706 static inline struct ppc_link_hash_entry *
4707 ppc_follow_link (struct ppc_link_hash_entry *h)
4708 {
4709   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4710 }
4711
4712 /* Merge PLT info on FROM with that on TO.  */
4713
4714 static void
4715 move_plt_plist (struct ppc_link_hash_entry *from,
4716                 struct ppc_link_hash_entry *to)
4717 {
4718   if (from->elf.plt.plist != NULL)
4719     {
4720       if (to->elf.plt.plist != NULL)
4721         {
4722           struct plt_entry **entp;
4723           struct plt_entry *ent;
4724
4725           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4726             {
4727               struct plt_entry *dent;
4728
4729               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4730                 if (dent->addend == ent->addend)
4731                   {
4732                     dent->plt.refcount += ent->plt.refcount;
4733                     *entp = ent->next;
4734                     break;
4735                   }
4736               if (dent == NULL)
4737                 entp = &ent->next;
4738             }
4739           *entp = to->elf.plt.plist;
4740         }
4741
4742       to->elf.plt.plist = from->elf.plt.plist;
4743       from->elf.plt.plist = NULL;
4744     }
4745 }
4746
4747 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4748
4749 static void
4750 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4751                                 struct elf_link_hash_entry *dir,
4752                                 struct elf_link_hash_entry *ind)
4753 {
4754   struct ppc_link_hash_entry *edir, *eind;
4755
4756   edir = (struct ppc_link_hash_entry *) dir;
4757   eind = (struct ppc_link_hash_entry *) ind;
4758
4759   edir->is_func |= eind->is_func;
4760   edir->is_func_descriptor |= eind->is_func_descriptor;
4761   edir->tls_mask |= eind->tls_mask;
4762   if (eind->oh != NULL)
4763     edir->oh = ppc_follow_link (eind->oh);
4764
4765   /* If called to transfer flags for a weakdef during processing
4766      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4767      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4768   if (!(ELIMINATE_COPY_RELOCS
4769         && eind->elf.root.type != bfd_link_hash_indirect
4770         && edir->elf.dynamic_adjusted))
4771     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4772
4773   if (edir->elf.versioned != versioned_hidden)
4774     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4775   edir->elf.ref_regular |= eind->elf.ref_regular;
4776   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4777   edir->elf.needs_plt |= eind->elf.needs_plt;
4778   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4779
4780   /* If we were called to copy over info for a weak sym, don't copy
4781      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4782      in order to simplify readonly_dynrelocs and save a field in the
4783      symbol hash entry, but that means dyn_relocs can't be used in any
4784      tests about a specific symbol, or affect other symbol flags which
4785      are then tested.
4786      Chain weakdefs so we can get from the weakdef back to an alias.
4787      The list is circular so that we don't need to use u.weakdef as
4788      well as this list to look at all aliases.  */
4789   if (eind->elf.root.type != bfd_link_hash_indirect)
4790     {
4791       struct ppc_link_hash_entry *cur, *add, *next;
4792
4793       add = eind;
4794       do
4795         {
4796           cur = edir->weakref;
4797           if (cur != NULL)
4798             {
4799               do
4800                 {
4801                   /* We can be called twice for the same symbols.
4802                      Don't make multiple loops.  */
4803                   if (cur == add)
4804                     return;
4805                   cur = cur->weakref;
4806                 } while (cur != edir);
4807             }
4808           next = add->weakref;
4809           if (cur != add)
4810             {
4811               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4812               edir->weakref = add;
4813             }
4814           add = next;
4815         } while (add != NULL && add != eind);
4816       return;
4817     }
4818
4819   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4820   if (eind->dyn_relocs != NULL)
4821     {
4822       if (edir->dyn_relocs != NULL)
4823         {
4824           struct elf_dyn_relocs **pp;
4825           struct elf_dyn_relocs *p;
4826
4827           /* Add reloc counts against the indirect sym to the direct sym
4828              list.  Merge any entries against the same section.  */
4829           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4830             {
4831               struct elf_dyn_relocs *q;
4832
4833               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4834                 if (q->sec == p->sec)
4835                   {
4836                     q->pc_count += p->pc_count;
4837                     q->count += p->count;
4838                     *pp = p->next;
4839                     break;
4840                   }
4841               if (q == NULL)
4842                 pp = &p->next;
4843             }
4844           *pp = edir->dyn_relocs;
4845         }
4846
4847       edir->dyn_relocs = eind->dyn_relocs;
4848       eind->dyn_relocs = NULL;
4849     }
4850
4851   /* Copy over got entries that we may have already seen to the
4852      symbol which just became indirect.  */
4853   if (eind->elf.got.glist != NULL)
4854     {
4855       if (edir->elf.got.glist != NULL)
4856         {
4857           struct got_entry **entp;
4858           struct got_entry *ent;
4859
4860           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4861             {
4862               struct got_entry *dent;
4863
4864               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4865                 if (dent->addend == ent->addend
4866                     && dent->owner == ent->owner
4867                     && dent->tls_type == ent->tls_type)
4868                   {
4869                     dent->got.refcount += ent->got.refcount;
4870                     *entp = ent->next;
4871                     break;
4872                   }
4873               if (dent == NULL)
4874                 entp = &ent->next;
4875             }
4876           *entp = edir->elf.got.glist;
4877         }
4878
4879       edir->elf.got.glist = eind->elf.got.glist;
4880       eind->elf.got.glist = NULL;
4881     }
4882
4883   /* And plt entries.  */
4884   move_plt_plist (eind, edir);
4885
4886   if (eind->elf.dynindx != -1)
4887     {
4888       if (edir->elf.dynindx != -1)
4889         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4890                                 edir->elf.dynstr_index);
4891       edir->elf.dynindx = eind->elf.dynindx;
4892       edir->elf.dynstr_index = eind->elf.dynstr_index;
4893       eind->elf.dynindx = -1;
4894       eind->elf.dynstr_index = 0;
4895     }
4896 }
4897
4898 /* Find the function descriptor hash entry from the given function code
4899    hash entry FH.  Link the entries via their OH fields.  */
4900
4901 static struct ppc_link_hash_entry *
4902 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4903 {
4904   struct ppc_link_hash_entry *fdh = fh->oh;
4905
4906   if (fdh == NULL)
4907     {
4908       const char *fd_name = fh->elf.root.root.string + 1;
4909
4910       fdh = (struct ppc_link_hash_entry *)
4911         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4912       if (fdh == NULL)
4913         return fdh;
4914
4915       fdh->is_func_descriptor = 1;
4916       fdh->oh = fh;
4917       fh->is_func = 1;
4918       fh->oh = fdh;
4919     }
4920
4921   fdh = ppc_follow_link (fdh);
4922   fdh->is_func_descriptor = 1;
4923   fdh->oh = fh;
4924   return fdh;
4925 }
4926
4927 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4928
4929 static struct ppc_link_hash_entry *
4930 make_fdh (struct bfd_link_info *info,
4931           struct ppc_link_hash_entry *fh)
4932 {
4933   bfd *abfd = fh->elf.root.u.undef.abfd;
4934   struct bfd_link_hash_entry *bh = NULL;
4935   struct ppc_link_hash_entry *fdh;
4936   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4937                     ? BSF_WEAK
4938                     : BSF_GLOBAL);
4939
4940   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4941                                          fh->elf.root.root.string + 1,
4942                                          flags, bfd_und_section_ptr, 0,
4943                                          NULL, FALSE, FALSE, &bh))
4944     return NULL;
4945
4946   fdh = (struct ppc_link_hash_entry *) bh;
4947   fdh->elf.non_elf = 0;
4948   fdh->fake = 1;
4949   fdh->is_func_descriptor = 1;
4950   fdh->oh = fh;
4951   fh->is_func = 1;
4952   fh->oh = fdh;
4953   return fdh;
4954 }
4955
4956 /* Fix function descriptor symbols defined in .opd sections to be
4957    function type.  */
4958
4959 static bfd_boolean
4960 ppc64_elf_add_symbol_hook (bfd *ibfd,
4961                            struct bfd_link_info *info,
4962                            Elf_Internal_Sym *isym,
4963                            const char **name,
4964                            flagword *flags ATTRIBUTE_UNUSED,
4965                            asection **sec,
4966                            bfd_vma *value)
4967 {
4968   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4969       && (ibfd->flags & DYNAMIC) == 0
4970       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4971     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4972
4973   if (*sec != NULL
4974       && strcmp ((*sec)->name, ".opd") == 0)
4975     {
4976       asection *code_sec;
4977
4978       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4979             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4980         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4981
4982       /* If the symbol is a function defined in .opd, and the function
4983          code is in a discarded group, let it appear to be undefined.  */
4984       if (!bfd_link_relocatable (info)
4985           && (*sec)->reloc_count != 0
4986           && opd_entry_value (*sec, *value, &code_sec, NULL,
4987                               FALSE) != (bfd_vma) -1
4988           && discarded_section (code_sec))
4989         {
4990           *sec = bfd_und_section_ptr;
4991           isym->st_shndx = SHN_UNDEF;
4992         }
4993     }
4994   else if (*sec != NULL
4995            && strcmp ((*sec)->name, ".toc") == 0
4996            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4997     {
4998       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4999       if (htab != NULL)
5000         htab->params->object_in_toc = 1;
5001     }
5002
5003   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5004     {
5005       if (abiversion (ibfd) == 0)
5006         set_abiversion (ibfd, 2);
5007       else if (abiversion (ibfd) == 1)
5008         {
5009           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
5010                                     " for ABI version 1\n"), name);
5011           bfd_set_error (bfd_error_bad_value);
5012           return FALSE;
5013         }
5014     }
5015
5016   return TRUE;
5017 }
5018
5019 /* Merge non-visibility st_other attributes: local entry point.  */
5020
5021 static void
5022 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5023                                   const Elf_Internal_Sym *isym,
5024                                   bfd_boolean definition,
5025                                   bfd_boolean dynamic)
5026 {
5027   if (definition && (!dynamic || !h->def_regular))
5028     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5029                 | ELF_ST_VISIBILITY (h->other));
5030 }
5031
5032 /* Hook called on merging a symbol.  We use this to clear "fake" since
5033    we now have a real symbol.  */
5034
5035 static bfd_boolean
5036 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5037                         const Elf_Internal_Sym *isym,
5038                         asection **psec ATTRIBUTE_UNUSED,
5039                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5040                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5041                         bfd *oldbfd ATTRIBUTE_UNUSED,
5042                         const asection *oldsec ATTRIBUTE_UNUSED)
5043 {
5044   ((struct ppc_link_hash_entry *) h)->fake = 0;
5045   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5046     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5047   return TRUE;
5048 }
5049
5050 /* This function makes an old ABI object reference to ".bar" cause the
5051    inclusion of a new ABI object archive that defines "bar".
5052    NAME is a symbol defined in an archive.  Return a symbol in the hash
5053    table that might be satisfied by the archive symbols.  */
5054
5055 static struct elf_link_hash_entry *
5056 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5057                                  struct bfd_link_info *info,
5058                                  const char *name)
5059 {
5060   struct elf_link_hash_entry *h;
5061   char *dot_name;
5062   size_t len;
5063
5064   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5065   if (h != NULL
5066       /* Don't return this sym if it is a fake function descriptor
5067          created by add_symbol_adjust.  */
5068       && !((struct ppc_link_hash_entry *) h)->fake)
5069     return h;
5070
5071   if (name[0] == '.')
5072     return h;
5073
5074   len = strlen (name);
5075   dot_name = bfd_alloc (abfd, len + 2);
5076   if (dot_name == NULL)
5077     return (struct elf_link_hash_entry *) 0 - 1;
5078   dot_name[0] = '.';
5079   memcpy (dot_name + 1, name, len + 1);
5080   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5081   bfd_release (abfd, dot_name);
5082   return h;
5083 }
5084
5085 /* This function satisfies all old ABI object references to ".bar" if a
5086    new ABI object defines "bar".  Well, at least, undefined dot symbols
5087    are made weak.  This stops later archive searches from including an
5088    object if we already have a function descriptor definition.  It also
5089    prevents the linker complaining about undefined symbols.
5090    We also check and correct mismatched symbol visibility here.  The
5091    most restrictive visibility of the function descriptor and the
5092    function entry symbol is used.  */
5093
5094 static bfd_boolean
5095 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5096 {
5097   struct ppc_link_hash_table *htab;
5098   struct ppc_link_hash_entry *fdh;
5099
5100   if (eh->elf.root.type == bfd_link_hash_warning)
5101     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5102
5103   if (eh->elf.root.type == bfd_link_hash_indirect)
5104     return TRUE;
5105
5106   if (eh->elf.root.root.string[0] != '.')
5107     abort ();
5108
5109   htab = ppc_hash_table (info);
5110   if (htab == NULL)
5111     return FALSE;
5112
5113   fdh = lookup_fdh (eh, htab);
5114   if (fdh == NULL
5115       && !bfd_link_relocatable (info)
5116       && (eh->elf.root.type == bfd_link_hash_undefined
5117           || eh->elf.root.type == bfd_link_hash_undefweak)
5118       && eh->elf.ref_regular)
5119     {
5120       /* Make an undefined function descriptor sym, in order to
5121          pull in an --as-needed shared lib.  Archives are handled
5122          elsewhere.  */
5123       fdh = make_fdh (info, eh);
5124       if (fdh == NULL)
5125         return FALSE;
5126     }
5127
5128   if (fdh != NULL)
5129     {
5130       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5131       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5132
5133       /* Make both descriptor and entry symbol have the most
5134          constraining visibility of either symbol.  */
5135       if (entry_vis < descr_vis)
5136         fdh->elf.other += entry_vis - descr_vis;
5137       else if (entry_vis > descr_vis)
5138         eh->elf.other += descr_vis - entry_vis;
5139
5140       /* Propagate reference flags from entry symbol to function
5141          descriptor symbol.  */
5142       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5143       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5144       fdh->elf.ref_regular |= eh->elf.ref_regular;
5145       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5146
5147       if (!fdh->elf.forced_local
5148           && fdh->elf.dynindx == -1
5149           && fdh->elf.versioned != versioned_hidden
5150           && (bfd_link_dll (info)
5151               || fdh->elf.def_dynamic
5152               || fdh->elf.ref_dynamic)
5153           && (eh->elf.ref_regular
5154               || eh->elf.def_regular))
5155         {
5156           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5157             return FALSE;
5158         }
5159     }
5160
5161   return TRUE;
5162 }
5163
5164 /* Set up opd section info and abiversion for IBFD, and process list
5165    of dot-symbols we made in link_hash_newfunc.  */
5166
5167 static bfd_boolean
5168 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5169 {
5170   struct ppc_link_hash_table *htab;
5171   struct ppc_link_hash_entry **p, *eh;
5172   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5173
5174   if (opd != NULL && opd->size != 0)
5175     {
5176       if (abiversion (ibfd) == 0)
5177         set_abiversion (ibfd, 1);
5178       else if (abiversion (ibfd) >= 2)
5179         {
5180           /* xgettext:c-format */
5181           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5182                                     " version %d\n"),
5183                                   ibfd, abiversion (ibfd));
5184           bfd_set_error (bfd_error_bad_value);
5185           return FALSE;
5186         }
5187
5188       if ((ibfd->flags & DYNAMIC) == 0
5189           && (opd->flags & SEC_RELOC) != 0
5190           && opd->reloc_count != 0
5191           && !bfd_is_abs_section (opd->output_section))
5192         {
5193           /* Garbage collection needs some extra help with .opd sections.
5194              We don't want to necessarily keep everything referenced by
5195              relocs in .opd, as that would keep all functions.  Instead,
5196              if we reference an .opd symbol (a function descriptor), we
5197              want to keep the function code symbol's section.  This is
5198              easy for global symbols, but for local syms we need to keep
5199              information about the associated function section.  */
5200           bfd_size_type amt;
5201           asection **opd_sym_map;
5202
5203           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5204           opd_sym_map = bfd_zalloc (ibfd, amt);
5205           if (opd_sym_map == NULL)
5206             return FALSE;
5207           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5208           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5209           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5210         }
5211     }
5212
5213   if (!is_ppc64_elf (info->output_bfd))
5214     return TRUE;
5215   htab = ppc_hash_table (info);
5216   if (htab == NULL)
5217     return FALSE;
5218
5219   /* For input files without an explicit abiversion in e_flags
5220      we should have flagged any with symbol st_other bits set
5221      as ELFv1 and above flagged those with .opd as ELFv2.
5222      Set the output abiversion if not yet set, and for any input
5223      still ambiguous, take its abiversion from the output.
5224      Differences in ABI are reported later.  */
5225   if (abiversion (info->output_bfd) == 0)
5226     set_abiversion (info->output_bfd, abiversion (ibfd));
5227   else if (abiversion (ibfd) == 0)
5228     set_abiversion (ibfd, abiversion (info->output_bfd));
5229
5230   p = &htab->dot_syms;
5231   while ((eh = *p) != NULL)
5232     {
5233       *p = NULL;
5234       if (&eh->elf == htab->elf.hgot)
5235         ;
5236       else if (htab->elf.hgot == NULL
5237                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5238         htab->elf.hgot = &eh->elf;
5239       else if (abiversion (ibfd) <= 1)
5240         {
5241           htab->need_func_desc_adj = 1;
5242           if (!add_symbol_adjust (eh, info))
5243             return FALSE;
5244         }
5245       p = &eh->u.next_dot_sym;
5246     }
5247   return TRUE;
5248 }
5249
5250 /* Undo hash table changes when an --as-needed input file is determined
5251    not to be needed.  */
5252
5253 static bfd_boolean
5254 ppc64_elf_notice_as_needed (bfd *ibfd,
5255                             struct bfd_link_info *info,
5256                             enum notice_asneeded_action act)
5257 {
5258   if (act == notice_not_needed)
5259     {
5260       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5261
5262       if (htab == NULL)
5263         return FALSE;
5264
5265       htab->dot_syms = NULL;
5266     }
5267   return _bfd_elf_notice_as_needed (ibfd, info, act);
5268 }
5269
5270 /* If --just-symbols against a final linked binary, then assume we need
5271    toc adjusting stubs when calling functions defined there.  */
5272
5273 static void
5274 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5275 {
5276   if ((sec->flags & SEC_CODE) != 0
5277       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5278       && is_ppc64_elf (sec->owner))
5279     {
5280       if (abiversion (sec->owner) >= 2
5281           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5282         sec->has_toc_reloc = 1;
5283     }
5284   _bfd_elf_link_just_syms (sec, info);
5285 }
5286
5287 static struct plt_entry **
5288 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5289                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5290 {
5291   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5292   struct plt_entry **local_plt;
5293   unsigned char *local_got_tls_masks;
5294
5295   if (local_got_ents == NULL)
5296     {
5297       bfd_size_type size = symtab_hdr->sh_info;
5298
5299       size *= (sizeof (*local_got_ents)
5300                + sizeof (*local_plt)
5301                + sizeof (*local_got_tls_masks));
5302       local_got_ents = bfd_zalloc (abfd, size);
5303       if (local_got_ents == NULL)
5304         return NULL;
5305       elf_local_got_ents (abfd) = local_got_ents;
5306     }
5307
5308   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5309     {
5310       struct got_entry *ent;
5311
5312       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5313         if (ent->addend == r_addend
5314             && ent->owner == abfd
5315             && ent->tls_type == tls_type)
5316           break;
5317       if (ent == NULL)
5318         {
5319           bfd_size_type amt = sizeof (*ent);
5320           ent = bfd_alloc (abfd, amt);
5321           if (ent == NULL)
5322             return FALSE;
5323           ent->next = local_got_ents[r_symndx];
5324           ent->addend = r_addend;
5325           ent->owner = abfd;
5326           ent->tls_type = tls_type;
5327           ent->is_indirect = FALSE;
5328           ent->got.refcount = 0;
5329           local_got_ents[r_symndx] = ent;
5330         }
5331       ent->got.refcount += 1;
5332     }
5333
5334   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5335   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5336   local_got_tls_masks[r_symndx] |= tls_type;
5337
5338   return local_plt + r_symndx;
5339 }
5340
5341 static bfd_boolean
5342 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5343 {
5344   struct plt_entry *ent;
5345
5346   for (ent = *plist; ent != NULL; ent = ent->next)
5347     if (ent->addend == addend)
5348       break;
5349   if (ent == NULL)
5350     {
5351       bfd_size_type amt = sizeof (*ent);
5352       ent = bfd_alloc (abfd, amt);
5353       if (ent == NULL)
5354         return FALSE;
5355       ent->next = *plist;
5356       ent->addend = addend;
5357       ent->plt.refcount = 0;
5358       *plist = ent;
5359     }
5360   ent->plt.refcount += 1;
5361   return TRUE;
5362 }
5363
5364 static bfd_boolean
5365 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5366 {
5367   return (r_type == R_PPC64_REL24
5368           || r_type == R_PPC64_REL14
5369           || r_type == R_PPC64_REL14_BRTAKEN
5370           || r_type == R_PPC64_REL14_BRNTAKEN
5371           || r_type == R_PPC64_ADDR24
5372           || r_type == R_PPC64_ADDR14
5373           || r_type == R_PPC64_ADDR14_BRTAKEN
5374           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5375 }
5376
5377 /* Look through the relocs for a section during the first phase, and
5378    calculate needed space in the global offset table, procedure
5379    linkage table, and dynamic reloc sections.  */
5380
5381 static bfd_boolean
5382 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5383                         asection *sec, const Elf_Internal_Rela *relocs)
5384 {
5385   struct ppc_link_hash_table *htab;
5386   Elf_Internal_Shdr *symtab_hdr;
5387   struct elf_link_hash_entry **sym_hashes;
5388   const Elf_Internal_Rela *rel;
5389   const Elf_Internal_Rela *rel_end;
5390   asection *sreloc;
5391   asection **opd_sym_map;
5392   struct elf_link_hash_entry *tga, *dottga;
5393
5394   if (bfd_link_relocatable (info))
5395     return TRUE;
5396
5397   /* Don't do anything special with non-loaded, non-alloced sections.
5398      In particular, any relocs in such sections should not affect GOT
5399      and PLT reference counting (ie. we don't allow them to create GOT
5400      or PLT entries), there's no possibility or desire to optimize TLS
5401      relocs, and there's not much point in propagating relocs to shared
5402      libs that the dynamic linker won't relocate.  */
5403   if ((sec->flags & SEC_ALLOC) == 0)
5404     return TRUE;
5405
5406   BFD_ASSERT (is_ppc64_elf (abfd));
5407
5408   htab = ppc_hash_table (info);
5409   if (htab == NULL)
5410     return FALSE;
5411
5412   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5413                               FALSE, FALSE, TRUE);
5414   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5415                                  FALSE, FALSE, TRUE);
5416   symtab_hdr = &elf_symtab_hdr (abfd);
5417   sym_hashes = elf_sym_hashes (abfd);
5418   sreloc = NULL;
5419   opd_sym_map = NULL;
5420   if (ppc64_elf_section_data (sec) != NULL
5421       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5422     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5423
5424   rel_end = relocs + sec->reloc_count;
5425   for (rel = relocs; rel < rel_end; rel++)
5426     {
5427       unsigned long r_symndx;
5428       struct elf_link_hash_entry *h;
5429       enum elf_ppc64_reloc_type r_type;
5430       int tls_type;
5431       struct _ppc64_elf_section_data *ppc64_sec;
5432       struct plt_entry **ifunc, **plt_list;
5433
5434       r_symndx = ELF64_R_SYM (rel->r_info);
5435       if (r_symndx < symtab_hdr->sh_info)
5436         h = NULL;
5437       else
5438         {
5439           struct ppc_link_hash_entry *eh;
5440
5441           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5442           h = elf_follow_link (h);
5443           eh = (struct ppc_link_hash_entry *) h;
5444
5445           /* PR15323, ref flags aren't set for references in the same
5446              object.  */
5447           h->root.non_ir_ref_regular = 1;
5448           if (eh->is_func && eh->oh != NULL)
5449             eh->oh->elf.root.non_ir_ref_regular = 1;
5450
5451           if (h == htab->elf.hgot)
5452             sec->has_toc_reloc = 1;
5453         }
5454
5455       tls_type = 0;
5456       ifunc = NULL;
5457       if (h != NULL)
5458         {
5459           if (h->type == STT_GNU_IFUNC)
5460             {
5461               h->needs_plt = 1;
5462               ifunc = &h->plt.plist;
5463             }
5464         }
5465       else
5466         {
5467           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5468                                                           abfd, r_symndx);
5469           if (isym == NULL)
5470             return FALSE;
5471
5472           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5473             {
5474               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5475                                              rel->r_addend, PLT_IFUNC);
5476               if (ifunc == NULL)
5477                 return FALSE;
5478             }
5479         }
5480
5481       r_type = ELF64_R_TYPE (rel->r_info);
5482       switch (r_type)
5483         {
5484         case R_PPC64_TLSGD:
5485         case R_PPC64_TLSLD:
5486           /* These special tls relocs tie a call to __tls_get_addr with
5487              its parameter symbol.  */
5488           break;
5489
5490         case R_PPC64_GOT_TLSLD16:
5491         case R_PPC64_GOT_TLSLD16_LO:
5492         case R_PPC64_GOT_TLSLD16_HI:
5493         case R_PPC64_GOT_TLSLD16_HA:
5494           tls_type = TLS_TLS | TLS_LD;
5495           goto dogottls;
5496
5497         case R_PPC64_GOT_TLSGD16:
5498         case R_PPC64_GOT_TLSGD16_LO:
5499         case R_PPC64_GOT_TLSGD16_HI:
5500         case R_PPC64_GOT_TLSGD16_HA:
5501           tls_type = TLS_TLS | TLS_GD;
5502           goto dogottls;
5503
5504         case R_PPC64_GOT_TPREL16_DS:
5505         case R_PPC64_GOT_TPREL16_LO_DS:
5506         case R_PPC64_GOT_TPREL16_HI:
5507         case R_PPC64_GOT_TPREL16_HA:
5508           if (bfd_link_dll (info))
5509             info->flags |= DF_STATIC_TLS;
5510           tls_type = TLS_TLS | TLS_TPREL;
5511           goto dogottls;
5512
5513         case R_PPC64_GOT_DTPREL16_DS:
5514         case R_PPC64_GOT_DTPREL16_LO_DS:
5515         case R_PPC64_GOT_DTPREL16_HI:
5516         case R_PPC64_GOT_DTPREL16_HA:
5517           tls_type = TLS_TLS | TLS_DTPREL;
5518         dogottls:
5519           sec->has_tls_reloc = 1;
5520           /* Fall through */
5521
5522         case R_PPC64_GOT16:
5523         case R_PPC64_GOT16_DS:
5524         case R_PPC64_GOT16_HA:
5525         case R_PPC64_GOT16_HI:
5526         case R_PPC64_GOT16_LO:
5527         case R_PPC64_GOT16_LO_DS:
5528           /* This symbol requires a global offset table entry.  */
5529           sec->has_toc_reloc = 1;
5530           if (r_type == R_PPC64_GOT_TLSLD16
5531               || r_type == R_PPC64_GOT_TLSGD16
5532               || r_type == R_PPC64_GOT_TPREL16_DS
5533               || r_type == R_PPC64_GOT_DTPREL16_DS
5534               || r_type == R_PPC64_GOT16
5535               || r_type == R_PPC64_GOT16_DS)
5536             {
5537               htab->do_multi_toc = 1;
5538               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5539             }
5540
5541           if (ppc64_elf_tdata (abfd)->got == NULL
5542               && !create_got_section (abfd, info))
5543             return FALSE;
5544
5545           if (h != NULL)
5546             {
5547               struct ppc_link_hash_entry *eh;
5548               struct got_entry *ent;
5549
5550               eh = (struct ppc_link_hash_entry *) h;
5551               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5552                 if (ent->addend == rel->r_addend
5553                     && ent->owner == abfd
5554                     && ent->tls_type == tls_type)
5555                   break;
5556               if (ent == NULL)
5557                 {
5558                   bfd_size_type amt = sizeof (*ent);
5559                   ent = bfd_alloc (abfd, amt);
5560                   if (ent == NULL)
5561                     return FALSE;
5562                   ent->next = eh->elf.got.glist;
5563                   ent->addend = rel->r_addend;
5564                   ent->owner = abfd;
5565                   ent->tls_type = tls_type;
5566                   ent->is_indirect = FALSE;
5567                   ent->got.refcount = 0;
5568                   eh->elf.got.glist = ent;
5569                 }
5570               ent->got.refcount += 1;
5571               eh->tls_mask |= tls_type;
5572             }
5573           else
5574             /* This is a global offset table entry for a local symbol.  */
5575             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5576                                         rel->r_addend, tls_type))
5577               return FALSE;
5578
5579           /* We may also need a plt entry if the symbol turns out to be
5580              an ifunc.  */
5581           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5582             {
5583               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5584                 return FALSE;
5585             }
5586           break;
5587
5588         case R_PPC64_PLT16_HA:
5589         case R_PPC64_PLT16_HI:
5590         case R_PPC64_PLT16_LO:
5591         case R_PPC64_PLT32:
5592         case R_PPC64_PLT64:
5593           /* This symbol requires a procedure linkage table entry.  */
5594           plt_list = ifunc;
5595           if (h != NULL)
5596             {
5597               h->needs_plt = 1;
5598               if (h->root.root.string[0] == '.'
5599                   && h->root.root.string[1] != '\0')
5600                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5601               plt_list = &h->plt.plist;
5602             }
5603           if (plt_list == NULL)
5604             {
5605               /* It does not make sense to have a procedure linkage
5606                  table entry for a non-ifunc local symbol.  */
5607               info->callbacks->einfo
5608                 /* xgettext:c-format */
5609                 (_("%H: %s reloc against local symbol\n"),
5610                  abfd, sec, rel->r_offset,
5611                  ppc64_elf_howto_table[r_type]->name);
5612               bfd_set_error (bfd_error_bad_value);
5613               return FALSE;
5614             }
5615           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5616             return FALSE;
5617           break;
5618
5619           /* The following relocations don't need to propagate the
5620              relocation if linking a shared object since they are
5621              section relative.  */
5622         case R_PPC64_SECTOFF:
5623         case R_PPC64_SECTOFF_LO:
5624         case R_PPC64_SECTOFF_HI:
5625         case R_PPC64_SECTOFF_HA:
5626         case R_PPC64_SECTOFF_DS:
5627         case R_PPC64_SECTOFF_LO_DS:
5628         case R_PPC64_DTPREL16:
5629         case R_PPC64_DTPREL16_LO:
5630         case R_PPC64_DTPREL16_HI:
5631         case R_PPC64_DTPREL16_HA:
5632         case R_PPC64_DTPREL16_DS:
5633         case R_PPC64_DTPREL16_LO_DS:
5634         case R_PPC64_DTPREL16_HIGH:
5635         case R_PPC64_DTPREL16_HIGHA:
5636         case R_PPC64_DTPREL16_HIGHER:
5637         case R_PPC64_DTPREL16_HIGHERA:
5638         case R_PPC64_DTPREL16_HIGHEST:
5639         case R_PPC64_DTPREL16_HIGHESTA:
5640           break;
5641
5642           /* Nor do these.  */
5643         case R_PPC64_REL16:
5644         case R_PPC64_REL16_LO:
5645         case R_PPC64_REL16_HI:
5646         case R_PPC64_REL16_HA:
5647         case R_PPC64_REL16DX_HA:
5648           break;
5649
5650           /* Not supported as a dynamic relocation.  */
5651         case R_PPC64_ADDR64_LOCAL:
5652           if (bfd_link_pic (info))
5653             {
5654               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5655                 ppc_howto_init ();
5656               /* xgettext:c-format */
5657               info->callbacks->einfo (_("%H: %s reloc unsupported "
5658                                         "in shared libraries and PIEs.\n"),
5659                                       abfd, sec, rel->r_offset,
5660                                       ppc64_elf_howto_table[r_type]->name);
5661               bfd_set_error (bfd_error_bad_value);
5662               return FALSE;
5663             }
5664           break;
5665
5666         case R_PPC64_TOC16:
5667         case R_PPC64_TOC16_DS:
5668           htab->do_multi_toc = 1;
5669           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5670           /* Fall through.  */
5671         case R_PPC64_TOC16_LO:
5672         case R_PPC64_TOC16_HI:
5673         case R_PPC64_TOC16_HA:
5674         case R_PPC64_TOC16_LO_DS:
5675           sec->has_toc_reloc = 1;
5676           break;
5677
5678           /* Marker reloc.  */
5679         case R_PPC64_ENTRY:
5680           break;
5681
5682           /* This relocation describes the C++ object vtable hierarchy.
5683              Reconstruct it for later use during GC.  */
5684         case R_PPC64_GNU_VTINHERIT:
5685           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5686             return FALSE;
5687           break;
5688
5689           /* This relocation describes which C++ vtable entries are actually
5690              used.  Record for later use during GC.  */
5691         case R_PPC64_GNU_VTENTRY:
5692           BFD_ASSERT (h != NULL);
5693           if (h != NULL
5694               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5695             return FALSE;
5696           break;
5697
5698         case R_PPC64_REL14:
5699         case R_PPC64_REL14_BRTAKEN:
5700         case R_PPC64_REL14_BRNTAKEN:
5701           {
5702             asection *dest = NULL;
5703
5704             /* Heuristic: If jumping outside our section, chances are
5705                we are going to need a stub.  */
5706             if (h != NULL)
5707               {
5708                 /* If the sym is weak it may be overridden later, so
5709                    don't assume we know where a weak sym lives.  */
5710                 if (h->root.type == bfd_link_hash_defined)
5711                   dest = h->root.u.def.section;
5712               }
5713             else
5714               {
5715                 Elf_Internal_Sym *isym;
5716
5717                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5718                                               abfd, r_symndx);
5719                 if (isym == NULL)
5720                   return FALSE;
5721
5722                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5723               }
5724
5725             if (dest != sec)
5726               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5727           }
5728           /* Fall through.  */
5729
5730         case R_PPC64_REL24:
5731           plt_list = ifunc;
5732           if (h != NULL)
5733             {
5734               h->needs_plt = 1;
5735               if (h->root.root.string[0] == '.'
5736                   && h->root.root.string[1] != '\0')
5737                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5738
5739               if (h == tga || h == dottga)
5740                 {
5741                   sec->has_tls_reloc = 1;
5742                   if (rel != relocs
5743                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5744                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5745                     /* We have a new-style __tls_get_addr call with
5746                        a marker reloc.  */
5747                     ;
5748                   else
5749                     /* Mark this section as having an old-style call.  */
5750                     sec->has_tls_get_addr_call = 1;
5751                 }
5752               plt_list = &h->plt.plist;
5753             }
5754
5755           /* We may need a .plt entry if the function this reloc
5756              refers to is in a shared lib.  */
5757           if (plt_list
5758               && !update_plt_info (abfd, plt_list, rel->r_addend))
5759             return FALSE;
5760           break;
5761
5762         case R_PPC64_ADDR14:
5763         case R_PPC64_ADDR14_BRNTAKEN:
5764         case R_PPC64_ADDR14_BRTAKEN:
5765         case R_PPC64_ADDR24:
5766           goto dodyn;
5767
5768         case R_PPC64_TPREL64:
5769           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5770           if (bfd_link_dll (info))
5771             info->flags |= DF_STATIC_TLS;
5772           goto dotlstoc;
5773
5774         case R_PPC64_DTPMOD64:
5775           if (rel + 1 < rel_end
5776               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5777               && rel[1].r_offset == rel->r_offset + 8)
5778             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5779           else
5780             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5781           goto dotlstoc;
5782
5783         case R_PPC64_DTPREL64:
5784           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5785           if (rel != relocs
5786               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5787               && rel[-1].r_offset == rel->r_offset - 8)
5788             /* This is the second reloc of a dtpmod, dtprel pair.
5789                Don't mark with TLS_DTPREL.  */
5790             goto dodyn;
5791
5792         dotlstoc:
5793           sec->has_tls_reloc = 1;
5794           if (h != NULL)
5795             {
5796               struct ppc_link_hash_entry *eh;
5797               eh = (struct ppc_link_hash_entry *) h;
5798               eh->tls_mask |= tls_type;
5799             }
5800           else
5801             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5802                                         rel->r_addend, tls_type))
5803               return FALSE;
5804
5805           ppc64_sec = ppc64_elf_section_data (sec);
5806           if (ppc64_sec->sec_type != sec_toc)
5807             {
5808               bfd_size_type amt;
5809
5810               /* One extra to simplify get_tls_mask.  */
5811               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5812               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5813               if (ppc64_sec->u.toc.symndx == NULL)
5814                 return FALSE;
5815               amt = sec->size * sizeof (bfd_vma) / 8;
5816               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5817               if (ppc64_sec->u.toc.add == NULL)
5818                 return FALSE;
5819               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5820               ppc64_sec->sec_type = sec_toc;
5821             }
5822           BFD_ASSERT (rel->r_offset % 8 == 0);
5823           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5824           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5825
5826           /* Mark the second slot of a GD or LD entry.
5827              -1 to indicate GD and -2 to indicate LD.  */
5828           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5829             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5830           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5831             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5832           goto dodyn;
5833
5834         case R_PPC64_TPREL16:
5835         case R_PPC64_TPREL16_LO:
5836         case R_PPC64_TPREL16_HI:
5837         case R_PPC64_TPREL16_HA:
5838         case R_PPC64_TPREL16_DS:
5839         case R_PPC64_TPREL16_LO_DS:
5840         case R_PPC64_TPREL16_HIGH:
5841         case R_PPC64_TPREL16_HIGHA:
5842         case R_PPC64_TPREL16_HIGHER:
5843         case R_PPC64_TPREL16_HIGHERA:
5844         case R_PPC64_TPREL16_HIGHEST:
5845         case R_PPC64_TPREL16_HIGHESTA:
5846           if (bfd_link_dll (info))
5847             info->flags |= DF_STATIC_TLS;
5848           goto dodyn;
5849
5850         case R_PPC64_ADDR64:
5851           if (opd_sym_map != NULL
5852               && rel + 1 < rel_end
5853               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5854             {
5855               if (h != NULL)
5856                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5857               else
5858                 {
5859                   asection *s;
5860                   Elf_Internal_Sym *isym;
5861
5862                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5863                                                 abfd, r_symndx);
5864                   if (isym == NULL)
5865                     return FALSE;
5866
5867                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5868                   if (s != NULL && s != sec)
5869                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5870                 }
5871             }
5872           /* Fall through.  */
5873
5874         case R_PPC64_ADDR16:
5875         case R_PPC64_ADDR16_DS:
5876         case R_PPC64_ADDR16_HA:
5877         case R_PPC64_ADDR16_HI:
5878         case R_PPC64_ADDR16_HIGH:
5879         case R_PPC64_ADDR16_HIGHA:
5880         case R_PPC64_ADDR16_HIGHER:
5881         case R_PPC64_ADDR16_HIGHERA:
5882         case R_PPC64_ADDR16_HIGHEST:
5883         case R_PPC64_ADDR16_HIGHESTA:
5884         case R_PPC64_ADDR16_LO:
5885         case R_PPC64_ADDR16_LO_DS:
5886           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5887               && rel->r_addend == 0)
5888             {
5889               /* We may need a .plt entry if this reloc refers to a
5890                  function in a shared lib.  */
5891               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5892                 return FALSE;
5893               h->pointer_equality_needed = 1;
5894             }
5895           /* Fall through.  */
5896
5897         case R_PPC64_REL30:
5898         case R_PPC64_REL32:
5899         case R_PPC64_REL64:
5900         case R_PPC64_ADDR32:
5901         case R_PPC64_UADDR16:
5902         case R_PPC64_UADDR32:
5903         case R_PPC64_UADDR64:
5904         case R_PPC64_TOC:
5905           if (h != NULL && !bfd_link_pic (info))
5906             /* We may need a copy reloc.  */
5907             h->non_got_ref = 1;
5908
5909           /* Don't propagate .opd relocs.  */
5910           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5911             break;
5912
5913           /* If we are creating a shared library, and this is a reloc
5914              against a global symbol, or a non PC relative reloc
5915              against a local symbol, then we need to copy the reloc
5916              into the shared library.  However, if we are linking with
5917              -Bsymbolic, we do not need to copy a reloc against a
5918              global symbol which is defined in an object we are
5919              including in the link (i.e., DEF_REGULAR is set).  At
5920              this point we have not seen all the input files, so it is
5921              possible that DEF_REGULAR is not set now but will be set
5922              later (it is never cleared).  In case of a weak definition,
5923              DEF_REGULAR may be cleared later by a strong definition in
5924              a shared library.  We account for that possibility below by
5925              storing information in the dyn_relocs field of the hash
5926              table entry.  A similar situation occurs when creating
5927              shared libraries and symbol visibility changes render the
5928              symbol local.
5929
5930              If on the other hand, we are creating an executable, we
5931              may need to keep relocations for symbols satisfied by a
5932              dynamic library if we manage to avoid copy relocs for the
5933              symbol.  */
5934         dodyn:
5935           if ((bfd_link_pic (info)
5936                && (must_be_dyn_reloc (info, r_type)
5937                    || (h != NULL
5938                        && (!SYMBOLIC_BIND (info, h)
5939                            || h->root.type == bfd_link_hash_defweak
5940                            || !h->def_regular))))
5941               || (ELIMINATE_COPY_RELOCS
5942                   && !bfd_link_pic (info)
5943                   && h != NULL
5944                   && (h->root.type == bfd_link_hash_defweak
5945                       || !h->def_regular))
5946               || (!bfd_link_pic (info)
5947                   && ifunc != NULL))
5948             {
5949               /* We must copy these reloc types into the output file.
5950                  Create a reloc section in dynobj and make room for
5951                  this reloc.  */
5952               if (sreloc == NULL)
5953                 {
5954                   sreloc = _bfd_elf_make_dynamic_reloc_section
5955                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5956
5957                   if (sreloc == NULL)
5958                     return FALSE;
5959                 }
5960
5961               /* If this is a global symbol, we count the number of
5962                  relocations we need for this symbol.  */
5963               if (h != NULL)
5964                 {
5965                   struct elf_dyn_relocs *p;
5966                   struct elf_dyn_relocs **head;
5967
5968                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5969                   p = *head;
5970                   if (p == NULL || p->sec != sec)
5971                     {
5972                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5973                       if (p == NULL)
5974                         return FALSE;
5975                       p->next = *head;
5976                       *head = p;
5977                       p->sec = sec;
5978                       p->count = 0;
5979                       p->pc_count = 0;
5980                     }
5981                   p->count += 1;
5982                   if (!must_be_dyn_reloc (info, r_type))
5983                     p->pc_count += 1;
5984                 }
5985               else
5986                 {
5987                   /* Track dynamic relocs needed for local syms too.
5988                      We really need local syms available to do this
5989                      easily.  Oh well.  */
5990                   struct ppc_dyn_relocs *p;
5991                   struct ppc_dyn_relocs **head;
5992                   bfd_boolean is_ifunc;
5993                   asection *s;
5994                   void *vpp;
5995                   Elf_Internal_Sym *isym;
5996
5997                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5998                                                 abfd, r_symndx);
5999                   if (isym == NULL)
6000                     return FALSE;
6001
6002                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6003                   if (s == NULL)
6004                     s = sec;
6005
6006                   vpp = &elf_section_data (s)->local_dynrel;
6007                   head = (struct ppc_dyn_relocs **) vpp;
6008                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6009                   p = *head;
6010                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6011                     p = p->next;
6012                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6013                     {
6014                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6015                       if (p == NULL)
6016                         return FALSE;
6017                       p->next = *head;
6018                       *head = p;
6019                       p->sec = sec;
6020                       p->ifunc = is_ifunc;
6021                       p->count = 0;
6022                     }
6023                   p->count += 1;
6024                 }
6025             }
6026           break;
6027
6028         default:
6029           break;
6030         }
6031     }
6032
6033   return TRUE;
6034 }
6035
6036 /* Merge backend specific data from an object file to the output
6037    object file when linking.  */
6038
6039 static bfd_boolean
6040 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6041 {
6042   bfd *obfd = info->output_bfd;
6043   unsigned long iflags, oflags;
6044
6045   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6046     return TRUE;
6047
6048   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6049     return TRUE;
6050
6051   if (!_bfd_generic_verify_endian_match (ibfd, info))
6052     return FALSE;
6053
6054   iflags = elf_elfheader (ibfd)->e_flags;
6055   oflags = elf_elfheader (obfd)->e_flags;
6056
6057   if (iflags & ~EF_PPC64_ABI)
6058     {
6059       _bfd_error_handler
6060         /* xgettext:c-format */
6061         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6062       bfd_set_error (bfd_error_bad_value);
6063       return FALSE;
6064     }
6065   else if (iflags != oflags && iflags != 0)
6066     {
6067       _bfd_error_handler
6068         /* xgettext:c-format */
6069         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6070          ibfd, iflags, oflags);
6071       bfd_set_error (bfd_error_bad_value);
6072       return FALSE;
6073     }
6074
6075   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6076
6077   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6078   _bfd_elf_merge_object_attributes (ibfd, info);
6079
6080   return TRUE;
6081 }
6082
6083 static bfd_boolean
6084 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6085 {
6086   /* Print normal ELF private data.  */
6087   _bfd_elf_print_private_bfd_data (abfd, ptr);
6088
6089   if (elf_elfheader (abfd)->e_flags != 0)
6090     {
6091       FILE *file = ptr;
6092
6093       fprintf (file, _("private flags = 0x%lx:"),
6094                elf_elfheader (abfd)->e_flags);
6095
6096       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6097         fprintf (file, _(" [abiv%ld]"),
6098                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6099       fputc ('\n', file);
6100     }
6101
6102   return TRUE;
6103 }
6104
6105 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6106    of the code entry point, and its section, which must be in the same
6107    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6108
6109 static bfd_vma
6110 opd_entry_value (asection *opd_sec,
6111                  bfd_vma offset,
6112                  asection **code_sec,
6113                  bfd_vma *code_off,
6114                  bfd_boolean in_code_sec)
6115 {
6116   bfd *opd_bfd = opd_sec->owner;
6117   Elf_Internal_Rela *relocs;
6118   Elf_Internal_Rela *lo, *hi, *look;
6119   bfd_vma val;
6120
6121   /* No relocs implies we are linking a --just-symbols object, or looking
6122      at a final linked executable with addr2line or somesuch.  */
6123   if (opd_sec->reloc_count == 0)
6124     {
6125       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6126
6127       if (contents == NULL)
6128         {
6129           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6130             return (bfd_vma) -1;
6131           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6132         }
6133
6134       /* PR 17512: file: 64b9dfbb.  */
6135       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6136         return (bfd_vma) -1;
6137
6138       val = bfd_get_64 (opd_bfd, contents + offset);
6139       if (code_sec != NULL)
6140         {
6141           asection *sec, *likely = NULL;
6142
6143           if (in_code_sec)
6144             {
6145               sec = *code_sec;
6146               if (sec->vma <= val
6147                   && val < sec->vma + sec->size)
6148                 likely = sec;
6149               else
6150                 val = -1;
6151             }
6152           else
6153             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6154               if (sec->vma <= val
6155                   && (sec->flags & SEC_LOAD) != 0
6156                   && (sec->flags & SEC_ALLOC) != 0)
6157                 likely = sec;
6158           if (likely != NULL)
6159             {
6160               *code_sec = likely;
6161               if (code_off != NULL)
6162                 *code_off = val - likely->vma;
6163             }
6164         }
6165       return val;
6166     }
6167
6168   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6169
6170   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6171   if (relocs == NULL)
6172     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6173   /* PR 17512: file: df8e1fd6.  */
6174   if (relocs == NULL)
6175     return (bfd_vma) -1;
6176
6177   /* Go find the opd reloc at the sym address.  */
6178   lo = relocs;
6179   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6180   val = (bfd_vma) -1;
6181   while (lo < hi)
6182     {
6183       look = lo + (hi - lo) / 2;
6184       if (look->r_offset < offset)
6185         lo = look + 1;
6186       else if (look->r_offset > offset)
6187         hi = look;
6188       else
6189         {
6190           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6191
6192           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6193               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6194             {
6195               unsigned long symndx = ELF64_R_SYM (look->r_info);
6196               asection *sec = NULL;
6197
6198               if (symndx >= symtab_hdr->sh_info
6199                   && elf_sym_hashes (opd_bfd) != NULL)
6200                 {
6201                   struct elf_link_hash_entry **sym_hashes;
6202                   struct elf_link_hash_entry *rh;
6203
6204                   sym_hashes = elf_sym_hashes (opd_bfd);
6205                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6206                   if (rh != NULL)
6207                     {
6208                       rh = elf_follow_link (rh);
6209                       if (rh->root.type != bfd_link_hash_defined
6210                           && rh->root.type != bfd_link_hash_defweak)
6211                         break;
6212                       if (rh->root.u.def.section->owner == opd_bfd)
6213                         {
6214                           val = rh->root.u.def.value;
6215                           sec = rh->root.u.def.section;
6216                         }
6217                     }
6218                 }
6219
6220               if (sec == NULL)
6221                 {
6222                   Elf_Internal_Sym *sym;
6223
6224                   if (symndx < symtab_hdr->sh_info)
6225                     {
6226                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6227                       if (sym == NULL)
6228                         {
6229                           size_t symcnt = symtab_hdr->sh_info;
6230                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6231                                                       symcnt, 0,
6232                                                       NULL, NULL, NULL);
6233                           if (sym == NULL)
6234                             break;
6235                           symtab_hdr->contents = (bfd_byte *) sym;
6236                         }
6237                       sym += symndx;
6238                     }
6239                   else
6240                     {
6241                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6242                                                   1, symndx,
6243                                                   NULL, NULL, NULL);
6244                       if (sym == NULL)
6245                         break;
6246                     }
6247                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6248                   if (sec == NULL)
6249                     break;
6250                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6251                   val = sym->st_value;
6252                 }
6253
6254               val += look->r_addend;
6255               if (code_off != NULL)
6256                 *code_off = val;
6257               if (code_sec != NULL)
6258                 {
6259                   if (in_code_sec && *code_sec != sec)
6260                     return -1;
6261                   else
6262                     *code_sec = sec;
6263                 }
6264               if (sec->output_section != NULL)
6265                 val += sec->output_section->vma + sec->output_offset;
6266             }
6267           break;
6268         }
6269     }
6270
6271   return val;
6272 }
6273
6274 /* If the ELF symbol SYM might be a function in SEC, return the
6275    function size and set *CODE_OFF to the function's entry point,
6276    otherwise return zero.  */
6277
6278 static bfd_size_type
6279 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6280                               bfd_vma *code_off)
6281 {
6282   bfd_size_type size;
6283
6284   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6285                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6286     return 0;
6287
6288   size = 0;
6289   if (!(sym->flags & BSF_SYNTHETIC))
6290     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6291
6292   if (strcmp (sym->section->name, ".opd") == 0)
6293     {
6294       struct _opd_sec_data *opd = get_opd_info (sym->section);
6295       bfd_vma symval = sym->value;
6296
6297       if (opd != NULL
6298           && opd->adjust != NULL
6299           && elf_section_data (sym->section)->relocs != NULL)
6300         {
6301           /* opd_entry_value will use cached relocs that have been
6302              adjusted, but with raw symbols.  That means both local
6303              and global symbols need adjusting.  */
6304           long adjust = opd->adjust[OPD_NDX (symval)];
6305           if (adjust == -1)
6306             return 0;
6307           symval += adjust;
6308         }
6309
6310       if (opd_entry_value (sym->section, symval,
6311                            &sec, code_off, TRUE) == (bfd_vma) -1)
6312         return 0;
6313       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6314          symbol.  This size has nothing to do with the code size of the
6315          function, which is what we're supposed to return, but the
6316          code size isn't available without looking up the dot-sym.
6317          However, doing that would be a waste of time particularly
6318          since elf_find_function will look at the dot-sym anyway.
6319          Now, elf_find_function will keep the largest size of any
6320          function sym found at the code address of interest, so return
6321          1 here to avoid it incorrectly caching a larger function size
6322          for a small function.  This does mean we return the wrong
6323          size for a new-ABI function of size 24, but all that does is
6324          disable caching for such functions.  */
6325       if (size == 24)
6326         size = 1;
6327     }
6328   else
6329     {
6330       if (sym->section != sec)
6331         return 0;
6332       *code_off = sym->value;
6333     }
6334   if (size == 0)
6335     size = 1;
6336   return size;
6337 }
6338
6339 /* Return true if symbol is a strong function defined in an ELFv2
6340    object with st_other localentry bits of zero, ie. its local entry
6341    point coincides with its global entry point.  */
6342
6343 static bfd_boolean
6344 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6345 {
6346   return (h != NULL
6347           && h->type == STT_FUNC
6348           && h->root.type == bfd_link_hash_defined
6349           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6350           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6351           && is_ppc64_elf (h->root.u.def.section->owner)
6352           && abiversion (h->root.u.def.section->owner) >= 2);
6353 }
6354
6355 /* Return true if symbol is defined in a regular object file.  */
6356
6357 static bfd_boolean
6358 is_static_defined (struct elf_link_hash_entry *h)
6359 {
6360   return ((h->root.type == bfd_link_hash_defined
6361            || h->root.type == bfd_link_hash_defweak)
6362           && h->root.u.def.section != NULL
6363           && h->root.u.def.section->output_section != NULL);
6364 }
6365
6366 /* If FDH is a function descriptor symbol, return the associated code
6367    entry symbol if it is defined.  Return NULL otherwise.  */
6368
6369 static struct ppc_link_hash_entry *
6370 defined_code_entry (struct ppc_link_hash_entry *fdh)
6371 {
6372   if (fdh->is_func_descriptor)
6373     {
6374       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6375       if (fh->elf.root.type == bfd_link_hash_defined
6376           || fh->elf.root.type == bfd_link_hash_defweak)
6377         return fh;
6378     }
6379   return NULL;
6380 }
6381
6382 /* If FH is a function code entry symbol, return the associated
6383    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6384
6385 static struct ppc_link_hash_entry *
6386 defined_func_desc (struct ppc_link_hash_entry *fh)
6387 {
6388   if (fh->oh != NULL
6389       && fh->oh->is_func_descriptor)
6390     {
6391       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6392       if (fdh->elf.root.type == bfd_link_hash_defined
6393           || fdh->elf.root.type == bfd_link_hash_defweak)
6394         return fdh;
6395     }
6396   return NULL;
6397 }
6398
6399 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6400
6401 /* Garbage collect sections, after first dealing with dot-symbols.  */
6402
6403 static bfd_boolean
6404 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6405 {
6406   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6407
6408   if (htab != NULL && htab->need_func_desc_adj)
6409     {
6410       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6411       htab->need_func_desc_adj = 0;
6412     }
6413   return bfd_elf_gc_sections (abfd, info);
6414 }
6415
6416 /* Mark all our entry sym sections, both opd and code section.  */
6417
6418 static void
6419 ppc64_elf_gc_keep (struct bfd_link_info *info)
6420 {
6421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6422   struct bfd_sym_chain *sym;
6423
6424   if (htab == NULL)
6425     return;
6426
6427   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6428     {
6429       struct ppc_link_hash_entry *eh, *fh;
6430       asection *sec;
6431
6432       eh = (struct ppc_link_hash_entry *)
6433         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6434       if (eh == NULL)
6435         continue;
6436       if (eh->elf.root.type != bfd_link_hash_defined
6437           && eh->elf.root.type != bfd_link_hash_defweak)
6438         continue;
6439
6440       fh = defined_code_entry (eh);
6441       if (fh != NULL)
6442         {
6443           sec = fh->elf.root.u.def.section;
6444           sec->flags |= SEC_KEEP;
6445         }
6446       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6447                && opd_entry_value (eh->elf.root.u.def.section,
6448                                    eh->elf.root.u.def.value,
6449                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6450         sec->flags |= SEC_KEEP;
6451
6452       sec = eh->elf.root.u.def.section;
6453       sec->flags |= SEC_KEEP;
6454     }
6455 }
6456
6457 /* Mark sections containing dynamically referenced symbols.  When
6458    building shared libraries, we must assume that any visible symbol is
6459    referenced.  */
6460
6461 static bfd_boolean
6462 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6463 {
6464   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6465   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6466   struct ppc_link_hash_entry *fdh;
6467   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6468
6469   /* Dynamic linking info is on the func descriptor sym.  */
6470   fdh = defined_func_desc (eh);
6471   if (fdh != NULL)
6472     eh = fdh;
6473
6474   if ((eh->elf.root.type == bfd_link_hash_defined
6475        || eh->elf.root.type == bfd_link_hash_defweak)
6476       && (eh->elf.ref_dynamic
6477           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6478               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6479               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6480               && (!bfd_link_executable (info)
6481                   || info->gc_keep_exported
6482                   || info->export_dynamic
6483                   || (eh->elf.dynamic
6484                       && d != NULL
6485                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6486               && (eh->elf.versioned >= versioned
6487                   || !bfd_hide_sym_by_version (info->version_info,
6488                                                eh->elf.root.root.string)))))
6489     {
6490       asection *code_sec;
6491       struct ppc_link_hash_entry *fh;
6492
6493       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6494
6495       /* Function descriptor syms cause the associated
6496          function code sym section to be marked.  */
6497       fh = defined_code_entry (eh);
6498       if (fh != NULL)
6499         {
6500           code_sec = fh->elf.root.u.def.section;
6501           code_sec->flags |= SEC_KEEP;
6502         }
6503       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6504                && opd_entry_value (eh->elf.root.u.def.section,
6505                                    eh->elf.root.u.def.value,
6506                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6507         code_sec->flags |= SEC_KEEP;
6508     }
6509
6510   return TRUE;
6511 }
6512
6513 /* Return the section that should be marked against GC for a given
6514    relocation.  */
6515
6516 static asection *
6517 ppc64_elf_gc_mark_hook (asection *sec,
6518                         struct bfd_link_info *info,
6519                         Elf_Internal_Rela *rel,
6520                         struct elf_link_hash_entry *h,
6521                         Elf_Internal_Sym *sym)
6522 {
6523   asection *rsec;
6524
6525   /* Syms return NULL if we're marking .opd, so we avoid marking all
6526      function sections, as all functions are referenced in .opd.  */
6527   rsec = NULL;
6528   if (get_opd_info (sec) != NULL)
6529     return rsec;
6530
6531   if (h != NULL)
6532     {
6533       enum elf_ppc64_reloc_type r_type;
6534       struct ppc_link_hash_entry *eh, *fh, *fdh;
6535
6536       r_type = ELF64_R_TYPE (rel->r_info);
6537       switch (r_type)
6538         {
6539         case R_PPC64_GNU_VTINHERIT:
6540         case R_PPC64_GNU_VTENTRY:
6541           break;
6542
6543         default:
6544           switch (h->root.type)
6545             {
6546             case bfd_link_hash_defined:
6547             case bfd_link_hash_defweak:
6548               eh = (struct ppc_link_hash_entry *) h;
6549               fdh = defined_func_desc (eh);
6550               if (fdh != NULL)
6551                 {
6552                   /* -mcall-aixdesc code references the dot-symbol on
6553                      a call reloc.  Mark the function descriptor too
6554                      against garbage collection.  */
6555                   fdh->elf.mark = 1;
6556                   if (fdh->elf.u.weakdef != NULL)
6557                     fdh->elf.u.weakdef->mark = 1;
6558                   eh = fdh;
6559                 }
6560
6561               /* Function descriptor syms cause the associated
6562                  function code sym section to be marked.  */
6563               fh = defined_code_entry (eh);
6564               if (fh != NULL)
6565                 {
6566                   /* They also mark their opd section.  */
6567                   eh->elf.root.u.def.section->gc_mark = 1;
6568
6569                   rsec = fh->elf.root.u.def.section;
6570                 }
6571               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6572                        && opd_entry_value (eh->elf.root.u.def.section,
6573                                            eh->elf.root.u.def.value,
6574                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6575                 eh->elf.root.u.def.section->gc_mark = 1;
6576               else
6577                 rsec = h->root.u.def.section;
6578               break;
6579
6580             case bfd_link_hash_common:
6581               rsec = h->root.u.c.p->section;
6582               break;
6583
6584             default:
6585               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6586             }
6587         }
6588     }
6589   else
6590     {
6591       struct _opd_sec_data *opd;
6592
6593       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6594       opd = get_opd_info (rsec);
6595       if (opd != NULL && opd->func_sec != NULL)
6596         {
6597           rsec->gc_mark = 1;
6598
6599           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6600         }
6601     }
6602
6603   return rsec;
6604 }
6605
6606 /* Update the .got, .plt. and dynamic reloc reference counts for the
6607    section being removed.  */
6608
6609 static bfd_boolean
6610 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6611                          asection *sec, const Elf_Internal_Rela *relocs)
6612 {
6613   struct ppc_link_hash_table *htab;
6614   Elf_Internal_Shdr *symtab_hdr;
6615   struct elf_link_hash_entry **sym_hashes;
6616   struct got_entry **local_got_ents;
6617   const Elf_Internal_Rela *rel, *relend;
6618
6619   if (bfd_link_relocatable (info))
6620     return TRUE;
6621
6622   if ((sec->flags & SEC_ALLOC) == 0)
6623     return TRUE;
6624
6625   elf_section_data (sec)->local_dynrel = NULL;
6626
6627   htab = ppc_hash_table (info);
6628   if (htab == NULL)
6629     return FALSE;
6630
6631   symtab_hdr = &elf_symtab_hdr (abfd);
6632   sym_hashes = elf_sym_hashes (abfd);
6633   local_got_ents = elf_local_got_ents (abfd);
6634
6635   relend = relocs + sec->reloc_count;
6636   for (rel = relocs; rel < relend; rel++)
6637     {
6638       unsigned long r_symndx;
6639       enum elf_ppc64_reloc_type r_type;
6640       struct elf_link_hash_entry *h = NULL;
6641       struct plt_entry **plt_list = NULL;
6642       unsigned char tls_type = 0;
6643
6644       r_symndx = ELF64_R_SYM (rel->r_info);
6645       r_type = ELF64_R_TYPE (rel->r_info);
6646       if (r_symndx >= symtab_hdr->sh_info)
6647         {
6648           struct ppc_link_hash_entry *eh;
6649           struct elf_dyn_relocs **pp;
6650           struct elf_dyn_relocs *p;
6651
6652           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6653           h = elf_follow_link (h);
6654           eh = (struct ppc_link_hash_entry *) h;
6655
6656           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6657             if (p->sec == sec)
6658               {
6659                 /* Everything must go for SEC.  */
6660                 *pp = p->next;
6661                 break;
6662               }
6663         }
6664
6665       switch (r_type)
6666         {
6667         case R_PPC64_GOT_TLSLD16:
6668         case R_PPC64_GOT_TLSLD16_LO:
6669         case R_PPC64_GOT_TLSLD16_HI:
6670         case R_PPC64_GOT_TLSLD16_HA:
6671           tls_type = TLS_TLS | TLS_LD;
6672           goto dogot;
6673
6674         case R_PPC64_GOT_TLSGD16:
6675         case R_PPC64_GOT_TLSGD16_LO:
6676         case R_PPC64_GOT_TLSGD16_HI:
6677         case R_PPC64_GOT_TLSGD16_HA:
6678           tls_type = TLS_TLS | TLS_GD;
6679           goto dogot;
6680
6681         case R_PPC64_GOT_TPREL16_DS:
6682         case R_PPC64_GOT_TPREL16_LO_DS:
6683         case R_PPC64_GOT_TPREL16_HI:
6684         case R_PPC64_GOT_TPREL16_HA:
6685           tls_type = TLS_TLS | TLS_TPREL;
6686           goto dogot;
6687
6688         case R_PPC64_GOT_DTPREL16_DS:
6689         case R_PPC64_GOT_DTPREL16_LO_DS:
6690         case R_PPC64_GOT_DTPREL16_HI:
6691         case R_PPC64_GOT_DTPREL16_HA:
6692           tls_type = TLS_TLS | TLS_DTPREL;
6693           goto dogot;
6694
6695         case R_PPC64_GOT16:
6696         case R_PPC64_GOT16_DS:
6697         case R_PPC64_GOT16_HA:
6698         case R_PPC64_GOT16_HI:
6699         case R_PPC64_GOT16_LO:
6700         case R_PPC64_GOT16_LO_DS:
6701         dogot:
6702           {
6703             struct got_entry *ent;
6704
6705             if (h != NULL)
6706               ent = h->got.glist;
6707             else
6708               ent = local_got_ents[r_symndx];
6709
6710             for (; ent != NULL; ent = ent->next)
6711               if (ent->addend == rel->r_addend
6712                   && ent->owner == abfd
6713                   && ent->tls_type == tls_type)
6714                 break;
6715             if (ent == NULL)
6716               abort ();
6717             if (ent->got.refcount > 0)
6718               ent->got.refcount -= 1;
6719           }
6720           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6721             plt_list = &h->plt.plist;
6722           break;
6723
6724         case R_PPC64_PLT16_HA:
6725         case R_PPC64_PLT16_HI:
6726         case R_PPC64_PLT16_LO:
6727         case R_PPC64_PLT32:
6728         case R_PPC64_PLT64:
6729         case R_PPC64_REL14:
6730         case R_PPC64_REL14_BRNTAKEN:
6731         case R_PPC64_REL14_BRTAKEN:
6732         case R_PPC64_REL24:
6733           if (h != NULL)
6734             plt_list = &h->plt.plist;
6735           else if (local_got_ents != NULL)
6736             {
6737               struct plt_entry **local_plt = (struct plt_entry **)
6738                 (local_got_ents + symtab_hdr->sh_info);
6739               unsigned char *local_got_tls_masks = (unsigned char *)
6740                 (local_plt + symtab_hdr->sh_info);
6741               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6742                 plt_list = local_plt + r_symndx;
6743             }
6744           break;
6745
6746         case R_PPC64_ADDR64:
6747         case R_PPC64_ADDR16:
6748         case R_PPC64_ADDR16_DS:
6749         case R_PPC64_ADDR16_HA:
6750         case R_PPC64_ADDR16_HI:
6751         case R_PPC64_ADDR16_HIGH:
6752         case R_PPC64_ADDR16_HIGHA:
6753         case R_PPC64_ADDR16_HIGHER:
6754         case R_PPC64_ADDR16_HIGHERA:
6755         case R_PPC64_ADDR16_HIGHEST:
6756         case R_PPC64_ADDR16_HIGHESTA:
6757         case R_PPC64_ADDR16_LO:
6758         case R_PPC64_ADDR16_LO_DS:
6759           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6760               && rel->r_addend == 0)
6761             plt_list = &h->plt.plist;
6762           break;
6763
6764         default:
6765           break;
6766         }
6767       if (plt_list != NULL)
6768         {
6769           struct plt_entry *ent;
6770
6771           for (ent = *plt_list; ent != NULL; ent = ent->next)
6772             if (ent->addend == rel->r_addend)
6773               break;
6774           if (ent != NULL && ent->plt.refcount > 0)
6775             ent->plt.refcount -= 1;
6776         }
6777     }
6778   return TRUE;
6779 }
6780
6781 /* The maximum size of .sfpr.  */
6782 #define SFPR_MAX (218*4)
6783
6784 struct sfpr_def_parms
6785 {
6786   const char name[12];
6787   unsigned char lo, hi;
6788   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6789   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6790 };
6791
6792 /* Auto-generate _save*, _rest* functions in .sfpr.
6793    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6794    instead.  */
6795
6796 static bfd_boolean
6797 sfpr_define (struct bfd_link_info *info,
6798              const struct sfpr_def_parms *parm,
6799              asection *stub_sec)
6800 {
6801   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6802   unsigned int i;
6803   size_t len = strlen (parm->name);
6804   bfd_boolean writing = FALSE;
6805   char sym[16];
6806
6807   if (htab == NULL)
6808     return FALSE;
6809
6810   memcpy (sym, parm->name, len);
6811   sym[len + 2] = 0;
6812
6813   for (i = parm->lo; i <= parm->hi; i++)
6814     {
6815       struct ppc_link_hash_entry *h;
6816
6817       sym[len + 0] = i / 10 + '0';
6818       sym[len + 1] = i % 10 + '0';
6819       h = (struct ppc_link_hash_entry *)
6820         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6821       if (stub_sec != NULL)
6822         {
6823           if (h != NULL
6824               && h->elf.root.type == bfd_link_hash_defined
6825               && h->elf.root.u.def.section == htab->sfpr)
6826             {
6827               struct elf_link_hash_entry *s;
6828               char buf[32];
6829               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6830               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6831               if (s == NULL)
6832                 return FALSE;
6833               if (s->root.type == bfd_link_hash_new
6834                   || (s->root.type = bfd_link_hash_defined
6835                       && s->root.u.def.section == stub_sec))
6836                 {
6837                   s->root.type = bfd_link_hash_defined;
6838                   s->root.u.def.section = stub_sec;
6839                   s->root.u.def.value = (stub_sec->size
6840                                          + h->elf.root.u.def.value);
6841                   s->ref_regular = 1;
6842                   s->def_regular = 1;
6843                   s->ref_regular_nonweak = 1;
6844                   s->forced_local = 1;
6845                   s->non_elf = 0;
6846                   s->root.linker_def = 1;
6847                 }
6848             }
6849           continue;
6850         }
6851       if (h != NULL)
6852         {
6853           h->save_res = 1;
6854           if (!h->elf.def_regular)
6855             {
6856               h->elf.root.type = bfd_link_hash_defined;
6857               h->elf.root.u.def.section = htab->sfpr;
6858               h->elf.root.u.def.value = htab->sfpr->size;
6859               h->elf.type = STT_FUNC;
6860               h->elf.def_regular = 1;
6861               h->elf.non_elf = 0;
6862               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6863               writing = TRUE;
6864               if (htab->sfpr->contents == NULL)
6865                 {
6866                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6867                   if (htab->sfpr->contents == NULL)
6868                     return FALSE;
6869                 }
6870             }
6871         }
6872       if (writing)
6873         {
6874           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6875           if (i != parm->hi)
6876             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6877           else
6878             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6879           htab->sfpr->size = p - htab->sfpr->contents;
6880         }
6881     }
6882
6883   return TRUE;
6884 }
6885
6886 static bfd_byte *
6887 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6888 {
6889   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6890   return p + 4;
6891 }
6892
6893 static bfd_byte *
6894 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6895 {
6896   p = savegpr0 (abfd, p, r);
6897   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6898   p = p + 4;
6899   bfd_put_32 (abfd, BLR, p);
6900   return p + 4;
6901 }
6902
6903 static bfd_byte *
6904 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6905 {
6906   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6907   return p + 4;
6908 }
6909
6910 static bfd_byte *
6911 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6912 {
6913   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6914   p = p + 4;
6915   p = restgpr0 (abfd, p, r);
6916   bfd_put_32 (abfd, MTLR_R0, p);
6917   p = p + 4;
6918   if (r == 29)
6919     {
6920       p = restgpr0 (abfd, p, 30);
6921       p = restgpr0 (abfd, p, 31);
6922     }
6923   bfd_put_32 (abfd, BLR, p);
6924   return p + 4;
6925 }
6926
6927 static bfd_byte *
6928 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6929 {
6930   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6931   return p + 4;
6932 }
6933
6934 static bfd_byte *
6935 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6936 {
6937   p = savegpr1 (abfd, p, r);
6938   bfd_put_32 (abfd, BLR, p);
6939   return p + 4;
6940 }
6941
6942 static bfd_byte *
6943 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6944 {
6945   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6946   return p + 4;
6947 }
6948
6949 static bfd_byte *
6950 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6951 {
6952   p = restgpr1 (abfd, p, r);
6953   bfd_put_32 (abfd, BLR, p);
6954   return p + 4;
6955 }
6956
6957 static bfd_byte *
6958 savefpr (bfd *abfd, bfd_byte *p, int r)
6959 {
6960   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6961   return p + 4;
6962 }
6963
6964 static bfd_byte *
6965 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6966 {
6967   p = savefpr (abfd, p, r);
6968   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6969   p = p + 4;
6970   bfd_put_32 (abfd, BLR, p);
6971   return p + 4;
6972 }
6973
6974 static bfd_byte *
6975 restfpr (bfd *abfd, bfd_byte *p, int r)
6976 {
6977   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6978   return p + 4;
6979 }
6980
6981 static bfd_byte *
6982 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6983 {
6984   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6985   p = p + 4;
6986   p = restfpr (abfd, p, r);
6987   bfd_put_32 (abfd, MTLR_R0, p);
6988   p = p + 4;
6989   if (r == 29)
6990     {
6991       p = restfpr (abfd, p, 30);
6992       p = restfpr (abfd, p, 31);
6993     }
6994   bfd_put_32 (abfd, BLR, p);
6995   return p + 4;
6996 }
6997
6998 static bfd_byte *
6999 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7000 {
7001   p = savefpr (abfd, p, r);
7002   bfd_put_32 (abfd, BLR, p);
7003   return p + 4;
7004 }
7005
7006 static bfd_byte *
7007 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7008 {
7009   p = restfpr (abfd, p, r);
7010   bfd_put_32 (abfd, BLR, p);
7011   return p + 4;
7012 }
7013
7014 static bfd_byte *
7015 savevr (bfd *abfd, bfd_byte *p, int r)
7016 {
7017   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7018   p = p + 4;
7019   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7020   return p + 4;
7021 }
7022
7023 static bfd_byte *
7024 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7025 {
7026   p = savevr (abfd, p, r);
7027   bfd_put_32 (abfd, BLR, p);
7028   return p + 4;
7029 }
7030
7031 static bfd_byte *
7032 restvr (bfd *abfd, bfd_byte *p, int r)
7033 {
7034   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7035   p = p + 4;
7036   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7037   return p + 4;
7038 }
7039
7040 static bfd_byte *
7041 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7042 {
7043   p = restvr (abfd, p, r);
7044   bfd_put_32 (abfd, BLR, p);
7045   return p + 4;
7046 }
7047
7048 /* Called via elf_link_hash_traverse to transfer dynamic linking
7049    information on function code symbol entries to their corresponding
7050    function descriptor symbol entries.  */
7051
7052 static bfd_boolean
7053 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7054 {
7055   struct bfd_link_info *info;
7056   struct ppc_link_hash_table *htab;
7057   struct ppc_link_hash_entry *fh;
7058   struct ppc_link_hash_entry *fdh;
7059   bfd_boolean force_local;
7060
7061   fh = (struct ppc_link_hash_entry *) h;
7062   if (fh->elf.root.type == bfd_link_hash_indirect)
7063     return TRUE;
7064
7065   if (!fh->is_func)
7066     return TRUE;
7067
7068   if (fh->elf.root.root.string[0] != '.'
7069       || fh->elf.root.root.string[1] == '\0')
7070     return TRUE;
7071
7072   info = inf;
7073   htab = ppc_hash_table (info);
7074   if (htab == NULL)
7075     return FALSE;
7076
7077   /* Find the corresponding function descriptor symbol.  */
7078   fdh = lookup_fdh (fh, htab);
7079
7080   /* Resolve undefined references to dot-symbols as the value
7081      in the function descriptor, if we have one in a regular object.
7082      This is to satisfy cases like ".quad .foo".  Calls to functions
7083      in dynamic objects are handled elsewhere.  */
7084   if ((fh->elf.root.type == bfd_link_hash_undefined
7085        || fh->elf.root.type == bfd_link_hash_undefweak)
7086       && (fdh->elf.root.type == bfd_link_hash_defined
7087           || fdh->elf.root.type == bfd_link_hash_defweak)
7088       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7089       && opd_entry_value (fdh->elf.root.u.def.section,
7090                           fdh->elf.root.u.def.value,
7091                           &fh->elf.root.u.def.section,
7092                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7093     {
7094       fh->elf.root.type = fdh->elf.root.type;
7095       fh->elf.forced_local = 1;
7096       fh->elf.def_regular = fdh->elf.def_regular;
7097       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7098     }
7099
7100   if (!fh->elf.dynamic)
7101     {
7102       struct plt_entry *ent;
7103
7104       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7105         if (ent->plt.refcount > 0)
7106           break;
7107       if (ent == NULL)
7108         return TRUE;
7109     }
7110
7111   /* Create a descriptor as undefined if necessary.  */
7112   if (fdh == NULL
7113       && !bfd_link_executable (info)
7114       && (fh->elf.root.type == bfd_link_hash_undefined
7115           || fh->elf.root.type == bfd_link_hash_undefweak))
7116     {
7117       fdh = make_fdh (info, fh);
7118       if (fdh == NULL)
7119         return FALSE;
7120     }
7121
7122   /* We can't support overriding of symbols on a fake descriptor.  */
7123   if (fdh != NULL
7124       && fdh->fake
7125       && (fh->elf.root.type == bfd_link_hash_defined
7126           || fh->elf.root.type == bfd_link_hash_defweak))
7127     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7128
7129   /* Transfer dynamic linking information to the function descriptor.  */
7130   if (fdh != NULL)
7131     {
7132       fdh->elf.ref_regular |= fh->elf.ref_regular;
7133       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7134       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7135       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7136       fdh->elf.dynamic |= fh->elf.dynamic;
7137       fdh->elf.needs_plt |= (fh->elf.needs_plt
7138                              || fh->elf.type == STT_FUNC
7139                              || fh->elf.type == STT_GNU_IFUNC);
7140       move_plt_plist (fh, fdh);
7141
7142       if (!fdh->elf.forced_local
7143           && fh->elf.dynindx != -1)
7144         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7145           return FALSE;
7146     }
7147
7148   /* Now that the info is on the function descriptor, clear the
7149      function code sym info.  Any function code syms for which we
7150      don't have a definition in a regular file, we force local.
7151      This prevents a shared library from exporting syms that have
7152      been imported from another library.  Function code syms that
7153      are really in the library we must leave global to prevent the
7154      linker dragging in a definition from a static library.  */
7155   force_local = (!fh->elf.def_regular
7156                  || fdh == NULL
7157                  || !fdh->elf.def_regular
7158                  || fdh->elf.forced_local);
7159   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7160
7161   return TRUE;
7162 }
7163
7164 static const struct sfpr_def_parms save_res_funcs[] =
7165   {
7166     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7167     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7168     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7169     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7170     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7171     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7172     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7173     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7174     { "._savef", 14, 31, savefpr, savefpr1_tail },
7175     { "._restf", 14, 31, restfpr, restfpr1_tail },
7176     { "_savevr_", 20, 31, savevr, savevr_tail },
7177     { "_restvr_", 20, 31, restvr, restvr_tail }
7178   };
7179
7180 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7181    this hook to a) provide some gcc support functions, and b) transfer
7182    dynamic linking information gathered so far on function code symbol
7183    entries, to their corresponding function descriptor symbol entries.  */
7184
7185 static bfd_boolean
7186 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7187                             struct bfd_link_info *info)
7188 {
7189   struct ppc_link_hash_table *htab;
7190
7191   htab = ppc_hash_table (info);
7192   if (htab == NULL)
7193     return FALSE;
7194
7195   /* Provide any missing _save* and _rest* functions.  */
7196   if (htab->sfpr != NULL)
7197     {
7198       unsigned int i;
7199
7200       htab->sfpr->size = 0;
7201       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7202         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7203           return FALSE;
7204       if (htab->sfpr->size == 0)
7205         htab->sfpr->flags |= SEC_EXCLUDE;
7206     }
7207
7208   if (bfd_link_relocatable (info))
7209     return TRUE;
7210
7211   if (htab->elf.hgot != NULL)
7212     {
7213       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7214       /* Make .TOC. defined so as to prevent it being made dynamic.
7215          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7216       if (!htab->elf.hgot->def_regular
7217           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7218         {
7219           htab->elf.hgot->root.type = bfd_link_hash_defined;
7220           htab->elf.hgot->root.u.def.value = 0;
7221           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7222           htab->elf.hgot->def_regular = 1;
7223           htab->elf.hgot->root.linker_def = 1;
7224         }
7225       htab->elf.hgot->type = STT_OBJECT;
7226       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7227                                | STV_HIDDEN);
7228     }
7229
7230   if (htab->need_func_desc_adj)
7231     {
7232       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7233       htab->need_func_desc_adj = 0;
7234     }
7235
7236   return TRUE;
7237 }
7238
7239 /* Return true if we have dynamic relocs against H that apply to
7240    read-only sections.  */
7241
7242 static bfd_boolean
7243 readonly_dynrelocs (struct elf_link_hash_entry *h)
7244 {
7245   struct ppc_link_hash_entry *eh;
7246   struct elf_dyn_relocs *p;
7247
7248   eh = (struct ppc_link_hash_entry *) h;
7249   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7250     {
7251       asection *s = p->sec->output_section;
7252
7253       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7254         return TRUE;
7255     }
7256   return FALSE;
7257 }
7258
7259 /* Return true if we have dynamic relocs against H or any of its weak
7260    aliases, that apply to read-only sections.  */
7261
7262 static bfd_boolean
7263 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7264 {
7265   struct ppc_link_hash_entry *eh;
7266
7267   eh = (struct ppc_link_hash_entry *) h;
7268   do
7269     {
7270       if (readonly_dynrelocs (&eh->elf))
7271         return TRUE;
7272       eh = eh->weakref;
7273     } while (eh != NULL && &eh->elf != h);
7274
7275   return FALSE;
7276 }
7277
7278 /* Return whether EH has pc-relative dynamic relocs.  */
7279
7280 static bfd_boolean
7281 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7282 {
7283   struct elf_dyn_relocs *p;
7284
7285   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7286     if (p->pc_count != 0)
7287       return TRUE;
7288   return FALSE;
7289 }
7290
7291 /* Return true if a global entry stub will be created for H.  Valid
7292    for ELFv2 before plt entries have been allocated.  */
7293
7294 static bfd_boolean
7295 global_entry_stub (struct elf_link_hash_entry *h)
7296 {
7297   struct plt_entry *pent;
7298
7299   if (!h->pointer_equality_needed
7300       || h->def_regular)
7301     return FALSE;
7302
7303   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7304     if (pent->plt.refcount > 0
7305         && pent->addend == 0)
7306       return TRUE;
7307
7308   return FALSE;
7309 }
7310
7311 /* Adjust a symbol defined by a dynamic object and referenced by a
7312    regular object.  The current definition is in some section of the
7313    dynamic object, but we're not including those sections.  We have to
7314    change the definition to something the rest of the link can
7315    understand.  */
7316
7317 static bfd_boolean
7318 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7319                                  struct elf_link_hash_entry *h)
7320 {
7321   struct ppc_link_hash_table *htab;
7322   asection *s, *srel;
7323
7324   htab = ppc_hash_table (info);
7325   if (htab == NULL)
7326     return FALSE;
7327
7328   /* Deal with function syms.  */
7329   if (h->type == STT_FUNC
7330       || h->type == STT_GNU_IFUNC
7331       || h->needs_plt)
7332     {
7333       /* Clear procedure linkage table information for any symbol that
7334          won't need a .plt entry.  */
7335       struct plt_entry *ent;
7336       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7337         if (ent->plt.refcount > 0)
7338           break;
7339       if (ent == NULL
7340           || (h->type != STT_GNU_IFUNC
7341               && (SYMBOL_CALLS_LOCAL (info, h)
7342                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7343           || ((struct ppc_link_hash_entry *) h)->save_res)
7344         {
7345           h->plt.plist = NULL;
7346           h->needs_plt = 0;
7347           h->pointer_equality_needed = 0;
7348         }
7349       else if (abiversion (info->output_bfd) >= 2)
7350         {
7351           /* Taking a function's address in a read/write section
7352              doesn't require us to define the function symbol in the
7353              executable on a global entry stub.  A dynamic reloc can
7354              be used instead.  The reason we prefer a few more dynamic
7355              relocs is that calling via a global entry stub costs a
7356              few more instructions, and pointer_equality_needed causes
7357              extra work in ld.so when resolving these symbols.  */
7358           if (global_entry_stub (h)
7359               && !alias_readonly_dynrelocs (h))
7360             {
7361               h->pointer_equality_needed = 0;
7362               /* After adjust_dynamic_symbol, non_got_ref set in
7363                  the non-pic case means that dyn_relocs for this
7364                  symbol should be discarded.  */
7365               h->non_got_ref = 0;
7366             }
7367
7368           /* If making a plt entry, then we don't need copy relocs.  */
7369           return TRUE;
7370         }
7371     }
7372   else
7373     h->plt.plist = NULL;
7374
7375   /* If this is a weak symbol, and there is a real definition, the
7376      processor independent code will have arranged for us to see the
7377      real definition first, and we can just use the same value.  */
7378   if (h->u.weakdef != NULL)
7379     {
7380       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7381                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7382       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7383       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7384       if (ELIMINATE_COPY_RELOCS)
7385         h->non_got_ref = h->u.weakdef->non_got_ref;
7386       return TRUE;
7387     }
7388
7389   /* If we are creating a shared library, we must presume that the
7390      only references to the symbol are via the global offset table.
7391      For such cases we need not do anything here; the relocations will
7392      be handled correctly by relocate_section.  */
7393   if (bfd_link_pic (info))
7394     return TRUE;
7395
7396   /* If there are no references to this symbol that do not use the
7397      GOT, we don't need to generate a copy reloc.  */
7398   if (!h->non_got_ref)
7399     return TRUE;
7400
7401   /* Don't generate a copy reloc for symbols defined in the executable.  */
7402   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7403
7404       /* If -z nocopyreloc was given, don't generate them either.  */
7405       || info->nocopyreloc
7406
7407       /* If we didn't find any dynamic relocs in read-only sections, then
7408          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7409       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7410
7411       /* Protected variables do not work with .dynbss.  The copy in
7412          .dynbss won't be used by the shared library with the protected
7413          definition for the variable.  Text relocations are preferable
7414          to an incorrect program.  */
7415       || h->protected_def)
7416     {
7417       h->non_got_ref = 0;
7418       return TRUE;
7419     }
7420
7421   if (h->plt.plist != NULL)
7422     {
7423       /* We should never get here, but unfortunately there are versions
7424          of gcc out there that improperly (for this ABI) put initialized
7425          function pointers, vtable refs and suchlike in read-only
7426          sections.  Allow them to proceed, but warn that this might
7427          break at runtime.  */
7428       info->callbacks->einfo
7429         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7430            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7431          h->root.root.string);
7432     }
7433
7434   /* This is a reference to a symbol defined by a dynamic object which
7435      is not a function.  */
7436
7437   /* We must allocate the symbol in our .dynbss section, which will
7438      become part of the .bss section of the executable.  There will be
7439      an entry for this symbol in the .dynsym section.  The dynamic
7440      object will contain position independent code, so all references
7441      from the dynamic object to this symbol will go through the global
7442      offset table.  The dynamic linker will use the .dynsym entry to
7443      determine the address it must put in the global offset table, so
7444      both the dynamic object and the regular object will refer to the
7445      same memory location for the variable.  */
7446
7447   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7448      to copy the initial value out of the dynamic object and into the
7449      runtime process image.  We need to remember the offset into the
7450      .rela.bss section we are going to use.  */
7451   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7452     {
7453       s = htab->elf.sdynrelro;
7454       srel = htab->elf.sreldynrelro;
7455     }
7456   else
7457     {
7458       s = htab->elf.sdynbss;
7459       srel = htab->elf.srelbss;
7460     }
7461   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7462     {
7463       srel->size += sizeof (Elf64_External_Rela);
7464       h->needs_copy = 1;
7465     }
7466
7467   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7468 }
7469
7470 /* If given a function descriptor symbol, hide both the function code
7471    sym and the descriptor.  */
7472 static void
7473 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7474                        struct elf_link_hash_entry *h,
7475                        bfd_boolean force_local)
7476 {
7477   struct ppc_link_hash_entry *eh;
7478   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7479
7480   eh = (struct ppc_link_hash_entry *) h;
7481   if (eh->is_func_descriptor)
7482     {
7483       struct ppc_link_hash_entry *fh = eh->oh;
7484
7485       if (fh == NULL)
7486         {
7487           const char *p, *q;
7488           struct elf_link_hash_table *htab = elf_hash_table (info);
7489           char save;
7490
7491           /* We aren't supposed to use alloca in BFD because on
7492              systems which do not have alloca the version in libiberty
7493              calls xmalloc, which might cause the program to crash
7494              when it runs out of memory.  This function doesn't have a
7495              return status, so there's no way to gracefully return an
7496              error.  So cheat.  We know that string[-1] can be safely
7497              accessed;  It's either a string in an ELF string table,
7498              or allocated in an objalloc structure.  */
7499
7500           p = eh->elf.root.root.string - 1;
7501           save = *p;
7502           *(char *) p = '.';
7503           fh = (struct ppc_link_hash_entry *)
7504             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7505           *(char *) p = save;
7506
7507           /* Unfortunately, if it so happens that the string we were
7508              looking for was allocated immediately before this string,
7509              then we overwrote the string terminator.  That's the only
7510              reason the lookup should fail.  */
7511           if (fh == NULL)
7512             {
7513               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7514               while (q >= eh->elf.root.root.string && *q == *p)
7515                 --q, --p;
7516               if (q < eh->elf.root.root.string && *p == '.')
7517                 fh = (struct ppc_link_hash_entry *)
7518                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7519             }
7520           if (fh != NULL)
7521             {
7522               eh->oh = fh;
7523               fh->oh = eh;
7524             }
7525         }
7526       if (fh != NULL)
7527         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7528     }
7529 }
7530
7531 static bfd_boolean
7532 get_sym_h (struct elf_link_hash_entry **hp,
7533            Elf_Internal_Sym **symp,
7534            asection **symsecp,
7535            unsigned char **tls_maskp,
7536            Elf_Internal_Sym **locsymsp,
7537            unsigned long r_symndx,
7538            bfd *ibfd)
7539 {
7540   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7541
7542   if (r_symndx >= symtab_hdr->sh_info)
7543     {
7544       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7545       struct elf_link_hash_entry *h;
7546
7547       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7548       h = elf_follow_link (h);
7549
7550       if (hp != NULL)
7551         *hp = h;
7552
7553       if (symp != NULL)
7554         *symp = NULL;
7555
7556       if (symsecp != NULL)
7557         {
7558           asection *symsec = NULL;
7559           if (h->root.type == bfd_link_hash_defined
7560               || h->root.type == bfd_link_hash_defweak)
7561             symsec = h->root.u.def.section;
7562           *symsecp = symsec;
7563         }
7564
7565       if (tls_maskp != NULL)
7566         {
7567           struct ppc_link_hash_entry *eh;
7568
7569           eh = (struct ppc_link_hash_entry *) h;
7570           *tls_maskp = &eh->tls_mask;
7571         }
7572     }
7573   else
7574     {
7575       Elf_Internal_Sym *sym;
7576       Elf_Internal_Sym *locsyms = *locsymsp;
7577
7578       if (locsyms == NULL)
7579         {
7580           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7581           if (locsyms == NULL)
7582             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7583                                             symtab_hdr->sh_info,
7584                                             0, NULL, NULL, NULL);
7585           if (locsyms == NULL)
7586             return FALSE;
7587           *locsymsp = locsyms;
7588         }
7589       sym = locsyms + r_symndx;
7590
7591       if (hp != NULL)
7592         *hp = NULL;
7593
7594       if (symp != NULL)
7595         *symp = sym;
7596
7597       if (symsecp != NULL)
7598         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7599
7600       if (tls_maskp != NULL)
7601         {
7602           struct got_entry **lgot_ents;
7603           unsigned char *tls_mask;
7604
7605           tls_mask = NULL;
7606           lgot_ents = elf_local_got_ents (ibfd);
7607           if (lgot_ents != NULL)
7608             {
7609               struct plt_entry **local_plt = (struct plt_entry **)
7610                 (lgot_ents + symtab_hdr->sh_info);
7611               unsigned char *lgot_masks = (unsigned char *)
7612                 (local_plt + symtab_hdr->sh_info);
7613               tls_mask = &lgot_masks[r_symndx];
7614             }
7615           *tls_maskp = tls_mask;
7616         }
7617     }
7618   return TRUE;
7619 }
7620
7621 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7622    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7623    type suitable for optimization, and 1 otherwise.  */
7624
7625 static int
7626 get_tls_mask (unsigned char **tls_maskp,
7627               unsigned long *toc_symndx,
7628               bfd_vma *toc_addend,
7629               Elf_Internal_Sym **locsymsp,
7630               const Elf_Internal_Rela *rel,
7631               bfd *ibfd)
7632 {
7633   unsigned long r_symndx;
7634   int next_r;
7635   struct elf_link_hash_entry *h;
7636   Elf_Internal_Sym *sym;
7637   asection *sec;
7638   bfd_vma off;
7639
7640   r_symndx = ELF64_R_SYM (rel->r_info);
7641   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7642     return 0;
7643
7644   if ((*tls_maskp != NULL && **tls_maskp != 0)
7645       || sec == NULL
7646       || ppc64_elf_section_data (sec) == NULL
7647       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7648     return 1;
7649
7650   /* Look inside a TOC section too.  */
7651   if (h != NULL)
7652     {
7653       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7654       off = h->root.u.def.value;
7655     }
7656   else
7657     off = sym->st_value;
7658   off += rel->r_addend;
7659   BFD_ASSERT (off % 8 == 0);
7660   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7661   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7662   if (toc_symndx != NULL)
7663     *toc_symndx = r_symndx;
7664   if (toc_addend != NULL)
7665     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7666   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7667     return 0;
7668   if ((h == NULL || is_static_defined (h))
7669       && (next_r == -1 || next_r == -2))
7670     return 1 - next_r;
7671   return 1;
7672 }
7673
7674 /* Find (or create) an entry in the tocsave hash table.  */
7675
7676 static struct tocsave_entry *
7677 tocsave_find (struct ppc_link_hash_table *htab,
7678               enum insert_option insert,
7679               Elf_Internal_Sym **local_syms,
7680               const Elf_Internal_Rela *irela,
7681               bfd *ibfd)
7682 {
7683   unsigned long r_indx;
7684   struct elf_link_hash_entry *h;
7685   Elf_Internal_Sym *sym;
7686   struct tocsave_entry ent, *p;
7687   hashval_t hash;
7688   struct tocsave_entry **slot;
7689
7690   r_indx = ELF64_R_SYM (irela->r_info);
7691   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7692     return NULL;
7693   if (ent.sec == NULL || ent.sec->output_section == NULL)
7694     {
7695       _bfd_error_handler
7696         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7697       return NULL;
7698     }
7699
7700   if (h != NULL)
7701     ent.offset = h->root.u.def.value;
7702   else
7703     ent.offset = sym->st_value;
7704   ent.offset += irela->r_addend;
7705
7706   hash = tocsave_htab_hash (&ent);
7707   slot = ((struct tocsave_entry **)
7708           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7709   if (slot == NULL)
7710     return NULL;
7711
7712   if (*slot == NULL)
7713     {
7714       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7715       if (p == NULL)
7716         return NULL;
7717       *p = ent;
7718       *slot = p;
7719     }
7720   return *slot;
7721 }
7722
7723 /* Adjust all global syms defined in opd sections.  In gcc generated
7724    code for the old ABI, these will already have been done.  */
7725
7726 static bfd_boolean
7727 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7728 {
7729   struct ppc_link_hash_entry *eh;
7730   asection *sym_sec;
7731   struct _opd_sec_data *opd;
7732
7733   if (h->root.type == bfd_link_hash_indirect)
7734     return TRUE;
7735
7736   if (h->root.type != bfd_link_hash_defined
7737       && h->root.type != bfd_link_hash_defweak)
7738     return TRUE;
7739
7740   eh = (struct ppc_link_hash_entry *) h;
7741   if (eh->adjust_done)
7742     return TRUE;
7743
7744   sym_sec = eh->elf.root.u.def.section;
7745   opd = get_opd_info (sym_sec);
7746   if (opd != NULL && opd->adjust != NULL)
7747     {
7748       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7749       if (adjust == -1)
7750         {
7751           /* This entry has been deleted.  */
7752           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7753           if (dsec == NULL)
7754             {
7755               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7756                 if (discarded_section (dsec))
7757                   {
7758                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7759                     break;
7760                   }
7761             }
7762           eh->elf.root.u.def.value = 0;
7763           eh->elf.root.u.def.section = dsec;
7764         }
7765       else
7766         eh->elf.root.u.def.value += adjust;
7767       eh->adjust_done = 1;
7768     }
7769   return TRUE;
7770 }
7771
7772 /* Handles decrementing dynamic reloc counts for the reloc specified by
7773    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7774    have already been determined.  */
7775
7776 static bfd_boolean
7777 dec_dynrel_count (bfd_vma r_info,
7778                   asection *sec,
7779                   struct bfd_link_info *info,
7780                   Elf_Internal_Sym **local_syms,
7781                   struct elf_link_hash_entry *h,
7782                   Elf_Internal_Sym *sym)
7783 {
7784   enum elf_ppc64_reloc_type r_type;
7785   asection *sym_sec = NULL;
7786
7787   /* Can this reloc be dynamic?  This switch, and later tests here
7788      should be kept in sync with the code in check_relocs.  */
7789   r_type = ELF64_R_TYPE (r_info);
7790   switch (r_type)
7791     {
7792     default:
7793       return TRUE;
7794
7795     case R_PPC64_TPREL16:
7796     case R_PPC64_TPREL16_LO:
7797     case R_PPC64_TPREL16_HI:
7798     case R_PPC64_TPREL16_HA:
7799     case R_PPC64_TPREL16_DS:
7800     case R_PPC64_TPREL16_LO_DS:
7801     case R_PPC64_TPREL16_HIGH:
7802     case R_PPC64_TPREL16_HIGHA:
7803     case R_PPC64_TPREL16_HIGHER:
7804     case R_PPC64_TPREL16_HIGHERA:
7805     case R_PPC64_TPREL16_HIGHEST:
7806     case R_PPC64_TPREL16_HIGHESTA:
7807     case R_PPC64_TPREL64:
7808     case R_PPC64_DTPMOD64:
7809     case R_PPC64_DTPREL64:
7810     case R_PPC64_ADDR64:
7811     case R_PPC64_REL30:
7812     case R_PPC64_REL32:
7813     case R_PPC64_REL64:
7814     case R_PPC64_ADDR14:
7815     case R_PPC64_ADDR14_BRNTAKEN:
7816     case R_PPC64_ADDR14_BRTAKEN:
7817     case R_PPC64_ADDR16:
7818     case R_PPC64_ADDR16_DS:
7819     case R_PPC64_ADDR16_HA:
7820     case R_PPC64_ADDR16_HI:
7821     case R_PPC64_ADDR16_HIGH:
7822     case R_PPC64_ADDR16_HIGHA:
7823     case R_PPC64_ADDR16_HIGHER:
7824     case R_PPC64_ADDR16_HIGHERA:
7825     case R_PPC64_ADDR16_HIGHEST:
7826     case R_PPC64_ADDR16_HIGHESTA:
7827     case R_PPC64_ADDR16_LO:
7828     case R_PPC64_ADDR16_LO_DS:
7829     case R_PPC64_ADDR24:
7830     case R_PPC64_ADDR32:
7831     case R_PPC64_UADDR16:
7832     case R_PPC64_UADDR32:
7833     case R_PPC64_UADDR64:
7834     case R_PPC64_TOC:
7835       break;
7836     }
7837
7838   if (local_syms != NULL)
7839     {
7840       unsigned long r_symndx;
7841       bfd *ibfd = sec->owner;
7842
7843       r_symndx = ELF64_R_SYM (r_info);
7844       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7845         return FALSE;
7846     }
7847
7848   if ((bfd_link_pic (info)
7849        && (must_be_dyn_reloc (info, r_type)
7850            || (h != NULL
7851                && (!SYMBOLIC_BIND (info, h)
7852                    || h->root.type == bfd_link_hash_defweak
7853                    || !h->def_regular))))
7854       || (ELIMINATE_COPY_RELOCS
7855           && !bfd_link_pic (info)
7856           && h != NULL
7857           && (h->root.type == bfd_link_hash_defweak
7858               || !h->def_regular)))
7859     ;
7860   else
7861     return TRUE;
7862
7863   if (h != NULL)
7864     {
7865       struct elf_dyn_relocs *p;
7866       struct elf_dyn_relocs **pp;
7867       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7868
7869       /* elf_gc_sweep may have already removed all dyn relocs associated
7870          with local syms for a given section.  Also, symbol flags are
7871          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7872          report a dynreloc miscount.  */
7873       if (*pp == NULL && info->gc_sections)
7874         return TRUE;
7875
7876       while ((p = *pp) != NULL)
7877         {
7878           if (p->sec == sec)
7879             {
7880               if (!must_be_dyn_reloc (info, r_type))
7881                 p->pc_count -= 1;
7882               p->count -= 1;
7883               if (p->count == 0)
7884                 *pp = p->next;
7885               return TRUE;
7886             }
7887           pp = &p->next;
7888         }
7889     }
7890   else
7891     {
7892       struct ppc_dyn_relocs *p;
7893       struct ppc_dyn_relocs **pp;
7894       void *vpp;
7895       bfd_boolean is_ifunc;
7896
7897       if (local_syms == NULL)
7898         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7899       if (sym_sec == NULL)
7900         sym_sec = sec;
7901
7902       vpp = &elf_section_data (sym_sec)->local_dynrel;
7903       pp = (struct ppc_dyn_relocs **) vpp;
7904
7905       if (*pp == NULL && info->gc_sections)
7906         return TRUE;
7907
7908       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7909       while ((p = *pp) != NULL)
7910         {
7911           if (p->sec == sec && p->ifunc == is_ifunc)
7912             {
7913               p->count -= 1;
7914               if (p->count == 0)
7915                 *pp = p->next;
7916               return TRUE;
7917             }
7918           pp = &p->next;
7919         }
7920     }
7921
7922   /* xgettext:c-format */
7923   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7924                           sec->owner, sec);
7925   bfd_set_error (bfd_error_bad_value);
7926   return FALSE;
7927 }
7928
7929 /* Remove unused Official Procedure Descriptor entries.  Currently we
7930    only remove those associated with functions in discarded link-once
7931    sections, or weakly defined functions that have been overridden.  It
7932    would be possible to remove many more entries for statically linked
7933    applications.  */
7934
7935 bfd_boolean
7936 ppc64_elf_edit_opd (struct bfd_link_info *info)
7937 {
7938   bfd *ibfd;
7939   bfd_boolean some_edited = FALSE;
7940   asection *need_pad = NULL;
7941   struct ppc_link_hash_table *htab;
7942
7943   htab = ppc_hash_table (info);
7944   if (htab == NULL)
7945     return FALSE;
7946
7947   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7948     {
7949       asection *sec;
7950       Elf_Internal_Rela *relstart, *rel, *relend;
7951       Elf_Internal_Shdr *symtab_hdr;
7952       Elf_Internal_Sym *local_syms;
7953       struct _opd_sec_data *opd;
7954       bfd_boolean need_edit, add_aux_fields, broken;
7955       bfd_size_type cnt_16b = 0;
7956
7957       if (!is_ppc64_elf (ibfd))
7958         continue;
7959
7960       sec = bfd_get_section_by_name (ibfd, ".opd");
7961       if (sec == NULL || sec->size == 0)
7962         continue;
7963
7964       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7965         continue;
7966
7967       if (sec->output_section == bfd_abs_section_ptr)
7968         continue;
7969
7970       /* Look through the section relocs.  */
7971       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7972         continue;
7973
7974       local_syms = NULL;
7975       symtab_hdr = &elf_symtab_hdr (ibfd);
7976
7977       /* Read the relocations.  */
7978       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7979                                             info->keep_memory);
7980       if (relstart == NULL)
7981         return FALSE;
7982
7983       /* First run through the relocs to check they are sane, and to
7984          determine whether we need to edit this opd section.  */
7985       need_edit = FALSE;
7986       broken = FALSE;
7987       need_pad = sec;
7988       relend = relstart + sec->reloc_count;
7989       for (rel = relstart; rel < relend; )
7990         {
7991           enum elf_ppc64_reloc_type r_type;
7992           unsigned long r_symndx;
7993           asection *sym_sec;
7994           struct elf_link_hash_entry *h;
7995           Elf_Internal_Sym *sym;
7996           bfd_vma offset;
7997
7998           /* .opd contains an array of 16 or 24 byte entries.  We're
7999              only interested in the reloc pointing to a function entry
8000              point.  */
8001           offset = rel->r_offset;
8002           if (rel + 1 == relend
8003               || rel[1].r_offset != offset + 8)
8004             {
8005               /* If someone messes with .opd alignment then after a
8006                  "ld -r" we might have padding in the middle of .opd.
8007                  Also, there's nothing to prevent someone putting
8008                  something silly in .opd with the assembler.  No .opd
8009                  optimization for them!  */
8010             broken_opd:
8011               _bfd_error_handler
8012                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
8013               broken = TRUE;
8014               break;
8015             }
8016
8017           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8018               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8019             {
8020               _bfd_error_handler
8021                 /* xgettext:c-format */
8022                 (_("%B: unexpected reloc type %u in .opd section"),
8023                  ibfd, r_type);
8024               broken = TRUE;
8025               break;
8026             }
8027
8028           r_symndx = ELF64_R_SYM (rel->r_info);
8029           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8030                           r_symndx, ibfd))
8031             goto error_ret;
8032
8033           if (sym_sec == NULL || sym_sec->owner == NULL)
8034             {
8035               const char *sym_name;
8036               if (h != NULL)
8037                 sym_name = h->root.root.string;
8038               else
8039                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8040                                              sym_sec);
8041
8042               _bfd_error_handler
8043                 /* xgettext:c-format */
8044                 (_("%B: undefined sym `%s' in .opd section"),
8045                  ibfd, sym_name);
8046               broken = TRUE;
8047               break;
8048             }
8049
8050           /* opd entries are always for functions defined in the
8051              current input bfd.  If the symbol isn't defined in the
8052              input bfd, then we won't be using the function in this
8053              bfd;  It must be defined in a linkonce section in another
8054              bfd, or is weak.  It's also possible that we are
8055              discarding the function due to a linker script /DISCARD/,
8056              which we test for via the output_section.  */
8057           if (sym_sec->owner != ibfd
8058               || sym_sec->output_section == bfd_abs_section_ptr)
8059             need_edit = TRUE;
8060
8061           rel += 2;
8062           if (rel + 1 == relend
8063               || (rel + 2 < relend
8064                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8065             ++rel;
8066
8067           if (rel == relend)
8068             {
8069               if (sec->size == offset + 24)
8070                 {
8071                   need_pad = NULL;
8072                   break;
8073                 }
8074               if (sec->size == offset + 16)
8075                 {
8076                   cnt_16b++;
8077                   break;
8078                 }
8079               goto broken_opd;
8080             }
8081           else if (rel + 1 < relend
8082                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8083                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8084             {
8085               if (rel[0].r_offset == offset + 16)
8086                 cnt_16b++;
8087               else if (rel[0].r_offset != offset + 24)
8088                 goto broken_opd;
8089             }
8090           else
8091             goto broken_opd;
8092         }
8093
8094       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8095
8096       if (!broken && (need_edit || add_aux_fields))
8097         {
8098           Elf_Internal_Rela *write_rel;
8099           Elf_Internal_Shdr *rel_hdr;
8100           bfd_byte *rptr, *wptr;
8101           bfd_byte *new_contents;
8102           bfd_size_type amt;
8103
8104           new_contents = NULL;
8105           amt = OPD_NDX (sec->size) * sizeof (long);
8106           opd = &ppc64_elf_section_data (sec)->u.opd;
8107           opd->adjust = bfd_zalloc (sec->owner, amt);
8108           if (opd->adjust == NULL)
8109             return FALSE;
8110           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8111
8112           /* This seems a waste of time as input .opd sections are all
8113              zeros as generated by gcc, but I suppose there's no reason
8114              this will always be so.  We might start putting something in
8115              the third word of .opd entries.  */
8116           if ((sec->flags & SEC_IN_MEMORY) == 0)
8117             {
8118               bfd_byte *loc;
8119               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8120                 {
8121                   if (loc != NULL)
8122                     free (loc);
8123                 error_ret:
8124                   if (local_syms != NULL
8125                       && symtab_hdr->contents != (unsigned char *) local_syms)
8126                     free (local_syms);
8127                   if (elf_section_data (sec)->relocs != relstart)
8128                     free (relstart);
8129                   return FALSE;
8130                 }
8131               sec->contents = loc;
8132               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8133             }
8134
8135           elf_section_data (sec)->relocs = relstart;
8136
8137           new_contents = sec->contents;
8138           if (add_aux_fields)
8139             {
8140               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8141               if (new_contents == NULL)
8142                 return FALSE;
8143               need_pad = NULL;
8144             }
8145           wptr = new_contents;
8146           rptr = sec->contents;
8147           write_rel = relstart;
8148           for (rel = relstart; rel < relend; )
8149             {
8150               unsigned long r_symndx;
8151               asection *sym_sec;
8152               struct elf_link_hash_entry *h;
8153               struct ppc_link_hash_entry *fdh = NULL;
8154               Elf_Internal_Sym *sym;
8155               long opd_ent_size;
8156               Elf_Internal_Rela *next_rel;
8157               bfd_boolean skip;
8158
8159               r_symndx = ELF64_R_SYM (rel->r_info);
8160               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8161                               r_symndx, ibfd))
8162                 goto error_ret;
8163
8164               next_rel = rel + 2;
8165               if (next_rel + 1 == relend
8166                   || (next_rel + 2 < relend
8167                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8168                 ++next_rel;
8169
8170               /* See if the .opd entry is full 24 byte or
8171                  16 byte (with fd_aux entry overlapped with next
8172                  fd_func).  */
8173               opd_ent_size = 24;
8174               if (next_rel == relend)
8175                 {
8176                   if (sec->size == rel->r_offset + 16)
8177                     opd_ent_size = 16;
8178                 }
8179               else if (next_rel->r_offset == rel->r_offset + 16)
8180                 opd_ent_size = 16;
8181
8182               if (h != NULL
8183                   && h->root.root.string[0] == '.')
8184                 {
8185                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8186                   if (fdh != NULL)
8187                     {
8188                       fdh = ppc_follow_link (fdh);
8189                       if (fdh->elf.root.type != bfd_link_hash_defined
8190                           && fdh->elf.root.type != bfd_link_hash_defweak)
8191                         fdh = NULL;
8192                     }
8193                 }
8194
8195               skip = (sym_sec->owner != ibfd
8196                       || sym_sec->output_section == bfd_abs_section_ptr);
8197               if (skip)
8198                 {
8199                   if (fdh != NULL && sym_sec->owner == ibfd)
8200                     {
8201                       /* Arrange for the function descriptor sym
8202                          to be dropped.  */
8203                       fdh->elf.root.u.def.value = 0;
8204                       fdh->elf.root.u.def.section = sym_sec;
8205                     }
8206                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8207
8208                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8209                     rel = next_rel;
8210                   else
8211                     while (1)
8212                       {
8213                         if (!dec_dynrel_count (rel->r_info, sec, info,
8214                                                NULL, h, sym))
8215                           goto error_ret;
8216
8217                         if (++rel == next_rel)
8218                           break;
8219
8220                         r_symndx = ELF64_R_SYM (rel->r_info);
8221                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8222                                         r_symndx, ibfd))
8223                           goto error_ret;
8224                       }
8225                 }
8226               else
8227                 {
8228                   /* We'll be keeping this opd entry.  */
8229                   long adjust;
8230
8231                   if (fdh != NULL)
8232                     {
8233                       /* Redefine the function descriptor symbol to
8234                          this location in the opd section.  It is
8235                          necessary to update the value here rather
8236                          than using an array of adjustments as we do
8237                          for local symbols, because various places
8238                          in the generic ELF code use the value
8239                          stored in u.def.value.  */
8240                       fdh->elf.root.u.def.value = wptr - new_contents;
8241                       fdh->adjust_done = 1;
8242                     }
8243
8244                   /* Local syms are a bit tricky.  We could
8245                      tweak them as they can be cached, but
8246                      we'd need to look through the local syms
8247                      for the function descriptor sym which we
8248                      don't have at the moment.  So keep an
8249                      array of adjustments.  */
8250                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8251                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8252
8253                   if (wptr != rptr)
8254                     memcpy (wptr, rptr, opd_ent_size);
8255                   wptr += opd_ent_size;
8256                   if (add_aux_fields && opd_ent_size == 16)
8257                     {
8258                       memset (wptr, '\0', 8);
8259                       wptr += 8;
8260                     }
8261
8262                   /* We need to adjust any reloc offsets to point to the
8263                      new opd entries.  */
8264                   for ( ; rel != next_rel; ++rel)
8265                     {
8266                       rel->r_offset += adjust;
8267                       if (write_rel != rel)
8268                         memcpy (write_rel, rel, sizeof (*rel));
8269                       ++write_rel;
8270                     }
8271                 }
8272
8273               rptr += opd_ent_size;
8274             }
8275
8276           sec->size = wptr - new_contents;
8277           sec->reloc_count = write_rel - relstart;
8278           if (add_aux_fields)
8279             {
8280               free (sec->contents);
8281               sec->contents = new_contents;
8282             }
8283
8284           /* Fudge the header size too, as this is used later in
8285              elf_bfd_final_link if we are emitting relocs.  */
8286           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8287           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8288           some_edited = TRUE;
8289         }
8290       else if (elf_section_data (sec)->relocs != relstart)
8291         free (relstart);
8292
8293       if (local_syms != NULL
8294           && symtab_hdr->contents != (unsigned char *) local_syms)
8295         {
8296           if (!info->keep_memory)
8297             free (local_syms);
8298           else
8299             symtab_hdr->contents = (unsigned char *) local_syms;
8300         }
8301     }
8302
8303   if (some_edited)
8304     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8305
8306   /* If we are doing a final link and the last .opd entry is just 16 byte
8307      long, add a 8 byte padding after it.  */
8308   if (need_pad != NULL && !bfd_link_relocatable (info))
8309     {
8310       bfd_byte *p;
8311
8312       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8313         {
8314           BFD_ASSERT (need_pad->size > 0);
8315
8316           p = bfd_malloc (need_pad->size + 8);
8317           if (p == NULL)
8318             return FALSE;
8319
8320           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8321                                           p, 0, need_pad->size))
8322             return FALSE;
8323
8324           need_pad->contents = p;
8325           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8326         }
8327       else
8328         {
8329           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8330           if (p == NULL)
8331             return FALSE;
8332
8333           need_pad->contents = p;
8334         }
8335
8336       memset (need_pad->contents + need_pad->size, 0, 8);
8337       need_pad->size += 8;
8338     }
8339
8340   return TRUE;
8341 }
8342
8343 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8344
8345 asection *
8346 ppc64_elf_tls_setup (struct bfd_link_info *info)
8347 {
8348   struct ppc_link_hash_table *htab;
8349
8350   htab = ppc_hash_table (info);
8351   if (htab == NULL)
8352     return NULL;
8353
8354   if (abiversion (info->output_bfd) == 1)
8355     htab->opd_abi = 1;
8356
8357   if (htab->params->no_multi_toc)
8358     htab->do_multi_toc = 0;
8359   else if (!htab->do_multi_toc)
8360     htab->params->no_multi_toc = 1;
8361
8362   /* Default to --no-plt-localentry, as this option can cause problems
8363      with symbol interposition.  For example, glibc libpthread.so and
8364      libc.so duplicate many pthread symbols, with a fallback
8365      implementation in libc.so.  In some cases the fallback does more
8366      work than the pthread implementation.  __pthread_condattr_destroy
8367      is one such symbol: the libpthread.so implementation is
8368      localentry:0 while the libc.so implementation is localentry:8.
8369      An app that "cleverly" uses dlopen to only load necessary
8370      libraries at runtime may omit loading libpthread.so when not
8371      running multi-threaded, which then results in the libc.so
8372      fallback symbols being used and ld.so complaining.  Now there
8373      are workarounds in ld (see non_zero_localentry) to detect the
8374      pthread situation, but that may not be the only case where
8375      --plt-localentry can cause trouble.  */
8376   if (htab->params->plt_localentry0 < 0)
8377     htab->params->plt_localentry0 = 0;
8378   if (htab->params->plt_localentry0
8379       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8380                                FALSE, FALSE, FALSE) == NULL)
8381     info->callbacks->einfo
8382       (_("%P: warning: --plt-localentry is especially dangerous without "
8383          "ld.so support to detect ABI violations.\n"));
8384
8385   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8386                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8387                                               FALSE, FALSE, TRUE));
8388   /* Move dynamic linking info to the function descriptor sym.  */
8389   if (htab->tls_get_addr != NULL)
8390     func_desc_adjust (&htab->tls_get_addr->elf, info);
8391   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8392                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8393                                                  FALSE, FALSE, TRUE));
8394   if (htab->params->tls_get_addr_opt)
8395     {
8396       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8397
8398       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8399                                   FALSE, FALSE, TRUE);
8400       if (opt != NULL)
8401         func_desc_adjust (opt, info);
8402       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8403                                      FALSE, FALSE, TRUE);
8404       if (opt_fd != NULL
8405           && (opt_fd->root.type == bfd_link_hash_defined
8406               || opt_fd->root.type == bfd_link_hash_defweak))
8407         {
8408           /* If glibc supports an optimized __tls_get_addr call stub,
8409              signalled by the presence of __tls_get_addr_opt, and we'll
8410              be calling __tls_get_addr via a plt call stub, then
8411              make __tls_get_addr point to __tls_get_addr_opt.  */
8412           tga_fd = &htab->tls_get_addr_fd->elf;
8413           if (htab->elf.dynamic_sections_created
8414               && tga_fd != NULL
8415               && (tga_fd->type == STT_FUNC
8416                   || tga_fd->needs_plt)
8417               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8418                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8419             {
8420               struct plt_entry *ent;
8421
8422               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8423                 if (ent->plt.refcount > 0)
8424                   break;
8425               if (ent != NULL)
8426                 {
8427                   tga_fd->root.type = bfd_link_hash_indirect;
8428                   tga_fd->root.u.i.link = &opt_fd->root;
8429                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8430                   opt_fd->mark = 1;
8431                   if (opt_fd->dynindx != -1)
8432                     {
8433                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8434                       opt_fd->dynindx = -1;
8435                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8436                                               opt_fd->dynstr_index);
8437                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8438                         return NULL;
8439                     }
8440                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8441                   tga = &htab->tls_get_addr->elf;
8442                   if (opt != NULL && tga != NULL)
8443                     {
8444                       tga->root.type = bfd_link_hash_indirect;
8445                       tga->root.u.i.link = &opt->root;
8446                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8447                       opt->mark = 1;
8448                       _bfd_elf_link_hash_hide_symbol (info, opt,
8449                                                       tga->forced_local);
8450                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8451                     }
8452                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8453                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8454                   if (htab->tls_get_addr != NULL)
8455                     {
8456                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8457                       htab->tls_get_addr->is_func = 1;
8458                     }
8459                 }
8460             }
8461         }
8462       else if (htab->params->tls_get_addr_opt < 0)
8463         htab->params->tls_get_addr_opt = 0;
8464     }
8465   return _bfd_elf_tls_setup (info->output_bfd, info);
8466 }
8467
8468 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8469    HASH1 or HASH2.  */
8470
8471 static bfd_boolean
8472 branch_reloc_hash_match (const bfd *ibfd,
8473                          const Elf_Internal_Rela *rel,
8474                          const struct ppc_link_hash_entry *hash1,
8475                          const struct ppc_link_hash_entry *hash2)
8476 {
8477   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8478   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8479   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8480
8481   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8482     {
8483       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8484       struct elf_link_hash_entry *h;
8485
8486       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8487       h = elf_follow_link (h);
8488       if (h == &hash1->elf || h == &hash2->elf)
8489         return TRUE;
8490     }
8491   return FALSE;
8492 }
8493
8494 /* Run through all the TLS relocs looking for optimization
8495    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8496    a preliminary section layout so that we know the TLS segment
8497    offsets.  We can't optimize earlier because some optimizations need
8498    to know the tp offset, and we need to optimize before allocating
8499    dynamic relocations.  */
8500
8501 bfd_boolean
8502 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8503 {
8504   bfd *ibfd;
8505   asection *sec;
8506   struct ppc_link_hash_table *htab;
8507   unsigned char *toc_ref;
8508   int pass;
8509
8510   if (!bfd_link_executable (info))
8511     return TRUE;
8512
8513   htab = ppc_hash_table (info);
8514   if (htab == NULL)
8515     return FALSE;
8516
8517   /* Make two passes over the relocs.  On the first pass, mark toc
8518      entries involved with tls relocs, and check that tls relocs
8519      involved in setting up a tls_get_addr call are indeed followed by
8520      such a call.  If they are not, we can't do any tls optimization.
8521      On the second pass twiddle tls_mask flags to notify
8522      relocate_section that optimization can be done, and adjust got
8523      and plt refcounts.  */
8524   toc_ref = NULL;
8525   for (pass = 0; pass < 2; ++pass)
8526     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8527       {
8528         Elf_Internal_Sym *locsyms = NULL;
8529         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8530
8531         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8532           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8533             {
8534               Elf_Internal_Rela *relstart, *rel, *relend;
8535               bfd_boolean found_tls_get_addr_arg = 0;
8536
8537               /* Read the relocations.  */
8538               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8539                                                     info->keep_memory);
8540               if (relstart == NULL)
8541                 {
8542                   free (toc_ref);
8543                   return FALSE;
8544                 }
8545
8546               relend = relstart + sec->reloc_count;
8547               for (rel = relstart; rel < relend; rel++)
8548                 {
8549                   enum elf_ppc64_reloc_type r_type;
8550                   unsigned long r_symndx;
8551                   struct elf_link_hash_entry *h;
8552                   Elf_Internal_Sym *sym;
8553                   asection *sym_sec;
8554                   unsigned char *tls_mask;
8555                   unsigned char tls_set, tls_clear, tls_type = 0;
8556                   bfd_vma value;
8557                   bfd_boolean ok_tprel, is_local;
8558                   long toc_ref_index = 0;
8559                   int expecting_tls_get_addr = 0;
8560                   bfd_boolean ret = FALSE;
8561
8562                   r_symndx = ELF64_R_SYM (rel->r_info);
8563                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8564                                   r_symndx, ibfd))
8565                     {
8566                     err_free_rel:
8567                       if (elf_section_data (sec)->relocs != relstart)
8568                         free (relstart);
8569                       if (toc_ref != NULL)
8570                         free (toc_ref);
8571                       if (locsyms != NULL
8572                           && (elf_symtab_hdr (ibfd).contents
8573                               != (unsigned char *) locsyms))
8574                         free (locsyms);
8575                       return ret;
8576                     }
8577
8578                   if (h != NULL)
8579                     {
8580                       if (h->root.type == bfd_link_hash_defined
8581                           || h->root.type == bfd_link_hash_defweak)
8582                         value = h->root.u.def.value;
8583                       else if (h->root.type == bfd_link_hash_undefweak)
8584                         value = 0;
8585                       else
8586                         {
8587                           found_tls_get_addr_arg = 0;
8588                           continue;
8589                         }
8590                     }
8591                   else
8592                     /* Symbols referenced by TLS relocs must be of type
8593                        STT_TLS.  So no need for .opd local sym adjust.  */
8594                     value = sym->st_value;
8595
8596                   ok_tprel = FALSE;
8597                   is_local = FALSE;
8598                   if (h == NULL
8599                       || !h->def_dynamic)
8600                     {
8601                       is_local = TRUE;
8602                       if (h != NULL
8603                           && h->root.type == bfd_link_hash_undefweak)
8604                         ok_tprel = TRUE;
8605                       else if (sym_sec != NULL
8606                                && sym_sec->output_section != NULL)
8607                         {
8608                           value += sym_sec->output_offset;
8609                           value += sym_sec->output_section->vma;
8610                           value -= htab->elf.tls_sec->vma;
8611                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8612                                       < (bfd_vma) 1 << 32);
8613                         }
8614                     }
8615
8616                   r_type = ELF64_R_TYPE (rel->r_info);
8617                   /* If this section has old-style __tls_get_addr calls
8618                      without marker relocs, then check that each
8619                      __tls_get_addr call reloc is preceded by a reloc
8620                      that conceivably belongs to the __tls_get_addr arg
8621                      setup insn.  If we don't find matching arg setup
8622                      relocs, don't do any tls optimization.  */
8623                   if (pass == 0
8624                       && sec->has_tls_get_addr_call
8625                       && h != NULL
8626                       && (h == &htab->tls_get_addr->elf
8627                           || h == &htab->tls_get_addr_fd->elf)
8628                       && !found_tls_get_addr_arg
8629                       && is_branch_reloc (r_type))
8630                     {
8631                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8632                                                 "TLS optimization disabled\n"),
8633                                               ibfd, sec, rel->r_offset);
8634                       ret = TRUE;
8635                       goto err_free_rel;
8636                     }
8637
8638                   found_tls_get_addr_arg = 0;
8639                   switch (r_type)
8640                     {
8641                     case R_PPC64_GOT_TLSLD16:
8642                     case R_PPC64_GOT_TLSLD16_LO:
8643                       expecting_tls_get_addr = 1;
8644                       found_tls_get_addr_arg = 1;
8645                       /* Fall through.  */
8646
8647                     case R_PPC64_GOT_TLSLD16_HI:
8648                     case R_PPC64_GOT_TLSLD16_HA:
8649                       /* These relocs should never be against a symbol
8650                          defined in a shared lib.  Leave them alone if
8651                          that turns out to be the case.  */
8652                       if (!is_local)
8653                         continue;
8654
8655                       /* LD -> LE */
8656                       tls_set = 0;
8657                       tls_clear = TLS_LD;
8658                       tls_type = TLS_TLS | TLS_LD;
8659                       break;
8660
8661                     case R_PPC64_GOT_TLSGD16:
8662                     case R_PPC64_GOT_TLSGD16_LO:
8663                       expecting_tls_get_addr = 1;
8664                       found_tls_get_addr_arg = 1;
8665                       /* Fall through. */
8666
8667                     case R_PPC64_GOT_TLSGD16_HI:
8668                     case R_PPC64_GOT_TLSGD16_HA:
8669                       if (ok_tprel)
8670                         /* GD -> LE */
8671                         tls_set = 0;
8672                       else
8673                         /* GD -> IE */
8674                         tls_set = TLS_TLS | TLS_TPRELGD;
8675                       tls_clear = TLS_GD;
8676                       tls_type = TLS_TLS | TLS_GD;
8677                       break;
8678
8679                     case R_PPC64_GOT_TPREL16_DS:
8680                     case R_PPC64_GOT_TPREL16_LO_DS:
8681                     case R_PPC64_GOT_TPREL16_HI:
8682                     case R_PPC64_GOT_TPREL16_HA:
8683                       if (ok_tprel)
8684                         {
8685                           /* IE -> LE */
8686                           tls_set = 0;
8687                           tls_clear = TLS_TPREL;
8688                           tls_type = TLS_TLS | TLS_TPREL;
8689                           break;
8690                         }
8691                       continue;
8692
8693                     case R_PPC64_TLSGD:
8694                     case R_PPC64_TLSLD:
8695                       found_tls_get_addr_arg = 1;
8696                       /* Fall through.  */
8697
8698                     case R_PPC64_TLS:
8699                     case R_PPC64_TOC16:
8700                     case R_PPC64_TOC16_LO:
8701                       if (sym_sec == NULL || sym_sec != toc)
8702                         continue;
8703
8704                       /* Mark this toc entry as referenced by a TLS
8705                          code sequence.  We can do that now in the
8706                          case of R_PPC64_TLS, and after checking for
8707                          tls_get_addr for the TOC16 relocs.  */
8708                       if (toc_ref == NULL)
8709                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8710                       if (toc_ref == NULL)
8711                         goto err_free_rel;
8712
8713                       if (h != NULL)
8714                         value = h->root.u.def.value;
8715                       else
8716                         value = sym->st_value;
8717                       value += rel->r_addend;
8718                       if (value % 8 != 0)
8719                         continue;
8720                       BFD_ASSERT (value < toc->size
8721                                   && toc->output_offset % 8 == 0);
8722                       toc_ref_index = (value + toc->output_offset) / 8;
8723                       if (r_type == R_PPC64_TLS
8724                           || r_type == R_PPC64_TLSGD
8725                           || r_type == R_PPC64_TLSLD)
8726                         {
8727                           toc_ref[toc_ref_index] = 1;
8728                           continue;
8729                         }
8730
8731                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8732                         continue;
8733
8734                       tls_set = 0;
8735                       tls_clear = 0;
8736                       expecting_tls_get_addr = 2;
8737                       break;
8738
8739                     case R_PPC64_TPREL64:
8740                       if (pass == 0
8741                           || sec != toc
8742                           || toc_ref == NULL
8743                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8744                         continue;
8745                       if (ok_tprel)
8746                         {
8747                           /* IE -> LE */
8748                           tls_set = TLS_EXPLICIT;
8749                           tls_clear = TLS_TPREL;
8750                           break;
8751                         }
8752                       continue;
8753
8754                     case R_PPC64_DTPMOD64:
8755                       if (pass == 0
8756                           || sec != toc
8757                           || toc_ref == NULL
8758                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8759                         continue;
8760                       if (rel + 1 < relend
8761                           && (rel[1].r_info
8762                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8763                           && rel[1].r_offset == rel->r_offset + 8)
8764                         {
8765                           if (ok_tprel)
8766                             /* GD -> LE */
8767                             tls_set = TLS_EXPLICIT | TLS_GD;
8768                           else
8769                             /* GD -> IE */
8770                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8771                           tls_clear = TLS_GD;
8772                         }
8773                       else
8774                         {
8775                           if (!is_local)
8776                             continue;
8777
8778                           /* LD -> LE */
8779                           tls_set = TLS_EXPLICIT;
8780                           tls_clear = TLS_LD;
8781                         }
8782                       break;
8783
8784                     default:
8785                       continue;
8786                     }
8787
8788                   if (pass == 0)
8789                     {
8790                       if (!expecting_tls_get_addr
8791                           || !sec->has_tls_get_addr_call)
8792                         continue;
8793
8794                       if (rel + 1 < relend
8795                           && branch_reloc_hash_match (ibfd, rel + 1,
8796                                                       htab->tls_get_addr,
8797                                                       htab->tls_get_addr_fd))
8798                         {
8799                           if (expecting_tls_get_addr == 2)
8800                             {
8801                               /* Check for toc tls entries.  */
8802                               unsigned char *toc_tls;
8803                               int retval;
8804
8805                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8806                                                      &locsyms,
8807                                                      rel, ibfd);
8808                               if (retval == 0)
8809                                 goto err_free_rel;
8810                               if (toc_tls != NULL)
8811                                 {
8812                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8813                                     found_tls_get_addr_arg = 1;
8814                                   if (retval > 1)
8815                                     toc_ref[toc_ref_index] = 1;
8816                                 }
8817                             }
8818                           continue;
8819                         }
8820
8821                       if (expecting_tls_get_addr != 1)
8822                         continue;
8823
8824                       /* Uh oh, we didn't find the expected call.  We
8825                          could just mark this symbol to exclude it
8826                          from tls optimization but it's safer to skip
8827                          the entire optimization.  */
8828                       /* xgettext:c-format */
8829                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8830                                                 "TLS optimization disabled\n"),
8831                                               ibfd, sec, rel->r_offset);
8832                       ret = TRUE;
8833                       goto err_free_rel;
8834                     }
8835
8836                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8837                     {
8838                       struct plt_entry *ent;
8839                       for (ent = htab->tls_get_addr->elf.plt.plist;
8840                            ent != NULL;
8841                            ent = ent->next)
8842                         if (ent->addend == 0)
8843                           {
8844                             if (ent->plt.refcount > 0)
8845                               {
8846                                 ent->plt.refcount -= 1;
8847                                 expecting_tls_get_addr = 0;
8848                               }
8849                             break;
8850                           }
8851                     }
8852
8853                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8854                     {
8855                       struct plt_entry *ent;
8856                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8857                            ent != NULL;
8858                            ent = ent->next)
8859                         if (ent->addend == 0)
8860                           {
8861                             if (ent->plt.refcount > 0)
8862                               ent->plt.refcount -= 1;
8863                             break;
8864                           }
8865                     }
8866
8867                   if (tls_clear == 0)
8868                     continue;
8869
8870                   if ((tls_set & TLS_EXPLICIT) == 0)
8871                     {
8872                       struct got_entry *ent;
8873
8874                       /* Adjust got entry for this reloc.  */
8875                       if (h != NULL)
8876                         ent = h->got.glist;
8877                       else
8878                         ent = elf_local_got_ents (ibfd)[r_symndx];
8879
8880                       for (; ent != NULL; ent = ent->next)
8881                         if (ent->addend == rel->r_addend
8882                             && ent->owner == ibfd
8883                             && ent->tls_type == tls_type)
8884                           break;
8885                       if (ent == NULL)
8886                         abort ();
8887
8888                       if (tls_set == 0)
8889                         {
8890                           /* We managed to get rid of a got entry.  */
8891                           if (ent->got.refcount > 0)
8892                             ent->got.refcount -= 1;
8893                         }
8894                     }
8895                   else
8896                     {
8897                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8898                          we'll lose one or two dyn relocs.  */
8899                       if (!dec_dynrel_count (rel->r_info, sec, info,
8900                                              NULL, h, sym))
8901                         return FALSE;
8902
8903                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8904                         {
8905                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8906                                                  NULL, h, sym))
8907                             return FALSE;
8908                         }
8909                     }
8910
8911                   *tls_mask |= tls_set;
8912                   *tls_mask &= ~tls_clear;
8913                 }
8914
8915               if (elf_section_data (sec)->relocs != relstart)
8916                 free (relstart);
8917             }
8918
8919         if (locsyms != NULL
8920             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8921           {
8922             if (!info->keep_memory)
8923               free (locsyms);
8924             else
8925               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8926           }
8927       }
8928
8929   if (toc_ref != NULL)
8930     free (toc_ref);
8931   htab->do_tls_opt = 1;
8932   return TRUE;
8933 }
8934
8935 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8936    the values of any global symbols in a toc section that has been
8937    edited.  Globals in toc sections should be a rarity, so this function
8938    sets a flag if any are found in toc sections other than the one just
8939    edited, so that further hash table traversals can be avoided.  */
8940
8941 struct adjust_toc_info
8942 {
8943   asection *toc;
8944   unsigned long *skip;
8945   bfd_boolean global_toc_syms;
8946 };
8947
8948 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8949
8950 static bfd_boolean
8951 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8952 {
8953   struct ppc_link_hash_entry *eh;
8954   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8955   unsigned long i;
8956
8957   if (h->root.type != bfd_link_hash_defined
8958       && h->root.type != bfd_link_hash_defweak)
8959     return TRUE;
8960
8961   eh = (struct ppc_link_hash_entry *) h;
8962   if (eh->adjust_done)
8963     return TRUE;
8964
8965   if (eh->elf.root.u.def.section == toc_inf->toc)
8966     {
8967       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8968         i = toc_inf->toc->rawsize >> 3;
8969       else
8970         i = eh->elf.root.u.def.value >> 3;
8971
8972       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8973         {
8974           _bfd_error_handler
8975             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8976           do
8977             ++i;
8978           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8979           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8980         }
8981
8982       eh->elf.root.u.def.value -= toc_inf->skip[i];
8983       eh->adjust_done = 1;
8984     }
8985   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8986     toc_inf->global_toc_syms = TRUE;
8987
8988   return TRUE;
8989 }
8990
8991 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8992    on a _LO variety toc/got reloc.  */
8993
8994 static bfd_boolean
8995 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8996 {
8997   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8998           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8999           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9000           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9001           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9002           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9003           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9004           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9005           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9006           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9007           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9008           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9009           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9010           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9011           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9012           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9013           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9014               /* Exclude lfqu by testing reloc.  If relocs are ever
9015                  defined for the reduced D field in psq_lu then those
9016                  will need testing too.  */
9017               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9018           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9019               && (insn & 1) == 0)
9020           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9021           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9022               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9023               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9024           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9025               && (insn & 1) == 0));
9026 }
9027
9028 /* Examine all relocs referencing .toc sections in order to remove
9029    unused .toc entries.  */
9030
9031 bfd_boolean
9032 ppc64_elf_edit_toc (struct bfd_link_info *info)
9033 {
9034   bfd *ibfd;
9035   struct adjust_toc_info toc_inf;
9036   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9037
9038   htab->do_toc_opt = 1;
9039   toc_inf.global_toc_syms = TRUE;
9040   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9041     {
9042       asection *toc, *sec;
9043       Elf_Internal_Shdr *symtab_hdr;
9044       Elf_Internal_Sym *local_syms;
9045       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9046       unsigned long *skip, *drop;
9047       unsigned char *used;
9048       unsigned char *keep, last, some_unused;
9049
9050       if (!is_ppc64_elf (ibfd))
9051         continue;
9052
9053       toc = bfd_get_section_by_name (ibfd, ".toc");
9054       if (toc == NULL
9055           || toc->size == 0
9056           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9057           || discarded_section (toc))
9058         continue;
9059
9060       toc_relocs = NULL;
9061       local_syms = NULL;
9062       symtab_hdr = &elf_symtab_hdr (ibfd);
9063
9064       /* Look at sections dropped from the final link.  */
9065       skip = NULL;
9066       relstart = NULL;
9067       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9068         {
9069           if (sec->reloc_count == 0
9070               || !discarded_section (sec)
9071               || get_opd_info (sec)
9072               || (sec->flags & SEC_ALLOC) == 0
9073               || (sec->flags & SEC_DEBUGGING) != 0)
9074             continue;
9075
9076           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9077           if (relstart == NULL)
9078             goto error_ret;
9079
9080           /* Run through the relocs to see which toc entries might be
9081              unused.  */
9082           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9083             {
9084               enum elf_ppc64_reloc_type r_type;
9085               unsigned long r_symndx;
9086               asection *sym_sec;
9087               struct elf_link_hash_entry *h;
9088               Elf_Internal_Sym *sym;
9089               bfd_vma val;
9090
9091               r_type = ELF64_R_TYPE (rel->r_info);
9092               switch (r_type)
9093                 {
9094                 default:
9095                   continue;
9096
9097                 case R_PPC64_TOC16:
9098                 case R_PPC64_TOC16_LO:
9099                 case R_PPC64_TOC16_HI:
9100                 case R_PPC64_TOC16_HA:
9101                 case R_PPC64_TOC16_DS:
9102                 case R_PPC64_TOC16_LO_DS:
9103                   break;
9104                 }
9105
9106               r_symndx = ELF64_R_SYM (rel->r_info);
9107               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9108                               r_symndx, ibfd))
9109                 goto error_ret;
9110
9111               if (sym_sec != toc)
9112                 continue;
9113
9114               if (h != NULL)
9115                 val = h->root.u.def.value;
9116               else
9117                 val = sym->st_value;
9118               val += rel->r_addend;
9119
9120               if (val >= toc->size)
9121                 continue;
9122
9123               /* Anything in the toc ought to be aligned to 8 bytes.
9124                  If not, don't mark as unused.  */
9125               if (val & 7)
9126                 continue;
9127
9128               if (skip == NULL)
9129                 {
9130                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9131                   if (skip == NULL)
9132                     goto error_ret;
9133                 }
9134
9135               skip[val >> 3] = ref_from_discarded;
9136             }
9137
9138           if (elf_section_data (sec)->relocs != relstart)
9139             free (relstart);
9140         }
9141
9142       /* For largetoc loads of address constants, we can convert
9143          .  addis rx,2,addr@got@ha
9144          .  ld ry,addr@got@l(rx)
9145          to
9146          .  addis rx,2,addr@toc@ha
9147          .  addi ry,rx,addr@toc@l
9148          when addr is within 2G of the toc pointer.  This then means
9149          that the word storing "addr" in the toc is no longer needed.  */
9150
9151       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9152           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9153           && toc->reloc_count != 0)
9154         {
9155           /* Read toc relocs.  */
9156           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9157                                                   info->keep_memory);
9158           if (toc_relocs == NULL)
9159             goto error_ret;
9160
9161           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9162             {
9163               enum elf_ppc64_reloc_type r_type;
9164               unsigned long r_symndx;
9165               asection *sym_sec;
9166               struct elf_link_hash_entry *h;
9167               Elf_Internal_Sym *sym;
9168               bfd_vma val, addr;
9169
9170               r_type = ELF64_R_TYPE (rel->r_info);
9171               if (r_type != R_PPC64_ADDR64)
9172                 continue;
9173
9174               r_symndx = ELF64_R_SYM (rel->r_info);
9175               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9176                               r_symndx, ibfd))
9177                 goto error_ret;
9178
9179               if (sym_sec == NULL
9180                   || sym_sec->output_section == NULL
9181                   || discarded_section (sym_sec))
9182                 continue;
9183
9184               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9185                 continue;
9186
9187               if (h != NULL)
9188                 {
9189                   if (h->type == STT_GNU_IFUNC)
9190                     continue;
9191                   val = h->root.u.def.value;
9192                 }
9193               else
9194                 {
9195                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9196                     continue;
9197                   val = sym->st_value;
9198                 }
9199               val += rel->r_addend;
9200               val += sym_sec->output_section->vma + sym_sec->output_offset;
9201
9202               /* We don't yet know the exact toc pointer value, but we
9203                  know it will be somewhere in the toc section.  Don't
9204                  optimize if the difference from any possible toc
9205                  pointer is outside [ff..f80008000, 7fff7fff].  */
9206               addr = toc->output_section->vma + TOC_BASE_OFF;
9207               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9208                 continue;
9209
9210               addr = toc->output_section->vma + toc->output_section->rawsize;
9211               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9212                 continue;
9213
9214               if (skip == NULL)
9215                 {
9216                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9217                   if (skip == NULL)
9218                     goto error_ret;
9219                 }
9220
9221               skip[rel->r_offset >> 3]
9222                 |= can_optimize | ((rel - toc_relocs) << 2);
9223             }
9224         }
9225
9226       if (skip == NULL)
9227         continue;
9228
9229       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9230       if (used == NULL)
9231         {
9232         error_ret:
9233           if (local_syms != NULL
9234               && symtab_hdr->contents != (unsigned char *) local_syms)
9235             free (local_syms);
9236           if (sec != NULL
9237               && relstart != NULL
9238               && elf_section_data (sec)->relocs != relstart)
9239             free (relstart);
9240           if (toc_relocs != NULL
9241               && elf_section_data (toc)->relocs != toc_relocs)
9242             free (toc_relocs);
9243           if (skip != NULL)
9244             free (skip);
9245           return FALSE;
9246         }
9247
9248       /* Now check all kept sections that might reference the toc.
9249          Check the toc itself last.  */
9250       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9251                   : ibfd->sections);
9252            sec != NULL;
9253            sec = (sec == toc ? NULL
9254                   : sec->next == NULL ? toc
9255                   : sec->next == toc && toc->next ? toc->next
9256                   : sec->next))
9257         {
9258           int repeat;
9259
9260           if (sec->reloc_count == 0
9261               || discarded_section (sec)
9262               || get_opd_info (sec)
9263               || (sec->flags & SEC_ALLOC) == 0
9264               || (sec->flags & SEC_DEBUGGING) != 0)
9265             continue;
9266
9267           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9268                                                 info->keep_memory);
9269           if (relstart == NULL)
9270             {
9271               free (used);
9272               goto error_ret;
9273             }
9274
9275           /* Mark toc entries referenced as used.  */
9276           do
9277             {
9278               repeat = 0;
9279               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9280                 {
9281                   enum elf_ppc64_reloc_type r_type;
9282                   unsigned long r_symndx;
9283                   asection *sym_sec;
9284                   struct elf_link_hash_entry *h;
9285                   Elf_Internal_Sym *sym;
9286                   bfd_vma val;
9287                   enum {no_check, check_lo, check_ha} insn_check;
9288
9289                   r_type = ELF64_R_TYPE (rel->r_info);
9290                   switch (r_type)
9291                     {
9292                     default:
9293                       insn_check = no_check;
9294                       break;
9295
9296                     case R_PPC64_GOT_TLSLD16_HA:
9297                     case R_PPC64_GOT_TLSGD16_HA:
9298                     case R_PPC64_GOT_TPREL16_HA:
9299                     case R_PPC64_GOT_DTPREL16_HA:
9300                     case R_PPC64_GOT16_HA:
9301                     case R_PPC64_TOC16_HA:
9302                       insn_check = check_ha;
9303                       break;
9304
9305                     case R_PPC64_GOT_TLSLD16_LO:
9306                     case R_PPC64_GOT_TLSGD16_LO:
9307                     case R_PPC64_GOT_TPREL16_LO_DS:
9308                     case R_PPC64_GOT_DTPREL16_LO_DS:
9309                     case R_PPC64_GOT16_LO:
9310                     case R_PPC64_GOT16_LO_DS:
9311                     case R_PPC64_TOC16_LO:
9312                     case R_PPC64_TOC16_LO_DS:
9313                       insn_check = check_lo;
9314                       break;
9315                     }
9316
9317                   if (insn_check != no_check)
9318                     {
9319                       bfd_vma off = rel->r_offset & ~3;
9320                       unsigned char buf[4];
9321                       unsigned int insn;
9322
9323                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9324                         {
9325                           free (used);
9326                           goto error_ret;
9327                         }
9328                       insn = bfd_get_32 (ibfd, buf);
9329                       if (insn_check == check_lo
9330                           ? !ok_lo_toc_insn (insn, r_type)
9331                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9332                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9333                         {
9334                           char str[12];
9335
9336                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9337                           sprintf (str, "%#08x", insn);
9338                           info->callbacks->einfo
9339                             /* xgettext:c-format */
9340                             (_("%H: toc optimization is not supported for"
9341                                " %s instruction.\n"),
9342                              ibfd, sec, rel->r_offset & ~3, str);
9343                         }
9344                     }
9345
9346                   switch (r_type)
9347                     {
9348                     case R_PPC64_TOC16:
9349                     case R_PPC64_TOC16_LO:
9350                     case R_PPC64_TOC16_HI:
9351                     case R_PPC64_TOC16_HA:
9352                     case R_PPC64_TOC16_DS:
9353                     case R_PPC64_TOC16_LO_DS:
9354                       /* In case we're taking addresses of toc entries.  */
9355                     case R_PPC64_ADDR64:
9356                       break;
9357
9358                     default:
9359                       continue;
9360                     }
9361
9362                   r_symndx = ELF64_R_SYM (rel->r_info);
9363                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9364                                   r_symndx, ibfd))
9365                     {
9366                       free (used);
9367                       goto error_ret;
9368                     }
9369
9370                   if (sym_sec != toc)
9371                     continue;
9372
9373                   if (h != NULL)
9374                     val = h->root.u.def.value;
9375                   else
9376                     val = sym->st_value;
9377                   val += rel->r_addend;
9378
9379                   if (val >= toc->size)
9380                     continue;
9381
9382                   if ((skip[val >> 3] & can_optimize) != 0)
9383                     {
9384                       bfd_vma off;
9385                       unsigned char opc;
9386
9387                       switch (r_type)
9388                         {
9389                         case R_PPC64_TOC16_HA:
9390                           break;
9391
9392                         case R_PPC64_TOC16_LO_DS:
9393                           off = rel->r_offset;
9394                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9395                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9396                                                          off, 1))
9397                             {
9398                               free (used);
9399                               goto error_ret;
9400                             }
9401                           if ((opc & (0x3f << 2)) == (58u << 2))
9402                             break;
9403                           /* Fall through.  */
9404
9405                         default:
9406                           /* Wrong sort of reloc, or not a ld.  We may
9407                              as well clear ref_from_discarded too.  */
9408                           skip[val >> 3] = 0;
9409                         }
9410                     }
9411
9412                   if (sec != toc)
9413                     used[val >> 3] = 1;
9414                   /* For the toc section, we only mark as used if this
9415                      entry itself isn't unused.  */
9416                   else if ((used[rel->r_offset >> 3]
9417                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9418                            && !used[val >> 3])
9419                     {
9420                       /* Do all the relocs again, to catch reference
9421                          chains.  */
9422                       repeat = 1;
9423                       used[val >> 3] = 1;
9424                     }
9425                 }
9426             }
9427           while (repeat);
9428
9429           if (elf_section_data (sec)->relocs != relstart)
9430             free (relstart);
9431         }
9432
9433       /* Merge the used and skip arrays.  Assume that TOC
9434          doublewords not appearing as either used or unused belong
9435          to an entry more than one doubleword in size.  */
9436       for (drop = skip, keep = used, last = 0, some_unused = 0;
9437            drop < skip + (toc->size + 7) / 8;
9438            ++drop, ++keep)
9439         {
9440           if (*keep)
9441             {
9442               *drop &= ~ref_from_discarded;
9443               if ((*drop & can_optimize) != 0)
9444                 some_unused = 1;
9445               last = 0;
9446             }
9447           else if ((*drop & ref_from_discarded) != 0)
9448             {
9449               some_unused = 1;
9450               last = ref_from_discarded;
9451             }
9452           else
9453             *drop = last;
9454         }
9455
9456       free (used);
9457
9458       if (some_unused)
9459         {
9460           bfd_byte *contents, *src;
9461           unsigned long off;
9462           Elf_Internal_Sym *sym;
9463           bfd_boolean local_toc_syms = FALSE;
9464
9465           /* Shuffle the toc contents, and at the same time convert the
9466              skip array from booleans into offsets.  */
9467           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9468             goto error_ret;
9469
9470           elf_section_data (toc)->this_hdr.contents = contents;
9471
9472           for (src = contents, off = 0, drop = skip;
9473                src < contents + toc->size;
9474                src += 8, ++drop)
9475             {
9476               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9477                 off += 8;
9478               else if (off != 0)
9479                 {
9480                   *drop = off;
9481                   memcpy (src - off, src, 8);
9482                 }
9483             }
9484           *drop = off;
9485           toc->rawsize = toc->size;
9486           toc->size = src - contents - off;
9487
9488           /* Adjust addends for relocs against the toc section sym,
9489              and optimize any accesses we can.  */
9490           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9491             {
9492               if (sec->reloc_count == 0
9493                   || discarded_section (sec))
9494                 continue;
9495
9496               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9497                                                     info->keep_memory);
9498               if (relstart == NULL)
9499                 goto error_ret;
9500
9501               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9502                 {
9503                   enum elf_ppc64_reloc_type r_type;
9504                   unsigned long r_symndx;
9505                   asection *sym_sec;
9506                   struct elf_link_hash_entry *h;
9507                   bfd_vma val;
9508
9509                   r_type = ELF64_R_TYPE (rel->r_info);
9510                   switch (r_type)
9511                     {
9512                     default:
9513                       continue;
9514
9515                     case R_PPC64_TOC16:
9516                     case R_PPC64_TOC16_LO:
9517                     case R_PPC64_TOC16_HI:
9518                     case R_PPC64_TOC16_HA:
9519                     case R_PPC64_TOC16_DS:
9520                     case R_PPC64_TOC16_LO_DS:
9521                     case R_PPC64_ADDR64:
9522                       break;
9523                     }
9524
9525                   r_symndx = ELF64_R_SYM (rel->r_info);
9526                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9527                                   r_symndx, ibfd))
9528                     goto error_ret;
9529
9530                   if (sym_sec != toc)
9531                     continue;
9532
9533                   if (h != NULL)
9534                     val = h->root.u.def.value;
9535                   else
9536                     {
9537                       val = sym->st_value;
9538                       if (val != 0)
9539                         local_toc_syms = TRUE;
9540                     }
9541
9542                   val += rel->r_addend;
9543
9544                   if (val > toc->rawsize)
9545                     val = toc->rawsize;
9546                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9547                     continue;
9548                   else if ((skip[val >> 3] & can_optimize) != 0)
9549                     {
9550                       Elf_Internal_Rela *tocrel
9551                         = toc_relocs + (skip[val >> 3] >> 2);
9552                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9553
9554                       switch (r_type)
9555                         {
9556                         case R_PPC64_TOC16_HA:
9557                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9558                           break;
9559
9560                         case R_PPC64_TOC16_LO_DS:
9561                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9562                           break;
9563
9564                         default:
9565                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9566                             ppc_howto_init ();
9567                           info->callbacks->einfo
9568                             /* xgettext:c-format */
9569                             (_("%H: %s references "
9570                                "optimized away TOC entry\n"),
9571                              ibfd, sec, rel->r_offset,
9572                              ppc64_elf_howto_table[r_type]->name);
9573                           bfd_set_error (bfd_error_bad_value);
9574                           goto error_ret;
9575                         }
9576                       rel->r_addend = tocrel->r_addend;
9577                       elf_section_data (sec)->relocs = relstart;
9578                       continue;
9579                     }
9580
9581                   if (h != NULL || sym->st_value != 0)
9582                     continue;
9583
9584                   rel->r_addend -= skip[val >> 3];
9585                   elf_section_data (sec)->relocs = relstart;
9586                 }
9587
9588               if (elf_section_data (sec)->relocs != relstart)
9589                 free (relstart);
9590             }
9591
9592           /* We shouldn't have local or global symbols defined in the TOC,
9593              but handle them anyway.  */
9594           if (local_syms != NULL)
9595             for (sym = local_syms;
9596                  sym < local_syms + symtab_hdr->sh_info;
9597                  ++sym)
9598               if (sym->st_value != 0
9599                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9600                 {
9601                   unsigned long i;
9602
9603                   if (sym->st_value > toc->rawsize)
9604                     i = toc->rawsize >> 3;
9605                   else
9606                     i = sym->st_value >> 3;
9607
9608                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9609                     {
9610                       if (local_toc_syms)
9611                         _bfd_error_handler
9612                           (_("%s defined on removed toc entry"),
9613                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9614                       do
9615                         ++i;
9616                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9617                       sym->st_value = (bfd_vma) i << 3;
9618                     }
9619
9620                   sym->st_value -= skip[i];
9621                   symtab_hdr->contents = (unsigned char *) local_syms;
9622                 }
9623
9624           /* Adjust any global syms defined in this toc input section.  */
9625           if (toc_inf.global_toc_syms)
9626             {
9627               toc_inf.toc = toc;
9628               toc_inf.skip = skip;
9629               toc_inf.global_toc_syms = FALSE;
9630               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9631                                       &toc_inf);
9632             }
9633
9634           if (toc->reloc_count != 0)
9635             {
9636               Elf_Internal_Shdr *rel_hdr;
9637               Elf_Internal_Rela *wrel;
9638               bfd_size_type sz;
9639
9640               /* Remove unused toc relocs, and adjust those we keep.  */
9641               if (toc_relocs == NULL)
9642                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9643                                                         info->keep_memory);
9644               if (toc_relocs == NULL)
9645                 goto error_ret;
9646
9647               wrel = toc_relocs;
9648               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9649                 if ((skip[rel->r_offset >> 3]
9650                      & (ref_from_discarded | can_optimize)) == 0)
9651                   {
9652                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9653                     wrel->r_info = rel->r_info;
9654                     wrel->r_addend = rel->r_addend;
9655                     ++wrel;
9656                   }
9657                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9658                                             &local_syms, NULL, NULL))
9659                   goto error_ret;
9660
9661               elf_section_data (toc)->relocs = toc_relocs;
9662               toc->reloc_count = wrel - toc_relocs;
9663               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9664               sz = rel_hdr->sh_entsize;
9665               rel_hdr->sh_size = toc->reloc_count * sz;
9666             }
9667         }
9668       else if (toc_relocs != NULL
9669                && elf_section_data (toc)->relocs != toc_relocs)
9670         free (toc_relocs);
9671
9672       if (local_syms != NULL
9673           && symtab_hdr->contents != (unsigned char *) local_syms)
9674         {
9675           if (!info->keep_memory)
9676             free (local_syms);
9677           else
9678             symtab_hdr->contents = (unsigned char *) local_syms;
9679         }
9680       free (skip);
9681     }
9682
9683   return TRUE;
9684 }
9685
9686 /* Return true iff input section I references the TOC using
9687    instructions limited to +/-32k offsets.  */
9688
9689 bfd_boolean
9690 ppc64_elf_has_small_toc_reloc (asection *i)
9691 {
9692   return (is_ppc64_elf (i->owner)
9693           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9694 }
9695
9696 /* Allocate space for one GOT entry.  */
9697
9698 static void
9699 allocate_got (struct elf_link_hash_entry *h,
9700               struct bfd_link_info *info,
9701               struct got_entry *gent)
9702 {
9703   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9704   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9705   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9706                  ? 16 : 8);
9707   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9708                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9709   asection *got = ppc64_elf_tdata (gent->owner)->got;
9710
9711   gent->got.offset = got->size;
9712   got->size += entsize;
9713
9714   if (h->type == STT_GNU_IFUNC)
9715     {
9716       htab->elf.irelplt->size += rentsize;
9717       htab->got_reli_size += rentsize;
9718     }
9719   else if ((bfd_link_pic (info)
9720             || (htab->elf.dynamic_sections_created
9721                 && h->dynindx != -1
9722                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9723            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9724     {
9725       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9726       relgot->size += rentsize;
9727     }
9728 }
9729
9730 /* This function merges got entries in the same toc group.  */
9731
9732 static void
9733 merge_got_entries (struct got_entry **pent)
9734 {
9735   struct got_entry *ent, *ent2;
9736
9737   for (ent = *pent; ent != NULL; ent = ent->next)
9738     if (!ent->is_indirect)
9739       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9740         if (!ent2->is_indirect
9741             && ent2->addend == ent->addend
9742             && ent2->tls_type == ent->tls_type
9743             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9744           {
9745             ent2->is_indirect = TRUE;
9746             ent2->got.ent = ent;
9747           }
9748 }
9749
9750 /* If H is undefined, make it dynamic if that makes sense.  */
9751
9752 static bfd_boolean
9753 ensure_undef_dynamic (struct bfd_link_info *info,
9754                       struct elf_link_hash_entry *h)
9755 {
9756   struct elf_link_hash_table *htab = elf_hash_table (info);
9757
9758   if (htab->dynamic_sections_created
9759       && ((info->dynamic_undefined_weak != 0
9760            && h->root.type == bfd_link_hash_undefweak)
9761           || h->root.type == bfd_link_hash_undefined)
9762       && h->dynindx == -1
9763       && !h->forced_local
9764       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9765     return bfd_elf_link_record_dynamic_symbol (info, h);
9766   return TRUE;
9767 }
9768
9769 /* Allocate space in .plt, .got and associated reloc sections for
9770    dynamic relocs.  */
9771
9772 static bfd_boolean
9773 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9774 {
9775   struct bfd_link_info *info;
9776   struct ppc_link_hash_table *htab;
9777   asection *s;
9778   struct ppc_link_hash_entry *eh;
9779   struct got_entry **pgent, *gent;
9780
9781   if (h->root.type == bfd_link_hash_indirect)
9782     return TRUE;
9783
9784   info = (struct bfd_link_info *) inf;
9785   htab = ppc_hash_table (info);
9786   if (htab == NULL)
9787     return FALSE;
9788
9789   eh = (struct ppc_link_hash_entry *) h;
9790   /* Run through the TLS GD got entries first if we're changing them
9791      to TPREL.  */
9792   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9793     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9794       if (gent->got.refcount > 0
9795           && (gent->tls_type & TLS_GD) != 0)
9796         {
9797           /* This was a GD entry that has been converted to TPREL.  If
9798              there happens to be a TPREL entry we can use that one.  */
9799           struct got_entry *ent;
9800           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9801             if (ent->got.refcount > 0
9802                 && (ent->tls_type & TLS_TPREL) != 0
9803                 && ent->addend == gent->addend
9804                 && ent->owner == gent->owner)
9805               {
9806                 gent->got.refcount = 0;
9807                 break;
9808               }
9809
9810           /* If not, then we'll be using our own TPREL entry.  */
9811           if (gent->got.refcount != 0)
9812             gent->tls_type = TLS_TLS | TLS_TPREL;
9813         }
9814
9815   /* Remove any list entry that won't generate a word in the GOT before
9816      we call merge_got_entries.  Otherwise we risk merging to empty
9817      entries.  */
9818   pgent = &h->got.glist;
9819   while ((gent = *pgent) != NULL)
9820     if (gent->got.refcount > 0)
9821       {
9822         if ((gent->tls_type & TLS_LD) != 0
9823             && !h->def_dynamic)
9824           {
9825             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9826             *pgent = gent->next;
9827           }
9828         else
9829           pgent = &gent->next;
9830       }
9831     else
9832       *pgent = gent->next;
9833
9834   if (!htab->do_multi_toc)
9835     merge_got_entries (&h->got.glist);
9836
9837   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9838     if (!gent->is_indirect)
9839       {
9840         /* Make sure this symbol is output as a dynamic symbol.  */
9841         if (!ensure_undef_dynamic (info, h))
9842           return FALSE;
9843
9844         if (!is_ppc64_elf (gent->owner))
9845           abort ();
9846
9847         allocate_got (h, info, gent);
9848       }
9849
9850   /* If no dynamic sections we can't have dynamic relocs, except for
9851      IFUNCs which are handled even in static executables.  */
9852   if (!htab->elf.dynamic_sections_created
9853       && h->type != STT_GNU_IFUNC)
9854     eh->dyn_relocs = NULL;
9855
9856   /* Also discard relocs on undefined weak syms with non-default
9857      visibility, or when dynamic_undefined_weak says so.  */
9858   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9859     eh->dyn_relocs = NULL;
9860
9861   if (eh->dyn_relocs != NULL)
9862     {
9863       struct elf_dyn_relocs *p, **pp;
9864
9865       /* In the shared -Bsymbolic case, discard space allocated for
9866          dynamic pc-relative relocs against symbols which turn out to
9867          be defined in regular objects.  For the normal shared case,
9868          discard space for relocs that have become local due to symbol
9869          visibility changes.  */
9870
9871       if (bfd_link_pic (info))
9872         {
9873           /* Relocs that use pc_count are those that appear on a call
9874              insn, or certain REL relocs (see must_be_dyn_reloc) that
9875              can be generated via assembly.  We want calls to
9876              protected symbols to resolve directly to the function
9877              rather than going via the plt.  If people want function
9878              pointer comparisons to work as expected then they should
9879              avoid writing weird assembly.  */
9880           if (SYMBOL_CALLS_LOCAL (info, h))
9881             {
9882               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9883                 {
9884                   p->count -= p->pc_count;
9885                   p->pc_count = 0;
9886                   if (p->count == 0)
9887                     *pp = p->next;
9888                   else
9889                     pp = &p->next;
9890                 }
9891             }
9892
9893           if (eh->dyn_relocs != NULL)
9894             {
9895               /* Make sure this symbol is output as a dynamic symbol.  */
9896               if (!ensure_undef_dynamic (info, h))
9897                 return FALSE;
9898             }
9899         }
9900       else if (h->type == STT_GNU_IFUNC)
9901         {
9902           /* A plt entry is always created when making direct calls to
9903              an ifunc, even when building a static executable, but
9904              that doesn't cover all cases.  We may have only an ifunc
9905              initialised function pointer for a given ifunc symbol.
9906
9907              For ELFv2, dynamic relocations are not required when
9908              generating a global entry PLT stub.  */
9909           if (abiversion (info->output_bfd) >= 2)
9910             {
9911               if (global_entry_stub (h))
9912                 eh->dyn_relocs = NULL;
9913             }
9914
9915           /* For ELFv1 we have function descriptors.  Descriptors need
9916              to be treated like PLT entries and thus have dynamic
9917              relocations.  One exception is when the function
9918              descriptor is copied into .dynbss (which should only
9919              happen with ancient versions of gcc).  */
9920           else if (h->needs_copy)
9921             eh->dyn_relocs = NULL;
9922         }
9923       else if (ELIMINATE_COPY_RELOCS)
9924         {
9925           /* For the non-pic case, discard space for relocs against
9926              symbols which turn out to need copy relocs or are not
9927              dynamic.  */
9928           if (!h->non_got_ref
9929               && !h->def_regular)
9930             {
9931               /* Make sure this symbol is output as a dynamic symbol.  */
9932               if (!ensure_undef_dynamic (info, h))
9933                 return FALSE;
9934
9935               if (h->dynindx == -1)
9936                 eh->dyn_relocs = NULL;
9937             }
9938           else
9939             eh->dyn_relocs = NULL;
9940         }
9941
9942       /* Finally, allocate space.  */
9943       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9944         {
9945           asection *sreloc = elf_section_data (p->sec)->sreloc;
9946           if (eh->elf.type == STT_GNU_IFUNC)
9947             sreloc = htab->elf.irelplt;
9948           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9949         }
9950     }
9951
9952   if ((htab->elf.dynamic_sections_created
9953        && h->dynindx != -1)
9954       || h->type == STT_GNU_IFUNC)
9955     {
9956       struct plt_entry *pent;
9957       bfd_boolean doneone = FALSE;
9958       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9959         if (pent->plt.refcount > 0)
9960           {
9961             if (!htab->elf.dynamic_sections_created
9962                 || h->dynindx == -1)
9963               {
9964                 s = htab->elf.iplt;
9965                 pent->plt.offset = s->size;
9966                 s->size += PLT_ENTRY_SIZE (htab);
9967                 s = htab->elf.irelplt;
9968               }
9969             else
9970               {
9971                 /* If this is the first .plt entry, make room for the special
9972                    first entry.  */
9973                 s = htab->elf.splt;
9974                 if (s->size == 0)
9975                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9976
9977                 pent->plt.offset = s->size;
9978
9979                 /* Make room for this entry.  */
9980                 s->size += PLT_ENTRY_SIZE (htab);
9981
9982                 /* Make room for the .glink code.  */
9983                 s = htab->glink;
9984                 if (s->size == 0)
9985                   s->size += GLINK_CALL_STUB_SIZE;
9986                 if (htab->opd_abi)
9987                   {
9988                     /* We need bigger stubs past index 32767.  */
9989                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9990                       s->size += 4;
9991                     s->size += 2*4;
9992                   }
9993                 else
9994                   s->size += 4;
9995
9996                 /* We also need to make an entry in the .rela.plt section.  */
9997                 s = htab->elf.srelplt;
9998               }
9999             s->size += sizeof (Elf64_External_Rela);
10000             doneone = TRUE;
10001           }
10002         else
10003           pent->plt.offset = (bfd_vma) -1;
10004       if (!doneone)
10005         {
10006           h->plt.plist = NULL;
10007           h->needs_plt = 0;
10008         }
10009     }
10010   else
10011     {
10012       h->plt.plist = NULL;
10013       h->needs_plt = 0;
10014     }
10015
10016   return TRUE;
10017 }
10018
10019 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10020    to set up space for global entry stubs.  These are put in glink,
10021    after the branch table.  */
10022
10023 static bfd_boolean
10024 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10025 {
10026   struct bfd_link_info *info;
10027   struct ppc_link_hash_table *htab;
10028   struct plt_entry *pent;
10029   asection *s;
10030
10031   if (h->root.type == bfd_link_hash_indirect)
10032     return TRUE;
10033
10034   if (!h->pointer_equality_needed)
10035     return TRUE;
10036
10037   if (h->def_regular)
10038     return TRUE;
10039
10040   info = inf;
10041   htab = ppc_hash_table (info);
10042   if (htab == NULL)
10043     return FALSE;
10044
10045   s = htab->glink;
10046   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10047     if (pent->plt.offset != (bfd_vma) -1
10048         && pent->addend == 0)
10049       {
10050         /* For ELFv2, if this symbol is not defined in a regular file
10051            and we are not generating a shared library or pie, then we
10052            need to define the symbol in the executable on a call stub.
10053            This is to avoid text relocations.  */
10054         s->size = (s->size + 15) & -16;
10055         h->root.type = bfd_link_hash_defined;
10056         h->root.u.def.section = s;
10057         h->root.u.def.value = s->size;
10058         s->size += 16;
10059         break;
10060       }
10061   return TRUE;
10062 }
10063
10064 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10065    read-only sections.  */
10066
10067 static bfd_boolean
10068 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10069 {
10070   if (h->root.type == bfd_link_hash_indirect)
10071     return TRUE;
10072
10073   if (readonly_dynrelocs (h))
10074     {
10075       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10076
10077       /* Not an error, just cut short the traversal.  */
10078       return FALSE;
10079     }
10080   return TRUE;
10081 }
10082
10083 /* Set the sizes of the dynamic sections.  */
10084
10085 static bfd_boolean
10086 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10087                                  struct bfd_link_info *info)
10088 {
10089   struct ppc_link_hash_table *htab;
10090   bfd *dynobj;
10091   asection *s;
10092   bfd_boolean relocs;
10093   bfd *ibfd;
10094   struct got_entry *first_tlsld;
10095
10096   htab = ppc_hash_table (info);
10097   if (htab == NULL)
10098     return FALSE;
10099
10100   dynobj = htab->elf.dynobj;
10101   if (dynobj == NULL)
10102     abort ();
10103
10104   if (htab->elf.dynamic_sections_created)
10105     {
10106       /* Set the contents of the .interp section to the interpreter.  */
10107       if (bfd_link_executable (info) && !info->nointerp)
10108         {
10109           s = bfd_get_linker_section (dynobj, ".interp");
10110           if (s == NULL)
10111             abort ();
10112           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10113           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10114         }
10115     }
10116
10117   /* Set up .got offsets for local syms, and space for local dynamic
10118      relocs.  */
10119   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10120     {
10121       struct got_entry **lgot_ents;
10122       struct got_entry **end_lgot_ents;
10123       struct plt_entry **local_plt;
10124       struct plt_entry **end_local_plt;
10125       unsigned char *lgot_masks;
10126       bfd_size_type locsymcount;
10127       Elf_Internal_Shdr *symtab_hdr;
10128
10129       if (!is_ppc64_elf (ibfd))
10130         continue;
10131
10132       for (s = ibfd->sections; s != NULL; s = s->next)
10133         {
10134           struct ppc_dyn_relocs *p;
10135
10136           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10137             {
10138               if (!bfd_is_abs_section (p->sec)
10139                   && bfd_is_abs_section (p->sec->output_section))
10140                 {
10141                   /* Input section has been discarded, either because
10142                      it is a copy of a linkonce section or due to
10143                      linker script /DISCARD/, so we'll be discarding
10144                      the relocs too.  */
10145                 }
10146               else if (p->count != 0)
10147                 {
10148                   asection *srel = elf_section_data (p->sec)->sreloc;
10149                   if (p->ifunc)
10150                     srel = htab->elf.irelplt;
10151                   srel->size += p->count * sizeof (Elf64_External_Rela);
10152                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10153                     info->flags |= DF_TEXTREL;
10154                 }
10155             }
10156         }
10157
10158       lgot_ents = elf_local_got_ents (ibfd);
10159       if (!lgot_ents)
10160         continue;
10161
10162       symtab_hdr = &elf_symtab_hdr (ibfd);
10163       locsymcount = symtab_hdr->sh_info;
10164       end_lgot_ents = lgot_ents + locsymcount;
10165       local_plt = (struct plt_entry **) end_lgot_ents;
10166       end_local_plt = local_plt + locsymcount;
10167       lgot_masks = (unsigned char *) end_local_plt;
10168       s = ppc64_elf_tdata (ibfd)->got;
10169       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10170         {
10171           struct got_entry **pent, *ent;
10172
10173           pent = lgot_ents;
10174           while ((ent = *pent) != NULL)
10175             if (ent->got.refcount > 0)
10176               {
10177                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10178                   {
10179                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10180                     *pent = ent->next;
10181                   }
10182                 else
10183                   {
10184                     unsigned int ent_size = 8;
10185                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10186
10187                     ent->got.offset = s->size;
10188                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10189                       {
10190                         ent_size *= 2;
10191                         rel_size *= 2;
10192                       }
10193                     s->size += ent_size;
10194                     if ((*lgot_masks & PLT_IFUNC) != 0)
10195                       {
10196                         htab->elf.irelplt->size += rel_size;
10197                         htab->got_reli_size += rel_size;
10198                       }
10199                     else if (bfd_link_pic (info))
10200                       {
10201                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10202                         srel->size += rel_size;
10203                       }
10204                     pent = &ent->next;
10205                   }
10206               }
10207             else
10208               *pent = ent->next;
10209         }
10210
10211       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10212       for (; local_plt < end_local_plt; ++local_plt)
10213         {
10214           struct plt_entry *ent;
10215
10216           for (ent = *local_plt; ent != NULL; ent = ent->next)
10217             if (ent->plt.refcount > 0)
10218               {
10219                 s = htab->elf.iplt;
10220                 ent->plt.offset = s->size;
10221                 s->size += PLT_ENTRY_SIZE (htab);
10222
10223                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10224               }
10225             else
10226               ent->plt.offset = (bfd_vma) -1;
10227         }
10228     }
10229
10230   /* Allocate global sym .plt and .got entries, and space for global
10231      sym dynamic relocs.  */
10232   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10233   /* Stash the end of glink branch table.  */
10234   if (htab->glink != NULL)
10235     htab->glink->rawsize = htab->glink->size;
10236
10237   if (!htab->opd_abi && !bfd_link_pic (info))
10238     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10239
10240   first_tlsld = NULL;
10241   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10242     {
10243       struct got_entry *ent;
10244
10245       if (!is_ppc64_elf (ibfd))
10246         continue;
10247
10248       ent = ppc64_tlsld_got (ibfd);
10249       if (ent->got.refcount > 0)
10250         {
10251           if (!htab->do_multi_toc && first_tlsld != NULL)
10252             {
10253               ent->is_indirect = TRUE;
10254               ent->got.ent = first_tlsld;
10255             }
10256           else
10257             {
10258               if (first_tlsld == NULL)
10259                 first_tlsld = ent;
10260               s = ppc64_elf_tdata (ibfd)->got;
10261               ent->got.offset = s->size;
10262               ent->owner = ibfd;
10263               s->size += 16;
10264               if (bfd_link_pic (info))
10265                 {
10266                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10267                   srel->size += sizeof (Elf64_External_Rela);
10268                 }
10269             }
10270         }
10271       else
10272         ent->got.offset = (bfd_vma) -1;
10273     }
10274
10275   /* We now have determined the sizes of the various dynamic sections.
10276      Allocate memory for them.  */
10277   relocs = FALSE;
10278   for (s = dynobj->sections; s != NULL; s = s->next)
10279     {
10280       if ((s->flags & SEC_LINKER_CREATED) == 0)
10281         continue;
10282
10283       if (s == htab->brlt || s == htab->relbrlt)
10284         /* These haven't been allocated yet;  don't strip.  */
10285         continue;
10286       else if (s == htab->elf.sgot
10287                || s == htab->elf.splt
10288                || s == htab->elf.iplt
10289                || s == htab->glink
10290                || s == htab->elf.sdynbss
10291                || s == htab->elf.sdynrelro)
10292         {
10293           /* Strip this section if we don't need it; see the
10294              comment below.  */
10295         }
10296       else if (s == htab->glink_eh_frame)
10297         {
10298           if (!bfd_is_abs_section (s->output_section))
10299             /* Not sized yet.  */
10300             continue;
10301         }
10302       else if (CONST_STRNEQ (s->name, ".rela"))
10303         {
10304           if (s->size != 0)
10305             {
10306               if (s != htab->elf.srelplt)
10307                 relocs = TRUE;
10308
10309               /* We use the reloc_count field as a counter if we need
10310                  to copy relocs into the output file.  */
10311               s->reloc_count = 0;
10312             }
10313         }
10314       else
10315         {
10316           /* It's not one of our sections, so don't allocate space.  */
10317           continue;
10318         }
10319
10320       if (s->size == 0)
10321         {
10322           /* If we don't need this section, strip it from the
10323              output file.  This is mostly to handle .rela.bss and
10324              .rela.plt.  We must create both sections in
10325              create_dynamic_sections, because they must be created
10326              before the linker maps input sections to output
10327              sections.  The linker does that before
10328              adjust_dynamic_symbol is called, and it is that
10329              function which decides whether anything needs to go
10330              into these sections.  */
10331           s->flags |= SEC_EXCLUDE;
10332           continue;
10333         }
10334
10335       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10336         continue;
10337
10338       /* Allocate memory for the section contents.  We use bfd_zalloc
10339          here in case unused entries are not reclaimed before the
10340          section's contents are written out.  This should not happen,
10341          but this way if it does we get a R_PPC64_NONE reloc in .rela
10342          sections instead of garbage.
10343          We also rely on the section contents being zero when writing
10344          the GOT and .dynrelro.  */
10345       s->contents = bfd_zalloc (dynobj, s->size);
10346       if (s->contents == NULL)
10347         return FALSE;
10348     }
10349
10350   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10351     {
10352       if (!is_ppc64_elf (ibfd))
10353         continue;
10354
10355       s = ppc64_elf_tdata (ibfd)->got;
10356       if (s != NULL && s != htab->elf.sgot)
10357         {
10358           if (s->size == 0)
10359             s->flags |= SEC_EXCLUDE;
10360           else
10361             {
10362               s->contents = bfd_zalloc (ibfd, s->size);
10363               if (s->contents == NULL)
10364                 return FALSE;
10365             }
10366         }
10367       s = ppc64_elf_tdata (ibfd)->relgot;
10368       if (s != NULL)
10369         {
10370           if (s->size == 0)
10371             s->flags |= SEC_EXCLUDE;
10372           else
10373             {
10374               s->contents = bfd_zalloc (ibfd, s->size);
10375               if (s->contents == NULL)
10376                 return FALSE;
10377               relocs = TRUE;
10378               s->reloc_count = 0;
10379             }
10380         }
10381     }
10382
10383   if (htab->elf.dynamic_sections_created)
10384     {
10385       bfd_boolean tls_opt;
10386
10387       /* Add some entries to the .dynamic section.  We fill in the
10388          values later, in ppc64_elf_finish_dynamic_sections, but we
10389          must add the entries now so that we get the correct size for
10390          the .dynamic section.  The DT_DEBUG entry is filled in by the
10391          dynamic linker and used by the debugger.  */
10392 #define add_dynamic_entry(TAG, VAL) \
10393   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10394
10395       if (bfd_link_executable (info))
10396         {
10397           if (!add_dynamic_entry (DT_DEBUG, 0))
10398             return FALSE;
10399         }
10400
10401       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10402         {
10403           if (!add_dynamic_entry (DT_PLTGOT, 0)
10404               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10405               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10406               || !add_dynamic_entry (DT_JMPREL, 0)
10407               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10408             return FALSE;
10409         }
10410
10411       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10412         {
10413           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10414               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10415             return FALSE;
10416         }
10417
10418       tls_opt = (htab->params->tls_get_addr_opt
10419                  && htab->tls_get_addr_fd != NULL
10420                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10421       if (tls_opt || !htab->opd_abi)
10422         {
10423           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10424             return FALSE;
10425         }
10426
10427       if (relocs)
10428         {
10429           if (!add_dynamic_entry (DT_RELA, 0)
10430               || !add_dynamic_entry (DT_RELASZ, 0)
10431               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10432             return FALSE;
10433
10434           /* If any dynamic relocs apply to a read-only section,
10435              then we need a DT_TEXTREL entry.  */
10436           if ((info->flags & DF_TEXTREL) == 0)
10437             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10438
10439           if ((info->flags & DF_TEXTREL) != 0)
10440             {
10441               if (!add_dynamic_entry (DT_TEXTREL, 0))
10442                 return FALSE;
10443             }
10444         }
10445     }
10446 #undef add_dynamic_entry
10447
10448   return TRUE;
10449 }
10450
10451 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10452
10453 static bfd_boolean
10454 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10455 {
10456   if (h->plt.plist != NULL
10457       && !h->def_regular
10458       && !h->pointer_equality_needed)
10459     return FALSE;
10460
10461   return _bfd_elf_hash_symbol (h);
10462 }
10463
10464 /* Determine the type of stub needed, if any, for a call.  */
10465
10466 static inline enum ppc_stub_type
10467 ppc_type_of_stub (asection *input_sec,
10468                   const Elf_Internal_Rela *rel,
10469                   struct ppc_link_hash_entry **hash,
10470                   struct plt_entry **plt_ent,
10471                   bfd_vma destination,
10472                   unsigned long local_off)
10473 {
10474   struct ppc_link_hash_entry *h = *hash;
10475   bfd_vma location;
10476   bfd_vma branch_offset;
10477   bfd_vma max_branch_offset;
10478   enum elf_ppc64_reloc_type r_type;
10479
10480   if (h != NULL)
10481     {
10482       struct plt_entry *ent;
10483       struct ppc_link_hash_entry *fdh = h;
10484       if (h->oh != NULL
10485           && h->oh->is_func_descriptor)
10486         {
10487           fdh = ppc_follow_link (h->oh);
10488           *hash = fdh;
10489         }
10490
10491       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10492         if (ent->addend == rel->r_addend
10493             && ent->plt.offset != (bfd_vma) -1)
10494           {
10495             *plt_ent = ent;
10496             return ppc_stub_plt_call;
10497           }
10498
10499       /* Here, we know we don't have a plt entry.  If we don't have a
10500          either a defined function descriptor or a defined entry symbol
10501          in a regular object file, then it is pointless trying to make
10502          any other type of stub.  */
10503       if (!is_static_defined (&fdh->elf)
10504           && !is_static_defined (&h->elf))
10505         return ppc_stub_none;
10506     }
10507   else if (elf_local_got_ents (input_sec->owner) != NULL)
10508     {
10509       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10510       struct plt_entry **local_plt = (struct plt_entry **)
10511         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10512       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10513
10514       if (local_plt[r_symndx] != NULL)
10515         {
10516           struct plt_entry *ent;
10517
10518           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10519             if (ent->addend == rel->r_addend
10520                 && ent->plt.offset != (bfd_vma) -1)
10521               {
10522                 *plt_ent = ent;
10523                 return ppc_stub_plt_call;
10524               }
10525         }
10526     }
10527
10528   /* Determine where the call point is.  */
10529   location = (input_sec->output_offset
10530               + input_sec->output_section->vma
10531               + rel->r_offset);
10532
10533   branch_offset = destination - location;
10534   r_type = ELF64_R_TYPE (rel->r_info);
10535
10536   /* Determine if a long branch stub is needed.  */
10537   max_branch_offset = 1 << 25;
10538   if (r_type != R_PPC64_REL24)
10539     max_branch_offset = 1 << 15;
10540
10541   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10542     /* We need a stub.  Figure out whether a long_branch or plt_branch
10543        is needed later.  */
10544     return ppc_stub_long_branch;
10545
10546   return ppc_stub_none;
10547 }
10548
10549 /* With power7 weakly ordered memory model, it is possible for ld.so
10550    to update a plt entry in one thread and have another thread see a
10551    stale zero toc entry.  To avoid this we need some sort of acquire
10552    barrier in the call stub.  One solution is to make the load of the
10553    toc word seem to appear to depend on the load of the function entry
10554    word.  Another solution is to test for r2 being zero, and branch to
10555    the appropriate glink entry if so.
10556
10557    .    fake dep barrier        compare
10558    .    ld 12,xxx(2)            ld 12,xxx(2)
10559    .    mtctr 12                mtctr 12
10560    .    xor 11,12,12            ld 2,xxx+8(2)
10561    .    add 2,2,11              cmpldi 2,0
10562    .    ld 2,xxx+8(2)           bnectr+
10563    .    bctr                    b <glink_entry>
10564
10565    The solution involving the compare turns out to be faster, so
10566    that's what we use unless the branch won't reach.  */
10567
10568 #define ALWAYS_USE_FAKE_DEP 0
10569 #define ALWAYS_EMIT_R2SAVE 0
10570
10571 #define PPC_LO(v) ((v) & 0xffff)
10572 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10573 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10574
10575 static inline unsigned int
10576 plt_stub_size (struct ppc_link_hash_table *htab,
10577                struct ppc_stub_hash_entry *stub_entry,
10578                bfd_vma off)
10579 {
10580   unsigned size = 12;
10581
10582   if (ALWAYS_EMIT_R2SAVE
10583       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10584     size += 4;
10585   if (PPC_HA (off) != 0)
10586     size += 4;
10587   if (htab->opd_abi)
10588     {
10589       size += 4;
10590       if (htab->params->plt_static_chain)
10591         size += 4;
10592       if (htab->params->plt_thread_safe
10593           && htab->elf.dynamic_sections_created
10594           && stub_entry->h != NULL
10595           && stub_entry->h->elf.dynindx != -1)
10596         size += 8;
10597       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10598         size += 4;
10599     }
10600   if (stub_entry->h != NULL
10601       && (stub_entry->h == htab->tls_get_addr_fd
10602           || stub_entry->h == htab->tls_get_addr)
10603       && htab->params->tls_get_addr_opt)
10604     {
10605       size += 7 * 4;
10606       if (ALWAYS_EMIT_R2SAVE
10607           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10608         size += 6 * 4;
10609     }
10610   return size;
10611 }
10612
10613 /* Depending on the sign of plt_stub_align:
10614    If positive, return the padding to align to a 2**plt_stub_align
10615    boundary.
10616    If negative, if this stub would cross fewer 2**plt_stub_align
10617    boundaries if we align, then return the padding needed to do so.  */
10618
10619 static inline unsigned int
10620 plt_stub_pad (struct ppc_link_hash_table *htab,
10621               struct ppc_stub_hash_entry *stub_entry,
10622               bfd_vma plt_off)
10623 {
10624   int stub_align;
10625   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10626   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10627
10628   if (htab->params->plt_stub_align >= 0)
10629     {
10630       stub_align = 1 << htab->params->plt_stub_align;
10631       if ((stub_off & (stub_align - 1)) != 0)
10632         return stub_align - (stub_off & (stub_align - 1));
10633       return 0;
10634     }
10635
10636   stub_align = 1 << -htab->params->plt_stub_align;
10637   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10638       > ((stub_size - 1) & -stub_align))
10639     return stub_align - (stub_off & (stub_align - 1));
10640   return 0;
10641 }
10642
10643 /* Build a .plt call stub.  */
10644
10645 static inline bfd_byte *
10646 build_plt_stub (struct ppc_link_hash_table *htab,
10647                 struct ppc_stub_hash_entry *stub_entry,
10648                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10649 {
10650   bfd *obfd = htab->params->stub_bfd;
10651   bfd_boolean plt_load_toc = htab->opd_abi;
10652   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10653   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10654                                  && htab->elf.dynamic_sections_created
10655                                  && stub_entry->h != NULL
10656                                  && stub_entry->h->elf.dynindx != -1);
10657   bfd_boolean use_fake_dep = plt_thread_safe;
10658   bfd_vma cmp_branch_off = 0;
10659
10660   if (!ALWAYS_USE_FAKE_DEP
10661       && plt_load_toc
10662       && plt_thread_safe
10663       && !((stub_entry->h == htab->tls_get_addr_fd
10664             || stub_entry->h == htab->tls_get_addr)
10665            && htab->params->tls_get_addr_opt))
10666     {
10667       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10668       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10669                           / PLT_ENTRY_SIZE (htab));
10670       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10671       bfd_vma to, from;
10672
10673       if (pltindex > 32768)
10674         glinkoff += (pltindex - 32768) * 4;
10675       to = (glinkoff
10676             + htab->glink->output_offset
10677             + htab->glink->output_section->vma);
10678       from = (p - stub_entry->group->stub_sec->contents
10679               + 4 * (ALWAYS_EMIT_R2SAVE
10680                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10681               + 4 * (PPC_HA (offset) != 0)
10682               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10683                      != PPC_HA (offset))
10684               + 4 * (plt_static_chain != 0)
10685               + 20
10686               + stub_entry->group->stub_sec->output_offset
10687               + stub_entry->group->stub_sec->output_section->vma);
10688       cmp_branch_off = to - from;
10689       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10690     }
10691
10692   if (PPC_HA (offset) != 0)
10693     {
10694       if (r != NULL)
10695         {
10696           if (ALWAYS_EMIT_R2SAVE
10697               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10698             r[0].r_offset += 4;
10699           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10700           r[1].r_offset = r[0].r_offset + 4;
10701           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10702           r[1].r_addend = r[0].r_addend;
10703           if (plt_load_toc)
10704             {
10705               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10706                 {
10707                   r[2].r_offset = r[1].r_offset + 4;
10708                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10709                   r[2].r_addend = r[0].r_addend;
10710                 }
10711               else
10712                 {
10713                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10714                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10715                   r[2].r_addend = r[0].r_addend + 8;
10716                   if (plt_static_chain)
10717                     {
10718                       r[3].r_offset = r[2].r_offset + 4;
10719                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10720                       r[3].r_addend = r[0].r_addend + 16;
10721                     }
10722                 }
10723             }
10724         }
10725       if (ALWAYS_EMIT_R2SAVE
10726           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10727         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10728       if (plt_load_toc)
10729         {
10730           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10731           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10732         }
10733       else
10734         {
10735           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10736           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10737         }
10738       if (plt_load_toc
10739           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10740         {
10741           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10742           offset = 0;
10743         }
10744       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10745       if (plt_load_toc)
10746         {
10747           if (use_fake_dep)
10748             {
10749               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10750               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10751             }
10752           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10753           if (plt_static_chain)
10754             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10755         }
10756     }
10757   else
10758     {
10759       if (r != NULL)
10760         {
10761           if (ALWAYS_EMIT_R2SAVE
10762               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10763             r[0].r_offset += 4;
10764           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10765           if (plt_load_toc)
10766             {
10767               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10768                 {
10769                   r[1].r_offset = r[0].r_offset + 4;
10770                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10771                   r[1].r_addend = r[0].r_addend;
10772                 }
10773               else
10774                 {
10775                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10776                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10777                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10778                   if (plt_static_chain)
10779                     {
10780                       r[2].r_offset = r[1].r_offset + 4;
10781                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10782                       r[2].r_addend = r[0].r_addend + 8;
10783                     }
10784                 }
10785             }
10786         }
10787       if (ALWAYS_EMIT_R2SAVE
10788           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10789         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10790       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10791       if (plt_load_toc
10792           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10793         {
10794           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10795           offset = 0;
10796         }
10797       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10798       if (plt_load_toc)
10799         {
10800           if (use_fake_dep)
10801             {
10802               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10803               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10804             }
10805           if (plt_static_chain)
10806             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10807           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10808         }
10809     }
10810   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10811     {
10812       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10813       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10814       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10815     }
10816   else
10817     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10818   return p;
10819 }
10820
10821 /* Build a special .plt call stub for __tls_get_addr.  */
10822
10823 #define LD_R11_0R3      0xe9630000
10824 #define LD_R12_0R3      0xe9830000
10825 #define MR_R0_R3        0x7c601b78
10826 #define CMPDI_R11_0     0x2c2b0000
10827 #define ADD_R3_R12_R13  0x7c6c6a14
10828 #define BEQLR           0x4d820020
10829 #define MR_R3_R0        0x7c030378
10830 #define STD_R11_0R1     0xf9610000
10831 #define BCTRL           0x4e800421
10832 #define LD_R11_0R1      0xe9610000
10833 #define MTLR_R11        0x7d6803a6
10834
10835 static inline bfd_byte *
10836 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10837                          struct ppc_stub_hash_entry *stub_entry,
10838                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10839 {
10840   bfd *obfd = htab->params->stub_bfd;
10841
10842   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10843   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10844   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10845   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10846   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10847   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10848   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10849   if (r != NULL)
10850     r[0].r_offset += 7 * 4;
10851   if (!ALWAYS_EMIT_R2SAVE
10852       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10853     return build_plt_stub (htab, stub_entry, p, offset, r);
10854
10855   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10856   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10857
10858   if (r != NULL)
10859     r[0].r_offset += 2 * 4;
10860   p = build_plt_stub (htab, stub_entry, p, offset, r);
10861   bfd_put_32 (obfd, BCTRL, p - 4);
10862
10863   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10864   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10865   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10866   bfd_put_32 (obfd, BLR, p),                    p += 4;
10867
10868   return p;
10869 }
10870
10871 static Elf_Internal_Rela *
10872 get_relocs (asection *sec, int count)
10873 {
10874   Elf_Internal_Rela *relocs;
10875   struct bfd_elf_section_data *elfsec_data;
10876
10877   elfsec_data = elf_section_data (sec);
10878   relocs = elfsec_data->relocs;
10879   if (relocs == NULL)
10880     {
10881       bfd_size_type relsize;
10882       relsize = sec->reloc_count * sizeof (*relocs);
10883       relocs = bfd_alloc (sec->owner, relsize);
10884       if (relocs == NULL)
10885         return NULL;
10886       elfsec_data->relocs = relocs;
10887       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10888                                           sizeof (Elf_Internal_Shdr));
10889       if (elfsec_data->rela.hdr == NULL)
10890         return NULL;
10891       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10892                                         * sizeof (Elf64_External_Rela));
10893       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10894       sec->reloc_count = 0;
10895     }
10896   relocs += sec->reloc_count;
10897   sec->reloc_count += count;
10898   return relocs;
10899 }
10900
10901 static bfd_vma
10902 get_r2off (struct bfd_link_info *info,
10903            struct ppc_stub_hash_entry *stub_entry)
10904 {
10905   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10906   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10907
10908   if (r2off == 0)
10909     {
10910       /* Support linking -R objects.  Get the toc pointer from the
10911          opd entry.  */
10912       char buf[8];
10913       if (!htab->opd_abi)
10914         return r2off;
10915       asection *opd = stub_entry->h->elf.root.u.def.section;
10916       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10917
10918       if (strcmp (opd->name, ".opd") != 0
10919           || opd->reloc_count != 0)
10920         {
10921           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10922                                   stub_entry->h->elf.root.root.string);
10923           bfd_set_error (bfd_error_bad_value);
10924           return (bfd_vma) -1;
10925         }
10926       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10927         return (bfd_vma) -1;
10928       r2off = bfd_get_64 (opd->owner, buf);
10929       r2off -= elf_gp (info->output_bfd);
10930     }
10931   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10932   return r2off;
10933 }
10934
10935 static bfd_boolean
10936 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10937 {
10938   struct ppc_stub_hash_entry *stub_entry;
10939   struct ppc_branch_hash_entry *br_entry;
10940   struct bfd_link_info *info;
10941   struct ppc_link_hash_table *htab;
10942   bfd_byte *loc;
10943   bfd_byte *p;
10944   bfd_vma dest, off;
10945   int size;
10946   Elf_Internal_Rela *r;
10947   asection *plt;
10948
10949   /* Massage our args to the form they really have.  */
10950   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10951   info = in_arg;
10952
10953   htab = ppc_hash_table (info);
10954   if (htab == NULL)
10955     return FALSE;
10956
10957   /* Make a note of the offset within the stubs for this entry.  */
10958   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10959   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10960
10961   htab->stub_count[stub_entry->stub_type - 1] += 1;
10962   switch (stub_entry->stub_type)
10963     {
10964     case ppc_stub_long_branch:
10965     case ppc_stub_long_branch_r2off:
10966       /* Branches are relative.  This is where we are going to.  */
10967       dest = (stub_entry->target_value
10968               + stub_entry->target_section->output_offset
10969               + stub_entry->target_section->output_section->vma);
10970       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10971       off = dest;
10972
10973       /* And this is where we are coming from.  */
10974       off -= (stub_entry->stub_offset
10975               + stub_entry->group->stub_sec->output_offset
10976               + stub_entry->group->stub_sec->output_section->vma);
10977
10978       size = 4;
10979       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10980         {
10981           bfd_vma r2off = get_r2off (info, stub_entry);
10982
10983           if (r2off == (bfd_vma) -1)
10984             {
10985               htab->stub_error = TRUE;
10986               return FALSE;
10987             }
10988           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10989           loc += 4;
10990           size = 8;
10991           if (PPC_HA (r2off) != 0)
10992             {
10993               bfd_put_32 (htab->params->stub_bfd,
10994                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10995               loc += 4;
10996               size += 4;
10997             }
10998           if (PPC_LO (r2off) != 0)
10999             {
11000               bfd_put_32 (htab->params->stub_bfd,
11001                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11002               loc += 4;
11003               size += 4;
11004             }
11005           off -= size - 4;
11006         }
11007       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
11008
11009       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11010         {
11011           info->callbacks->einfo
11012             (_("%P: long branch stub `%s' offset overflow\n"),
11013              stub_entry->root.string);
11014           htab->stub_error = TRUE;
11015           return FALSE;
11016         }
11017
11018       if (info->emitrelocations)
11019         {
11020           r = get_relocs (stub_entry->group->stub_sec, 1);
11021           if (r == NULL)
11022             return FALSE;
11023           r->r_offset = loc - stub_entry->group->stub_sec->contents;
11024           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11025           r->r_addend = dest;
11026           if (stub_entry->h != NULL)
11027             {
11028               struct elf_link_hash_entry **hashes;
11029               unsigned long symndx;
11030               struct ppc_link_hash_entry *h;
11031
11032               hashes = elf_sym_hashes (htab->params->stub_bfd);
11033               if (hashes == NULL)
11034                 {
11035                   bfd_size_type hsize;
11036
11037                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11038                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11039                   if (hashes == NULL)
11040                     return FALSE;
11041                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11042                   htab->stub_globals = 1;
11043                 }
11044               symndx = htab->stub_globals++;
11045               h = stub_entry->h;
11046               hashes[symndx] = &h->elf;
11047               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11048               if (h->oh != NULL && h->oh->is_func)
11049                 h = ppc_follow_link (h->oh);
11050               if (h->elf.root.u.def.section != stub_entry->target_section)
11051                 /* H is an opd symbol.  The addend must be zero.  */
11052                 r->r_addend = 0;
11053               else
11054                 {
11055                   off = (h->elf.root.u.def.value
11056                          + h->elf.root.u.def.section->output_offset
11057                          + h->elf.root.u.def.section->output_section->vma);
11058                   r->r_addend -= off;
11059                 }
11060             }
11061         }
11062       break;
11063
11064     case ppc_stub_plt_branch:
11065     case ppc_stub_plt_branch_r2off:
11066       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11067                                          stub_entry->root.string + 9,
11068                                          FALSE, FALSE);
11069       if (br_entry == NULL)
11070         {
11071           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
11072                                   stub_entry->root.string);
11073           htab->stub_error = TRUE;
11074           return FALSE;
11075         }
11076
11077       dest = (stub_entry->target_value
11078               + stub_entry->target_section->output_offset
11079               + stub_entry->target_section->output_section->vma);
11080       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11081         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11082
11083       bfd_put_64 (htab->brlt->owner, dest,
11084                   htab->brlt->contents + br_entry->offset);
11085
11086       if (br_entry->iter == htab->stub_iteration)
11087         {
11088           br_entry->iter = 0;
11089
11090           if (htab->relbrlt != NULL)
11091             {
11092               /* Create a reloc for the branch lookup table entry.  */
11093               Elf_Internal_Rela rela;
11094               bfd_byte *rl;
11095
11096               rela.r_offset = (br_entry->offset
11097                                + htab->brlt->output_offset
11098                                + htab->brlt->output_section->vma);
11099               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11100               rela.r_addend = dest;
11101
11102               rl = htab->relbrlt->contents;
11103               rl += (htab->relbrlt->reloc_count++
11104                      * sizeof (Elf64_External_Rela));
11105               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11106             }
11107           else if (info->emitrelocations)
11108             {
11109               r = get_relocs (htab->brlt, 1);
11110               if (r == NULL)
11111                 return FALSE;
11112               /* brlt, being SEC_LINKER_CREATED does not go through the
11113                  normal reloc processing.  Symbols and offsets are not
11114                  translated from input file to output file form, so
11115                  set up the offset per the output file.  */
11116               r->r_offset = (br_entry->offset
11117                              + htab->brlt->output_offset
11118                              + htab->brlt->output_section->vma);
11119               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11120               r->r_addend = dest;
11121             }
11122         }
11123
11124       dest = (br_entry->offset
11125               + htab->brlt->output_offset
11126               + htab->brlt->output_section->vma);
11127
11128       off = (dest
11129              - elf_gp (htab->brlt->output_section->owner)
11130              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11131
11132       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11133         {
11134           info->callbacks->einfo
11135             (_("%P: linkage table error against `%T'\n"),
11136              stub_entry->root.string);
11137           bfd_set_error (bfd_error_bad_value);
11138           htab->stub_error = TRUE;
11139           return FALSE;
11140         }
11141
11142       if (info->emitrelocations)
11143         {
11144           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11145           if (r == NULL)
11146             return FALSE;
11147           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11148           if (bfd_big_endian (info->output_bfd))
11149             r[0].r_offset += 2;
11150           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11151             r[0].r_offset += 4;
11152           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11153           r[0].r_addend = dest;
11154           if (PPC_HA (off) != 0)
11155             {
11156               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11157               r[1].r_offset = r[0].r_offset + 4;
11158               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11159               r[1].r_addend = r[0].r_addend;
11160             }
11161         }
11162
11163       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11164         {
11165           if (PPC_HA (off) != 0)
11166             {
11167               size = 16;
11168               bfd_put_32 (htab->params->stub_bfd,
11169                           ADDIS_R12_R2 | PPC_HA (off), loc);
11170               loc += 4;
11171               bfd_put_32 (htab->params->stub_bfd,
11172                           LD_R12_0R12 | PPC_LO (off), loc);
11173             }
11174           else
11175             {
11176               size = 12;
11177               bfd_put_32 (htab->params->stub_bfd,
11178                           LD_R12_0R2 | PPC_LO (off), loc);
11179             }
11180         }
11181       else
11182         {
11183           bfd_vma r2off = get_r2off (info, stub_entry);
11184
11185           if (r2off == (bfd_vma) -1)
11186             {
11187               htab->stub_error = TRUE;
11188               return FALSE;
11189             }
11190
11191           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11192           loc += 4;
11193           size = 16;
11194           if (PPC_HA (off) != 0)
11195             {
11196               size += 4;
11197               bfd_put_32 (htab->params->stub_bfd,
11198                           ADDIS_R12_R2 | PPC_HA (off), loc);
11199               loc += 4;
11200               bfd_put_32 (htab->params->stub_bfd,
11201                           LD_R12_0R12 | PPC_LO (off), loc);
11202             }
11203           else
11204             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11205
11206           if (PPC_HA (r2off) != 0)
11207             {
11208               size += 4;
11209               loc += 4;
11210               bfd_put_32 (htab->params->stub_bfd,
11211                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11212             }
11213           if (PPC_LO (r2off) != 0)
11214             {
11215               size += 4;
11216               loc += 4;
11217               bfd_put_32 (htab->params->stub_bfd,
11218                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11219             }
11220         }
11221       loc += 4;
11222       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11223       loc += 4;
11224       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11225       break;
11226
11227     case ppc_stub_plt_call:
11228     case ppc_stub_plt_call_r2save:
11229       if (stub_entry->h != NULL
11230           && stub_entry->h->is_func_descriptor
11231           && stub_entry->h->oh != NULL)
11232         {
11233           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11234
11235           /* If the old-ABI "dot-symbol" is undefined make it weak so
11236              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11237           if (fh->elf.root.type == bfd_link_hash_undefined
11238               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11239                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11240             fh->elf.root.type = bfd_link_hash_undefweak;
11241         }
11242
11243       /* Now build the stub.  */
11244       dest = stub_entry->plt_ent->plt.offset & ~1;
11245       if (dest >= (bfd_vma) -2)
11246         abort ();
11247
11248       plt = htab->elf.splt;
11249       if (!htab->elf.dynamic_sections_created
11250           || stub_entry->h == NULL
11251           || stub_entry->h->elf.dynindx == -1)
11252         plt = htab->elf.iplt;
11253
11254       dest += plt->output_offset + plt->output_section->vma;
11255
11256       if (stub_entry->h == NULL
11257           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11258         {
11259           Elf_Internal_Rela rela;
11260           bfd_byte *rl;
11261
11262           rela.r_offset = dest;
11263           if (htab->opd_abi)
11264             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11265           else
11266             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11267           rela.r_addend = (stub_entry->target_value
11268                            + stub_entry->target_section->output_offset
11269                            + stub_entry->target_section->output_section->vma);
11270
11271           rl = (htab->elf.irelplt->contents
11272                 + (htab->elf.irelplt->reloc_count++
11273                    * sizeof (Elf64_External_Rela)));
11274           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11275           stub_entry->plt_ent->plt.offset |= 1;
11276           htab->local_ifunc_resolver = 1;
11277         }
11278
11279       off = (dest
11280              - elf_gp (plt->output_section->owner)
11281              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11282
11283       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11284         {
11285           info->callbacks->einfo
11286             /* xgettext:c-format */
11287             (_("%P: linkage table error against `%T'\n"),
11288              stub_entry->h != NULL
11289              ? stub_entry->h->elf.root.root.string
11290              : "<local sym>");
11291           bfd_set_error (bfd_error_bad_value);
11292           htab->stub_error = TRUE;
11293           return FALSE;
11294         }
11295
11296       if (htab->params->plt_stub_align != 0)
11297         {
11298           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11299
11300           stub_entry->group->stub_sec->size += pad;
11301           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11302           loc += pad;
11303         }
11304
11305       r = NULL;
11306       if (info->emitrelocations)
11307         {
11308           r = get_relocs (stub_entry->group->stub_sec,
11309                           ((PPC_HA (off) != 0)
11310                            + (htab->opd_abi
11311                               ? 2 + (htab->params->plt_static_chain
11312                                      && PPC_HA (off + 16) == PPC_HA (off))
11313                               : 1)));
11314           if (r == NULL)
11315             return FALSE;
11316           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11317           if (bfd_big_endian (info->output_bfd))
11318             r[0].r_offset += 2;
11319           r[0].r_addend = dest;
11320         }
11321       if (stub_entry->h != NULL
11322           && (stub_entry->h == htab->tls_get_addr_fd
11323               || stub_entry->h == htab->tls_get_addr)
11324           && htab->params->tls_get_addr_opt)
11325         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11326       else
11327         p = build_plt_stub (htab, stub_entry, loc, off, r);
11328       size = p - loc;
11329       break;
11330
11331     case ppc_stub_save_res:
11332       return TRUE;
11333
11334     default:
11335       BFD_FAIL ();
11336       return FALSE;
11337     }
11338
11339   stub_entry->group->stub_sec->size += size;
11340
11341   if (htab->params->emit_stub_syms)
11342     {
11343       struct elf_link_hash_entry *h;
11344       size_t len1, len2;
11345       char *name;
11346       const char *const stub_str[] = { "long_branch",
11347                                        "long_branch_r2off",
11348                                        "plt_branch",
11349                                        "plt_branch_r2off",
11350                                        "plt_call",
11351                                        "plt_call" };
11352
11353       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11354       len2 = strlen (stub_entry->root.string);
11355       name = bfd_malloc (len1 + len2 + 2);
11356       if (name == NULL)
11357         return FALSE;
11358       memcpy (name, stub_entry->root.string, 9);
11359       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11360       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11361       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11362       if (h == NULL)
11363         return FALSE;
11364       if (h->root.type == bfd_link_hash_new)
11365         {
11366           h->root.type = bfd_link_hash_defined;
11367           h->root.u.def.section = stub_entry->group->stub_sec;
11368           h->root.u.def.value = stub_entry->stub_offset;
11369           h->ref_regular = 1;
11370           h->def_regular = 1;
11371           h->ref_regular_nonweak = 1;
11372           h->forced_local = 1;
11373           h->non_elf = 0;
11374           h->root.linker_def = 1;
11375         }
11376     }
11377
11378   return TRUE;
11379 }
11380
11381 /* As above, but don't actually build the stub.  Just bump offset so
11382    we know stub section sizes, and select plt_branch stubs where
11383    long_branch stubs won't do.  */
11384
11385 static bfd_boolean
11386 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11387 {
11388   struct ppc_stub_hash_entry *stub_entry;
11389   struct bfd_link_info *info;
11390   struct ppc_link_hash_table *htab;
11391   bfd_vma off;
11392   int size;
11393
11394   /* Massage our args to the form they really have.  */
11395   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11396   info = in_arg;
11397
11398   htab = ppc_hash_table (info);
11399   if (htab == NULL)
11400     return FALSE;
11401
11402   if (stub_entry->h != NULL
11403       && stub_entry->h->save_res
11404       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11405       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11406     {
11407       /* Don't make stubs to out-of-line register save/restore
11408          functions.  Instead, emit copies of the functions.  */
11409       stub_entry->group->needs_save_res = 1;
11410       stub_entry->stub_type = ppc_stub_save_res;
11411       return TRUE;
11412     }
11413
11414   if (stub_entry->stub_type == ppc_stub_plt_call
11415       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11416     {
11417       asection *plt;
11418       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11419       if (off >= (bfd_vma) -2)
11420         abort ();
11421       plt = htab->elf.splt;
11422       if (!htab->elf.dynamic_sections_created
11423           || stub_entry->h == NULL
11424           || stub_entry->h->elf.dynindx == -1)
11425         plt = htab->elf.iplt;
11426       off += (plt->output_offset
11427               + plt->output_section->vma
11428               - elf_gp (plt->output_section->owner)
11429               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11430
11431       size = plt_stub_size (htab, stub_entry, off);
11432       if (stub_entry->h != NULL
11433           && (stub_entry->h == htab->tls_get_addr_fd
11434               || stub_entry->h == htab->tls_get_addr)
11435           && htab->params->tls_get_addr_opt
11436           && (ALWAYS_EMIT_R2SAVE
11437               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11438         stub_entry->group->tls_get_addr_opt_bctrl
11439           = stub_entry->group->stub_sec->size + size - 5 * 4;
11440
11441       if (htab->params->plt_stub_align)
11442         size += plt_stub_pad (htab, stub_entry, off);
11443       if (info->emitrelocations)
11444         {
11445           stub_entry->group->stub_sec->reloc_count
11446             += ((PPC_HA (off) != 0)
11447                 + (htab->opd_abi
11448                    ? 2 + (htab->params->plt_static_chain
11449                           && PPC_HA (off + 16) == PPC_HA (off))
11450                    : 1));
11451           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11452         }
11453     }
11454   else
11455     {
11456       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11457          variants.  */
11458       bfd_vma r2off = 0;
11459       bfd_vma local_off = 0;
11460
11461       off = (stub_entry->target_value
11462              + stub_entry->target_section->output_offset
11463              + stub_entry->target_section->output_section->vma);
11464       off -= (stub_entry->group->stub_sec->size
11465               + stub_entry->group->stub_sec->output_offset
11466               + stub_entry->group->stub_sec->output_section->vma);
11467
11468       /* Reset the stub type from the plt variant in case we now
11469          can reach with a shorter stub.  */
11470       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11471         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11472
11473       size = 4;
11474       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11475         {
11476           r2off = get_r2off (info, stub_entry);
11477           if (r2off == (bfd_vma) -1)
11478             {
11479               htab->stub_error = TRUE;
11480               return FALSE;
11481             }
11482           size = 8;
11483           if (PPC_HA (r2off) != 0)
11484             size += 4;
11485           if (PPC_LO (r2off) != 0)
11486             size += 4;
11487           off -= size - 4;
11488         }
11489
11490       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11491
11492       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11493          Do the same for -R objects without function descriptors.  */
11494       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11495           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11496               && r2off == 0
11497               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11498         {
11499           struct ppc_branch_hash_entry *br_entry;
11500
11501           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11502                                              stub_entry->root.string + 9,
11503                                              TRUE, FALSE);
11504           if (br_entry == NULL)
11505             {
11506               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11507                                       stub_entry->root.string);
11508               htab->stub_error = TRUE;
11509               return FALSE;
11510             }
11511
11512           if (br_entry->iter != htab->stub_iteration)
11513             {
11514               br_entry->iter = htab->stub_iteration;
11515               br_entry->offset = htab->brlt->size;
11516               htab->brlt->size += 8;
11517
11518               if (htab->relbrlt != NULL)
11519                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11520               else if (info->emitrelocations)
11521                 {
11522                   htab->brlt->reloc_count += 1;
11523                   htab->brlt->flags |= SEC_RELOC;
11524                 }
11525             }
11526
11527           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11528           off = (br_entry->offset
11529                  + htab->brlt->output_offset
11530                  + htab->brlt->output_section->vma
11531                  - elf_gp (htab->brlt->output_section->owner)
11532                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11533
11534           if (info->emitrelocations)
11535             {
11536               stub_entry->group->stub_sec->reloc_count
11537                 += 1 + (PPC_HA (off) != 0);
11538               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11539             }
11540
11541           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11542             {
11543               size = 12;
11544               if (PPC_HA (off) != 0)
11545                 size = 16;
11546             }
11547           else
11548             {
11549               size = 16;
11550               if (PPC_HA (off) != 0)
11551                 size += 4;
11552
11553               if (PPC_HA (r2off) != 0)
11554                 size += 4;
11555               if (PPC_LO (r2off) != 0)
11556                 size += 4;
11557             }
11558         }
11559       else if (info->emitrelocations)
11560         {
11561           stub_entry->group->stub_sec->reloc_count += 1;
11562           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11563         }
11564     }
11565
11566   stub_entry->group->stub_sec->size += size;
11567   return TRUE;
11568 }
11569
11570 /* Set up various things so that we can make a list of input sections
11571    for each output section included in the link.  Returns -1 on error,
11572    0 when no stubs will be needed, and 1 on success.  */
11573
11574 int
11575 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11576 {
11577   unsigned int id;
11578   bfd_size_type amt;
11579   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11580
11581   if (htab == NULL)
11582     return -1;
11583
11584   htab->sec_info_arr_size = bfd_get_next_section_id ();
11585   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11586   htab->sec_info = bfd_zmalloc (amt);
11587   if (htab->sec_info == NULL)
11588     return -1;
11589
11590   /* Set toc_off for com, und, abs and ind sections.  */
11591   for (id = 0; id < 3; id++)
11592     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11593
11594   return 1;
11595 }
11596
11597 /* Set up for first pass at multitoc partitioning.  */
11598
11599 void
11600 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11601 {
11602   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11603
11604   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11605   htab->toc_bfd = NULL;
11606   htab->toc_first_sec = NULL;
11607 }
11608
11609 /* The linker repeatedly calls this function for each TOC input section
11610    and linker generated GOT section.  Group input bfds such that the toc
11611    within a group is less than 64k in size.  */
11612
11613 bfd_boolean
11614 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11615 {
11616   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11617   bfd_vma addr, off, limit;
11618
11619   if (htab == NULL)
11620     return FALSE;
11621
11622   if (!htab->second_toc_pass)
11623     {
11624       /* Keep track of the first .toc or .got section for this input bfd.  */
11625       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11626
11627       if (new_bfd)
11628         {
11629           htab->toc_bfd = isec->owner;
11630           htab->toc_first_sec = isec;
11631         }
11632
11633       addr = isec->output_offset + isec->output_section->vma;
11634       off = addr - htab->toc_curr;
11635       limit = 0x80008000;
11636       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11637         limit = 0x10000;
11638       if (off + isec->size > limit)
11639         {
11640           addr = (htab->toc_first_sec->output_offset
11641                   + htab->toc_first_sec->output_section->vma);
11642           htab->toc_curr = addr;
11643           htab->toc_curr &= -TOC_BASE_ALIGN;
11644         }
11645
11646       /* toc_curr is the base address of this toc group.  Set elf_gp
11647          for the input section to be the offset relative to the
11648          output toc base plus 0x8000.  Making the input elf_gp an
11649          offset allows us to move the toc as a whole without
11650          recalculating input elf_gp.  */
11651       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11652       off += TOC_BASE_OFF;
11653
11654       /* Die if someone uses a linker script that doesn't keep input
11655          file .toc and .got together.  */
11656       if (new_bfd
11657           && elf_gp (isec->owner) != 0
11658           && elf_gp (isec->owner) != off)
11659         return FALSE;
11660
11661       elf_gp (isec->owner) = off;
11662       return TRUE;
11663     }
11664
11665   /* During the second pass toc_first_sec points to the start of
11666      a toc group, and toc_curr is used to track the old elf_gp.
11667      We use toc_bfd to ensure we only look at each bfd once.  */
11668   if (htab->toc_bfd == isec->owner)
11669     return TRUE;
11670   htab->toc_bfd = isec->owner;
11671
11672   if (htab->toc_first_sec == NULL
11673       || htab->toc_curr != elf_gp (isec->owner))
11674     {
11675       htab->toc_curr = elf_gp (isec->owner);
11676       htab->toc_first_sec = isec;
11677     }
11678   addr = (htab->toc_first_sec->output_offset
11679           + htab->toc_first_sec->output_section->vma);
11680   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11681   elf_gp (isec->owner) = off;
11682
11683   return TRUE;
11684 }
11685
11686 /* Called via elf_link_hash_traverse to merge GOT entries for global
11687    symbol H.  */
11688
11689 static bfd_boolean
11690 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11691 {
11692   if (h->root.type == bfd_link_hash_indirect)
11693     return TRUE;
11694
11695   merge_got_entries (&h->got.glist);
11696
11697   return TRUE;
11698 }
11699
11700 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11701    symbol H.  */
11702
11703 static bfd_boolean
11704 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11705 {
11706   struct got_entry *gent;
11707
11708   if (h->root.type == bfd_link_hash_indirect)
11709     return TRUE;
11710
11711   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11712     if (!gent->is_indirect)
11713       allocate_got (h, (struct bfd_link_info *) inf, gent);
11714   return TRUE;
11715 }
11716
11717 /* Called on the first multitoc pass after the last call to
11718    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11719    entries.  */
11720
11721 bfd_boolean
11722 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11723 {
11724   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11725   struct bfd *ibfd, *ibfd2;
11726   bfd_boolean done_something;
11727
11728   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11729
11730   if (!htab->do_multi_toc)
11731     return FALSE;
11732
11733   /* Merge global sym got entries within a toc group.  */
11734   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11735
11736   /* And tlsld_got.  */
11737   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11738     {
11739       struct got_entry *ent, *ent2;
11740
11741       if (!is_ppc64_elf (ibfd))
11742         continue;
11743
11744       ent = ppc64_tlsld_got (ibfd);
11745       if (!ent->is_indirect
11746           && ent->got.offset != (bfd_vma) -1)
11747         {
11748           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11749             {
11750               if (!is_ppc64_elf (ibfd2))
11751                 continue;
11752
11753               ent2 = ppc64_tlsld_got (ibfd2);
11754               if (!ent2->is_indirect
11755                   && ent2->got.offset != (bfd_vma) -1
11756                   && elf_gp (ibfd2) == elf_gp (ibfd))
11757                 {
11758                   ent2->is_indirect = TRUE;
11759                   ent2->got.ent = ent;
11760                 }
11761             }
11762         }
11763     }
11764
11765   /* Zap sizes of got sections.  */
11766   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11767   htab->elf.irelplt->size -= htab->got_reli_size;
11768   htab->got_reli_size = 0;
11769
11770   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11771     {
11772       asection *got, *relgot;
11773
11774       if (!is_ppc64_elf (ibfd))
11775         continue;
11776
11777       got = ppc64_elf_tdata (ibfd)->got;
11778       if (got != NULL)
11779         {
11780           got->rawsize = got->size;
11781           got->size = 0;
11782           relgot = ppc64_elf_tdata (ibfd)->relgot;
11783           relgot->rawsize = relgot->size;
11784           relgot->size = 0;
11785         }
11786     }
11787
11788   /* Now reallocate the got, local syms first.  We don't need to
11789      allocate section contents again since we never increase size.  */
11790   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11791     {
11792       struct got_entry **lgot_ents;
11793       struct got_entry **end_lgot_ents;
11794       struct plt_entry **local_plt;
11795       struct plt_entry **end_local_plt;
11796       unsigned char *lgot_masks;
11797       bfd_size_type locsymcount;
11798       Elf_Internal_Shdr *symtab_hdr;
11799       asection *s;
11800
11801       if (!is_ppc64_elf (ibfd))
11802         continue;
11803
11804       lgot_ents = elf_local_got_ents (ibfd);
11805       if (!lgot_ents)
11806         continue;
11807
11808       symtab_hdr = &elf_symtab_hdr (ibfd);
11809       locsymcount = symtab_hdr->sh_info;
11810       end_lgot_ents = lgot_ents + locsymcount;
11811       local_plt = (struct plt_entry **) end_lgot_ents;
11812       end_local_plt = local_plt + locsymcount;
11813       lgot_masks = (unsigned char *) end_local_plt;
11814       s = ppc64_elf_tdata (ibfd)->got;
11815       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11816         {
11817           struct got_entry *ent;
11818
11819           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11820             {
11821               unsigned int ent_size = 8;
11822               unsigned int rel_size = sizeof (Elf64_External_Rela);
11823
11824               ent->got.offset = s->size;
11825               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11826                 {
11827                   ent_size *= 2;
11828                   rel_size *= 2;
11829                 }
11830               s->size += ent_size;
11831               if ((*lgot_masks & PLT_IFUNC) != 0)
11832                 {
11833                   htab->elf.irelplt->size += rel_size;
11834                   htab->got_reli_size += rel_size;
11835                 }
11836               else if (bfd_link_pic (info))
11837                 {
11838                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11839                   srel->size += rel_size;
11840                 }
11841             }
11842         }
11843     }
11844
11845   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11846
11847   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11848     {
11849       struct got_entry *ent;
11850
11851       if (!is_ppc64_elf (ibfd))
11852         continue;
11853
11854       ent = ppc64_tlsld_got (ibfd);
11855       if (!ent->is_indirect
11856           && ent->got.offset != (bfd_vma) -1)
11857         {
11858           asection *s = ppc64_elf_tdata (ibfd)->got;
11859           ent->got.offset = s->size;
11860           s->size += 16;
11861           if (bfd_link_pic (info))
11862             {
11863               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11864               srel->size += sizeof (Elf64_External_Rela);
11865             }
11866         }
11867     }
11868
11869   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11870   if (!done_something)
11871     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11872       {
11873         asection *got;
11874
11875         if (!is_ppc64_elf (ibfd))
11876           continue;
11877
11878         got = ppc64_elf_tdata (ibfd)->got;
11879         if (got != NULL)
11880           {
11881             done_something = got->rawsize != got->size;
11882             if (done_something)
11883               break;
11884           }
11885       }
11886
11887   if (done_something)
11888     (*htab->params->layout_sections_again) ();
11889
11890   /* Set up for second pass over toc sections to recalculate elf_gp
11891      on input sections.  */
11892   htab->toc_bfd = NULL;
11893   htab->toc_first_sec = NULL;
11894   htab->second_toc_pass = TRUE;
11895   return done_something;
11896 }
11897
11898 /* Called after second pass of multitoc partitioning.  */
11899
11900 void
11901 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11902 {
11903   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11904
11905   /* After the second pass, toc_curr tracks the TOC offset used
11906      for code sections below in ppc64_elf_next_input_section.  */
11907   htab->toc_curr = TOC_BASE_OFF;
11908 }
11909
11910 /* No toc references were found in ISEC.  If the code in ISEC makes no
11911    calls, then there's no need to use toc adjusting stubs when branching
11912    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11913    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11914    needed, and 2 if a cyclical call-graph was found but no other reason
11915    for a stub was detected.  If called from the top level, a return of
11916    2 means the same as a return of 0.  */
11917
11918 static int
11919 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11920 {
11921   int ret;
11922
11923   /* Mark this section as checked.  */
11924   isec->call_check_done = 1;
11925
11926   /* We know none of our code bearing sections will need toc stubs.  */
11927   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11928     return 0;
11929
11930   if (isec->size == 0)
11931     return 0;
11932
11933   if (isec->output_section == NULL)
11934     return 0;
11935
11936   ret = 0;
11937   if (isec->reloc_count != 0)
11938     {
11939       Elf_Internal_Rela *relstart, *rel;
11940       Elf_Internal_Sym *local_syms;
11941       struct ppc_link_hash_table *htab;
11942
11943       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11944                                             info->keep_memory);
11945       if (relstart == NULL)
11946         return -1;
11947
11948       /* Look for branches to outside of this section.  */
11949       local_syms = NULL;
11950       htab = ppc_hash_table (info);
11951       if (htab == NULL)
11952         return -1;
11953
11954       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11955         {
11956           enum elf_ppc64_reloc_type r_type;
11957           unsigned long r_symndx;
11958           struct elf_link_hash_entry *h;
11959           struct ppc_link_hash_entry *eh;
11960           Elf_Internal_Sym *sym;
11961           asection *sym_sec;
11962           struct _opd_sec_data *opd;
11963           bfd_vma sym_value;
11964           bfd_vma dest;
11965
11966           r_type = ELF64_R_TYPE (rel->r_info);
11967           if (r_type != R_PPC64_REL24
11968               && r_type != R_PPC64_REL14
11969               && r_type != R_PPC64_REL14_BRTAKEN
11970               && r_type != R_PPC64_REL14_BRNTAKEN)
11971             continue;
11972
11973           r_symndx = ELF64_R_SYM (rel->r_info);
11974           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11975                           isec->owner))
11976             {
11977               ret = -1;
11978               break;
11979             }
11980
11981           /* Calls to dynamic lib functions go through a plt call stub
11982              that uses r2.  */
11983           eh = (struct ppc_link_hash_entry *) h;
11984           if (eh != NULL
11985               && (eh->elf.plt.plist != NULL
11986                   || (eh->oh != NULL
11987                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11988             {
11989               ret = 1;
11990               break;
11991             }
11992
11993           if (sym_sec == NULL)
11994             /* Ignore other undefined symbols.  */
11995             continue;
11996
11997           /* Assume branches to other sections not included in the
11998              link need stubs too, to cover -R and absolute syms.  */
11999           if (sym_sec->output_section == NULL)
12000             {
12001               ret = 1;
12002               break;
12003             }
12004
12005           if (h == NULL)
12006             sym_value = sym->st_value;
12007           else
12008             {
12009               if (h->root.type != bfd_link_hash_defined
12010                   && h->root.type != bfd_link_hash_defweak)
12011                 abort ();
12012               sym_value = h->root.u.def.value;
12013             }
12014           sym_value += rel->r_addend;
12015
12016           /* If this branch reloc uses an opd sym, find the code section.  */
12017           opd = get_opd_info (sym_sec);
12018           if (opd != NULL)
12019             {
12020               if (h == NULL && opd->adjust != NULL)
12021                 {
12022                   long adjust;
12023
12024                   adjust = opd->adjust[OPD_NDX (sym_value)];
12025                   if (adjust == -1)
12026                     /* Assume deleted functions won't ever be called.  */
12027                     continue;
12028                   sym_value += adjust;
12029                 }
12030
12031               dest = opd_entry_value (sym_sec, sym_value,
12032                                       &sym_sec, NULL, FALSE);
12033               if (dest == (bfd_vma) -1)
12034                 continue;
12035             }
12036           else
12037             dest = (sym_value
12038                     + sym_sec->output_offset
12039                     + sym_sec->output_section->vma);
12040
12041           /* Ignore branch to self.  */
12042           if (sym_sec == isec)
12043             continue;
12044
12045           /* If the called function uses the toc, we need a stub.  */
12046           if (sym_sec->has_toc_reloc
12047               || sym_sec->makes_toc_func_call)
12048             {
12049               ret = 1;
12050               break;
12051             }
12052
12053           /* Assume any branch that needs a long branch stub might in fact
12054              need a plt_branch stub.  A plt_branch stub uses r2.  */
12055           else if (dest - (isec->output_offset
12056                            + isec->output_section->vma
12057                            + rel->r_offset) + (1 << 25)
12058                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12059                                                              ? h->other
12060                                                              : sym->st_other))
12061             {
12062               ret = 1;
12063               break;
12064             }
12065
12066           /* If calling back to a section in the process of being
12067              tested, we can't say for sure that no toc adjusting stubs
12068              are needed, so don't return zero.  */
12069           else if (sym_sec->call_check_in_progress)
12070             ret = 2;
12071
12072           /* Branches to another section that itself doesn't have any TOC
12073              references are OK.  Recursively call ourselves to check.  */
12074           else if (!sym_sec->call_check_done)
12075             {
12076               int recur;
12077
12078               /* Mark current section as indeterminate, so that other
12079                  sections that call back to current won't be marked as
12080                  known.  */
12081               isec->call_check_in_progress = 1;
12082               recur = toc_adjusting_stub_needed (info, sym_sec);
12083               isec->call_check_in_progress = 0;
12084
12085               if (recur != 0)
12086                 {
12087                   ret = recur;
12088                   if (recur != 2)
12089                     break;
12090                 }
12091             }
12092         }
12093
12094       if (local_syms != NULL
12095           && (elf_symtab_hdr (isec->owner).contents
12096               != (unsigned char *) local_syms))
12097         free (local_syms);
12098       if (elf_section_data (isec)->relocs != relstart)
12099         free (relstart);
12100     }
12101
12102   if ((ret & 1) == 0
12103       && isec->map_head.s != NULL
12104       && (strcmp (isec->output_section->name, ".init") == 0
12105           || strcmp (isec->output_section->name, ".fini") == 0))
12106     {
12107       if (isec->map_head.s->has_toc_reloc
12108           || isec->map_head.s->makes_toc_func_call)
12109         ret = 1;
12110       else if (!isec->map_head.s->call_check_done)
12111         {
12112           int recur;
12113           isec->call_check_in_progress = 1;
12114           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12115           isec->call_check_in_progress = 0;
12116           if (recur != 0)
12117             ret = recur;
12118         }
12119     }
12120
12121   if (ret == 1)
12122     isec->makes_toc_func_call = 1;
12123
12124   return ret;
12125 }
12126
12127 /* The linker repeatedly calls this function for each input section,
12128    in the order that input sections are linked into output sections.
12129    Build lists of input sections to determine groupings between which
12130    we may insert linker stubs.  */
12131
12132 bfd_boolean
12133 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12134 {
12135   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12136
12137   if (htab == NULL)
12138     return FALSE;
12139
12140   if ((isec->output_section->flags & SEC_CODE) != 0
12141       && isec->output_section->id < htab->sec_info_arr_size)
12142     {
12143       /* This happens to make the list in reverse order,
12144          which is what we want.  */
12145       htab->sec_info[isec->id].u.list
12146         = htab->sec_info[isec->output_section->id].u.list;
12147       htab->sec_info[isec->output_section->id].u.list = isec;
12148     }
12149
12150   if (htab->multi_toc_needed)
12151     {
12152       /* Analyse sections that aren't already flagged as needing a
12153          valid toc pointer.  Exclude .fixup for the linux kernel.
12154          .fixup contains branches, but only back to the function that
12155          hit an exception.  */
12156       if (!(isec->has_toc_reloc
12157             || (isec->flags & SEC_CODE) == 0
12158             || strcmp (isec->name, ".fixup") == 0
12159             || isec->call_check_done))
12160         {
12161           if (toc_adjusting_stub_needed (info, isec) < 0)
12162             return FALSE;
12163         }
12164       /* Make all sections use the TOC assigned for this object file.
12165          This will be wrong for pasted sections;  We fix that in
12166          check_pasted_section().  */
12167       if (elf_gp (isec->owner) != 0)
12168         htab->toc_curr = elf_gp (isec->owner);
12169     }
12170
12171   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12172   return TRUE;
12173 }
12174
12175 /* Check that all .init and .fini sections use the same toc, if they
12176    have toc relocs.  */
12177
12178 static bfd_boolean
12179 check_pasted_section (struct bfd_link_info *info, const char *name)
12180 {
12181   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12182
12183   if (o != NULL)
12184     {
12185       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12186       bfd_vma toc_off = 0;
12187       asection *i;
12188
12189       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12190         if (i->has_toc_reloc)
12191           {
12192             if (toc_off == 0)
12193               toc_off = htab->sec_info[i->id].toc_off;
12194             else if (toc_off != htab->sec_info[i->id].toc_off)
12195               return FALSE;
12196           }
12197
12198       if (toc_off == 0)
12199         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12200           if (i->makes_toc_func_call)
12201             {
12202               toc_off = htab->sec_info[i->id].toc_off;
12203               break;
12204             }
12205
12206       /* Make sure the whole pasted function uses the same toc offset.  */
12207       if (toc_off != 0)
12208         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12209           htab->sec_info[i->id].toc_off = toc_off;
12210     }
12211   return TRUE;
12212 }
12213
12214 bfd_boolean
12215 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12216 {
12217   return (check_pasted_section (info, ".init")
12218           & check_pasted_section (info, ".fini"));
12219 }
12220
12221 /* See whether we can group stub sections together.  Grouping stub
12222    sections may result in fewer stubs.  More importantly, we need to
12223    put all .init* and .fini* stubs at the beginning of the .init or
12224    .fini output sections respectively, because glibc splits the
12225    _init and _fini functions into multiple parts.  Putting a stub in
12226    the middle of a function is not a good idea.  */
12227
12228 static bfd_boolean
12229 group_sections (struct bfd_link_info *info,
12230                 bfd_size_type stub_group_size,
12231                 bfd_boolean stubs_always_before_branch)
12232 {
12233   struct ppc_link_hash_table *htab;
12234   asection *osec;
12235   bfd_boolean suppress_size_errors;
12236
12237   htab = ppc_hash_table (info);
12238   if (htab == NULL)
12239     return FALSE;
12240
12241   suppress_size_errors = FALSE;
12242   if (stub_group_size == 1)
12243     {
12244       /* Default values.  */
12245       if (stubs_always_before_branch)
12246         stub_group_size = 0x1e00000;
12247       else
12248         stub_group_size = 0x1c00000;
12249       suppress_size_errors = TRUE;
12250     }
12251
12252   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12253     {
12254       asection *tail;
12255
12256       if (osec->id >= htab->sec_info_arr_size)
12257         continue;
12258
12259       tail = htab->sec_info[osec->id].u.list;
12260       while (tail != NULL)
12261         {
12262           asection *curr;
12263           asection *prev;
12264           bfd_size_type total;
12265           bfd_boolean big_sec;
12266           bfd_vma curr_toc;
12267           struct map_stub *group;
12268           bfd_size_type group_size;
12269
12270           curr = tail;
12271           total = tail->size;
12272           group_size = (ppc64_elf_section_data (tail) != NULL
12273                         && ppc64_elf_section_data (tail)->has_14bit_branch
12274                         ? stub_group_size >> 10 : stub_group_size);
12275
12276           big_sec = total > group_size;
12277           if (big_sec && !suppress_size_errors)
12278             /* xgettext:c-format */
12279             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12280                                 tail->owner, tail);
12281           curr_toc = htab->sec_info[tail->id].toc_off;
12282
12283           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12284                  && ((total += curr->output_offset - prev->output_offset)
12285                      < (ppc64_elf_section_data (prev) != NULL
12286                         && ppc64_elf_section_data (prev)->has_14bit_branch
12287                         ? (group_size = stub_group_size >> 10) : group_size))
12288                  && htab->sec_info[prev->id].toc_off == curr_toc)
12289             curr = prev;
12290
12291           /* OK, the size from the start of CURR to the end is less
12292              than group_size and thus can be handled by one stub
12293              section.  (or the tail section is itself larger than
12294              group_size, in which case we may be toast.)  We should
12295              really be keeping track of the total size of stubs added
12296              here, as stubs contribute to the final output section
12297              size.  That's a little tricky, and this way will only
12298              break if stubs added make the total size more than 2^25,
12299              ie. for the default stub_group_size, if stubs total more
12300              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12301           group = bfd_alloc (curr->owner, sizeof (*group));
12302           if (group == NULL)
12303             return FALSE;
12304           group->link_sec = curr;
12305           group->stub_sec = NULL;
12306           group->needs_save_res = 0;
12307           group->tls_get_addr_opt_bctrl = -1u;
12308           group->next = htab->group;
12309           htab->group = group;
12310           do
12311             {
12312               prev = htab->sec_info[tail->id].u.list;
12313               /* Set up this stub group.  */
12314               htab->sec_info[tail->id].u.group = group;
12315             }
12316           while (tail != curr && (tail = prev) != NULL);
12317
12318           /* But wait, there's more!  Input sections up to group_size
12319              bytes before the stub section can be handled by it too.
12320              Don't do this if we have a really large section after the
12321              stubs, as adding more stubs increases the chance that
12322              branches may not reach into the stub section.  */
12323           if (!stubs_always_before_branch && !big_sec)
12324             {
12325               total = 0;
12326               while (prev != NULL
12327                      && ((total += tail->output_offset - prev->output_offset)
12328                          < (ppc64_elf_section_data (prev) != NULL
12329                             && ppc64_elf_section_data (prev)->has_14bit_branch
12330                             ? (group_size = stub_group_size >> 10) : group_size))
12331                      && htab->sec_info[prev->id].toc_off == curr_toc)
12332                 {
12333                   tail = prev;
12334                   prev = htab->sec_info[tail->id].u.list;
12335                   htab->sec_info[tail->id].u.group = group;
12336                 }
12337             }
12338           tail = prev;
12339         }
12340     }
12341   return TRUE;
12342 }
12343
12344 static const unsigned char glink_eh_frame_cie[] =
12345 {
12346   0, 0, 0, 16,                          /* length.  */
12347   0, 0, 0, 0,                           /* id.  */
12348   1,                                    /* CIE version.  */
12349   'z', 'R', 0,                          /* Augmentation string.  */
12350   4,                                    /* Code alignment.  */
12351   0x78,                                 /* Data alignment.  */
12352   65,                                   /* RA reg.  */
12353   1,                                    /* Augmentation size.  */
12354   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12355   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12356 };
12357
12358 static size_t
12359 stub_eh_frame_size (struct map_stub *group, size_t align)
12360 {
12361   size_t this_size = 17;
12362   if (group->tls_get_addr_opt_bctrl != -1u)
12363     {
12364       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12365       if (to_bctrl < 64)
12366         this_size += 1;
12367       else if (to_bctrl < 256)
12368         this_size += 2;
12369       else if (to_bctrl < 65536)
12370         this_size += 3;
12371       else
12372         this_size += 5;
12373       this_size += 6;
12374     }
12375   this_size = (this_size + align - 1) & -align;
12376   return this_size;
12377 }
12378
12379 /* Stripping output sections is normally done before dynamic section
12380    symbols have been allocated.  This function is called later, and
12381    handles cases like htab->brlt which is mapped to its own output
12382    section.  */
12383
12384 static void
12385 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12386 {
12387   if (isec->size == 0
12388       && isec->output_section->size == 0
12389       && !(isec->output_section->flags & SEC_KEEP)
12390       && !bfd_section_removed_from_list (info->output_bfd,
12391                                          isec->output_section)
12392       && elf_section_data (isec->output_section)->dynindx == 0)
12393     {
12394       isec->output_section->flags |= SEC_EXCLUDE;
12395       bfd_section_list_remove (info->output_bfd, isec->output_section);
12396       info->output_bfd->section_count--;
12397     }
12398 }
12399
12400 /* Determine and set the size of the stub section for a final link.
12401
12402    The basic idea here is to examine all the relocations looking for
12403    PC-relative calls to a target that is unreachable with a "bl"
12404    instruction.  */
12405
12406 bfd_boolean
12407 ppc64_elf_size_stubs (struct bfd_link_info *info)
12408 {
12409   bfd_size_type stub_group_size;
12410   bfd_boolean stubs_always_before_branch;
12411   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12412
12413   if (htab == NULL)
12414     return FALSE;
12415
12416   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12417     htab->params->plt_thread_safe = 1;
12418   if (!htab->opd_abi)
12419     htab->params->plt_thread_safe = 0;
12420   else if (htab->params->plt_thread_safe == -1)
12421     {
12422       static const char *const thread_starter[] =
12423         {
12424           "pthread_create",
12425           /* libstdc++ */
12426           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12427           /* librt */
12428           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12429           "mq_notify", "create_timer",
12430           /* libanl */
12431           "getaddrinfo_a",
12432           /* libgomp */
12433           "GOMP_parallel",
12434           "GOMP_parallel_start",
12435           "GOMP_parallel_loop_static",
12436           "GOMP_parallel_loop_static_start",
12437           "GOMP_parallel_loop_dynamic",
12438           "GOMP_parallel_loop_dynamic_start",
12439           "GOMP_parallel_loop_guided",
12440           "GOMP_parallel_loop_guided_start",
12441           "GOMP_parallel_loop_runtime",
12442           "GOMP_parallel_loop_runtime_start",
12443           "GOMP_parallel_sections",
12444           "GOMP_parallel_sections_start",
12445           /* libgo */
12446           "__go_go",
12447         };
12448       unsigned i;
12449
12450       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12451         {
12452           struct elf_link_hash_entry *h;
12453           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12454                                     FALSE, FALSE, TRUE);
12455           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12456           if (htab->params->plt_thread_safe)
12457             break;
12458         }
12459     }
12460   stubs_always_before_branch = htab->params->group_size < 0;
12461   if (htab->params->group_size < 0)
12462     stub_group_size = -htab->params->group_size;
12463   else
12464     stub_group_size = htab->params->group_size;
12465
12466   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12467     return FALSE;
12468
12469 #define STUB_SHRINK_ITER 20
12470   /* Loop until no stubs added.  After iteration 20 of this loop we may
12471      exit on a stub section shrinking.  This is to break out of a
12472      pathological case where adding stubs on one iteration decreases
12473      section gaps (perhaps due to alignment), which then requires
12474      fewer or smaller stubs on the next iteration.  */
12475
12476   while (1)
12477     {
12478       bfd *input_bfd;
12479       unsigned int bfd_indx;
12480       struct map_stub *group;
12481
12482       htab->stub_iteration += 1;
12483
12484       for (input_bfd = info->input_bfds, bfd_indx = 0;
12485            input_bfd != NULL;
12486            input_bfd = input_bfd->link.next, bfd_indx++)
12487         {
12488           Elf_Internal_Shdr *symtab_hdr;
12489           asection *section;
12490           Elf_Internal_Sym *local_syms = NULL;
12491
12492           if (!is_ppc64_elf (input_bfd))
12493             continue;
12494
12495           /* We'll need the symbol table in a second.  */
12496           symtab_hdr = &elf_symtab_hdr (input_bfd);
12497           if (symtab_hdr->sh_info == 0)
12498             continue;
12499
12500           /* Walk over each section attached to the input bfd.  */
12501           for (section = input_bfd->sections;
12502                section != NULL;
12503                section = section->next)
12504             {
12505               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12506
12507               /* If there aren't any relocs, then there's nothing more
12508                  to do.  */
12509               if ((section->flags & SEC_RELOC) == 0
12510                   || (section->flags & SEC_ALLOC) == 0
12511                   || (section->flags & SEC_LOAD) == 0
12512                   || (section->flags & SEC_CODE) == 0
12513                   || section->reloc_count == 0)
12514                 continue;
12515
12516               /* If this section is a link-once section that will be
12517                  discarded, then don't create any stubs.  */
12518               if (section->output_section == NULL
12519                   || section->output_section->owner != info->output_bfd)
12520                 continue;
12521
12522               /* Get the relocs.  */
12523               internal_relocs
12524                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12525                                              info->keep_memory);
12526               if (internal_relocs == NULL)
12527                 goto error_ret_free_local;
12528
12529               /* Now examine each relocation.  */
12530               irela = internal_relocs;
12531               irelaend = irela + section->reloc_count;
12532               for (; irela < irelaend; irela++)
12533                 {
12534                   enum elf_ppc64_reloc_type r_type;
12535                   unsigned int r_indx;
12536                   enum ppc_stub_type stub_type;
12537                   struct ppc_stub_hash_entry *stub_entry;
12538                   asection *sym_sec, *code_sec;
12539                   bfd_vma sym_value, code_value;
12540                   bfd_vma destination;
12541                   unsigned long local_off;
12542                   bfd_boolean ok_dest;
12543                   struct ppc_link_hash_entry *hash;
12544                   struct ppc_link_hash_entry *fdh;
12545                   struct elf_link_hash_entry *h;
12546                   Elf_Internal_Sym *sym;
12547                   char *stub_name;
12548                   const asection *id_sec;
12549                   struct _opd_sec_data *opd;
12550                   struct plt_entry *plt_ent;
12551
12552                   r_type = ELF64_R_TYPE (irela->r_info);
12553                   r_indx = ELF64_R_SYM (irela->r_info);
12554
12555                   if (r_type >= R_PPC64_max)
12556                     {
12557                       bfd_set_error (bfd_error_bad_value);
12558                       goto error_ret_free_internal;
12559                     }
12560
12561                   /* Only look for stubs on branch instructions.  */
12562                   if (r_type != R_PPC64_REL24
12563                       && r_type != R_PPC64_REL14
12564                       && r_type != R_PPC64_REL14_BRTAKEN
12565                       && r_type != R_PPC64_REL14_BRNTAKEN)
12566                     continue;
12567
12568                   /* Now determine the call target, its name, value,
12569                      section.  */
12570                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12571                                   r_indx, input_bfd))
12572                     goto error_ret_free_internal;
12573                   hash = (struct ppc_link_hash_entry *) h;
12574
12575                   ok_dest = FALSE;
12576                   fdh = NULL;
12577                   sym_value = 0;
12578                   if (hash == NULL)
12579                     {
12580                       sym_value = sym->st_value;
12581                       if (sym_sec != NULL
12582                           && sym_sec->output_section != NULL)
12583                         ok_dest = TRUE;
12584                     }
12585                   else if (hash->elf.root.type == bfd_link_hash_defined
12586                            || hash->elf.root.type == bfd_link_hash_defweak)
12587                     {
12588                       sym_value = hash->elf.root.u.def.value;
12589                       if (sym_sec->output_section != NULL)
12590                         ok_dest = TRUE;
12591                     }
12592                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12593                            || hash->elf.root.type == bfd_link_hash_undefined)
12594                     {
12595                       /* Recognise an old ABI func code entry sym, and
12596                          use the func descriptor sym instead if it is
12597                          defined.  */
12598                       if (hash->elf.root.root.string[0] == '.'
12599                           && hash->oh != NULL)
12600                         {
12601                           fdh = ppc_follow_link (hash->oh);
12602                           if (fdh->elf.root.type == bfd_link_hash_defined
12603                               || fdh->elf.root.type == bfd_link_hash_defweak)
12604                             {
12605                               sym_sec = fdh->elf.root.u.def.section;
12606                               sym_value = fdh->elf.root.u.def.value;
12607                               if (sym_sec->output_section != NULL)
12608                                 ok_dest = TRUE;
12609                             }
12610                           else
12611                             fdh = NULL;
12612                         }
12613                     }
12614                   else
12615                     {
12616                       bfd_set_error (bfd_error_bad_value);
12617                       goto error_ret_free_internal;
12618                     }
12619
12620                   destination = 0;
12621                   local_off = 0;
12622                   if (ok_dest)
12623                     {
12624                       sym_value += irela->r_addend;
12625                       destination = (sym_value
12626                                      + sym_sec->output_offset
12627                                      + sym_sec->output_section->vma);
12628                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12629                                                             ? hash->elf.other
12630                                                             : sym->st_other);
12631                     }
12632
12633                   code_sec = sym_sec;
12634                   code_value = sym_value;
12635                   opd = get_opd_info (sym_sec);
12636                   if (opd != NULL)
12637                     {
12638                       bfd_vma dest;
12639
12640                       if (hash == NULL && opd->adjust != NULL)
12641                         {
12642                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12643                           if (adjust == -1)
12644                             continue;
12645                           code_value += adjust;
12646                           sym_value += adjust;
12647                         }
12648                       dest = opd_entry_value (sym_sec, sym_value,
12649                                               &code_sec, &code_value, FALSE);
12650                       if (dest != (bfd_vma) -1)
12651                         {
12652                           destination = dest;
12653                           if (fdh != NULL)
12654                             {
12655                               /* Fixup old ABI sym to point at code
12656                                  entry.  */
12657                               hash->elf.root.type = bfd_link_hash_defweak;
12658                               hash->elf.root.u.def.section = code_sec;
12659                               hash->elf.root.u.def.value = code_value;
12660                             }
12661                         }
12662                     }
12663
12664                   /* Determine what (if any) linker stub is needed.  */
12665                   plt_ent = NULL;
12666                   stub_type = ppc_type_of_stub (section, irela, &hash,
12667                                                 &plt_ent, destination,
12668                                                 local_off);
12669
12670                   if (stub_type != ppc_stub_plt_call)
12671                     {
12672                       /* Check whether we need a TOC adjusting stub.
12673                          Since the linker pastes together pieces from
12674                          different object files when creating the
12675                          _init and _fini functions, it may be that a
12676                          call to what looks like a local sym is in
12677                          fact a call needing a TOC adjustment.  */
12678                       if (code_sec != NULL
12679                           && code_sec->output_section != NULL
12680                           && (htab->sec_info[code_sec->id].toc_off
12681                               != htab->sec_info[section->id].toc_off)
12682                           && (code_sec->has_toc_reloc
12683                               || code_sec->makes_toc_func_call))
12684                         stub_type = ppc_stub_long_branch_r2off;
12685                     }
12686
12687                   if (stub_type == ppc_stub_none)
12688                     continue;
12689
12690                   /* __tls_get_addr calls might be eliminated.  */
12691                   if (stub_type != ppc_stub_plt_call
12692                       && hash != NULL
12693                       && (hash == htab->tls_get_addr
12694                           || hash == htab->tls_get_addr_fd)
12695                       && section->has_tls_reloc
12696                       && irela != internal_relocs)
12697                     {
12698                       /* Get tls info.  */
12699                       unsigned char *tls_mask;
12700
12701                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12702                                          irela - 1, input_bfd))
12703                         goto error_ret_free_internal;
12704                       if (*tls_mask != 0)
12705                         continue;
12706                     }
12707
12708                   if (stub_type == ppc_stub_plt_call)
12709                     {
12710                       if (!htab->opd_abi
12711                           && htab->params->plt_localentry0 != 0
12712                           && is_elfv2_localentry0 (&hash->elf))
12713                         htab->has_plt_localentry0 = 1;
12714                       else if (irela + 1 < irelaend
12715                                && irela[1].r_offset == irela->r_offset + 4
12716                                && (ELF64_R_TYPE (irela[1].r_info)
12717                                    == R_PPC64_TOCSAVE))
12718                         {
12719                           if (!tocsave_find (htab, INSERT,
12720                                              &local_syms, irela + 1, input_bfd))
12721                             goto error_ret_free_internal;
12722                         }
12723                       else
12724                         stub_type = ppc_stub_plt_call_r2save;
12725                     }
12726
12727                   /* Support for grouping stub sections.  */
12728                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12729
12730                   /* Get the name of this stub.  */
12731                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12732                   if (!stub_name)
12733                     goto error_ret_free_internal;
12734
12735                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12736                                                      stub_name, FALSE, FALSE);
12737                   if (stub_entry != NULL)
12738                     {
12739                       /* The proper stub has already been created.  */
12740                       free (stub_name);
12741                       if (stub_type == ppc_stub_plt_call_r2save)
12742                         stub_entry->stub_type = stub_type;
12743                       continue;
12744                     }
12745
12746                   stub_entry = ppc_add_stub (stub_name, section, info);
12747                   if (stub_entry == NULL)
12748                     {
12749                       free (stub_name);
12750                     error_ret_free_internal:
12751                       if (elf_section_data (section)->relocs == NULL)
12752                         free (internal_relocs);
12753                     error_ret_free_local:
12754                       if (local_syms != NULL
12755                           && (symtab_hdr->contents
12756                               != (unsigned char *) local_syms))
12757                         free (local_syms);
12758                       return FALSE;
12759                     }
12760
12761                   stub_entry->stub_type = stub_type;
12762                   if (stub_type != ppc_stub_plt_call
12763                       && stub_type != ppc_stub_plt_call_r2save)
12764                     {
12765                       stub_entry->target_value = code_value;
12766                       stub_entry->target_section = code_sec;
12767                     }
12768                   else
12769                     {
12770                       stub_entry->target_value = sym_value;
12771                       stub_entry->target_section = sym_sec;
12772                     }
12773                   stub_entry->h = hash;
12774                   stub_entry->plt_ent = plt_ent;
12775                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12776
12777                   if (stub_entry->h != NULL)
12778                     htab->stub_globals += 1;
12779                 }
12780
12781               /* We're done with the internal relocs, free them.  */
12782               if (elf_section_data (section)->relocs != internal_relocs)
12783                 free (internal_relocs);
12784             }
12785
12786           if (local_syms != NULL
12787               && symtab_hdr->contents != (unsigned char *) local_syms)
12788             {
12789               if (!info->keep_memory)
12790                 free (local_syms);
12791               else
12792                 symtab_hdr->contents = (unsigned char *) local_syms;
12793             }
12794         }
12795
12796       /* We may have added some stubs.  Find out the new size of the
12797          stub sections.  */
12798       for (group = htab->group; group != NULL; group = group->next)
12799         if (group->stub_sec != NULL)
12800           {
12801             asection *stub_sec = group->stub_sec;
12802
12803             if (htab->stub_iteration <= STUB_SHRINK_ITER
12804                 || stub_sec->rawsize < stub_sec->size)
12805               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12806               stub_sec->rawsize = stub_sec->size;
12807             stub_sec->size = 0;
12808             stub_sec->reloc_count = 0;
12809             stub_sec->flags &= ~SEC_RELOC;
12810           }
12811
12812       htab->brlt->size = 0;
12813       htab->brlt->reloc_count = 0;
12814       htab->brlt->flags &= ~SEC_RELOC;
12815       if (htab->relbrlt != NULL)
12816         htab->relbrlt->size = 0;
12817
12818       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12819
12820       for (group = htab->group; group != NULL; group = group->next)
12821         if (group->needs_save_res)
12822           group->stub_sec->size += htab->sfpr->size;
12823
12824       if (info->emitrelocations
12825           && htab->glink != NULL && htab->glink->size != 0)
12826         {
12827           htab->glink->reloc_count = 1;
12828           htab->glink->flags |= SEC_RELOC;
12829         }
12830
12831       if (htab->glink_eh_frame != NULL
12832           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12833           && htab->glink_eh_frame->output_section->size != 0)
12834         {
12835           size_t size = 0, align = 4;
12836
12837           for (group = htab->group; group != NULL; group = group->next)
12838             if (group->stub_sec != NULL)
12839               size += stub_eh_frame_size (group, align);
12840           if (htab->glink != NULL && htab->glink->size != 0)
12841             size += (24 + align - 1) & -align;
12842           if (size != 0)
12843             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12844           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12845           size = (size + align - 1) & -align;
12846           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12847           htab->glink_eh_frame->size = size;
12848         }
12849
12850       if (htab->params->plt_stub_align != 0)
12851         for (group = htab->group; group != NULL; group = group->next)
12852           if (group->stub_sec != NULL)
12853             group->stub_sec->size = ((group->stub_sec->size
12854                                       + (1 << htab->params->plt_stub_align) - 1)
12855                                      & -(1 << htab->params->plt_stub_align));
12856
12857       for (group = htab->group; group != NULL; group = group->next)
12858         if (group->stub_sec != NULL
12859             && group->stub_sec->rawsize != group->stub_sec->size
12860             && (htab->stub_iteration <= STUB_SHRINK_ITER
12861                 || group->stub_sec->rawsize < group->stub_sec->size))
12862           break;
12863
12864       if (group == NULL
12865           && (htab->glink_eh_frame == NULL
12866               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12867         break;
12868
12869       /* Ask the linker to do its stuff.  */
12870       (*htab->params->layout_sections_again) ();
12871     }
12872
12873   if (htab->glink_eh_frame != NULL
12874       && htab->glink_eh_frame->size != 0)
12875     {
12876       bfd_vma val;
12877       bfd_byte *p, *last_fde;
12878       size_t last_fde_len, size, align, pad;
12879       struct map_stub *group;
12880
12881       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12882       if (p == NULL)
12883         return FALSE;
12884       htab->glink_eh_frame->contents = p;
12885       last_fde = p;
12886       align = 4;
12887
12888       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12889       /* CIE length (rewrite in case little-endian).  */
12890       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12891       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12892       p += last_fde_len + 4;
12893
12894       for (group = htab->group; group != NULL; group = group->next)
12895         if (group->stub_sec != NULL)
12896           {
12897             last_fde = p;
12898             last_fde_len = stub_eh_frame_size (group, align) - 4;
12899             /* FDE length.  */
12900             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12901             p += 4;
12902             /* CIE pointer.  */
12903             val = p - htab->glink_eh_frame->contents;
12904             bfd_put_32 (htab->elf.dynobj, val, p);
12905             p += 4;
12906             /* Offset to stub section, written later.  */
12907             p += 4;
12908             /* stub section size.  */
12909             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12910             p += 4;
12911             /* Augmentation.  */
12912             p += 1;
12913             if (group->tls_get_addr_opt_bctrl != -1u)
12914               {
12915                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12916
12917                 /* This FDE needs more than just the default.
12918                    Describe __tls_get_addr_opt stub LR.  */
12919                 if (to_bctrl < 64)
12920                   *p++ = DW_CFA_advance_loc + to_bctrl;
12921                 else if (to_bctrl < 256)
12922                   {
12923                     *p++ = DW_CFA_advance_loc1;
12924                     *p++ = to_bctrl;
12925                   }
12926                 else if (to_bctrl < 65536)
12927                   {
12928                     *p++ = DW_CFA_advance_loc2;
12929                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12930                     p += 2;
12931                   }
12932                 else
12933                   {
12934                     *p++ = DW_CFA_advance_loc4;
12935                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12936                     p += 4;
12937                   }
12938                 *p++ = DW_CFA_offset_extended_sf;
12939                 *p++ = 65;
12940                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12941                 *p++ = DW_CFA_advance_loc + 4;
12942                 *p++ = DW_CFA_restore_extended;
12943                 *p++ = 65;
12944               }
12945             /* Pad.  */
12946             p = last_fde + last_fde_len + 4;
12947           }
12948       if (htab->glink != NULL && htab->glink->size != 0)
12949         {
12950           last_fde = p;
12951           last_fde_len = ((24 + align - 1) & -align) - 4;
12952           /* FDE length.  */
12953           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12954           p += 4;
12955           /* CIE pointer.  */
12956           val = p - htab->glink_eh_frame->contents;
12957           bfd_put_32 (htab->elf.dynobj, val, p);
12958           p += 4;
12959           /* Offset to .glink, written later.  */
12960           p += 4;
12961           /* .glink size.  */
12962           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12963           p += 4;
12964           /* Augmentation.  */
12965           p += 1;
12966
12967           *p++ = DW_CFA_advance_loc + 1;
12968           *p++ = DW_CFA_register;
12969           *p++ = 65;
12970           *p++ = htab->opd_abi ? 12 : 0;
12971           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12972           *p++ = DW_CFA_restore_extended;
12973           *p++ = 65;
12974           p += ((24 + align - 1) & -align) - 24;
12975         }
12976       /* Subsume any padding into the last FDE if user .eh_frame
12977          sections are aligned more than glink_eh_frame.  Otherwise any
12978          zero padding will be seen as a terminator.  */
12979       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12980       size = p - htab->glink_eh_frame->contents;
12981       pad = ((size + align - 1) & -align) - size;
12982       htab->glink_eh_frame->size = size + pad;
12983       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12984     }
12985
12986   maybe_strip_output (info, htab->brlt);
12987   if (htab->glink_eh_frame != NULL)
12988     maybe_strip_output (info, htab->glink_eh_frame);
12989
12990   return TRUE;
12991 }
12992
12993 /* Called after we have determined section placement.  If sections
12994    move, we'll be called again.  Provide a value for TOCstart.  */
12995
12996 bfd_vma
12997 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12998 {
12999   asection *s;
13000   bfd_vma TOCstart, adjust;
13001
13002   if (info != NULL)
13003     {
13004       struct elf_link_hash_entry *h;
13005       struct elf_link_hash_table *htab = elf_hash_table (info);
13006
13007       if (is_elf_hash_table (htab)
13008           && htab->hgot != NULL)
13009         h = htab->hgot;
13010       else
13011         {
13012           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13013           if (is_elf_hash_table (htab))
13014             htab->hgot = h;
13015         }
13016       if (h != NULL
13017           && h->root.type == bfd_link_hash_defined
13018           && !h->root.linker_def
13019           && (!is_elf_hash_table (htab)
13020               || h->def_regular))
13021         {
13022           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13023                       + h->root.u.def.section->output_offset
13024                       + h->root.u.def.section->output_section->vma);
13025           _bfd_set_gp_value (obfd, TOCstart);
13026           return TOCstart;
13027         }
13028     }
13029
13030   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13031      order.  The TOC starts where the first of these sections starts.  */
13032   s = bfd_get_section_by_name (obfd, ".got");
13033   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13034     s = bfd_get_section_by_name (obfd, ".toc");
13035   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13036     s = bfd_get_section_by_name (obfd, ".tocbss");
13037   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13038     s = bfd_get_section_by_name (obfd, ".plt");
13039   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13040     {
13041       /* This may happen for
13042          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13043          .toc directive
13044          o  bad linker script
13045          o --gc-sections and empty TOC sections
13046
13047          FIXME: Warn user?  */
13048
13049       /* Look for a likely section.  We probably won't even be
13050          using TOCstart.  */
13051       for (s = obfd->sections; s != NULL; s = s->next)
13052         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13053                          | SEC_EXCLUDE))
13054             == (SEC_ALLOC | SEC_SMALL_DATA))
13055           break;
13056       if (s == NULL)
13057         for (s = obfd->sections; s != NULL; s = s->next)
13058           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13059               == (SEC_ALLOC | SEC_SMALL_DATA))
13060             break;
13061       if (s == NULL)
13062         for (s = obfd->sections; s != NULL; s = s->next)
13063           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13064               == SEC_ALLOC)
13065             break;
13066       if (s == NULL)
13067         for (s = obfd->sections; s != NULL; s = s->next)
13068           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13069             break;
13070     }
13071
13072   TOCstart = 0;
13073   if (s != NULL)
13074     TOCstart = s->output_section->vma + s->output_offset;
13075
13076   /* Force alignment.  */
13077   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13078   TOCstart -= adjust;
13079   _bfd_set_gp_value (obfd, TOCstart);
13080
13081   if (info != NULL && s != NULL)
13082     {
13083       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13084
13085       if (htab != NULL)
13086         {
13087           if (htab->elf.hgot != NULL)
13088             {
13089               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13090               htab->elf.hgot->root.u.def.section = s;
13091             }
13092         }
13093       else
13094         {
13095           struct bfd_link_hash_entry *bh = NULL;
13096           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13097                                             s, TOC_BASE_OFF - adjust,
13098                                             NULL, FALSE, FALSE, &bh);
13099         }
13100     }
13101   return TOCstart;
13102 }
13103
13104 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13105    write out any global entry stubs.  */
13106
13107 static bfd_boolean
13108 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13109 {
13110   struct bfd_link_info *info;
13111   struct ppc_link_hash_table *htab;
13112   struct plt_entry *pent;
13113   asection *s;
13114
13115   if (h->root.type == bfd_link_hash_indirect)
13116     return TRUE;
13117
13118   if (!h->pointer_equality_needed)
13119     return TRUE;
13120
13121   if (h->def_regular)
13122     return TRUE;
13123
13124   info = inf;
13125   htab = ppc_hash_table (info);
13126   if (htab == NULL)
13127     return FALSE;
13128
13129   s = htab->glink;
13130   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13131     if (pent->plt.offset != (bfd_vma) -1
13132         && pent->addend == 0)
13133       {
13134         bfd_byte *p;
13135         asection *plt;
13136         bfd_vma off;
13137
13138         p = s->contents + h->root.u.def.value;
13139         plt = htab->elf.splt;
13140         if (!htab->elf.dynamic_sections_created
13141             || h->dynindx == -1)
13142           plt = htab->elf.iplt;
13143         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13144         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13145
13146         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13147           {
13148             info->callbacks->einfo
13149               (_("%P: linkage table error against `%T'\n"),
13150                h->root.root.string);
13151             bfd_set_error (bfd_error_bad_value);
13152             htab->stub_error = TRUE;
13153           }
13154
13155         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13156         if (htab->params->emit_stub_syms)
13157           {
13158             size_t len = strlen (h->root.root.string);
13159             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13160
13161             if (name == NULL)
13162               return FALSE;
13163
13164             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13165             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13166             if (h == NULL)
13167               return FALSE;
13168             if (h->root.type == bfd_link_hash_new)
13169               {
13170                 h->root.type = bfd_link_hash_defined;
13171                 h->root.u.def.section = s;
13172                 h->root.u.def.value = p - s->contents;
13173                 h->ref_regular = 1;
13174                 h->def_regular = 1;
13175                 h->ref_regular_nonweak = 1;
13176                 h->forced_local = 1;
13177                 h->non_elf = 0;
13178                 h->root.linker_def = 1;
13179               }
13180           }
13181
13182         if (PPC_HA (off) != 0)
13183           {
13184             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13185             p += 4;
13186           }
13187         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13188         p += 4;
13189         bfd_put_32 (s->owner, MTCTR_R12, p);
13190         p += 4;
13191         bfd_put_32 (s->owner, BCTR, p);
13192         break;
13193       }
13194   return TRUE;
13195 }
13196
13197 /* Build all the stubs associated with the current output file.
13198    The stubs are kept in a hash table attached to the main linker
13199    hash table.  This function is called via gldelf64ppc_finish.  */
13200
13201 bfd_boolean
13202 ppc64_elf_build_stubs (struct bfd_link_info *info,
13203                        char **stats)
13204 {
13205   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13206   struct map_stub *group;
13207   asection *stub_sec;
13208   bfd_byte *p;
13209   int stub_sec_count = 0;
13210
13211   if (htab == NULL)
13212     return FALSE;
13213
13214   /* Allocate memory to hold the linker stubs.  */
13215   for (group = htab->group; group != NULL; group = group->next)
13216     if ((stub_sec = group->stub_sec) != NULL
13217         && stub_sec->size != 0)
13218       {
13219         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13220         if (stub_sec->contents == NULL)
13221           return FALSE;
13222         stub_sec->size = 0;
13223       }
13224
13225   if (htab->glink != NULL && htab->glink->size != 0)
13226     {
13227       unsigned int indx;
13228       bfd_vma plt0;
13229
13230       /* Build the .glink plt call stub.  */
13231       if (htab->params->emit_stub_syms)
13232         {
13233           struct elf_link_hash_entry *h;
13234           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13235                                     TRUE, FALSE, FALSE);
13236           if (h == NULL)
13237             return FALSE;
13238           if (h->root.type == bfd_link_hash_new)
13239             {
13240               h->root.type = bfd_link_hash_defined;
13241               h->root.u.def.section = htab->glink;
13242               h->root.u.def.value = 8;
13243               h->ref_regular = 1;
13244               h->def_regular = 1;
13245               h->ref_regular_nonweak = 1;
13246               h->forced_local = 1;
13247               h->non_elf = 0;
13248               h->root.linker_def = 1;
13249             }
13250         }
13251       plt0 = (htab->elf.splt->output_section->vma
13252               + htab->elf.splt->output_offset
13253               - 16);
13254       if (info->emitrelocations)
13255         {
13256           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13257           if (r == NULL)
13258             return FALSE;
13259           r->r_offset = (htab->glink->output_offset
13260                          + htab->glink->output_section->vma);
13261           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13262           r->r_addend = plt0;
13263         }
13264       p = htab->glink->contents;
13265       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13266       bfd_put_64 (htab->glink->owner, plt0, p);
13267       p += 8;
13268       if (htab->opd_abi)
13269         {
13270           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13271           p += 4;
13272           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13273           p += 4;
13274           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13275           p += 4;
13276           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13277           p += 4;
13278           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13279           p += 4;
13280           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13281           p += 4;
13282           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13283           p += 4;
13284           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13285           p += 4;
13286           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13287           p += 4;
13288           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13289           p += 4;
13290         }
13291       else
13292         {
13293           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13294           p += 4;
13295           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13296           p += 4;
13297           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13298           p += 4;
13299           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13300           p += 4;
13301           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13302           p += 4;
13303           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13304           p += 4;
13305           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13306           p += 4;
13307           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13308           p += 4;
13309           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13310           p += 4;
13311           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13312           p += 4;
13313           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13314           p += 4;
13315           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13316           p += 4;
13317           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13318           p += 4;
13319         }
13320       bfd_put_32 (htab->glink->owner, BCTR, p);
13321       p += 4;
13322       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13323         {
13324           bfd_put_32 (htab->glink->owner, NOP, p);
13325           p += 4;
13326         }
13327
13328       /* Build the .glink lazy link call stubs.  */
13329       indx = 0;
13330       while (p < htab->glink->contents + htab->glink->rawsize)
13331         {
13332           if (htab->opd_abi)
13333             {
13334               if (indx < 0x8000)
13335                 {
13336                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13337                   p += 4;
13338                 }
13339               else
13340                 {
13341                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13342                   p += 4;
13343                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13344                               p);
13345                   p += 4;
13346                 }
13347             }
13348           bfd_put_32 (htab->glink->owner,
13349                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13350           indx++;
13351           p += 4;
13352         }
13353
13354       /* Build .glink global entry stubs.  */
13355       if (htab->glink->size > htab->glink->rawsize)
13356         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13357     }
13358
13359   if (htab->brlt != NULL && htab->brlt->size != 0)
13360     {
13361       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13362                                          htab->brlt->size);
13363       if (htab->brlt->contents == NULL)
13364         return FALSE;
13365     }
13366   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13367     {
13368       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13369                                             htab->relbrlt->size);
13370       if (htab->relbrlt->contents == NULL)
13371         return FALSE;
13372     }
13373
13374   /* Build the stubs as directed by the stub hash table.  */
13375   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13376
13377   for (group = htab->group; group != NULL; group = group->next)
13378     if (group->needs_save_res)
13379       {
13380         stub_sec = group->stub_sec;
13381         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13382                 htab->sfpr->size);
13383         if (htab->params->emit_stub_syms)
13384           {
13385             unsigned int i;
13386
13387             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13388               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13389                 return FALSE;
13390           }
13391         stub_sec->size += htab->sfpr->size;
13392       }
13393
13394   if (htab->relbrlt != NULL)
13395     htab->relbrlt->reloc_count = 0;
13396
13397   if (htab->params->plt_stub_align != 0)
13398     for (group = htab->group; group != NULL; group = group->next)
13399       if ((stub_sec = group->stub_sec) != NULL)
13400         stub_sec->size = ((stub_sec->size
13401                            + (1 << htab->params->plt_stub_align) - 1)
13402                           & -(1 << htab->params->plt_stub_align));
13403
13404   for (group = htab->group; group != NULL; group = group->next)
13405     if ((stub_sec = group->stub_sec) != NULL)
13406       {
13407         stub_sec_count += 1;
13408         if (stub_sec->rawsize != stub_sec->size
13409             && (htab->stub_iteration <= STUB_SHRINK_ITER
13410                 || stub_sec->rawsize < stub_sec->size))
13411           break;
13412       }
13413
13414   if (group != NULL)
13415     {
13416       htab->stub_error = TRUE;
13417       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13418     }
13419
13420   if (htab->stub_error)
13421     return FALSE;
13422
13423   if (stats != NULL)
13424     {
13425       *stats = bfd_malloc (500);
13426       if (*stats == NULL)
13427         return FALSE;
13428
13429       sprintf (*stats, _("linker stubs in %u group%s\n"
13430                          "  branch       %lu\n"
13431                          "  toc adjust   %lu\n"
13432                          "  long branch  %lu\n"
13433                          "  long toc adj %lu\n"
13434                          "  plt call     %lu\n"
13435                          "  plt call toc %lu\n"
13436                          "  global entry %lu"),
13437                stub_sec_count,
13438                stub_sec_count == 1 ? "" : "s",
13439                htab->stub_count[ppc_stub_long_branch - 1],
13440                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13441                htab->stub_count[ppc_stub_plt_branch - 1],
13442                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13443                htab->stub_count[ppc_stub_plt_call - 1],
13444                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13445                htab->stub_count[ppc_stub_global_entry - 1]);
13446     }
13447   return TRUE;
13448 }
13449
13450 /* What to do when ld finds relocations against symbols defined in
13451    discarded sections.  */
13452
13453 static unsigned int
13454 ppc64_elf_action_discarded (asection *sec)
13455 {
13456   if (strcmp (".opd", sec->name) == 0)
13457     return 0;
13458
13459   if (strcmp (".toc", sec->name) == 0)
13460     return 0;
13461
13462   if (strcmp (".toc1", sec->name) == 0)
13463     return 0;
13464
13465   return _bfd_elf_default_action_discarded (sec);
13466 }
13467
13468 /* The RELOCATE_SECTION function is called by the ELF backend linker
13469    to handle the relocations for a section.
13470
13471    The relocs are always passed as Rela structures; if the section
13472    actually uses Rel structures, the r_addend field will always be
13473    zero.
13474
13475    This function is responsible for adjust the section contents as
13476    necessary, and (if using Rela relocs and generating a
13477    relocatable output file) adjusting the reloc addend as
13478    necessary.
13479
13480    This function does not have to worry about setting the reloc
13481    address or the reloc symbol index.
13482
13483    LOCAL_SYMS is a pointer to the swapped in local symbols.
13484
13485    LOCAL_SECTIONS is an array giving the section in the input file
13486    corresponding to the st_shndx field of each local symbol.
13487
13488    The global hash table entry for the global symbols can be found
13489    via elf_sym_hashes (input_bfd).
13490
13491    When generating relocatable output, this function must handle
13492    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13493    going to be the section symbol corresponding to the output
13494    section, which means that the addend must be adjusted
13495    accordingly.  */
13496
13497 static bfd_boolean
13498 ppc64_elf_relocate_section (bfd *output_bfd,
13499                             struct bfd_link_info *info,
13500                             bfd *input_bfd,
13501                             asection *input_section,
13502                             bfd_byte *contents,
13503                             Elf_Internal_Rela *relocs,
13504                             Elf_Internal_Sym *local_syms,
13505                             asection **local_sections)
13506 {
13507   struct ppc_link_hash_table *htab;
13508   Elf_Internal_Shdr *symtab_hdr;
13509   struct elf_link_hash_entry **sym_hashes;
13510   Elf_Internal_Rela *rel;
13511   Elf_Internal_Rela *wrel;
13512   Elf_Internal_Rela *relend;
13513   Elf_Internal_Rela outrel;
13514   bfd_byte *loc;
13515   struct got_entry **local_got_ents;
13516   bfd_vma TOCstart;
13517   bfd_boolean ret = TRUE;
13518   bfd_boolean is_opd;
13519   /* Assume 'at' branch hints.  */
13520   bfd_boolean is_isa_v2 = TRUE;
13521   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13522
13523   /* Initialize howto table if needed.  */
13524   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13525     ppc_howto_init ();
13526
13527   htab = ppc_hash_table (info);
13528   if (htab == NULL)
13529     return FALSE;
13530
13531   /* Don't relocate stub sections.  */
13532   if (input_section->owner == htab->params->stub_bfd)
13533     return TRUE;
13534
13535   BFD_ASSERT (is_ppc64_elf (input_bfd));
13536
13537   local_got_ents = elf_local_got_ents (input_bfd);
13538   TOCstart = elf_gp (output_bfd);
13539   symtab_hdr = &elf_symtab_hdr (input_bfd);
13540   sym_hashes = elf_sym_hashes (input_bfd);
13541   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13542
13543   rel = wrel = relocs;
13544   relend = relocs + input_section->reloc_count;
13545   for (; rel < relend; wrel++, rel++)
13546     {
13547       enum elf_ppc64_reloc_type r_type;
13548       bfd_vma addend;
13549       bfd_reloc_status_type r;
13550       Elf_Internal_Sym *sym;
13551       asection *sec;
13552       struct elf_link_hash_entry *h_elf;
13553       struct ppc_link_hash_entry *h;
13554       struct ppc_link_hash_entry *fdh;
13555       const char *sym_name;
13556       unsigned long r_symndx, toc_symndx;
13557       bfd_vma toc_addend;
13558       unsigned char tls_mask, tls_gd, tls_type;
13559       unsigned char sym_type;
13560       bfd_vma relocation;
13561       bfd_boolean unresolved_reloc;
13562       bfd_boolean warned;
13563       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13564       unsigned int insn;
13565       unsigned int mask;
13566       struct ppc_stub_hash_entry *stub_entry;
13567       bfd_vma max_br_offset;
13568       bfd_vma from;
13569       Elf_Internal_Rela orig_rel;
13570       reloc_howto_type *howto;
13571       struct reloc_howto_struct alt_howto;
13572
13573     again:
13574       orig_rel = *rel;
13575
13576       r_type = ELF64_R_TYPE (rel->r_info);
13577       r_symndx = ELF64_R_SYM (rel->r_info);
13578
13579       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13580          symbol of the previous ADDR64 reloc.  The symbol gives us the
13581          proper TOC base to use.  */
13582       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13583           && wrel != relocs
13584           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13585           && is_opd)
13586         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13587
13588       sym = NULL;
13589       sec = NULL;
13590       h_elf = NULL;
13591       sym_name = NULL;
13592       unresolved_reloc = FALSE;
13593       warned = FALSE;
13594
13595       if (r_symndx < symtab_hdr->sh_info)
13596         {
13597           /* It's a local symbol.  */
13598           struct _opd_sec_data *opd;
13599
13600           sym = local_syms + r_symndx;
13601           sec = local_sections[r_symndx];
13602           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13603           sym_type = ELF64_ST_TYPE (sym->st_info);
13604           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13605           opd = get_opd_info (sec);
13606           if (opd != NULL && opd->adjust != NULL)
13607             {
13608               long adjust = opd->adjust[OPD_NDX (sym->st_value
13609                                                  + rel->r_addend)];
13610               if (adjust == -1)
13611                 relocation = 0;
13612               else
13613                 {
13614                   /* If this is a relocation against the opd section sym
13615                      and we have edited .opd, adjust the reloc addend so
13616                      that ld -r and ld --emit-relocs output is correct.
13617                      If it is a reloc against some other .opd symbol,
13618                      then the symbol value will be adjusted later.  */
13619                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13620                     rel->r_addend += adjust;
13621                   else
13622                     relocation += adjust;
13623                 }
13624             }
13625         }
13626       else
13627         {
13628           bfd_boolean ignored;
13629
13630           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13631                                    r_symndx, symtab_hdr, sym_hashes,
13632                                    h_elf, sec, relocation,
13633                                    unresolved_reloc, warned, ignored);
13634           sym_name = h_elf->root.root.string;
13635           sym_type = h_elf->type;
13636           if (sec != NULL
13637               && sec->owner == output_bfd
13638               && strcmp (sec->name, ".opd") == 0)
13639             {
13640               /* This is a symbol defined in a linker script.  All
13641                  such are defined in output sections, even those
13642                  defined by simple assignment from a symbol defined in
13643                  an input section.  Transfer the symbol to an
13644                  appropriate input .opd section, so that a branch to
13645                  this symbol will be mapped to the location specified
13646                  by the opd entry.  */
13647               struct bfd_link_order *lo;
13648               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13649                 if (lo->type == bfd_indirect_link_order)
13650                   {
13651                     asection *isec = lo->u.indirect.section;
13652                     if (h_elf->root.u.def.value >= isec->output_offset
13653                         && h_elf->root.u.def.value < (isec->output_offset
13654                                                       + isec->size))
13655                       {
13656                         h_elf->root.u.def.value -= isec->output_offset;
13657                         h_elf->root.u.def.section = isec;
13658                         sec = isec;
13659                         break;
13660                       }
13661                   }
13662             }
13663         }
13664       h = (struct ppc_link_hash_entry *) h_elf;
13665
13666       if (sec != NULL && discarded_section (sec))
13667         {
13668           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13669                                input_bfd, input_section,
13670                                contents + rel->r_offset);
13671           wrel->r_offset = rel->r_offset;
13672           wrel->r_info = 0;
13673           wrel->r_addend = 0;
13674
13675           /* For ld -r, remove relocations in debug sections against
13676              symbols defined in discarded sections.  Not done for
13677              non-debug to preserve relocs in .eh_frame which the
13678              eh_frame editing code expects to be present.  */
13679           if (bfd_link_relocatable (info)
13680               && (input_section->flags & SEC_DEBUGGING))
13681             wrel--;
13682
13683           continue;
13684         }
13685
13686       if (bfd_link_relocatable (info))
13687         goto copy_reloc;
13688
13689       if (h != NULL && &h->elf == htab->elf.hgot)
13690         {
13691           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13692           sec = bfd_abs_section_ptr;
13693           unresolved_reloc = FALSE;
13694         }
13695
13696       /* TLS optimizations.  Replace instruction sequences and relocs
13697          based on information we collected in tls_optimize.  We edit
13698          RELOCS so that --emit-relocs will output something sensible
13699          for the final instruction stream.  */
13700       tls_mask = 0;
13701       tls_gd = 0;
13702       toc_symndx = 0;
13703       if (h != NULL)
13704         tls_mask = h->tls_mask;
13705       else if (local_got_ents != NULL)
13706         {
13707           struct plt_entry **local_plt = (struct plt_entry **)
13708             (local_got_ents + symtab_hdr->sh_info);
13709           unsigned char *lgot_masks = (unsigned char *)
13710             (local_plt + symtab_hdr->sh_info);
13711           tls_mask = lgot_masks[r_symndx];
13712         }
13713       if (tls_mask == 0
13714           && (r_type == R_PPC64_TLS
13715               || r_type == R_PPC64_TLSGD
13716               || r_type == R_PPC64_TLSLD))
13717         {
13718           /* Check for toc tls entries.  */
13719           unsigned char *toc_tls;
13720
13721           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13722                              &local_syms, rel, input_bfd))
13723             return FALSE;
13724
13725           if (toc_tls)
13726             tls_mask = *toc_tls;
13727         }
13728
13729       /* Check that tls relocs are used with tls syms, and non-tls
13730          relocs are used with non-tls syms.  */
13731       if (r_symndx != STN_UNDEF
13732           && r_type != R_PPC64_NONE
13733           && (h == NULL
13734               || h->elf.root.type == bfd_link_hash_defined
13735               || h->elf.root.type == bfd_link_hash_defweak)
13736           && (IS_PPC64_TLS_RELOC (r_type)
13737               != (sym_type == STT_TLS
13738                   || (sym_type == STT_SECTION
13739                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13740         {
13741           if (tls_mask != 0
13742               && (r_type == R_PPC64_TLS
13743                   || r_type == R_PPC64_TLSGD
13744                   || r_type == R_PPC64_TLSLD))
13745             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13746             ;
13747           else
13748             info->callbacks->einfo
13749               (!IS_PPC64_TLS_RELOC (r_type)
13750                /* xgettext:c-format */
13751                ? _("%H: %s used with TLS symbol `%T'\n")
13752                /* xgettext:c-format */
13753                : _("%H: %s used with non-TLS symbol `%T'\n"),
13754                input_bfd, input_section, rel->r_offset,
13755                ppc64_elf_howto_table[r_type]->name,
13756                sym_name);
13757         }
13758
13759       /* Ensure reloc mapping code below stays sane.  */
13760       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13761           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13762           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13763           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13764           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13765           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13766           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13767           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13768           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13769           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13770         abort ();
13771
13772       switch (r_type)
13773         {
13774         default:
13775           break;
13776
13777         case R_PPC64_LO_DS_OPT:
13778           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13779           if ((insn & (0x3f << 26)) != 58u << 26)
13780             abort ();
13781           insn += (14u << 26) - (58u << 26);
13782           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13783           r_type = R_PPC64_TOC16_LO;
13784           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13785           break;
13786
13787         case R_PPC64_TOC16:
13788         case R_PPC64_TOC16_LO:
13789         case R_PPC64_TOC16_DS:
13790         case R_PPC64_TOC16_LO_DS:
13791           {
13792             /* Check for toc tls entries.  */
13793             unsigned char *toc_tls;
13794             int retval;
13795
13796             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13797                                    &local_syms, rel, input_bfd);
13798             if (retval == 0)
13799               return FALSE;
13800
13801             if (toc_tls)
13802               {
13803                 tls_mask = *toc_tls;
13804                 if (r_type == R_PPC64_TOC16_DS
13805                     || r_type == R_PPC64_TOC16_LO_DS)
13806                   {
13807                     if (tls_mask != 0
13808                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13809                       goto toctprel;
13810                   }
13811                 else
13812                   {
13813                     /* If we found a GD reloc pair, then we might be
13814                        doing a GD->IE transition.  */
13815                     if (retval == 2)
13816                       {
13817                         tls_gd = TLS_TPRELGD;
13818                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13819                           goto tls_ldgd_opt;
13820                       }
13821                     else if (retval == 3)
13822                       {
13823                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13824                           goto tls_ldgd_opt;
13825                       }
13826                   }
13827               }
13828           }
13829           break;
13830
13831         case R_PPC64_GOT_TPREL16_HI:
13832         case R_PPC64_GOT_TPREL16_HA:
13833           if (tls_mask != 0
13834               && (tls_mask & TLS_TPREL) == 0)
13835             {
13836               rel->r_offset -= d_offset;
13837               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13838               r_type = R_PPC64_NONE;
13839               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13840             }
13841           break;
13842
13843         case R_PPC64_GOT_TPREL16_DS:
13844         case R_PPC64_GOT_TPREL16_LO_DS:
13845           if (tls_mask != 0
13846               && (tls_mask & TLS_TPREL) == 0)
13847             {
13848             toctprel:
13849               insn = bfd_get_32 (input_bfd,
13850                                  contents + rel->r_offset - d_offset);
13851               insn &= 31 << 21;
13852               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13853               bfd_put_32 (input_bfd, insn,
13854                           contents + rel->r_offset - d_offset);
13855               r_type = R_PPC64_TPREL16_HA;
13856               if (toc_symndx != 0)
13857                 {
13858                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13859                   rel->r_addend = toc_addend;
13860                   /* We changed the symbol.  Start over in order to
13861                      get h, sym, sec etc. right.  */
13862                   goto again;
13863                 }
13864               else
13865                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13866             }
13867           break;
13868
13869         case R_PPC64_TLS:
13870           if (tls_mask != 0
13871               && (tls_mask & TLS_TPREL) == 0)
13872             {
13873               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13874               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13875               if (insn == 0)
13876                 abort ();
13877               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13878               /* Was PPC64_TLS which sits on insn boundary, now
13879                  PPC64_TPREL16_LO which is at low-order half-word.  */
13880               rel->r_offset += d_offset;
13881               r_type = R_PPC64_TPREL16_LO;
13882               if (toc_symndx != 0)
13883                 {
13884                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13885                   rel->r_addend = toc_addend;
13886                   /* We changed the symbol.  Start over in order to
13887                      get h, sym, sec etc. right.  */
13888                   goto again;
13889                 }
13890               else
13891                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13892             }
13893           break;
13894
13895         case R_PPC64_GOT_TLSGD16_HI:
13896         case R_PPC64_GOT_TLSGD16_HA:
13897           tls_gd = TLS_TPRELGD;
13898           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13899             goto tls_gdld_hi;
13900           break;
13901
13902         case R_PPC64_GOT_TLSLD16_HI:
13903         case R_PPC64_GOT_TLSLD16_HA:
13904           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13905             {
13906             tls_gdld_hi:
13907               if ((tls_mask & tls_gd) != 0)
13908                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13909                           + R_PPC64_GOT_TPREL16_DS);
13910               else
13911                 {
13912                   rel->r_offset -= d_offset;
13913                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13914                   r_type = R_PPC64_NONE;
13915                 }
13916               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13917             }
13918           break;
13919
13920         case R_PPC64_GOT_TLSGD16:
13921         case R_PPC64_GOT_TLSGD16_LO:
13922           tls_gd = TLS_TPRELGD;
13923           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13924             goto tls_ldgd_opt;
13925           break;
13926
13927         case R_PPC64_GOT_TLSLD16:
13928         case R_PPC64_GOT_TLSLD16_LO:
13929           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13930             {
13931               unsigned int insn1, insn2;
13932               bfd_vma offset;
13933
13934             tls_ldgd_opt:
13935               offset = (bfd_vma) -1;
13936               /* If not using the newer R_PPC64_TLSGD/LD to mark
13937                  __tls_get_addr calls, we must trust that the call
13938                  stays with its arg setup insns, ie. that the next
13939                  reloc is the __tls_get_addr call associated with
13940                  the current reloc.  Edit both insns.  */
13941               if (input_section->has_tls_get_addr_call
13942                   && rel + 1 < relend
13943                   && branch_reloc_hash_match (input_bfd, rel + 1,
13944                                               htab->tls_get_addr,
13945                                               htab->tls_get_addr_fd))
13946                 offset = rel[1].r_offset;
13947               /* We read the low GOT_TLS (or TOC16) insn because we
13948                  need to keep the destination reg.  It may be
13949                  something other than the usual r3, and moved to r3
13950                  before the call by intervening code.  */
13951               insn1 = bfd_get_32 (input_bfd,
13952                                   contents + rel->r_offset - d_offset);
13953               if ((tls_mask & tls_gd) != 0)
13954                 {
13955                   /* IE */
13956                   insn1 &= (0x1f << 21) | (0x1f << 16);
13957                   insn1 |= 58 << 26;    /* ld */
13958                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13959                   if (offset != (bfd_vma) -1)
13960                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13961                   if ((tls_mask & TLS_EXPLICIT) == 0)
13962                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13963                               + R_PPC64_GOT_TPREL16_DS);
13964                   else
13965                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13966                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13967                 }
13968               else
13969                 {
13970                   /* LE */
13971                   insn1 &= 0x1f << 21;
13972                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13973                   insn2 = 0x38630000;   /* addi 3,3,0 */
13974                   if (tls_gd == 0)
13975                     {
13976                       /* Was an LD reloc.  */
13977                       if (toc_symndx)
13978                         sec = local_sections[toc_symndx];
13979                       for (r_symndx = 0;
13980                            r_symndx < symtab_hdr->sh_info;
13981                            r_symndx++)
13982                         if (local_sections[r_symndx] == sec)
13983                           break;
13984                       if (r_symndx >= symtab_hdr->sh_info)
13985                         r_symndx = STN_UNDEF;
13986                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13987                       if (r_symndx != STN_UNDEF)
13988                         rel->r_addend -= (local_syms[r_symndx].st_value
13989                                           + sec->output_offset
13990                                           + sec->output_section->vma);
13991                     }
13992                   else if (toc_symndx != 0)
13993                     {
13994                       r_symndx = toc_symndx;
13995                       rel->r_addend = toc_addend;
13996                     }
13997                   r_type = R_PPC64_TPREL16_HA;
13998                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13999                   if (offset != (bfd_vma) -1)
14000                     {
14001                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14002                                                     R_PPC64_TPREL16_LO);
14003                       rel[1].r_offset = offset + d_offset;
14004                       rel[1].r_addend = rel->r_addend;
14005                     }
14006                 }
14007               bfd_put_32 (input_bfd, insn1,
14008                           contents + rel->r_offset - d_offset);
14009               if (offset != (bfd_vma) -1)
14010                 bfd_put_32 (input_bfd, insn2, contents + offset);
14011               if ((tls_mask & tls_gd) == 0
14012                   && (tls_gd == 0 || toc_symndx != 0))
14013                 {
14014                   /* We changed the symbol.  Start over in order
14015                      to get h, sym, sec etc. right.  */
14016                   goto again;
14017                 }
14018             }
14019           break;
14020
14021         case R_PPC64_TLSGD:
14022           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
14023             {
14024               unsigned int insn2;
14025               bfd_vma offset = rel->r_offset;
14026
14027               if ((tls_mask & TLS_TPRELGD) != 0)
14028                 {
14029                   /* IE */
14030                   r_type = R_PPC64_NONE;
14031                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14032                 }
14033               else
14034                 {
14035                   /* LE */
14036                   if (toc_symndx != 0)
14037                     {
14038                       r_symndx = toc_symndx;
14039                       rel->r_addend = toc_addend;
14040                     }
14041                   r_type = R_PPC64_TPREL16_LO;
14042                   rel->r_offset = offset + d_offset;
14043                   insn2 = 0x38630000;   /* addi 3,3,0 */
14044                 }
14045               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14046               /* Zap the reloc on the _tls_get_addr call too.  */
14047               BFD_ASSERT (offset == rel[1].r_offset);
14048               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14049               bfd_put_32 (input_bfd, insn2, contents + offset);
14050               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14051                 goto again;
14052             }
14053           break;
14054
14055         case R_PPC64_TLSLD:
14056           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14057             {
14058               unsigned int insn2;
14059               bfd_vma offset = rel->r_offset;
14060
14061               if (toc_symndx)
14062                 sec = local_sections[toc_symndx];
14063               for (r_symndx = 0;
14064                    r_symndx < symtab_hdr->sh_info;
14065                    r_symndx++)
14066                 if (local_sections[r_symndx] == sec)
14067                   break;
14068               if (r_symndx >= symtab_hdr->sh_info)
14069                 r_symndx = STN_UNDEF;
14070               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14071               if (r_symndx != STN_UNDEF)
14072                 rel->r_addend -= (local_syms[r_symndx].st_value
14073                                   + sec->output_offset
14074                                   + sec->output_section->vma);
14075
14076               r_type = R_PPC64_TPREL16_LO;
14077               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14078               rel->r_offset = offset + d_offset;
14079               /* Zap the reloc on the _tls_get_addr call too.  */
14080               BFD_ASSERT (offset == rel[1].r_offset);
14081               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14082               insn2 = 0x38630000;       /* addi 3,3,0 */
14083               bfd_put_32 (input_bfd, insn2, contents + offset);
14084               goto again;
14085             }
14086           break;
14087
14088         case R_PPC64_DTPMOD64:
14089           if (rel + 1 < relend
14090               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14091               && rel[1].r_offset == rel->r_offset + 8)
14092             {
14093               if ((tls_mask & TLS_GD) == 0)
14094                 {
14095                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14096                   if ((tls_mask & TLS_TPRELGD) != 0)
14097                     r_type = R_PPC64_TPREL64;
14098                   else
14099                     {
14100                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14101                       r_type = R_PPC64_NONE;
14102                     }
14103                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14104                 }
14105             }
14106           else
14107             {
14108               if ((tls_mask & TLS_LD) == 0)
14109                 {
14110                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14111                   r_type = R_PPC64_NONE;
14112                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14113                 }
14114             }
14115           break;
14116
14117         case R_PPC64_TPREL64:
14118           if ((tls_mask & TLS_TPREL) == 0)
14119             {
14120               r_type = R_PPC64_NONE;
14121               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14122             }
14123           break;
14124
14125         case R_PPC64_ENTRY:
14126           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14127           if (!bfd_link_pic (info)
14128               && !info->traditional_format
14129               && relocation + 0x80008000 <= 0xffffffff)
14130             {
14131               unsigned int insn1, insn2;
14132
14133               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14134               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14135               if ((insn1 & ~0xfffc) == LD_R2_0R12
14136                   && insn2 == ADD_R2_R2_R12)
14137                 {
14138                   bfd_put_32 (input_bfd,
14139                               LIS_R2 + PPC_HA (relocation),
14140                               contents + rel->r_offset);
14141                   bfd_put_32 (input_bfd,
14142                               ADDI_R2_R2 + PPC_LO (relocation),
14143                               contents + rel->r_offset + 4);
14144                 }
14145             }
14146           else
14147             {
14148               relocation -= (rel->r_offset
14149                              + input_section->output_offset
14150                              + input_section->output_section->vma);
14151               if (relocation + 0x80008000 <= 0xffffffff)
14152                 {
14153                   unsigned int insn1, insn2;
14154
14155                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14156                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14157                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14158                       && insn2 == ADD_R2_R2_R12)
14159                     {
14160                       bfd_put_32 (input_bfd,
14161                                   ADDIS_R2_R12 + PPC_HA (relocation),
14162                                   contents + rel->r_offset);
14163                       bfd_put_32 (input_bfd,
14164                                   ADDI_R2_R2 + PPC_LO (relocation),
14165                                   contents + rel->r_offset + 4);
14166                     }
14167                 }
14168             }
14169           break;
14170
14171         case R_PPC64_REL16_HA:
14172           /* If we are generating a non-PIC executable, edit
14173              .  0:      addis 2,12,.TOC.-0b@ha
14174              .          addi 2,2,.TOC.-0b@l
14175              used by ELFv2 global entry points to set up r2, to
14176              .          lis 2,.TOC.@ha
14177              .          addi 2,2,.TOC.@l
14178              if .TOC. is in range.  */
14179           if (!bfd_link_pic (info)
14180               && !info->traditional_format
14181               && !htab->opd_abi
14182               && rel->r_addend == d_offset
14183               && h != NULL && &h->elf == htab->elf.hgot
14184               && rel + 1 < relend
14185               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14186               && rel[1].r_offset == rel->r_offset + 4
14187               && rel[1].r_addend == rel->r_addend + 4
14188               && relocation + 0x80008000 <= 0xffffffff)
14189             {
14190               unsigned int insn1, insn2;
14191               bfd_vma offset = rel->r_offset - d_offset;
14192               insn1 = bfd_get_32 (input_bfd, contents + offset);
14193               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14194               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14195                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14196                 {
14197                   r_type = R_PPC64_ADDR16_HA;
14198                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14199                   rel->r_addend -= d_offset;
14200                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14201                   rel[1].r_addend -= d_offset + 4;
14202                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14203                 }
14204             }
14205           break;
14206         }
14207
14208       /* Handle other relocations that tweak non-addend part of insn.  */
14209       insn = 0;
14210       max_br_offset = 1 << 25;
14211       addend = rel->r_addend;
14212       reloc_dest = DEST_NORMAL;
14213       switch (r_type)
14214         {
14215         default:
14216           break;
14217
14218         case R_PPC64_TOCSAVE:
14219           if (relocation + addend == (rel->r_offset
14220                                       + input_section->output_offset
14221                                       + input_section->output_section->vma)
14222               && tocsave_find (htab, NO_INSERT,
14223                                &local_syms, rel, input_bfd))
14224             {
14225               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14226               if (insn == NOP
14227                   || insn == CROR_151515 || insn == CROR_313131)
14228                 bfd_put_32 (input_bfd,
14229                             STD_R2_0R1 + STK_TOC (htab),
14230                             contents + rel->r_offset);
14231             }
14232           break;
14233
14234           /* Branch taken prediction relocations.  */
14235         case R_PPC64_ADDR14_BRTAKEN:
14236         case R_PPC64_REL14_BRTAKEN:
14237           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14238           /* Fall through.  */
14239
14240           /* Branch not taken prediction relocations.  */
14241         case R_PPC64_ADDR14_BRNTAKEN:
14242         case R_PPC64_REL14_BRNTAKEN:
14243           insn |= bfd_get_32 (input_bfd,
14244                               contents + rel->r_offset) & ~(0x01 << 21);
14245           /* Fall through.  */
14246
14247         case R_PPC64_REL14:
14248           max_br_offset = 1 << 15;
14249           /* Fall through.  */
14250
14251         case R_PPC64_REL24:
14252           /* Calls to functions with a different TOC, such as calls to
14253              shared objects, need to alter the TOC pointer.  This is
14254              done using a linkage stub.  A REL24 branching to these
14255              linkage stubs needs to be followed by a nop, as the nop
14256              will be replaced with an instruction to restore the TOC
14257              base pointer.  */
14258           fdh = h;
14259           if (h != NULL
14260               && h->oh != NULL
14261               && h->oh->is_func_descriptor)
14262             fdh = ppc_follow_link (h->oh);
14263           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14264                                            htab);
14265           if (stub_entry != NULL
14266               && (stub_entry->stub_type == ppc_stub_plt_call
14267                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14268                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14269                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14270             {
14271               bfd_boolean can_plt_call = FALSE;
14272
14273               if (stub_entry->stub_type == ppc_stub_plt_call
14274                   && !htab->opd_abi
14275                   && htab->params->plt_localentry0 != 0
14276                   && is_elfv2_localentry0 (&h->elf))
14277                 {
14278                   /* The function doesn't use or change r2.  */
14279                   can_plt_call = TRUE;
14280                 }
14281
14282               /* All of these stubs may modify r2, so there must be a
14283                  branch and link followed by a nop.  The nop is
14284                  replaced by an insn to restore r2.  */
14285               else if (rel->r_offset + 8 <= input_section->size)
14286                 {
14287                   unsigned long br;
14288
14289                   br = bfd_get_32 (input_bfd,
14290                                    contents + rel->r_offset);
14291                   if ((br & 1) != 0)
14292                     {
14293                       unsigned long nop;
14294
14295                       nop = bfd_get_32 (input_bfd,
14296                                         contents + rel->r_offset + 4);
14297                       if (nop == NOP
14298                           || nop == CROR_151515 || nop == CROR_313131)
14299                         {
14300                           if (h != NULL
14301                               && (h == htab->tls_get_addr_fd
14302                                   || h == htab->tls_get_addr)
14303                               && htab->params->tls_get_addr_opt)
14304                             {
14305                               /* Special stub used, leave nop alone.  */
14306                             }
14307                           else
14308                             bfd_put_32 (input_bfd,
14309                                         LD_R2_0R1 + STK_TOC (htab),
14310                                         contents + rel->r_offset + 4);
14311                           can_plt_call = TRUE;
14312                         }
14313                     }
14314                 }
14315
14316               if (!can_plt_call && h != NULL)
14317                 {
14318                   const char *name = h->elf.root.root.string;
14319
14320                   if (*name == '.')
14321                     ++name;
14322
14323                   if (strncmp (name, "__libc_start_main", 17) == 0
14324                       && (name[17] == 0 || name[17] == '@'))
14325                     {
14326                       /* Allow crt1 branch to go via a toc adjusting
14327                          stub.  Other calls that never return could do
14328                          the same, if we could detect such.  */
14329                       can_plt_call = TRUE;
14330                     }
14331                 }
14332
14333               if (!can_plt_call)
14334                 {
14335                   /* g++ as of 20130507 emits self-calls without a
14336                      following nop.  This is arguably wrong since we
14337                      have conflicting information.  On the one hand a
14338                      global symbol and on the other a local call
14339                      sequence, but don't error for this special case.
14340                      It isn't possible to cheaply verify we have
14341                      exactly such a call.  Allow all calls to the same
14342                      section.  */
14343                   asection *code_sec = sec;
14344
14345                   if (get_opd_info (sec) != NULL)
14346                     {
14347                       bfd_vma off = (relocation + addend
14348                                      - sec->output_section->vma
14349                                      - sec->output_offset);
14350
14351                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14352                     }
14353                   if (code_sec == input_section)
14354                     can_plt_call = TRUE;
14355                 }
14356
14357               if (!can_plt_call)
14358                 {
14359                   if (stub_entry->stub_type == ppc_stub_plt_call
14360                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14361                     info->callbacks->einfo
14362                       /* xgettext:c-format */
14363                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14364                          "recompile with -fPIC\n"),
14365                        input_bfd, input_section, rel->r_offset, sym_name);
14366                   else
14367                     info->callbacks->einfo
14368                       /* xgettext:c-format */
14369                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14370                          "(-mcmodel=small toc adjust stub)\n"),
14371                        input_bfd, input_section, rel->r_offset, sym_name);
14372
14373                   bfd_set_error (bfd_error_bad_value);
14374                   ret = FALSE;
14375                 }
14376
14377               if (can_plt_call
14378                   && (stub_entry->stub_type == ppc_stub_plt_call
14379                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14380                 unresolved_reloc = FALSE;
14381             }
14382
14383           if ((stub_entry == NULL
14384                || stub_entry->stub_type == ppc_stub_long_branch
14385                || stub_entry->stub_type == ppc_stub_plt_branch)
14386               && get_opd_info (sec) != NULL)
14387             {
14388               /* The branch destination is the value of the opd entry. */
14389               bfd_vma off = (relocation + addend
14390                              - sec->output_section->vma
14391                              - sec->output_offset);
14392               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14393               if (dest != (bfd_vma) -1)
14394                 {
14395                   relocation = dest;
14396                   addend = 0;
14397                   reloc_dest = DEST_OPD;
14398                 }
14399             }
14400
14401           /* If the branch is out of reach we ought to have a long
14402              branch stub.  */
14403           from = (rel->r_offset
14404                   + input_section->output_offset
14405                   + input_section->output_section->vma);
14406
14407           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14408                                                   ? fdh->elf.other
14409                                                   : sym->st_other);
14410
14411           if (stub_entry != NULL
14412               && (stub_entry->stub_type == ppc_stub_long_branch
14413                   || stub_entry->stub_type == ppc_stub_plt_branch)
14414               && (r_type == R_PPC64_ADDR14_BRTAKEN
14415                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14416                   || (relocation + addend - from + max_br_offset
14417                       < 2 * max_br_offset)))
14418             /* Don't use the stub if this branch is in range.  */
14419             stub_entry = NULL;
14420
14421           if (stub_entry != NULL)
14422             {
14423               /* Munge up the value and addend so that we call the stub
14424                  rather than the procedure directly.  */
14425               asection *stub_sec = stub_entry->group->stub_sec;
14426
14427               if (stub_entry->stub_type == ppc_stub_save_res)
14428                 relocation += (stub_sec->output_offset
14429                                + stub_sec->output_section->vma
14430                                + stub_sec->size - htab->sfpr->size
14431                                - htab->sfpr->output_offset
14432                                - htab->sfpr->output_section->vma);
14433               else
14434                 relocation = (stub_entry->stub_offset
14435                               + stub_sec->output_offset
14436                               + stub_sec->output_section->vma);
14437               addend = 0;
14438               reloc_dest = DEST_STUB;
14439
14440               if ((stub_entry->stub_type == ppc_stub_plt_call
14441                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14442                   && (ALWAYS_EMIT_R2SAVE
14443                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14444                   && rel + 1 < relend
14445                   && rel[1].r_offset == rel->r_offset + 4
14446                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14447                 relocation += 4;
14448             }
14449
14450           if (insn != 0)
14451             {
14452               if (is_isa_v2)
14453                 {
14454                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14455                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14456                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14457                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14458                     insn |= 0x02 << 21;
14459                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14460                     insn |= 0x08 << 21;
14461                   else
14462                     break;
14463                 }
14464               else
14465                 {
14466                   /* Invert 'y' bit if not the default.  */
14467                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14468                     insn ^= 0x01 << 21;
14469                 }
14470
14471               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14472             }
14473
14474           /* NOP out calls to undefined weak functions.
14475              We can thus call a weak function without first
14476              checking whether the function is defined.  */
14477           else if (h != NULL
14478                    && h->elf.root.type == bfd_link_hash_undefweak
14479                    && h->elf.dynindx == -1
14480                    && r_type == R_PPC64_REL24
14481                    && relocation == 0
14482                    && addend == 0)
14483             {
14484               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14485               goto copy_reloc;
14486             }
14487           break;
14488         }
14489
14490       /* Set `addend'.  */
14491       tls_type = 0;
14492       switch (r_type)
14493         {
14494         default:
14495           info->callbacks->einfo
14496             /* xgettext:c-format */
14497             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14498              input_bfd, (int) r_type, sym_name);
14499
14500           bfd_set_error (bfd_error_bad_value);
14501           ret = FALSE;
14502           goto copy_reloc;
14503
14504         case R_PPC64_NONE:
14505         case R_PPC64_TLS:
14506         case R_PPC64_TLSGD:
14507         case R_PPC64_TLSLD:
14508         case R_PPC64_TOCSAVE:
14509         case R_PPC64_GNU_VTINHERIT:
14510         case R_PPC64_GNU_VTENTRY:
14511         case R_PPC64_ENTRY:
14512           goto copy_reloc;
14513
14514           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14515              address in the GOT as relocation value instead of the
14516              symbol's value itself.  Also, create a GOT entry for the
14517              symbol and put the symbol value there.  */
14518         case R_PPC64_GOT_TLSGD16:
14519         case R_PPC64_GOT_TLSGD16_LO:
14520         case R_PPC64_GOT_TLSGD16_HI:
14521         case R_PPC64_GOT_TLSGD16_HA:
14522           tls_type = TLS_TLS | TLS_GD;
14523           goto dogot;
14524
14525         case R_PPC64_GOT_TLSLD16:
14526         case R_PPC64_GOT_TLSLD16_LO:
14527         case R_PPC64_GOT_TLSLD16_HI:
14528         case R_PPC64_GOT_TLSLD16_HA:
14529           tls_type = TLS_TLS | TLS_LD;
14530           goto dogot;
14531
14532         case R_PPC64_GOT_TPREL16_DS:
14533         case R_PPC64_GOT_TPREL16_LO_DS:
14534         case R_PPC64_GOT_TPREL16_HI:
14535         case R_PPC64_GOT_TPREL16_HA:
14536           tls_type = TLS_TLS | TLS_TPREL;
14537           goto dogot;
14538
14539         case R_PPC64_GOT_DTPREL16_DS:
14540         case R_PPC64_GOT_DTPREL16_LO_DS:
14541         case R_PPC64_GOT_DTPREL16_HI:
14542         case R_PPC64_GOT_DTPREL16_HA:
14543           tls_type = TLS_TLS | TLS_DTPREL;
14544           goto dogot;
14545
14546         case R_PPC64_GOT16:
14547         case R_PPC64_GOT16_LO:
14548         case R_PPC64_GOT16_HI:
14549         case R_PPC64_GOT16_HA:
14550         case R_PPC64_GOT16_DS:
14551         case R_PPC64_GOT16_LO_DS:
14552         dogot:
14553           {
14554             /* Relocation is to the entry for this symbol in the global
14555                offset table.  */
14556             asection *got;
14557             bfd_vma *offp;
14558             bfd_vma off;
14559             unsigned long indx = 0;
14560             struct got_entry *ent;
14561
14562             if (tls_type == (TLS_TLS | TLS_LD)
14563                 && (h == NULL
14564                     || !h->elf.def_dynamic))
14565               ent = ppc64_tlsld_got (input_bfd);
14566             else
14567               {
14568                 if (h != NULL)
14569                   {
14570                     if (!htab->elf.dynamic_sections_created
14571                         || h->elf.dynindx == -1
14572                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14573                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14574                       /* This is actually a static link, or it is a
14575                          -Bsymbolic link and the symbol is defined
14576                          locally, or the symbol was forced to be local
14577                          because of a version file.  */
14578                       ;
14579                     else
14580                       {
14581                         indx = h->elf.dynindx;
14582                         unresolved_reloc = FALSE;
14583                       }
14584                     ent = h->elf.got.glist;
14585                   }
14586                 else
14587                   {
14588                     if (local_got_ents == NULL)
14589                       abort ();
14590                     ent = local_got_ents[r_symndx];
14591                   }
14592
14593                 for (; ent != NULL; ent = ent->next)
14594                   if (ent->addend == orig_rel.r_addend
14595                       && ent->owner == input_bfd
14596                       && ent->tls_type == tls_type)
14597                     break;
14598               }
14599
14600             if (ent == NULL)
14601               abort ();
14602             if (ent->is_indirect)
14603               ent = ent->got.ent;
14604             offp = &ent->got.offset;
14605             got = ppc64_elf_tdata (ent->owner)->got;
14606             if (got == NULL)
14607               abort ();
14608
14609             /* The offset must always be a multiple of 8.  We use the
14610                least significant bit to record whether we have already
14611                processed this entry.  */
14612             off = *offp;
14613             if ((off & 1) != 0)
14614               off &= ~1;
14615             else
14616               {
14617                 /* Generate relocs for the dynamic linker, except in
14618                    the case of TLSLD where we'll use one entry per
14619                    module.  */
14620                 asection *relgot;
14621                 bfd_boolean ifunc;
14622
14623                 *offp = off | 1;
14624                 relgot = NULL;
14625                 ifunc = (h != NULL
14626                          ? h->elf.type == STT_GNU_IFUNC
14627                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14628                 if (ifunc)
14629                   {
14630                     relgot = htab->elf.irelplt;
14631                     if (indx == 0)
14632                       htab->local_ifunc_resolver = 1;
14633                     else if (is_static_defined (&h->elf))
14634                       htab->maybe_local_ifunc_resolver = 1;
14635                   }
14636                 else if (indx != 0
14637                          || (bfd_link_pic (info)
14638                              && (h == NULL
14639                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14640                                  || (tls_type == (TLS_TLS | TLS_LD)
14641                                      && !h->elf.def_dynamic))))
14642                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14643                 if (relgot != NULL)
14644                   {
14645                     outrel.r_offset = (got->output_section->vma
14646                                        + got->output_offset
14647                                        + off);
14648                     outrel.r_addend = addend;
14649                     if (tls_type & (TLS_LD | TLS_GD))
14650                       {
14651                         outrel.r_addend = 0;
14652                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14653                         if (tls_type == (TLS_TLS | TLS_GD))
14654                           {
14655                             loc = relgot->contents;
14656                             loc += (relgot->reloc_count++
14657                                     * sizeof (Elf64_External_Rela));
14658                             bfd_elf64_swap_reloca_out (output_bfd,
14659                                                        &outrel, loc);
14660                             outrel.r_offset += 8;
14661                             outrel.r_addend = addend;
14662                             outrel.r_info
14663                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14664                           }
14665                       }
14666                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14667                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14668                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14669                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14670                     else if (indx != 0)
14671                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14672                     else
14673                       {
14674                         if (ifunc)
14675                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14676                         else
14677                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14678
14679                         /* Write the .got section contents for the sake
14680                            of prelink.  */
14681                         loc = got->contents + off;
14682                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14683                                     loc);
14684                       }
14685
14686                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14687                       {
14688                         outrel.r_addend += relocation;
14689                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14690                           {
14691                             if (htab->elf.tls_sec == NULL)
14692                               outrel.r_addend = 0;
14693                             else
14694                               outrel.r_addend -= htab->elf.tls_sec->vma;
14695                           }
14696                       }
14697                     loc = relgot->contents;
14698                     loc += (relgot->reloc_count++
14699                             * sizeof (Elf64_External_Rela));
14700                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14701                   }
14702
14703                 /* Init the .got section contents here if we're not
14704                    emitting a reloc.  */
14705                 else
14706                   {
14707                     relocation += addend;
14708                     if (tls_type != 0)
14709                       {
14710                         if (htab->elf.tls_sec == NULL)
14711                           relocation = 0;
14712                         else
14713                           {
14714                             if (tls_type & TLS_LD)
14715                               relocation = 0;
14716                             else
14717                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14718                             if (tls_type & TLS_TPREL)
14719                               relocation += DTP_OFFSET - TP_OFFSET;
14720                           }
14721
14722                         if (tls_type & (TLS_GD | TLS_LD))
14723                           {
14724                             bfd_put_64 (output_bfd, relocation,
14725                                         got->contents + off + 8);
14726                             relocation = 1;
14727                           }
14728                       }
14729                     bfd_put_64 (output_bfd, relocation,
14730                                 got->contents + off);
14731                   }
14732               }
14733
14734             if (off >= (bfd_vma) -2)
14735               abort ();
14736
14737             relocation = got->output_section->vma + got->output_offset + off;
14738             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14739           }
14740           break;
14741
14742         case R_PPC64_PLT16_HA:
14743         case R_PPC64_PLT16_HI:
14744         case R_PPC64_PLT16_LO:
14745         case R_PPC64_PLT32:
14746         case R_PPC64_PLT64:
14747           /* Relocation is to the entry for this symbol in the
14748              procedure linkage table.  */
14749           {
14750             struct plt_entry **plt_list = NULL;
14751             if (h != NULL)
14752               plt_list = &h->elf.plt.plist;
14753             else if (local_got_ents != NULL)
14754               {
14755                 struct plt_entry **local_plt = (struct plt_entry **)
14756                   (local_got_ents + symtab_hdr->sh_info);
14757                 unsigned char *local_got_tls_masks = (unsigned char *)
14758                   (local_plt + symtab_hdr->sh_info);
14759                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14760                   plt_list = local_plt + r_symndx;
14761               }
14762             if (plt_list)
14763               {
14764                 struct plt_entry *ent;
14765
14766                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14767                   if (ent->plt.offset != (bfd_vma) -1
14768                       && ent->addend == orig_rel.r_addend)
14769                     {
14770                       asection *plt;
14771
14772                       plt = htab->elf.splt;
14773                       if (!htab->elf.dynamic_sections_created
14774                           || h == NULL
14775                           || h->elf.dynindx == -1)
14776                         plt = htab->elf.iplt;
14777                       relocation = (plt->output_section->vma
14778                                     + plt->output_offset
14779                                     + ent->plt.offset);
14780                       addend = 0;
14781                       unresolved_reloc = FALSE;
14782                       break;
14783                     }
14784               }
14785           }
14786           break;
14787
14788         case R_PPC64_TOC:
14789           /* Relocation value is TOC base.  */
14790           relocation = TOCstart;
14791           if (r_symndx == STN_UNDEF)
14792             relocation += htab->sec_info[input_section->id].toc_off;
14793           else if (unresolved_reloc)
14794             ;
14795           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14796             relocation += htab->sec_info[sec->id].toc_off;
14797           else
14798             unresolved_reloc = TRUE;
14799           goto dodyn;
14800
14801           /* TOC16 relocs.  We want the offset relative to the TOC base,
14802              which is the address of the start of the TOC plus 0x8000.
14803              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14804              in this order.  */
14805         case R_PPC64_TOC16:
14806         case R_PPC64_TOC16_LO:
14807         case R_PPC64_TOC16_HI:
14808         case R_PPC64_TOC16_DS:
14809         case R_PPC64_TOC16_LO_DS:
14810         case R_PPC64_TOC16_HA:
14811           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14812           break;
14813
14814           /* Relocate against the beginning of the section.  */
14815         case R_PPC64_SECTOFF:
14816         case R_PPC64_SECTOFF_LO:
14817         case R_PPC64_SECTOFF_HI:
14818         case R_PPC64_SECTOFF_DS:
14819         case R_PPC64_SECTOFF_LO_DS:
14820         case R_PPC64_SECTOFF_HA:
14821           if (sec != NULL)
14822             addend -= sec->output_section->vma;
14823           break;
14824
14825         case R_PPC64_REL16:
14826         case R_PPC64_REL16_LO:
14827         case R_PPC64_REL16_HI:
14828         case R_PPC64_REL16_HA:
14829         case R_PPC64_REL16DX_HA:
14830           break;
14831
14832         case R_PPC64_REL14:
14833         case R_PPC64_REL14_BRNTAKEN:
14834         case R_PPC64_REL14_BRTAKEN:
14835         case R_PPC64_REL24:
14836           break;
14837
14838         case R_PPC64_TPREL16:
14839         case R_PPC64_TPREL16_LO:
14840         case R_PPC64_TPREL16_HI:
14841         case R_PPC64_TPREL16_HA:
14842         case R_PPC64_TPREL16_DS:
14843         case R_PPC64_TPREL16_LO_DS:
14844         case R_PPC64_TPREL16_HIGH:
14845         case R_PPC64_TPREL16_HIGHA:
14846         case R_PPC64_TPREL16_HIGHER:
14847         case R_PPC64_TPREL16_HIGHERA:
14848         case R_PPC64_TPREL16_HIGHEST:
14849         case R_PPC64_TPREL16_HIGHESTA:
14850           if (h != NULL
14851               && h->elf.root.type == bfd_link_hash_undefweak
14852               && h->elf.dynindx == -1)
14853             {
14854               /* Make this relocation against an undefined weak symbol
14855                  resolve to zero.  This is really just a tweak, since
14856                  code using weak externs ought to check that they are
14857                  defined before using them.  */
14858               bfd_byte *p = contents + rel->r_offset - d_offset;
14859
14860               insn = bfd_get_32 (input_bfd, p);
14861               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14862               if (insn != 0)
14863                 bfd_put_32 (input_bfd, insn, p);
14864               break;
14865             }
14866           if (htab->elf.tls_sec != NULL)
14867             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14868           /* The TPREL16 relocs shouldn't really be used in shared
14869              libs or with non-local symbols as that will result in
14870              DT_TEXTREL being set, but support them anyway.  */
14871           goto dodyn;
14872
14873         case R_PPC64_DTPREL16:
14874         case R_PPC64_DTPREL16_LO:
14875         case R_PPC64_DTPREL16_HI:
14876         case R_PPC64_DTPREL16_HA:
14877         case R_PPC64_DTPREL16_DS:
14878         case R_PPC64_DTPREL16_LO_DS:
14879         case R_PPC64_DTPREL16_HIGH:
14880         case R_PPC64_DTPREL16_HIGHA:
14881         case R_PPC64_DTPREL16_HIGHER:
14882         case R_PPC64_DTPREL16_HIGHERA:
14883         case R_PPC64_DTPREL16_HIGHEST:
14884         case R_PPC64_DTPREL16_HIGHESTA:
14885           if (htab->elf.tls_sec != NULL)
14886             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14887           break;
14888
14889         case R_PPC64_ADDR64_LOCAL:
14890           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14891                                               ? h->elf.other
14892                                               : sym->st_other);
14893           break;
14894
14895         case R_PPC64_DTPMOD64:
14896           relocation = 1;
14897           addend = 0;
14898           goto dodyn;
14899
14900         case R_PPC64_TPREL64:
14901           if (htab->elf.tls_sec != NULL)
14902             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14903           goto dodyn;
14904
14905         case R_PPC64_DTPREL64:
14906           if (htab->elf.tls_sec != NULL)
14907             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14908           /* Fall through.  */
14909
14910           /* Relocations that may need to be propagated if this is a
14911              dynamic object.  */
14912         case R_PPC64_REL30:
14913         case R_PPC64_REL32:
14914         case R_PPC64_REL64:
14915         case R_PPC64_ADDR14:
14916         case R_PPC64_ADDR14_BRNTAKEN:
14917         case R_PPC64_ADDR14_BRTAKEN:
14918         case R_PPC64_ADDR16:
14919         case R_PPC64_ADDR16_DS:
14920         case R_PPC64_ADDR16_HA:
14921         case R_PPC64_ADDR16_HI:
14922         case R_PPC64_ADDR16_HIGH:
14923         case R_PPC64_ADDR16_HIGHA:
14924         case R_PPC64_ADDR16_HIGHER:
14925         case R_PPC64_ADDR16_HIGHERA:
14926         case R_PPC64_ADDR16_HIGHEST:
14927         case R_PPC64_ADDR16_HIGHESTA:
14928         case R_PPC64_ADDR16_LO:
14929         case R_PPC64_ADDR16_LO_DS:
14930         case R_PPC64_ADDR24:
14931         case R_PPC64_ADDR32:
14932         case R_PPC64_ADDR64:
14933         case R_PPC64_UADDR16:
14934         case R_PPC64_UADDR32:
14935         case R_PPC64_UADDR64:
14936         dodyn:
14937           if ((input_section->flags & SEC_ALLOC) == 0)
14938             break;
14939
14940           if (NO_OPD_RELOCS && is_opd)
14941             break;
14942
14943           if (bfd_link_pic (info)
14944               ? ((h == NULL
14945                   || h->dyn_relocs != NULL)
14946                  && ((h != NULL && pc_dynrelocs (h))
14947                      || must_be_dyn_reloc (info, r_type)))
14948               : (h != NULL
14949                  ? h->dyn_relocs != NULL
14950                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14951             {
14952               bfd_boolean skip, relocate;
14953               asection *sreloc;
14954               bfd_vma out_off;
14955               long indx = 0;
14956
14957               /* When generating a dynamic object, these relocations
14958                  are copied into the output file to be resolved at run
14959                  time.  */
14960
14961               skip = FALSE;
14962               relocate = FALSE;
14963
14964               out_off = _bfd_elf_section_offset (output_bfd, info,
14965                                                  input_section, rel->r_offset);
14966               if (out_off == (bfd_vma) -1)
14967                 skip = TRUE;
14968               else if (out_off == (bfd_vma) -2)
14969                 skip = TRUE, relocate = TRUE;
14970               out_off += (input_section->output_section->vma
14971                           + input_section->output_offset);
14972               outrel.r_offset = out_off;
14973               outrel.r_addend = rel->r_addend;
14974
14975               /* Optimize unaligned reloc use.  */
14976               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14977                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14978                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14979               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14980                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14981                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14982               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14983                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14984                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14985
14986               if (skip)
14987                 memset (&outrel, 0, sizeof outrel);
14988               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14989                        && !is_opd
14990                        && r_type != R_PPC64_TOC)
14991                 {
14992                   indx = h->elf.dynindx;
14993                   BFD_ASSERT (indx != -1);
14994                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14995                 }
14996               else
14997                 {
14998                   /* This symbol is local, or marked to become local,
14999                      or this is an opd section reloc which must point
15000                      at a local function.  */
15001                   outrel.r_addend += relocation;
15002                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15003                     {
15004                       if (is_opd && h != NULL)
15005                         {
15006                           /* Lie about opd entries.  This case occurs
15007                              when building shared libraries and we
15008                              reference a function in another shared
15009                              lib.  The same thing happens for a weak
15010                              definition in an application that's
15011                              overridden by a strong definition in a
15012                              shared lib.  (I believe this is a generic
15013                              bug in binutils handling of weak syms.)
15014                              In these cases we won't use the opd
15015                              entry in this lib.  */
15016                           unresolved_reloc = FALSE;
15017                         }
15018                       if (!is_opd
15019                           && r_type == R_PPC64_ADDR64
15020                           && (h != NULL
15021                               ? h->elf.type == STT_GNU_IFUNC
15022                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15023                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15024                       else
15025                         {
15026                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15027
15028                           /* We need to relocate .opd contents for ld.so.
15029                              Prelink also wants simple and consistent rules
15030                              for relocs.  This make all RELATIVE relocs have
15031                              *r_offset equal to r_addend.  */
15032                           relocate = TRUE;
15033                         }
15034                     }
15035                   else
15036                     {
15037                       if (h != NULL
15038                           ? h->elf.type == STT_GNU_IFUNC
15039                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15040                         {
15041                           info->callbacks->einfo
15042                             /* xgettext:c-format */
15043                             (_("%H: %s for indirect "
15044                                "function `%T' unsupported\n"),
15045                              input_bfd, input_section, rel->r_offset,
15046                              ppc64_elf_howto_table[r_type]->name,
15047                              sym_name);
15048                           ret = FALSE;
15049                         }
15050                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15051                         ;
15052                       else if (sec == NULL || sec->owner == NULL)
15053                         {
15054                           bfd_set_error (bfd_error_bad_value);
15055                           return FALSE;
15056                         }
15057                       else
15058                         {
15059                           asection *osec;
15060
15061                           osec = sec->output_section;
15062                           indx = elf_section_data (osec)->dynindx;
15063
15064                           if (indx == 0)
15065                             {
15066                               if ((osec->flags & SEC_READONLY) == 0
15067                                   && htab->elf.data_index_section != NULL)
15068                                 osec = htab->elf.data_index_section;
15069                               else
15070                                 osec = htab->elf.text_index_section;
15071                               indx = elf_section_data (osec)->dynindx;
15072                             }
15073                           BFD_ASSERT (indx != 0);
15074
15075                           /* We are turning this relocation into one
15076                              against a section symbol, so subtract out
15077                              the output section's address but not the
15078                              offset of the input section in the output
15079                              section.  */
15080                           outrel.r_addend -= osec->vma;
15081                         }
15082
15083                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15084                     }
15085                 }
15086
15087               sreloc = elf_section_data (input_section)->sreloc;
15088               if (h != NULL
15089                   ? h->elf.type == STT_GNU_IFUNC
15090                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15091                 {
15092                   sreloc = htab->elf.irelplt;
15093                   if (indx == 0)
15094                     htab->local_ifunc_resolver = 1;
15095                   else if (is_static_defined (&h->elf))
15096                     htab->maybe_local_ifunc_resolver = 1;
15097                 }
15098               if (sreloc == NULL)
15099                 abort ();
15100
15101               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15102                   >= sreloc->size)
15103                 abort ();
15104               loc = sreloc->contents;
15105               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15106               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15107
15108               /* If this reloc is against an external symbol, it will
15109                  be computed at runtime, so there's no need to do
15110                  anything now.  However, for the sake of prelink ensure
15111                  that the section contents are a known value.  */
15112               if (! relocate)
15113                 {
15114                   unresolved_reloc = FALSE;
15115                   /* The value chosen here is quite arbitrary as ld.so
15116                      ignores section contents except for the special
15117                      case of .opd where the contents might be accessed
15118                      before relocation.  Choose zero, as that won't
15119                      cause reloc overflow.  */
15120                   relocation = 0;
15121                   addend = 0;
15122                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15123                      to improve backward compatibility with older
15124                      versions of ld.  */
15125                   if (r_type == R_PPC64_ADDR64)
15126                     addend = outrel.r_addend;
15127                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15128                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15129                     addend = outrel.r_offset;
15130                 }
15131             }
15132           break;
15133
15134         case R_PPC64_COPY:
15135         case R_PPC64_GLOB_DAT:
15136         case R_PPC64_JMP_SLOT:
15137         case R_PPC64_JMP_IREL:
15138         case R_PPC64_RELATIVE:
15139           /* We shouldn't ever see these dynamic relocs in relocatable
15140              files.  */
15141           /* Fall through.  */
15142
15143         case R_PPC64_PLTGOT16:
15144         case R_PPC64_PLTGOT16_DS:
15145         case R_PPC64_PLTGOT16_HA:
15146         case R_PPC64_PLTGOT16_HI:
15147         case R_PPC64_PLTGOT16_LO:
15148         case R_PPC64_PLTGOT16_LO_DS:
15149         case R_PPC64_PLTREL32:
15150         case R_PPC64_PLTREL64:
15151           /* These ones haven't been implemented yet.  */
15152
15153           info->callbacks->einfo
15154             /* xgettext:c-format */
15155             (_("%P: %B: %s is not supported for `%T'\n"),
15156              input_bfd,
15157              ppc64_elf_howto_table[r_type]->name, sym_name);
15158
15159           bfd_set_error (bfd_error_invalid_operation);
15160           ret = FALSE;
15161           goto copy_reloc;
15162         }
15163
15164       /* Multi-instruction sequences that access the TOC can be
15165          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15166          to             nop;           addi rb,r2,x;  */
15167       howto = ppc64_elf_howto_table[(int) r_type];
15168       switch (r_type)
15169         {
15170         default:
15171           break;
15172
15173         case R_PPC64_GOT_TLSLD16_HI:
15174         case R_PPC64_GOT_TLSGD16_HI:
15175         case R_PPC64_GOT_TPREL16_HI:
15176         case R_PPC64_GOT_DTPREL16_HI:
15177         case R_PPC64_GOT16_HI:
15178         case R_PPC64_TOC16_HI:
15179           /* These relocs would only be useful if building up an
15180              offset to later add to r2, perhaps in an indexed
15181              addressing mode instruction.  Don't try to optimize.
15182              Unfortunately, the possibility of someone building up an
15183              offset like this or even with the HA relocs, means that
15184              we need to check the high insn when optimizing the low
15185              insn.  */
15186           break;
15187
15188         case R_PPC64_GOT_TLSLD16_HA:
15189         case R_PPC64_GOT_TLSGD16_HA:
15190         case R_PPC64_GOT_TPREL16_HA:
15191         case R_PPC64_GOT_DTPREL16_HA:
15192         case R_PPC64_GOT16_HA:
15193         case R_PPC64_TOC16_HA:
15194           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15195               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15196             {
15197               bfd_byte *p = contents + (rel->r_offset & ~3);
15198               bfd_put_32 (input_bfd, NOP, p);
15199             }
15200           break;
15201
15202         case R_PPC64_GOT_TLSLD16_LO:
15203         case R_PPC64_GOT_TLSGD16_LO:
15204         case R_PPC64_GOT_TPREL16_LO_DS:
15205         case R_PPC64_GOT_DTPREL16_LO_DS:
15206         case R_PPC64_GOT16_LO:
15207         case R_PPC64_GOT16_LO_DS:
15208         case R_PPC64_TOC16_LO:
15209         case R_PPC64_TOC16_LO_DS:
15210           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15211               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15212             {
15213               bfd_byte *p = contents + (rel->r_offset & ~3);
15214               insn = bfd_get_32 (input_bfd, p);
15215               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15216                 {
15217                   /* Transform addic to addi when we change reg.  */
15218                   insn &= ~((0x3f << 26) | (0x1f << 16));
15219                   insn |= (14u << 26) | (2 << 16);
15220                 }
15221               else
15222                 {
15223                   insn &= ~(0x1f << 16);
15224                   insn |= 2 << 16;
15225                 }
15226               bfd_put_32 (input_bfd, insn, p);
15227             }
15228           break;
15229
15230         case R_PPC64_TPREL16_HA:
15231           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15232             {
15233               bfd_byte *p = contents + (rel->r_offset & ~3);
15234               insn = bfd_get_32 (input_bfd, p);
15235               if ((insn & ((0x3f << 26) | 0x1f << 16))
15236                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15237                 /* xgettext:c-format */
15238                 info->callbacks->minfo
15239                   (_("%H: warning: %s unexpected insn %#x.\n"),
15240                    input_bfd, input_section, rel->r_offset, howto->name, insn);
15241               else
15242                 bfd_put_32 (input_bfd, NOP, p);
15243             }
15244           break;
15245
15246         case R_PPC64_TPREL16_LO:
15247         case R_PPC64_TPREL16_LO_DS:
15248           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15249             {
15250               bfd_byte *p = contents + (rel->r_offset & ~3);
15251               insn = bfd_get_32 (input_bfd, p);
15252               insn &= ~(0x1f << 16);
15253               insn |= 13 << 16;
15254               bfd_put_32 (input_bfd, insn, p);
15255             }
15256           break;
15257         }
15258
15259       /* Do any further special processing.  */
15260       switch (r_type)
15261         {
15262         default:
15263           break;
15264
15265         case R_PPC64_REL16_HA:
15266         case R_PPC64_REL16DX_HA:
15267         case R_PPC64_ADDR16_HA:
15268         case R_PPC64_ADDR16_HIGHA:
15269         case R_PPC64_ADDR16_HIGHERA:
15270         case R_PPC64_ADDR16_HIGHESTA:
15271         case R_PPC64_TOC16_HA:
15272         case R_PPC64_SECTOFF_HA:
15273         case R_PPC64_TPREL16_HA:
15274         case R_PPC64_TPREL16_HIGHA:
15275         case R_PPC64_TPREL16_HIGHERA:
15276         case R_PPC64_TPREL16_HIGHESTA:
15277         case R_PPC64_DTPREL16_HA:
15278         case R_PPC64_DTPREL16_HIGHA:
15279         case R_PPC64_DTPREL16_HIGHERA:
15280         case R_PPC64_DTPREL16_HIGHESTA:
15281           /* It's just possible that this symbol is a weak symbol
15282              that's not actually defined anywhere. In that case,
15283              'sec' would be NULL, and we should leave the symbol
15284              alone (it will be set to zero elsewhere in the link).  */
15285           if (sec == NULL)
15286             break;
15287           /* Fall through.  */
15288
15289         case R_PPC64_GOT16_HA:
15290         case R_PPC64_PLTGOT16_HA:
15291         case R_PPC64_PLT16_HA:
15292         case R_PPC64_GOT_TLSGD16_HA:
15293         case R_PPC64_GOT_TLSLD16_HA:
15294         case R_PPC64_GOT_TPREL16_HA:
15295         case R_PPC64_GOT_DTPREL16_HA:
15296           /* Add 0x10000 if sign bit in 0:15 is set.
15297              Bits 0:15 are not used.  */
15298           addend += 0x8000;
15299           break;
15300
15301         case R_PPC64_ADDR16_DS:
15302         case R_PPC64_ADDR16_LO_DS:
15303         case R_PPC64_GOT16_DS:
15304         case R_PPC64_GOT16_LO_DS:
15305         case R_PPC64_PLT16_LO_DS:
15306         case R_PPC64_SECTOFF_DS:
15307         case R_PPC64_SECTOFF_LO_DS:
15308         case R_PPC64_TOC16_DS:
15309         case R_PPC64_TOC16_LO_DS:
15310         case R_PPC64_PLTGOT16_DS:
15311         case R_PPC64_PLTGOT16_LO_DS:
15312         case R_PPC64_GOT_TPREL16_DS:
15313         case R_PPC64_GOT_TPREL16_LO_DS:
15314         case R_PPC64_GOT_DTPREL16_DS:
15315         case R_PPC64_GOT_DTPREL16_LO_DS:
15316         case R_PPC64_TPREL16_DS:
15317         case R_PPC64_TPREL16_LO_DS:
15318         case R_PPC64_DTPREL16_DS:
15319         case R_PPC64_DTPREL16_LO_DS:
15320           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15321           mask = 3;
15322           /* If this reloc is against an lq, lxv, or stxv insn, then
15323              the value must be a multiple of 16.  This is somewhat of
15324              a hack, but the "correct" way to do this by defining _DQ
15325              forms of all the _DS relocs bloats all reloc switches in
15326              this file.  It doesn't make much sense to use these
15327              relocs in data, so testing the insn should be safe.  */
15328           if ((insn & (0x3f << 26)) == (56u << 26)
15329               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15330             mask = 15;
15331           relocation += addend;
15332           addend = insn & (mask ^ 3);
15333           if ((relocation & mask) != 0)
15334             {
15335               relocation ^= relocation & mask;
15336               info->callbacks->einfo
15337                 /* xgettext:c-format */
15338                 (_("%H: error: %s not a multiple of %u\n"),
15339                  input_bfd, input_section, rel->r_offset,
15340                  howto->name,
15341                  mask + 1);
15342               bfd_set_error (bfd_error_bad_value);
15343               ret = FALSE;
15344               goto copy_reloc;
15345             }
15346           break;
15347         }
15348
15349       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15350          because such sections are not SEC_ALLOC and thus ld.so will
15351          not process them.  */
15352       if (unresolved_reloc
15353           && !((input_section->flags & SEC_DEBUGGING) != 0
15354                && h->elf.def_dynamic)
15355           && _bfd_elf_section_offset (output_bfd, info, input_section,
15356                                       rel->r_offset) != (bfd_vma) -1)
15357         {
15358           info->callbacks->einfo
15359             /* xgettext:c-format */
15360             (_("%H: unresolvable %s against `%T'\n"),
15361              input_bfd, input_section, rel->r_offset,
15362              howto->name,
15363              h->elf.root.root.string);
15364           ret = FALSE;
15365         }
15366
15367       /* 16-bit fields in insns mostly have signed values, but a
15368          few insns have 16-bit unsigned values.  Really, we should
15369          have different reloc types.  */
15370       if (howto->complain_on_overflow != complain_overflow_dont
15371           && howto->dst_mask == 0xffff
15372           && (input_section->flags & SEC_CODE) != 0)
15373         {
15374           enum complain_overflow complain = complain_overflow_signed;
15375
15376           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15377           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15378             complain = complain_overflow_bitfield;
15379           else if (howto->rightshift == 0
15380                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15381                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15382                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15383                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15384                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15385                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15386             complain = complain_overflow_unsigned;
15387           if (howto->complain_on_overflow != complain)
15388             {
15389               alt_howto = *howto;
15390               alt_howto.complain_on_overflow = complain;
15391               howto = &alt_howto;
15392             }
15393         }
15394
15395       if (r_type == R_PPC64_REL16DX_HA)
15396         {
15397           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15398           if (rel->r_offset + 4 > input_section->size)
15399             r = bfd_reloc_outofrange;
15400           else
15401             {
15402               relocation += addend;
15403               relocation -= (rel->r_offset
15404                              + input_section->output_offset
15405                              + input_section->output_section->vma);
15406               relocation = (bfd_signed_vma) relocation >> 16;
15407               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15408               insn &= ~0x1fffc1;
15409               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15410               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15411               r = bfd_reloc_ok;
15412               if (relocation + 0x8000 > 0xffff)
15413                 r = bfd_reloc_overflow;
15414             }
15415         }
15416       else
15417         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15418                                       rel->r_offset, relocation, addend);
15419
15420       if (r != bfd_reloc_ok)
15421         {
15422           char *more_info = NULL;
15423           const char *reloc_name = howto->name;
15424
15425           if (reloc_dest != DEST_NORMAL)
15426             {
15427               more_info = bfd_malloc (strlen (reloc_name) + 8);
15428               if (more_info != NULL)
15429                 {
15430                   strcpy (more_info, reloc_name);
15431                   strcat (more_info, (reloc_dest == DEST_OPD
15432                                       ? " (OPD)" : " (stub)"));
15433                   reloc_name = more_info;
15434                 }
15435             }
15436
15437           if (r == bfd_reloc_overflow)
15438             {
15439               /* On code like "if (foo) foo();" don't report overflow
15440                  on a branch to zero when foo is undefined.  */
15441               if (!warned
15442                   && (reloc_dest == DEST_STUB
15443                       || !(h != NULL
15444                            && (h->elf.root.type == bfd_link_hash_undefweak
15445                                || h->elf.root.type == bfd_link_hash_undefined)
15446                            && is_branch_reloc (r_type))))
15447                 info->callbacks->reloc_overflow (info, &h->elf.root,
15448                                                  sym_name, reloc_name,
15449                                                  orig_rel.r_addend,
15450                                                  input_bfd, input_section,
15451                                                  rel->r_offset);
15452             }
15453           else
15454             {
15455               info->callbacks->einfo
15456                 /* xgettext:c-format */
15457                 (_("%H: %s against `%T': error %d\n"),
15458                  input_bfd, input_section, rel->r_offset,
15459                  reloc_name, sym_name, (int) r);
15460               ret = FALSE;
15461             }
15462           if (more_info != NULL)
15463             free (more_info);
15464         }
15465     copy_reloc:
15466       if (wrel != rel)
15467         *wrel = *rel;
15468     }
15469
15470   if (wrel != rel)
15471     {
15472       Elf_Internal_Shdr *rel_hdr;
15473       size_t deleted = rel - wrel;
15474
15475       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15476       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15477       if (rel_hdr->sh_size == 0)
15478         {
15479           /* It is too late to remove an empty reloc section.  Leave
15480              one NONE reloc.
15481              ??? What is wrong with an empty section???  */
15482           rel_hdr->sh_size = rel_hdr->sh_entsize;
15483           deleted -= 1;
15484         }
15485       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15486       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15487       input_section->reloc_count -= deleted;
15488     }
15489
15490   /* If we're emitting relocations, then shortly after this function
15491      returns, reloc offsets and addends for this section will be
15492      adjusted.  Worse, reloc symbol indices will be for the output
15493      file rather than the input.  Save a copy of the relocs for
15494      opd_entry_value.  */
15495   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15496     {
15497       bfd_size_type amt;
15498       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15499       rel = bfd_alloc (input_bfd, amt);
15500       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15501       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15502       if (rel == NULL)
15503         return FALSE;
15504       memcpy (rel, relocs, amt);
15505     }
15506   return ret;
15507 }
15508
15509 /* Adjust the value of any local symbols in opd sections.  */
15510
15511 static int
15512 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15513                               const char *name ATTRIBUTE_UNUSED,
15514                               Elf_Internal_Sym *elfsym,
15515                               asection *input_sec,
15516                               struct elf_link_hash_entry *h)
15517 {
15518   struct _opd_sec_data *opd;
15519   long adjust;
15520   bfd_vma value;
15521
15522   if (h != NULL)
15523     return 1;
15524
15525   opd = get_opd_info (input_sec);
15526   if (opd == NULL || opd->adjust == NULL)
15527     return 1;
15528
15529   value = elfsym->st_value - input_sec->output_offset;
15530   if (!bfd_link_relocatable (info))
15531     value -= input_sec->output_section->vma;
15532
15533   adjust = opd->adjust[OPD_NDX (value)];
15534   if (adjust == -1)
15535     return 2;
15536
15537   elfsym->st_value += adjust;
15538   return 1;
15539 }
15540
15541 /* Finish up dynamic symbol handling.  We set the contents of various
15542    dynamic sections here.  */
15543
15544 static bfd_boolean
15545 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15546                                  struct bfd_link_info *info,
15547                                  struct elf_link_hash_entry *h,
15548                                  Elf_Internal_Sym *sym)
15549 {
15550   struct ppc_link_hash_table *htab;
15551   struct plt_entry *ent;
15552   Elf_Internal_Rela rela;
15553   bfd_byte *loc;
15554
15555   htab = ppc_hash_table (info);
15556   if (htab == NULL)
15557     return FALSE;
15558
15559   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15560     if (ent->plt.offset != (bfd_vma) -1)
15561       {
15562         /* This symbol has an entry in the procedure linkage
15563            table.  Set it up.  */
15564         if (!htab->elf.dynamic_sections_created
15565             || h->dynindx == -1)
15566           {
15567             BFD_ASSERT (h->type == STT_GNU_IFUNC
15568                         && h->def_regular
15569                         && (h->root.type == bfd_link_hash_defined
15570                             || h->root.type == bfd_link_hash_defweak));
15571             rela.r_offset = (htab->elf.iplt->output_section->vma
15572                              + htab->elf.iplt->output_offset
15573                              + ent->plt.offset);
15574             if (htab->opd_abi)
15575               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15576             else
15577               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15578             rela.r_addend = (h->root.u.def.value
15579                              + h->root.u.def.section->output_offset
15580                              + h->root.u.def.section->output_section->vma
15581                              + ent->addend);
15582             loc = (htab->elf.irelplt->contents
15583                    + (htab->elf.irelplt->reloc_count++
15584                       * sizeof (Elf64_External_Rela)));
15585             htab->local_ifunc_resolver = 1;
15586           }
15587         else
15588           {
15589             rela.r_offset = (htab->elf.splt->output_section->vma
15590                              + htab->elf.splt->output_offset
15591                              + ent->plt.offset);
15592             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15593             rela.r_addend = ent->addend;
15594             loc = (htab->elf.srelplt->contents
15595                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15596                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15597             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15598               htab->maybe_local_ifunc_resolver = 1;
15599           }
15600         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15601
15602         if (!htab->opd_abi)
15603           {
15604             if (!h->def_regular)
15605               {
15606                 /* Mark the symbol as undefined, rather than as
15607                    defined in glink.  Leave the value if there were
15608                    any relocations where pointer equality matters
15609                    (this is a clue for the dynamic linker, to make
15610                    function pointer comparisons work between an
15611                    application and shared library), otherwise set it
15612                    to zero.  */
15613                 sym->st_shndx = SHN_UNDEF;
15614                 if (!h->pointer_equality_needed)
15615                   sym->st_value = 0;
15616                 else if (!h->ref_regular_nonweak)
15617                   {
15618                     /* This breaks function pointer comparisons, but
15619                        that is better than breaking tests for a NULL
15620                        function pointer.  */
15621                     sym->st_value = 0;
15622                   }
15623               }
15624           }
15625       }
15626
15627   if (h->needs_copy)
15628     {
15629       /* This symbol needs a copy reloc.  Set it up.  */
15630       asection *srel;
15631
15632       if (h->dynindx == -1
15633           || (h->root.type != bfd_link_hash_defined
15634               && h->root.type != bfd_link_hash_defweak)
15635           || htab->elf.srelbss == NULL
15636           || htab->elf.sreldynrelro == NULL)
15637         abort ();
15638
15639       rela.r_offset = (h->root.u.def.value
15640                        + h->root.u.def.section->output_section->vma
15641                        + h->root.u.def.section->output_offset);
15642       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15643       rela.r_addend = 0;
15644       if (h->root.u.def.section == htab->elf.sdynrelro)
15645         srel = htab->elf.sreldynrelro;
15646       else
15647         srel = htab->elf.srelbss;
15648       loc = srel->contents;
15649       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15650       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15651     }
15652
15653   return TRUE;
15654 }
15655
15656 /* Used to decide how to sort relocs in an optimal manner for the
15657    dynamic linker, before writing them out.  */
15658
15659 static enum elf_reloc_type_class
15660 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15661                             const asection *rel_sec,
15662                             const Elf_Internal_Rela *rela)
15663 {
15664   enum elf_ppc64_reloc_type r_type;
15665   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15666
15667   if (rel_sec == htab->elf.irelplt)
15668     return reloc_class_ifunc;
15669
15670   r_type = ELF64_R_TYPE (rela->r_info);
15671   switch (r_type)
15672     {
15673     case R_PPC64_RELATIVE:
15674       return reloc_class_relative;
15675     case R_PPC64_JMP_SLOT:
15676       return reloc_class_plt;
15677     case R_PPC64_COPY:
15678       return reloc_class_copy;
15679     default:
15680       return reloc_class_normal;
15681     }
15682 }
15683
15684 /* Finish up the dynamic sections.  */
15685
15686 static bfd_boolean
15687 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15688                                    struct bfd_link_info *info)
15689 {
15690   struct ppc_link_hash_table *htab;
15691   bfd *dynobj;
15692   asection *sdyn;
15693
15694   htab = ppc_hash_table (info);
15695   if (htab == NULL)
15696     return FALSE;
15697
15698   dynobj = htab->elf.dynobj;
15699   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15700
15701   if (htab->elf.dynamic_sections_created)
15702     {
15703       Elf64_External_Dyn *dyncon, *dynconend;
15704
15705       if (sdyn == NULL || htab->elf.sgot == NULL)
15706         abort ();
15707
15708       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15709       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15710       for (; dyncon < dynconend; dyncon++)
15711         {
15712           Elf_Internal_Dyn dyn;
15713           asection *s;
15714
15715           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15716
15717           switch (dyn.d_tag)
15718             {
15719             default:
15720               continue;
15721
15722             case DT_PPC64_GLINK:
15723               s = htab->glink;
15724               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15725               /* We stupidly defined DT_PPC64_GLINK to be the start
15726                  of glink rather than the first entry point, which is
15727                  what ld.so needs, and now have a bigger stub to
15728                  support automatic multiple TOCs.  */
15729               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15730               break;
15731
15732             case DT_PPC64_OPD:
15733               s = bfd_get_section_by_name (output_bfd, ".opd");
15734               if (s == NULL)
15735                 continue;
15736               dyn.d_un.d_ptr = s->vma;
15737               break;
15738
15739             case DT_PPC64_OPT:
15740               if (htab->do_multi_toc && htab->multi_toc_needed)
15741                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15742               if (htab->has_plt_localentry0)
15743                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15744               break;
15745
15746             case DT_PPC64_OPDSZ:
15747               s = bfd_get_section_by_name (output_bfd, ".opd");
15748               if (s == NULL)
15749                 continue;
15750               dyn.d_un.d_val = s->size;
15751               break;
15752
15753             case DT_PLTGOT:
15754               s = htab->elf.splt;
15755               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15756               break;
15757
15758             case DT_JMPREL:
15759               s = htab->elf.srelplt;
15760               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15761               break;
15762
15763             case DT_PLTRELSZ:
15764               dyn.d_un.d_val = htab->elf.srelplt->size;
15765               break;
15766
15767             case DT_TEXTREL:
15768               if (htab->local_ifunc_resolver)
15769                 info->callbacks->einfo
15770                   (_("%X%P: text relocations and GNU indirect "
15771                      "functions will result in a segfault at runtime\n"));
15772               else if (htab->maybe_local_ifunc_resolver)
15773                 info->callbacks->einfo
15774                   (_("%P: warning: text relocations and GNU indirect "
15775                      "functions may result in a segfault at runtime\n"));
15776               continue;
15777             }
15778
15779           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15780         }
15781     }
15782
15783   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15784       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15785     {
15786       /* Fill in the first entry in the global offset table.
15787          We use it to hold the link-time TOCbase.  */
15788       bfd_put_64 (output_bfd,
15789                   elf_gp (output_bfd) + TOC_BASE_OFF,
15790                   htab->elf.sgot->contents);
15791
15792       /* Set .got entry size.  */
15793       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15794     }
15795
15796   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15797       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15798     {
15799       /* Set .plt entry size.  */
15800       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15801         = PLT_ENTRY_SIZE (htab);
15802     }
15803
15804   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15805      brlt ourselves if emitrelocations.  */
15806   if (htab->brlt != NULL
15807       && htab->brlt->reloc_count != 0
15808       && !_bfd_elf_link_output_relocs (output_bfd,
15809                                        htab->brlt,
15810                                        elf_section_data (htab->brlt)->rela.hdr,
15811                                        elf_section_data (htab->brlt)->relocs,
15812                                        NULL))
15813     return FALSE;
15814
15815   if (htab->glink != NULL
15816       && htab->glink->reloc_count != 0
15817       && !_bfd_elf_link_output_relocs (output_bfd,
15818                                        htab->glink,
15819                                        elf_section_data (htab->glink)->rela.hdr,
15820                                        elf_section_data (htab->glink)->relocs,
15821                                        NULL))
15822     return FALSE;
15823
15824   if (htab->glink_eh_frame != NULL
15825       && htab->glink_eh_frame->size != 0)
15826     {
15827       bfd_vma val;
15828       bfd_byte *p;
15829       struct map_stub *group;
15830       size_t align = 4;
15831
15832       p = htab->glink_eh_frame->contents;
15833       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15834
15835       for (group = htab->group; group != NULL; group = group->next)
15836         if (group->stub_sec != NULL)
15837           {
15838             /* Offset to stub section.  */
15839             val = (group->stub_sec->output_section->vma
15840                    + group->stub_sec->output_offset);
15841             val -= (htab->glink_eh_frame->output_section->vma
15842                     + htab->glink_eh_frame->output_offset
15843                     + (p + 8 - htab->glink_eh_frame->contents));
15844             if (val + 0x80000000 > 0xffffffff)
15845               {
15846                 info->callbacks->einfo
15847                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15848                    group->stub_sec->name);
15849                 return FALSE;
15850               }
15851             bfd_put_32 (dynobj, val, p + 8);
15852             p += stub_eh_frame_size (group, align);
15853           }
15854       if (htab->glink != NULL && htab->glink->size != 0)
15855         {
15856           /* Offset to .glink.  */
15857           val = (htab->glink->output_section->vma
15858                  + htab->glink->output_offset
15859                  + 8);
15860           val -= (htab->glink_eh_frame->output_section->vma
15861                   + htab->glink_eh_frame->output_offset
15862                   + (p + 8 - htab->glink_eh_frame->contents));
15863           if (val + 0x80000000 > 0xffffffff)
15864             {
15865               info->callbacks->einfo
15866                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15867                  htab->glink->name);
15868               return FALSE;
15869             }
15870           bfd_put_32 (dynobj, val, p + 8);
15871           p += (24 + align - 1) & -align;
15872         }
15873
15874       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15875           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15876                                                htab->glink_eh_frame,
15877                                                htab->glink_eh_frame->contents))
15878         return FALSE;
15879     }
15880
15881   /* We need to handle writing out multiple GOT sections ourselves,
15882      since we didn't add them to DYNOBJ.  We know dynobj is the first
15883      bfd.  */
15884   while ((dynobj = dynobj->link.next) != NULL)
15885     {
15886       asection *s;
15887
15888       if (!is_ppc64_elf (dynobj))
15889         continue;
15890
15891       s = ppc64_elf_tdata (dynobj)->got;
15892       if (s != NULL
15893           && s->size != 0
15894           && s->output_section != bfd_abs_section_ptr
15895           && !bfd_set_section_contents (output_bfd, s->output_section,
15896                                         s->contents, s->output_offset,
15897                                         s->size))
15898         return FALSE;
15899       s = ppc64_elf_tdata (dynobj)->relgot;
15900       if (s != NULL
15901           && s->size != 0
15902           && s->output_section != bfd_abs_section_ptr
15903           && !bfd_set_section_contents (output_bfd, s->output_section,
15904                                         s->contents, s->output_offset,
15905                                         s->size))
15906         return FALSE;
15907     }
15908
15909   return TRUE;
15910 }
15911
15912 #include "elf64-target.h"
15913
15914 /* FreeBSD support */
15915
15916 #undef  TARGET_LITTLE_SYM
15917 #undef  TARGET_LITTLE_NAME
15918
15919 #undef  TARGET_BIG_SYM
15920 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15921 #undef  TARGET_BIG_NAME
15922 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15923
15924 #undef  ELF_OSABI
15925 #define ELF_OSABI       ELFOSABI_FREEBSD
15926
15927 #undef  elf64_bed
15928 #define elf64_bed       elf64_powerpc_fbsd_bed
15929
15930 #include "elf64-target.h"