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 on error.  */
4124   unsigned int stub_error:1;
4125
4126   /* Whether func_desc_adjust needs to be run over symbols.  */
4127   unsigned int need_func_desc_adj:1;
4128
4129   /* Whether there exist local gnu indirect function resolvers,
4130      referenced by dynamic relocations.  */
4131   unsigned int local_ifunc_resolver:1;
4132   unsigned int maybe_local_ifunc_resolver:1;
4133
4134   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4135   unsigned int has_plt_localentry0:1;
4136
4137   /* Incremented every time we size stubs.  */
4138   unsigned int stub_iteration;
4139
4140   /* Small local sym cache.  */
4141   struct sym_cache sym_cache;
4142 };
4143
4144 /* Rename some of the generic section flags to better document how they
4145    are used here.  */
4146
4147 /* Nonzero if this section has TLS related relocations.  */
4148 #define has_tls_reloc sec_flg0
4149
4150 /* Nonzero if this section has a call to __tls_get_addr.  */
4151 #define has_tls_get_addr_call sec_flg1
4152
4153 /* Nonzero if this section has any toc or got relocs.  */
4154 #define has_toc_reloc sec_flg2
4155
4156 /* Nonzero if this section has a call to another section that uses
4157    the toc or got.  */
4158 #define makes_toc_func_call sec_flg3
4159
4160 /* Recursion protection when determining above flag.  */
4161 #define call_check_in_progress sec_flg4
4162 #define call_check_done sec_flg5
4163
4164 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4165
4166 #define ppc_hash_table(p) \
4167   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4168   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4169
4170 #define ppc_stub_hash_lookup(table, string, create, copy) \
4171   ((struct ppc_stub_hash_entry *) \
4172    bfd_hash_lookup ((table), (string), (create), (copy)))
4173
4174 #define ppc_branch_hash_lookup(table, string, create, copy) \
4175   ((struct ppc_branch_hash_entry *) \
4176    bfd_hash_lookup ((table), (string), (create), (copy)))
4177
4178 /* Create an entry in the stub hash table.  */
4179
4180 static struct bfd_hash_entry *
4181 stub_hash_newfunc (struct bfd_hash_entry *entry,
4182                    struct bfd_hash_table *table,
4183                    const char *string)
4184 {
4185   /* Allocate the structure if it has not already been allocated by a
4186      subclass.  */
4187   if (entry == NULL)
4188     {
4189       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4190       if (entry == NULL)
4191         return entry;
4192     }
4193
4194   /* Call the allocation method of the superclass.  */
4195   entry = bfd_hash_newfunc (entry, table, string);
4196   if (entry != NULL)
4197     {
4198       struct ppc_stub_hash_entry *eh;
4199
4200       /* Initialize the local fields.  */
4201       eh = (struct ppc_stub_hash_entry *) entry;
4202       eh->stub_type = ppc_stub_none;
4203       eh->group = NULL;
4204       eh->stub_offset = 0;
4205       eh->target_value = 0;
4206       eh->target_section = NULL;
4207       eh->h = NULL;
4208       eh->plt_ent = NULL;
4209       eh->other = 0;
4210     }
4211
4212   return entry;
4213 }
4214
4215 /* Create an entry in the branch hash table.  */
4216
4217 static struct bfd_hash_entry *
4218 branch_hash_newfunc (struct bfd_hash_entry *entry,
4219                      struct bfd_hash_table *table,
4220                      const char *string)
4221 {
4222   /* Allocate the structure if it has not already been allocated by a
4223      subclass.  */
4224   if (entry == NULL)
4225     {
4226       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4227       if (entry == NULL)
4228         return entry;
4229     }
4230
4231   /* Call the allocation method of the superclass.  */
4232   entry = bfd_hash_newfunc (entry, table, string);
4233   if (entry != NULL)
4234     {
4235       struct ppc_branch_hash_entry *eh;
4236
4237       /* Initialize the local fields.  */
4238       eh = (struct ppc_branch_hash_entry *) entry;
4239       eh->offset = 0;
4240       eh->iter = 0;
4241     }
4242
4243   return entry;
4244 }
4245
4246 /* Create an entry in a ppc64 ELF linker hash table.  */
4247
4248 static struct bfd_hash_entry *
4249 link_hash_newfunc (struct bfd_hash_entry *entry,
4250                    struct bfd_hash_table *table,
4251                    const char *string)
4252 {
4253   /* Allocate the structure if it has not already been allocated by a
4254      subclass.  */
4255   if (entry == NULL)
4256     {
4257       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4258       if (entry == NULL)
4259         return entry;
4260     }
4261
4262   /* Call the allocation method of the superclass.  */
4263   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4264   if (entry != NULL)
4265     {
4266       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4267
4268       memset (&eh->u.stub_cache, 0,
4269               (sizeof (struct ppc_link_hash_entry)
4270                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4271
4272       /* When making function calls, old ABI code references function entry
4273          points (dot symbols), while new ABI code references the function
4274          descriptor symbol.  We need to make any combination of reference and
4275          definition work together, without breaking archive linking.
4276
4277          For a defined function "foo" and an undefined call to "bar":
4278          An old object defines "foo" and ".foo", references ".bar" (possibly
4279          "bar" too).
4280          A new object defines "foo" and references "bar".
4281
4282          A new object thus has no problem with its undefined symbols being
4283          satisfied by definitions in an old object.  On the other hand, the
4284          old object won't have ".bar" satisfied by a new object.
4285
4286          Keep a list of newly added dot-symbols.  */
4287
4288       if (string[0] == '.')
4289         {
4290           struct ppc_link_hash_table *htab;
4291
4292           htab = (struct ppc_link_hash_table *) table;
4293           eh->u.next_dot_sym = htab->dot_syms;
4294           htab->dot_syms = eh;
4295         }
4296     }
4297
4298   return entry;
4299 }
4300
4301 struct tocsave_entry {
4302   asection *sec;
4303   bfd_vma offset;
4304 };
4305
4306 static hashval_t
4307 tocsave_htab_hash (const void *p)
4308 {
4309   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4310   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4311 }
4312
4313 static int
4314 tocsave_htab_eq (const void *p1, const void *p2)
4315 {
4316   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4317   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4318   return e1->sec == e2->sec && e1->offset == e2->offset;
4319 }
4320
4321 /* Destroy a ppc64 ELF linker hash table.  */
4322
4323 static void
4324 ppc64_elf_link_hash_table_free (bfd *obfd)
4325 {
4326   struct ppc_link_hash_table *htab;
4327
4328   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4329   if (htab->tocsave_htab)
4330     htab_delete (htab->tocsave_htab);
4331   bfd_hash_table_free (&htab->branch_hash_table);
4332   bfd_hash_table_free (&htab->stub_hash_table);
4333   _bfd_elf_link_hash_table_free (obfd);
4334 }
4335
4336 /* Create a ppc64 ELF linker hash table.  */
4337
4338 static struct bfd_link_hash_table *
4339 ppc64_elf_link_hash_table_create (bfd *abfd)
4340 {
4341   struct ppc_link_hash_table *htab;
4342   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4343
4344   htab = bfd_zmalloc (amt);
4345   if (htab == NULL)
4346     return NULL;
4347
4348   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4349                                       sizeof (struct ppc_link_hash_entry),
4350                                       PPC64_ELF_DATA))
4351     {
4352       free (htab);
4353       return NULL;
4354     }
4355
4356   /* Init the stub hash table too.  */
4357   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4358                             sizeof (struct ppc_stub_hash_entry)))
4359     {
4360       _bfd_elf_link_hash_table_free (abfd);
4361       return NULL;
4362     }
4363
4364   /* And the branch hash table.  */
4365   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4366                             sizeof (struct ppc_branch_hash_entry)))
4367     {
4368       bfd_hash_table_free (&htab->stub_hash_table);
4369       _bfd_elf_link_hash_table_free (abfd);
4370       return NULL;
4371     }
4372
4373   htab->tocsave_htab = htab_try_create (1024,
4374                                         tocsave_htab_hash,
4375                                         tocsave_htab_eq,
4376                                         NULL);
4377   if (htab->tocsave_htab == NULL)
4378     {
4379       ppc64_elf_link_hash_table_free (abfd);
4380       return NULL;
4381     }
4382   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4383
4384   /* Initializing two fields of the union is just cosmetic.  We really
4385      only care about glist, but when compiled on a 32-bit host the
4386      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4387      debugger inspection of these fields look nicer.  */
4388   htab->elf.init_got_refcount.refcount = 0;
4389   htab->elf.init_got_refcount.glist = NULL;
4390   htab->elf.init_plt_refcount.refcount = 0;
4391   htab->elf.init_plt_refcount.glist = NULL;
4392   htab->elf.init_got_offset.offset = 0;
4393   htab->elf.init_got_offset.glist = NULL;
4394   htab->elf.init_plt_offset.offset = 0;
4395   htab->elf.init_plt_offset.glist = NULL;
4396
4397   return &htab->elf.root;
4398 }
4399
4400 /* Create sections for linker generated code.  */
4401
4402 static bfd_boolean
4403 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4404 {
4405   struct ppc_link_hash_table *htab;
4406   flagword flags;
4407
4408   htab = ppc_hash_table (info);
4409
4410   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4411            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4412   if (htab->params->save_restore_funcs)
4413     {
4414       /* Create .sfpr for code to save and restore fp regs.  */
4415       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4416                                                        flags);
4417       if (htab->sfpr == NULL
4418           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4419         return FALSE;
4420     }
4421
4422   if (bfd_link_relocatable (info))
4423     return TRUE;
4424
4425   /* Create .glink for lazy dynamic linking support.  */
4426   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4427                                                     flags);
4428   if (htab->glink == NULL
4429       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4430     return FALSE;
4431
4432   if (!info->no_ld_generated_unwind_info)
4433     {
4434       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4435                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4436       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4437                                                                  ".eh_frame",
4438                                                                  flags);
4439       if (htab->glink_eh_frame == NULL
4440           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4441         return FALSE;
4442     }
4443
4444   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4445   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4446   if (htab->elf.iplt == NULL
4447       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4448     return FALSE;
4449
4450   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4451            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4452   htab->elf.irelplt
4453     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4454   if (htab->elf.irelplt == NULL
4455       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4456     return FALSE;
4457
4458   /* Create branch lookup table for plt_branch stubs.  */
4459   flags = (SEC_ALLOC | SEC_LOAD
4460            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4461   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4462                                                    flags);
4463   if (htab->brlt == NULL
4464       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4465     return FALSE;
4466
4467   if (!bfd_link_pic (info))
4468     return TRUE;
4469
4470   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4471            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4472   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4473                                                       ".rela.branch_lt",
4474                                                       flags);
4475   if (htab->relbrlt == NULL
4476       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4477     return FALSE;
4478
4479   return TRUE;
4480 }
4481
4482 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4483
4484 bfd_boolean
4485 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4486                          struct ppc64_elf_params *params)
4487 {
4488   struct ppc_link_hash_table *htab;
4489
4490   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4491
4492 /* Always hook our dynamic sections into the first bfd, which is the
4493    linker created stub bfd.  This ensures that the GOT header is at
4494    the start of the output TOC section.  */
4495   htab = ppc_hash_table (info);
4496   htab->elf.dynobj = params->stub_bfd;
4497   htab->params = params;
4498
4499   return create_linkage_sections (htab->elf.dynobj, info);
4500 }
4501
4502 /* Build a name for an entry in the stub hash table.  */
4503
4504 static char *
4505 ppc_stub_name (const asection *input_section,
4506                const asection *sym_sec,
4507                const struct ppc_link_hash_entry *h,
4508                const Elf_Internal_Rela *rel)
4509 {
4510   char *stub_name;
4511   ssize_t len;
4512
4513   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4514      offsets from a sym as a branch target?  In fact, we could
4515      probably assume the addend is always zero.  */
4516   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4517
4518   if (h)
4519     {
4520       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4521       stub_name = bfd_malloc (len);
4522       if (stub_name == NULL)
4523         return stub_name;
4524
4525       len = sprintf (stub_name, "%08x.%s+%x",
4526                      input_section->id & 0xffffffff,
4527                      h->elf.root.root.string,
4528                      (int) rel->r_addend & 0xffffffff);
4529     }
4530   else
4531     {
4532       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4533       stub_name = bfd_malloc (len);
4534       if (stub_name == NULL)
4535         return stub_name;
4536
4537       len = sprintf (stub_name, "%08x.%x:%x+%x",
4538                      input_section->id & 0xffffffff,
4539                      sym_sec->id & 0xffffffff,
4540                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4541                      (int) rel->r_addend & 0xffffffff);
4542     }
4543   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4544     stub_name[len - 2] = 0;
4545   return stub_name;
4546 }
4547
4548 /* Look up an entry in the stub hash.  Stub entries are cached because
4549    creating the stub name takes a bit of time.  */
4550
4551 static struct ppc_stub_hash_entry *
4552 ppc_get_stub_entry (const asection *input_section,
4553                     const asection *sym_sec,
4554                     struct ppc_link_hash_entry *h,
4555                     const Elf_Internal_Rela *rel,
4556                     struct ppc_link_hash_table *htab)
4557 {
4558   struct ppc_stub_hash_entry *stub_entry;
4559   struct map_stub *group;
4560
4561   /* If this input section is part of a group of sections sharing one
4562      stub section, then use the id of the first section in the group.
4563      Stub names need to include a section id, as there may well be
4564      more than one stub used to reach say, printf, and we need to
4565      distinguish between them.  */
4566   group = htab->sec_info[input_section->id].u.group;
4567   if (group == NULL)
4568     return NULL;
4569
4570   if (h != NULL && h->u.stub_cache != NULL
4571       && h->u.stub_cache->h == h
4572       && h->u.stub_cache->group == group)
4573     {
4574       stub_entry = h->u.stub_cache;
4575     }
4576   else
4577     {
4578       char *stub_name;
4579
4580       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4581       if (stub_name == NULL)
4582         return NULL;
4583
4584       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4585                                          stub_name, FALSE, FALSE);
4586       if (h != NULL)
4587         h->u.stub_cache = stub_entry;
4588
4589       free (stub_name);
4590     }
4591
4592   return stub_entry;
4593 }
4594
4595 /* Add a new stub entry to the stub hash.  Not all fields of the new
4596    stub entry are initialised.  */
4597
4598 static struct ppc_stub_hash_entry *
4599 ppc_add_stub (const char *stub_name,
4600               asection *section,
4601               struct bfd_link_info *info)
4602 {
4603   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4604   struct map_stub *group;
4605   asection *link_sec;
4606   asection *stub_sec;
4607   struct ppc_stub_hash_entry *stub_entry;
4608
4609   group = htab->sec_info[section->id].u.group;
4610   link_sec = group->link_sec;
4611   stub_sec = group->stub_sec;
4612   if (stub_sec == NULL)
4613     {
4614       size_t namelen;
4615       bfd_size_type len;
4616       char *s_name;
4617
4618       namelen = strlen (link_sec->name);
4619       len = namelen + sizeof (STUB_SUFFIX);
4620       s_name = bfd_alloc (htab->params->stub_bfd, len);
4621       if (s_name == NULL)
4622         return NULL;
4623
4624       memcpy (s_name, link_sec->name, namelen);
4625       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4626       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4627       if (stub_sec == NULL)
4628         return NULL;
4629       group->stub_sec = stub_sec;
4630     }
4631
4632   /* Enter this entry into the linker stub hash table.  */
4633   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4634                                      TRUE, FALSE);
4635   if (stub_entry == NULL)
4636     {
4637       /* xgettext:c-format */
4638       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4639                               section->owner, stub_name);
4640       return NULL;
4641     }
4642
4643   stub_entry->group = group;
4644   stub_entry->stub_offset = 0;
4645   return stub_entry;
4646 }
4647
4648 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4649    not already done.  */
4650
4651 static bfd_boolean
4652 create_got_section (bfd *abfd, struct bfd_link_info *info)
4653 {
4654   asection *got, *relgot;
4655   flagword flags;
4656   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4657
4658   if (!is_ppc64_elf (abfd))
4659     return FALSE;
4660   if (htab == NULL)
4661     return FALSE;
4662
4663   if (!htab->elf.sgot
4664       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4665     return FALSE;
4666
4667   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4668            | SEC_LINKER_CREATED);
4669
4670   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4671   if (!got
4672       || !bfd_set_section_alignment (abfd, got, 3))
4673     return FALSE;
4674
4675   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4676                                                flags | SEC_READONLY);
4677   if (!relgot
4678       || ! bfd_set_section_alignment (abfd, relgot, 3))
4679     return FALSE;
4680
4681   ppc64_elf_tdata (abfd)->got = got;
4682   ppc64_elf_tdata (abfd)->relgot = relgot;
4683   return TRUE;
4684 }
4685
4686 /* Follow indirect and warning symbol links.  */
4687
4688 static inline struct bfd_link_hash_entry *
4689 follow_link (struct bfd_link_hash_entry *h)
4690 {
4691   while (h->type == bfd_link_hash_indirect
4692          || h->type == bfd_link_hash_warning)
4693     h = h->u.i.link;
4694   return h;
4695 }
4696
4697 static inline struct elf_link_hash_entry *
4698 elf_follow_link (struct elf_link_hash_entry *h)
4699 {
4700   return (struct elf_link_hash_entry *) follow_link (&h->root);
4701 }
4702
4703 static inline struct ppc_link_hash_entry *
4704 ppc_follow_link (struct ppc_link_hash_entry *h)
4705 {
4706   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4707 }
4708
4709 /* Merge PLT info on FROM with that on TO.  */
4710
4711 static void
4712 move_plt_plist (struct ppc_link_hash_entry *from,
4713                 struct ppc_link_hash_entry *to)
4714 {
4715   if (from->elf.plt.plist != NULL)
4716     {
4717       if (to->elf.plt.plist != NULL)
4718         {
4719           struct plt_entry **entp;
4720           struct plt_entry *ent;
4721
4722           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4723             {
4724               struct plt_entry *dent;
4725
4726               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4727                 if (dent->addend == ent->addend)
4728                   {
4729                     dent->plt.refcount += ent->plt.refcount;
4730                     *entp = ent->next;
4731                     break;
4732                   }
4733               if (dent == NULL)
4734                 entp = &ent->next;
4735             }
4736           *entp = to->elf.plt.plist;
4737         }
4738
4739       to->elf.plt.plist = from->elf.plt.plist;
4740       from->elf.plt.plist = NULL;
4741     }
4742 }
4743
4744 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4745
4746 static void
4747 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4748                                 struct elf_link_hash_entry *dir,
4749                                 struct elf_link_hash_entry *ind)
4750 {
4751   struct ppc_link_hash_entry *edir, *eind;
4752
4753   edir = (struct ppc_link_hash_entry *) dir;
4754   eind = (struct ppc_link_hash_entry *) ind;
4755
4756   edir->is_func |= eind->is_func;
4757   edir->is_func_descriptor |= eind->is_func_descriptor;
4758   edir->tls_mask |= eind->tls_mask;
4759   if (eind->oh != NULL)
4760     edir->oh = ppc_follow_link (eind->oh);
4761
4762   /* If called to transfer flags for a weakdef during processing
4763      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4764      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4765   if (!(ELIMINATE_COPY_RELOCS
4766         && eind->elf.root.type != bfd_link_hash_indirect
4767         && edir->elf.dynamic_adjusted))
4768     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4769
4770   if (edir->elf.versioned != versioned_hidden)
4771     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4772   edir->elf.ref_regular |= eind->elf.ref_regular;
4773   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4774   edir->elf.needs_plt |= eind->elf.needs_plt;
4775   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4776
4777   /* If we were called to copy over info for a weak sym, don't copy
4778      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4779      in order to simplify readonly_dynrelocs and save a field in the
4780      symbol hash entry, but that means dyn_relocs can't be used in any
4781      tests about a specific symbol, or affect other symbol flags which
4782      are then tested.
4783      Chain weakdefs so we can get from the weakdef back to an alias.
4784      The list is circular so that we don't need to use u.weakdef as
4785      well as this list to look at all aliases.  */
4786   if (eind->elf.root.type != bfd_link_hash_indirect)
4787     {
4788       struct ppc_link_hash_entry *cur, *add, *next;
4789
4790       add = eind;
4791       do
4792         {
4793           cur = edir->weakref;
4794           if (cur != NULL)
4795             {
4796               do
4797                 {
4798                   /* We can be called twice for the same symbols.
4799                      Don't make multiple loops.  */
4800                   if (cur == add)
4801                     return;
4802                   cur = cur->weakref;
4803                 } while (cur != edir);
4804             }
4805           next = add->weakref;
4806           if (cur != add)
4807             {
4808               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4809               edir->weakref = add;
4810             }
4811           add = next;
4812         } while (add != NULL && add != eind);
4813       return;
4814     }
4815
4816   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4817   if (eind->dyn_relocs != NULL)
4818     {
4819       if (edir->dyn_relocs != NULL)
4820         {
4821           struct elf_dyn_relocs **pp;
4822           struct elf_dyn_relocs *p;
4823
4824           /* Add reloc counts against the indirect sym to the direct sym
4825              list.  Merge any entries against the same section.  */
4826           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4827             {
4828               struct elf_dyn_relocs *q;
4829
4830               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4831                 if (q->sec == p->sec)
4832                   {
4833                     q->pc_count += p->pc_count;
4834                     q->count += p->count;
4835                     *pp = p->next;
4836                     break;
4837                   }
4838               if (q == NULL)
4839                 pp = &p->next;
4840             }
4841           *pp = edir->dyn_relocs;
4842         }
4843
4844       edir->dyn_relocs = eind->dyn_relocs;
4845       eind->dyn_relocs = NULL;
4846     }
4847
4848   /* Copy over got entries that we may have already seen to the
4849      symbol which just became indirect.  */
4850   if (eind->elf.got.glist != NULL)
4851     {
4852       if (edir->elf.got.glist != NULL)
4853         {
4854           struct got_entry **entp;
4855           struct got_entry *ent;
4856
4857           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4858             {
4859               struct got_entry *dent;
4860
4861               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4862                 if (dent->addend == ent->addend
4863                     && dent->owner == ent->owner
4864                     && dent->tls_type == ent->tls_type)
4865                   {
4866                     dent->got.refcount += ent->got.refcount;
4867                     *entp = ent->next;
4868                     break;
4869                   }
4870               if (dent == NULL)
4871                 entp = &ent->next;
4872             }
4873           *entp = edir->elf.got.glist;
4874         }
4875
4876       edir->elf.got.glist = eind->elf.got.glist;
4877       eind->elf.got.glist = NULL;
4878     }
4879
4880   /* And plt entries.  */
4881   move_plt_plist (eind, edir);
4882
4883   if (eind->elf.dynindx != -1)
4884     {
4885       if (edir->elf.dynindx != -1)
4886         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4887                                 edir->elf.dynstr_index);
4888       edir->elf.dynindx = eind->elf.dynindx;
4889       edir->elf.dynstr_index = eind->elf.dynstr_index;
4890       eind->elf.dynindx = -1;
4891       eind->elf.dynstr_index = 0;
4892     }
4893 }
4894
4895 /* Find the function descriptor hash entry from the given function code
4896    hash entry FH.  Link the entries via their OH fields.  */
4897
4898 static struct ppc_link_hash_entry *
4899 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4900 {
4901   struct ppc_link_hash_entry *fdh = fh->oh;
4902
4903   if (fdh == NULL)
4904     {
4905       const char *fd_name = fh->elf.root.root.string + 1;
4906
4907       fdh = (struct ppc_link_hash_entry *)
4908         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4909       if (fdh == NULL)
4910         return fdh;
4911
4912       fdh->is_func_descriptor = 1;
4913       fdh->oh = fh;
4914       fh->is_func = 1;
4915       fh->oh = fdh;
4916     }
4917
4918   fdh = ppc_follow_link (fdh);
4919   fdh->is_func_descriptor = 1;
4920   fdh->oh = fh;
4921   return fdh;
4922 }
4923
4924 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4925
4926 static struct ppc_link_hash_entry *
4927 make_fdh (struct bfd_link_info *info,
4928           struct ppc_link_hash_entry *fh)
4929 {
4930   bfd *abfd = fh->elf.root.u.undef.abfd;
4931   struct bfd_link_hash_entry *bh = NULL;
4932   struct ppc_link_hash_entry *fdh;
4933   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4934                     ? BSF_WEAK
4935                     : BSF_GLOBAL);
4936
4937   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4938                                          fh->elf.root.root.string + 1,
4939                                          flags, bfd_und_section_ptr, 0,
4940                                          NULL, FALSE, FALSE, &bh))
4941     return NULL;
4942
4943   fdh = (struct ppc_link_hash_entry *) bh;
4944   fdh->elf.non_elf = 0;
4945   fdh->fake = 1;
4946   fdh->is_func_descriptor = 1;
4947   fdh->oh = fh;
4948   fh->is_func = 1;
4949   fh->oh = fdh;
4950   return fdh;
4951 }
4952
4953 /* Fix function descriptor symbols defined in .opd sections to be
4954    function type.  */
4955
4956 static bfd_boolean
4957 ppc64_elf_add_symbol_hook (bfd *ibfd,
4958                            struct bfd_link_info *info,
4959                            Elf_Internal_Sym *isym,
4960                            const char **name,
4961                            flagword *flags ATTRIBUTE_UNUSED,
4962                            asection **sec,
4963                            bfd_vma *value)
4964 {
4965   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4966       && (ibfd->flags & DYNAMIC) == 0
4967       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4968     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4969
4970   if (*sec != NULL
4971       && strcmp ((*sec)->name, ".opd") == 0)
4972     {
4973       asection *code_sec;
4974
4975       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4976             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4977         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4978
4979       /* If the symbol is a function defined in .opd, and the function
4980          code is in a discarded group, let it appear to be undefined.  */
4981       if (!bfd_link_relocatable (info)
4982           && (*sec)->reloc_count != 0
4983           && opd_entry_value (*sec, *value, &code_sec, NULL,
4984                               FALSE) != (bfd_vma) -1
4985           && discarded_section (code_sec))
4986         {
4987           *sec = bfd_und_section_ptr;
4988           isym->st_shndx = SHN_UNDEF;
4989         }
4990     }
4991   else if (*sec != NULL
4992            && strcmp ((*sec)->name, ".toc") == 0
4993            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4994     {
4995       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4996       if (htab != NULL)
4997         htab->params->object_in_toc = 1;
4998     }
4999
5000   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5001     {
5002       if (abiversion (ibfd) == 0)
5003         set_abiversion (ibfd, 2);
5004       else if (abiversion (ibfd) == 1)
5005         {
5006           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
5007                                     " for ABI version 1\n"), name);
5008           bfd_set_error (bfd_error_bad_value);
5009           return FALSE;
5010         }
5011     }
5012
5013   return TRUE;
5014 }
5015
5016 /* Merge non-visibility st_other attributes: local entry point.  */
5017
5018 static void
5019 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5020                                   const Elf_Internal_Sym *isym,
5021                                   bfd_boolean definition,
5022                                   bfd_boolean dynamic)
5023 {
5024   if (definition && (!dynamic || !h->def_regular))
5025     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5026                 | ELF_ST_VISIBILITY (h->other));
5027 }
5028
5029 /* Hook called on merging a symbol.  We use this to clear "fake" since
5030    we now have a real symbol.  */
5031
5032 static bfd_boolean
5033 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5034                         const Elf_Internal_Sym *isym,
5035                         asection **psec ATTRIBUTE_UNUSED,
5036                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5037                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5038                         bfd *oldbfd ATTRIBUTE_UNUSED,
5039                         const asection *oldsec ATTRIBUTE_UNUSED)
5040 {
5041   ((struct ppc_link_hash_entry *) h)->fake = 0;
5042   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5043     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5044   return TRUE;
5045 }
5046
5047 /* This function makes an old ABI object reference to ".bar" cause the
5048    inclusion of a new ABI object archive that defines "bar".
5049    NAME is a symbol defined in an archive.  Return a symbol in the hash
5050    table that might be satisfied by the archive symbols.  */
5051
5052 static struct elf_link_hash_entry *
5053 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5054                                  struct bfd_link_info *info,
5055                                  const char *name)
5056 {
5057   struct elf_link_hash_entry *h;
5058   char *dot_name;
5059   size_t len;
5060
5061   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5062   if (h != NULL
5063       /* Don't return this sym if it is a fake function descriptor
5064          created by add_symbol_adjust.  */
5065       && !((struct ppc_link_hash_entry *) h)->fake)
5066     return h;
5067
5068   if (name[0] == '.')
5069     return h;
5070
5071   len = strlen (name);
5072   dot_name = bfd_alloc (abfd, len + 2);
5073   if (dot_name == NULL)
5074     return (struct elf_link_hash_entry *) 0 - 1;
5075   dot_name[0] = '.';
5076   memcpy (dot_name + 1, name, len + 1);
5077   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5078   bfd_release (abfd, dot_name);
5079   return h;
5080 }
5081
5082 /* This function satisfies all old ABI object references to ".bar" if a
5083    new ABI object defines "bar".  Well, at least, undefined dot symbols
5084    are made weak.  This stops later archive searches from including an
5085    object if we already have a function descriptor definition.  It also
5086    prevents the linker complaining about undefined symbols.
5087    We also check and correct mismatched symbol visibility here.  The
5088    most restrictive visibility of the function descriptor and the
5089    function entry symbol is used.  */
5090
5091 static bfd_boolean
5092 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5093 {
5094   struct ppc_link_hash_table *htab;
5095   struct ppc_link_hash_entry *fdh;
5096
5097   if (eh->elf.root.type == bfd_link_hash_warning)
5098     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5099
5100   if (eh->elf.root.type == bfd_link_hash_indirect)
5101     return TRUE;
5102
5103   if (eh->elf.root.root.string[0] != '.')
5104     abort ();
5105
5106   htab = ppc_hash_table (info);
5107   if (htab == NULL)
5108     return FALSE;
5109
5110   fdh = lookup_fdh (eh, htab);
5111   if (fdh == NULL
5112       && !bfd_link_relocatable (info)
5113       && (eh->elf.root.type == bfd_link_hash_undefined
5114           || eh->elf.root.type == bfd_link_hash_undefweak)
5115       && eh->elf.ref_regular)
5116     {
5117       /* Make an undefined function descriptor sym, in order to
5118          pull in an --as-needed shared lib.  Archives are handled
5119          elsewhere.  */
5120       fdh = make_fdh (info, eh);
5121       if (fdh == NULL)
5122         return FALSE;
5123     }
5124
5125   if (fdh != NULL)
5126     {
5127       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5128       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5129
5130       /* Make both descriptor and entry symbol have the most
5131          constraining visibility of either symbol.  */
5132       if (entry_vis < descr_vis)
5133         fdh->elf.other += entry_vis - descr_vis;
5134       else if (entry_vis > descr_vis)
5135         eh->elf.other += descr_vis - entry_vis;
5136
5137       /* Propagate reference flags from entry symbol to function
5138          descriptor symbol.  */
5139       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5140       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5141       fdh->elf.ref_regular |= eh->elf.ref_regular;
5142       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5143
5144       if (!fdh->elf.forced_local
5145           && fdh->elf.dynindx == -1
5146           && fdh->elf.versioned != versioned_hidden
5147           && (bfd_link_dll (info)
5148               || fdh->elf.def_dynamic
5149               || fdh->elf.ref_dynamic)
5150           && (eh->elf.ref_regular
5151               || eh->elf.def_regular))
5152         {
5153           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5154             return FALSE;
5155         }
5156     }
5157
5158   return TRUE;
5159 }
5160
5161 /* Set up opd section info and abiversion for IBFD, and process list
5162    of dot-symbols we made in link_hash_newfunc.  */
5163
5164 static bfd_boolean
5165 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5166 {
5167   struct ppc_link_hash_table *htab;
5168   struct ppc_link_hash_entry **p, *eh;
5169   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5170
5171   if (opd != NULL && opd->size != 0)
5172     {
5173       if (abiversion (ibfd) == 0)
5174         set_abiversion (ibfd, 1);
5175       else if (abiversion (ibfd) >= 2)
5176         {
5177           /* xgettext:c-format */
5178           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5179                                     " version %d\n"),
5180                                   ibfd, abiversion (ibfd));
5181           bfd_set_error (bfd_error_bad_value);
5182           return FALSE;
5183         }
5184
5185       if ((ibfd->flags & DYNAMIC) == 0
5186           && (opd->flags & SEC_RELOC) != 0
5187           && opd->reloc_count != 0
5188           && !bfd_is_abs_section (opd->output_section))
5189         {
5190           /* Garbage collection needs some extra help with .opd sections.
5191              We don't want to necessarily keep everything referenced by
5192              relocs in .opd, as that would keep all functions.  Instead,
5193              if we reference an .opd symbol (a function descriptor), we
5194              want to keep the function code symbol's section.  This is
5195              easy for global symbols, but for local syms we need to keep
5196              information about the associated function section.  */
5197           bfd_size_type amt;
5198           asection **opd_sym_map;
5199
5200           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5201           opd_sym_map = bfd_zalloc (ibfd, amt);
5202           if (opd_sym_map == NULL)
5203             return FALSE;
5204           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5205           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5206           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5207         }
5208     }
5209
5210   if (!is_ppc64_elf (info->output_bfd))
5211     return TRUE;
5212   htab = ppc_hash_table (info);
5213   if (htab == NULL)
5214     return FALSE;
5215
5216   /* For input files without an explicit abiversion in e_flags
5217      we should have flagged any with symbol st_other bits set
5218      as ELFv1 and above flagged those with .opd as ELFv2.
5219      Set the output abiversion if not yet set, and for any input
5220      still ambiguous, take its abiversion from the output.
5221      Differences in ABI are reported later.  */
5222   if (abiversion (info->output_bfd) == 0)
5223     set_abiversion (info->output_bfd, abiversion (ibfd));
5224   else if (abiversion (ibfd) == 0)
5225     set_abiversion (ibfd, abiversion (info->output_bfd));
5226
5227   p = &htab->dot_syms;
5228   while ((eh = *p) != NULL)
5229     {
5230       *p = NULL;
5231       if (&eh->elf == htab->elf.hgot)
5232         ;
5233       else if (htab->elf.hgot == NULL
5234                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5235         htab->elf.hgot = &eh->elf;
5236       else if (abiversion (ibfd) <= 1)
5237         {
5238           htab->need_func_desc_adj = 1;
5239           if (!add_symbol_adjust (eh, info))
5240             return FALSE;
5241         }
5242       p = &eh->u.next_dot_sym;
5243     }
5244   return TRUE;
5245 }
5246
5247 /* Undo hash table changes when an --as-needed input file is determined
5248    not to be needed.  */
5249
5250 static bfd_boolean
5251 ppc64_elf_notice_as_needed (bfd *ibfd,
5252                             struct bfd_link_info *info,
5253                             enum notice_asneeded_action act)
5254 {
5255   if (act == notice_not_needed)
5256     {
5257       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5258
5259       if (htab == NULL)
5260         return FALSE;
5261
5262       htab->dot_syms = NULL;
5263     }
5264   return _bfd_elf_notice_as_needed (ibfd, info, act);
5265 }
5266
5267 /* If --just-symbols against a final linked binary, then assume we need
5268    toc adjusting stubs when calling functions defined there.  */
5269
5270 static void
5271 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5272 {
5273   if ((sec->flags & SEC_CODE) != 0
5274       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5275       && is_ppc64_elf (sec->owner))
5276     {
5277       if (abiversion (sec->owner) >= 2
5278           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5279         sec->has_toc_reloc = 1;
5280     }
5281   _bfd_elf_link_just_syms (sec, info);
5282 }
5283
5284 static struct plt_entry **
5285 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5286                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5287 {
5288   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5289   struct plt_entry **local_plt;
5290   unsigned char *local_got_tls_masks;
5291
5292   if (local_got_ents == NULL)
5293     {
5294       bfd_size_type size = symtab_hdr->sh_info;
5295
5296       size *= (sizeof (*local_got_ents)
5297                + sizeof (*local_plt)
5298                + sizeof (*local_got_tls_masks));
5299       local_got_ents = bfd_zalloc (abfd, size);
5300       if (local_got_ents == NULL)
5301         return NULL;
5302       elf_local_got_ents (abfd) = local_got_ents;
5303     }
5304
5305   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5306     {
5307       struct got_entry *ent;
5308
5309       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5310         if (ent->addend == r_addend
5311             && ent->owner == abfd
5312             && ent->tls_type == tls_type)
5313           break;
5314       if (ent == NULL)
5315         {
5316           bfd_size_type amt = sizeof (*ent);
5317           ent = bfd_alloc (abfd, amt);
5318           if (ent == NULL)
5319             return FALSE;
5320           ent->next = local_got_ents[r_symndx];
5321           ent->addend = r_addend;
5322           ent->owner = abfd;
5323           ent->tls_type = tls_type;
5324           ent->is_indirect = FALSE;
5325           ent->got.refcount = 0;
5326           local_got_ents[r_symndx] = ent;
5327         }
5328       ent->got.refcount += 1;
5329     }
5330
5331   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5332   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5333   local_got_tls_masks[r_symndx] |= tls_type;
5334
5335   return local_plt + r_symndx;
5336 }
5337
5338 static bfd_boolean
5339 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5340 {
5341   struct plt_entry *ent;
5342
5343   for (ent = *plist; ent != NULL; ent = ent->next)
5344     if (ent->addend == addend)
5345       break;
5346   if (ent == NULL)
5347     {
5348       bfd_size_type amt = sizeof (*ent);
5349       ent = bfd_alloc (abfd, amt);
5350       if (ent == NULL)
5351         return FALSE;
5352       ent->next = *plist;
5353       ent->addend = addend;
5354       ent->plt.refcount = 0;
5355       *plist = ent;
5356     }
5357   ent->plt.refcount += 1;
5358   return TRUE;
5359 }
5360
5361 static bfd_boolean
5362 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5363 {
5364   return (r_type == R_PPC64_REL24
5365           || r_type == R_PPC64_REL14
5366           || r_type == R_PPC64_REL14_BRTAKEN
5367           || r_type == R_PPC64_REL14_BRNTAKEN
5368           || r_type == R_PPC64_ADDR24
5369           || r_type == R_PPC64_ADDR14
5370           || r_type == R_PPC64_ADDR14_BRTAKEN
5371           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5372 }
5373
5374 /* Look through the relocs for a section during the first phase, and
5375    calculate needed space in the global offset table, procedure
5376    linkage table, and dynamic reloc sections.  */
5377
5378 static bfd_boolean
5379 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5380                         asection *sec, const Elf_Internal_Rela *relocs)
5381 {
5382   struct ppc_link_hash_table *htab;
5383   Elf_Internal_Shdr *symtab_hdr;
5384   struct elf_link_hash_entry **sym_hashes;
5385   const Elf_Internal_Rela *rel;
5386   const Elf_Internal_Rela *rel_end;
5387   asection *sreloc;
5388   asection **opd_sym_map;
5389   struct elf_link_hash_entry *tga, *dottga;
5390
5391   if (bfd_link_relocatable (info))
5392     return TRUE;
5393
5394   /* Don't do anything special with non-loaded, non-alloced sections.
5395      In particular, any relocs in such sections should not affect GOT
5396      and PLT reference counting (ie. we don't allow them to create GOT
5397      or PLT entries), there's no possibility or desire to optimize TLS
5398      relocs, and there's not much point in propagating relocs to shared
5399      libs that the dynamic linker won't relocate.  */
5400   if ((sec->flags & SEC_ALLOC) == 0)
5401     return TRUE;
5402
5403   BFD_ASSERT (is_ppc64_elf (abfd));
5404
5405   htab = ppc_hash_table (info);
5406   if (htab == NULL)
5407     return FALSE;
5408
5409   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5410                               FALSE, FALSE, TRUE);
5411   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5412                                  FALSE, FALSE, TRUE);
5413   symtab_hdr = &elf_symtab_hdr (abfd);
5414   sym_hashes = elf_sym_hashes (abfd);
5415   sreloc = NULL;
5416   opd_sym_map = NULL;
5417   if (ppc64_elf_section_data (sec) != NULL
5418       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5419     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5420
5421   rel_end = relocs + sec->reloc_count;
5422   for (rel = relocs; rel < rel_end; rel++)
5423     {
5424       unsigned long r_symndx;
5425       struct elf_link_hash_entry *h;
5426       enum elf_ppc64_reloc_type r_type;
5427       int tls_type;
5428       struct _ppc64_elf_section_data *ppc64_sec;
5429       struct plt_entry **ifunc, **plt_list;
5430
5431       r_symndx = ELF64_R_SYM (rel->r_info);
5432       if (r_symndx < symtab_hdr->sh_info)
5433         h = NULL;
5434       else
5435         {
5436           struct ppc_link_hash_entry *eh;
5437
5438           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5439           h = elf_follow_link (h);
5440           eh = (struct ppc_link_hash_entry *) h;
5441
5442           /* PR15323, ref flags aren't set for references in the same
5443              object.  */
5444           h->root.non_ir_ref_regular = 1;
5445           if (eh->is_func && eh->oh != NULL)
5446             eh->oh->elf.root.non_ir_ref_regular = 1;
5447
5448           if (h == htab->elf.hgot)
5449             sec->has_toc_reloc = 1;
5450         }
5451
5452       tls_type = 0;
5453       ifunc = NULL;
5454       if (h != NULL)
5455         {
5456           if (h->type == STT_GNU_IFUNC)
5457             {
5458               h->needs_plt = 1;
5459               ifunc = &h->plt.plist;
5460             }
5461         }
5462       else
5463         {
5464           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5465                                                           abfd, r_symndx);
5466           if (isym == NULL)
5467             return FALSE;
5468
5469           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5470             {
5471               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5472                                              rel->r_addend, PLT_IFUNC);
5473               if (ifunc == NULL)
5474                 return FALSE;
5475             }
5476         }
5477
5478       r_type = ELF64_R_TYPE (rel->r_info);
5479       switch (r_type)
5480         {
5481         case R_PPC64_TLSGD:
5482         case R_PPC64_TLSLD:
5483           /* These special tls relocs tie a call to __tls_get_addr with
5484              its parameter symbol.  */
5485           break;
5486
5487         case R_PPC64_GOT_TLSLD16:
5488         case R_PPC64_GOT_TLSLD16_LO:
5489         case R_PPC64_GOT_TLSLD16_HI:
5490         case R_PPC64_GOT_TLSLD16_HA:
5491           tls_type = TLS_TLS | TLS_LD;
5492           goto dogottls;
5493
5494         case R_PPC64_GOT_TLSGD16:
5495         case R_PPC64_GOT_TLSGD16_LO:
5496         case R_PPC64_GOT_TLSGD16_HI:
5497         case R_PPC64_GOT_TLSGD16_HA:
5498           tls_type = TLS_TLS | TLS_GD;
5499           goto dogottls;
5500
5501         case R_PPC64_GOT_TPREL16_DS:
5502         case R_PPC64_GOT_TPREL16_LO_DS:
5503         case R_PPC64_GOT_TPREL16_HI:
5504         case R_PPC64_GOT_TPREL16_HA:
5505           if (bfd_link_dll (info))
5506             info->flags |= DF_STATIC_TLS;
5507           tls_type = TLS_TLS | TLS_TPREL;
5508           goto dogottls;
5509
5510         case R_PPC64_GOT_DTPREL16_DS:
5511         case R_PPC64_GOT_DTPREL16_LO_DS:
5512         case R_PPC64_GOT_DTPREL16_HI:
5513         case R_PPC64_GOT_DTPREL16_HA:
5514           tls_type = TLS_TLS | TLS_DTPREL;
5515         dogottls:
5516           sec->has_tls_reloc = 1;
5517           /* Fall through */
5518
5519         case R_PPC64_GOT16:
5520         case R_PPC64_GOT16_DS:
5521         case R_PPC64_GOT16_HA:
5522         case R_PPC64_GOT16_HI:
5523         case R_PPC64_GOT16_LO:
5524         case R_PPC64_GOT16_LO_DS:
5525           /* This symbol requires a global offset table entry.  */
5526           sec->has_toc_reloc = 1;
5527           if (r_type == R_PPC64_GOT_TLSLD16
5528               || r_type == R_PPC64_GOT_TLSGD16
5529               || r_type == R_PPC64_GOT_TPREL16_DS
5530               || r_type == R_PPC64_GOT_DTPREL16_DS
5531               || r_type == R_PPC64_GOT16
5532               || r_type == R_PPC64_GOT16_DS)
5533             {
5534               htab->do_multi_toc = 1;
5535               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5536             }
5537
5538           if (ppc64_elf_tdata (abfd)->got == NULL
5539               && !create_got_section (abfd, info))
5540             return FALSE;
5541
5542           if (h != NULL)
5543             {
5544               struct ppc_link_hash_entry *eh;
5545               struct got_entry *ent;
5546
5547               eh = (struct ppc_link_hash_entry *) h;
5548               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5549                 if (ent->addend == rel->r_addend
5550                     && ent->owner == abfd
5551                     && ent->tls_type == tls_type)
5552                   break;
5553               if (ent == NULL)
5554                 {
5555                   bfd_size_type amt = sizeof (*ent);
5556                   ent = bfd_alloc (abfd, amt);
5557                   if (ent == NULL)
5558                     return FALSE;
5559                   ent->next = eh->elf.got.glist;
5560                   ent->addend = rel->r_addend;
5561                   ent->owner = abfd;
5562                   ent->tls_type = tls_type;
5563                   ent->is_indirect = FALSE;
5564                   ent->got.refcount = 0;
5565                   eh->elf.got.glist = ent;
5566                 }
5567               ent->got.refcount += 1;
5568               eh->tls_mask |= tls_type;
5569             }
5570           else
5571             /* This is a global offset table entry for a local symbol.  */
5572             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5573                                         rel->r_addend, tls_type))
5574               return FALSE;
5575
5576           /* We may also need a plt entry if the symbol turns out to be
5577              an ifunc.  */
5578           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5579             {
5580               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5581                 return FALSE;
5582             }
5583           break;
5584
5585         case R_PPC64_PLT16_HA:
5586         case R_PPC64_PLT16_HI:
5587         case R_PPC64_PLT16_LO:
5588         case R_PPC64_PLT32:
5589         case R_PPC64_PLT64:
5590           /* This symbol requires a procedure linkage table entry.  */
5591           plt_list = ifunc;
5592           if (h != NULL)
5593             {
5594               h->needs_plt = 1;
5595               if (h->root.root.string[0] == '.'
5596                   && h->root.root.string[1] != '\0')
5597                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5598               plt_list = &h->plt.plist;
5599             }
5600           if (plt_list == NULL)
5601             {
5602               /* It does not make sense to have a procedure linkage
5603                  table entry for a non-ifunc local symbol.  */
5604               info->callbacks->einfo
5605                 /* xgettext:c-format */
5606                 (_("%H: %s reloc against local symbol\n"),
5607                  abfd, sec, rel->r_offset,
5608                  ppc64_elf_howto_table[r_type]->name);
5609               bfd_set_error (bfd_error_bad_value);
5610               return FALSE;
5611             }
5612           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5613             return FALSE;
5614           break;
5615
5616           /* The following relocations don't need to propagate the
5617              relocation if linking a shared object since they are
5618              section relative.  */
5619         case R_PPC64_SECTOFF:
5620         case R_PPC64_SECTOFF_LO:
5621         case R_PPC64_SECTOFF_HI:
5622         case R_PPC64_SECTOFF_HA:
5623         case R_PPC64_SECTOFF_DS:
5624         case R_PPC64_SECTOFF_LO_DS:
5625         case R_PPC64_DTPREL16:
5626         case R_PPC64_DTPREL16_LO:
5627         case R_PPC64_DTPREL16_HI:
5628         case R_PPC64_DTPREL16_HA:
5629         case R_PPC64_DTPREL16_DS:
5630         case R_PPC64_DTPREL16_LO_DS:
5631         case R_PPC64_DTPREL16_HIGH:
5632         case R_PPC64_DTPREL16_HIGHA:
5633         case R_PPC64_DTPREL16_HIGHER:
5634         case R_PPC64_DTPREL16_HIGHERA:
5635         case R_PPC64_DTPREL16_HIGHEST:
5636         case R_PPC64_DTPREL16_HIGHESTA:
5637           break;
5638
5639           /* Nor do these.  */
5640         case R_PPC64_REL16:
5641         case R_PPC64_REL16_LO:
5642         case R_PPC64_REL16_HI:
5643         case R_PPC64_REL16_HA:
5644         case R_PPC64_REL16DX_HA:
5645           break;
5646
5647           /* Not supported as a dynamic relocation.  */
5648         case R_PPC64_ADDR64_LOCAL:
5649           if (bfd_link_pic (info))
5650             {
5651               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5652                 ppc_howto_init ();
5653               /* xgettext:c-format */
5654               info->callbacks->einfo (_("%H: %s reloc unsupported "
5655                                         "in shared libraries and PIEs.\n"),
5656                                       abfd, sec, rel->r_offset,
5657                                       ppc64_elf_howto_table[r_type]->name);
5658               bfd_set_error (bfd_error_bad_value);
5659               return FALSE;
5660             }
5661           break;
5662
5663         case R_PPC64_TOC16:
5664         case R_PPC64_TOC16_DS:
5665           htab->do_multi_toc = 1;
5666           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5667           /* Fall through.  */
5668         case R_PPC64_TOC16_LO:
5669         case R_PPC64_TOC16_HI:
5670         case R_PPC64_TOC16_HA:
5671         case R_PPC64_TOC16_LO_DS:
5672           sec->has_toc_reloc = 1;
5673           break;
5674
5675           /* Marker reloc.  */
5676         case R_PPC64_ENTRY:
5677           break;
5678
5679           /* This relocation describes the C++ object vtable hierarchy.
5680              Reconstruct it for later use during GC.  */
5681         case R_PPC64_GNU_VTINHERIT:
5682           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5683             return FALSE;
5684           break;
5685
5686           /* This relocation describes which C++ vtable entries are actually
5687              used.  Record for later use during GC.  */
5688         case R_PPC64_GNU_VTENTRY:
5689           BFD_ASSERT (h != NULL);
5690           if (h != NULL
5691               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5692             return FALSE;
5693           break;
5694
5695         case R_PPC64_REL14:
5696         case R_PPC64_REL14_BRTAKEN:
5697         case R_PPC64_REL14_BRNTAKEN:
5698           {
5699             asection *dest = NULL;
5700
5701             /* Heuristic: If jumping outside our section, chances are
5702                we are going to need a stub.  */
5703             if (h != NULL)
5704               {
5705                 /* If the sym is weak it may be overridden later, so
5706                    don't assume we know where a weak sym lives.  */
5707                 if (h->root.type == bfd_link_hash_defined)
5708                   dest = h->root.u.def.section;
5709               }
5710             else
5711               {
5712                 Elf_Internal_Sym *isym;
5713
5714                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5715                                               abfd, r_symndx);
5716                 if (isym == NULL)
5717                   return FALSE;
5718
5719                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5720               }
5721
5722             if (dest != sec)
5723               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5724           }
5725           /* Fall through.  */
5726
5727         case R_PPC64_REL24:
5728           plt_list = ifunc;
5729           if (h != NULL)
5730             {
5731               h->needs_plt = 1;
5732               if (h->root.root.string[0] == '.'
5733                   && h->root.root.string[1] != '\0')
5734                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5735
5736               if (h == tga || h == dottga)
5737                 {
5738                   sec->has_tls_reloc = 1;
5739                   if (rel != relocs
5740                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5741                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5742                     /* We have a new-style __tls_get_addr call with
5743                        a marker reloc.  */
5744                     ;
5745                   else
5746                     /* Mark this section as having an old-style call.  */
5747                     sec->has_tls_get_addr_call = 1;
5748                 }
5749               plt_list = &h->plt.plist;
5750             }
5751
5752           /* We may need a .plt entry if the function this reloc
5753              refers to is in a shared lib.  */
5754           if (plt_list
5755               && !update_plt_info (abfd, plt_list, rel->r_addend))
5756             return FALSE;
5757           break;
5758
5759         case R_PPC64_ADDR14:
5760         case R_PPC64_ADDR14_BRNTAKEN:
5761         case R_PPC64_ADDR14_BRTAKEN:
5762         case R_PPC64_ADDR24:
5763           goto dodyn;
5764
5765         case R_PPC64_TPREL64:
5766           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5767           if (bfd_link_dll (info))
5768             info->flags |= DF_STATIC_TLS;
5769           goto dotlstoc;
5770
5771         case R_PPC64_DTPMOD64:
5772           if (rel + 1 < rel_end
5773               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5774               && rel[1].r_offset == rel->r_offset + 8)
5775             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5776           else
5777             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5778           goto dotlstoc;
5779
5780         case R_PPC64_DTPREL64:
5781           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5782           if (rel != relocs
5783               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5784               && rel[-1].r_offset == rel->r_offset - 8)
5785             /* This is the second reloc of a dtpmod, dtprel pair.
5786                Don't mark with TLS_DTPREL.  */
5787             goto dodyn;
5788
5789         dotlstoc:
5790           sec->has_tls_reloc = 1;
5791           if (h != NULL)
5792             {
5793               struct ppc_link_hash_entry *eh;
5794               eh = (struct ppc_link_hash_entry *) h;
5795               eh->tls_mask |= tls_type;
5796             }
5797           else
5798             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5799                                         rel->r_addend, tls_type))
5800               return FALSE;
5801
5802           ppc64_sec = ppc64_elf_section_data (sec);
5803           if (ppc64_sec->sec_type != sec_toc)
5804             {
5805               bfd_size_type amt;
5806
5807               /* One extra to simplify get_tls_mask.  */
5808               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5809               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5810               if (ppc64_sec->u.toc.symndx == NULL)
5811                 return FALSE;
5812               amt = sec->size * sizeof (bfd_vma) / 8;
5813               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5814               if (ppc64_sec->u.toc.add == NULL)
5815                 return FALSE;
5816               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5817               ppc64_sec->sec_type = sec_toc;
5818             }
5819           BFD_ASSERT (rel->r_offset % 8 == 0);
5820           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5821           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5822
5823           /* Mark the second slot of a GD or LD entry.
5824              -1 to indicate GD and -2 to indicate LD.  */
5825           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5826             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5827           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5828             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5829           goto dodyn;
5830
5831         case R_PPC64_TPREL16:
5832         case R_PPC64_TPREL16_LO:
5833         case R_PPC64_TPREL16_HI:
5834         case R_PPC64_TPREL16_HA:
5835         case R_PPC64_TPREL16_DS:
5836         case R_PPC64_TPREL16_LO_DS:
5837         case R_PPC64_TPREL16_HIGH:
5838         case R_PPC64_TPREL16_HIGHA:
5839         case R_PPC64_TPREL16_HIGHER:
5840         case R_PPC64_TPREL16_HIGHERA:
5841         case R_PPC64_TPREL16_HIGHEST:
5842         case R_PPC64_TPREL16_HIGHESTA:
5843           if (bfd_link_dll (info))
5844             info->flags |= DF_STATIC_TLS;
5845           goto dodyn;
5846
5847         case R_PPC64_ADDR64:
5848           if (opd_sym_map != NULL
5849               && rel + 1 < rel_end
5850               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5851             {
5852               if (h != NULL)
5853                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5854               else
5855                 {
5856                   asection *s;
5857                   Elf_Internal_Sym *isym;
5858
5859                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5860                                                 abfd, r_symndx);
5861                   if (isym == NULL)
5862                     return FALSE;
5863
5864                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5865                   if (s != NULL && s != sec)
5866                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5867                 }
5868             }
5869           /* Fall through.  */
5870
5871         case R_PPC64_ADDR16:
5872         case R_PPC64_ADDR16_DS:
5873         case R_PPC64_ADDR16_HA:
5874         case R_PPC64_ADDR16_HI:
5875         case R_PPC64_ADDR16_HIGH:
5876         case R_PPC64_ADDR16_HIGHA:
5877         case R_PPC64_ADDR16_HIGHER:
5878         case R_PPC64_ADDR16_HIGHERA:
5879         case R_PPC64_ADDR16_HIGHEST:
5880         case R_PPC64_ADDR16_HIGHESTA:
5881         case R_PPC64_ADDR16_LO:
5882         case R_PPC64_ADDR16_LO_DS:
5883           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5884               && rel->r_addend == 0)
5885             {
5886               /* We may need a .plt entry if this reloc refers to a
5887                  function in a shared lib.  */
5888               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5889                 return FALSE;
5890               h->pointer_equality_needed = 1;
5891             }
5892           /* Fall through.  */
5893
5894         case R_PPC64_REL30:
5895         case R_PPC64_REL32:
5896         case R_PPC64_REL64:
5897         case R_PPC64_ADDR32:
5898         case R_PPC64_UADDR16:
5899         case R_PPC64_UADDR32:
5900         case R_PPC64_UADDR64:
5901         case R_PPC64_TOC:
5902           if (h != NULL && !bfd_link_pic (info))
5903             /* We may need a copy reloc.  */
5904             h->non_got_ref = 1;
5905
5906           /* Don't propagate .opd relocs.  */
5907           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5908             break;
5909
5910           /* If we are creating a shared library, and this is a reloc
5911              against a global symbol, or a non PC relative reloc
5912              against a local symbol, then we need to copy the reloc
5913              into the shared library.  However, if we are linking with
5914              -Bsymbolic, we do not need to copy a reloc against a
5915              global symbol which is defined in an object we are
5916              including in the link (i.e., DEF_REGULAR is set).  At
5917              this point we have not seen all the input files, so it is
5918              possible that DEF_REGULAR is not set now but will be set
5919              later (it is never cleared).  In case of a weak definition,
5920              DEF_REGULAR may be cleared later by a strong definition in
5921              a shared library.  We account for that possibility below by
5922              storing information in the dyn_relocs field of the hash
5923              table entry.  A similar situation occurs when creating
5924              shared libraries and symbol visibility changes render the
5925              symbol local.
5926
5927              If on the other hand, we are creating an executable, we
5928              may need to keep relocations for symbols satisfied by a
5929              dynamic library if we manage to avoid copy relocs for the
5930              symbol.  */
5931         dodyn:
5932           if ((bfd_link_pic (info)
5933                && (must_be_dyn_reloc (info, r_type)
5934                    || (h != NULL
5935                        && (!SYMBOLIC_BIND (info, h)
5936                            || h->root.type == bfd_link_hash_defweak
5937                            || !h->def_regular))))
5938               || (ELIMINATE_COPY_RELOCS
5939                   && !bfd_link_pic (info)
5940                   && h != NULL
5941                   && (h->root.type == bfd_link_hash_defweak
5942                       || !h->def_regular))
5943               || (!bfd_link_pic (info)
5944                   && ifunc != NULL))
5945             {
5946               /* We must copy these reloc types into the output file.
5947                  Create a reloc section in dynobj and make room for
5948                  this reloc.  */
5949               if (sreloc == NULL)
5950                 {
5951                   sreloc = _bfd_elf_make_dynamic_reloc_section
5952                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5953
5954                   if (sreloc == NULL)
5955                     return FALSE;
5956                 }
5957
5958               /* If this is a global symbol, we count the number of
5959                  relocations we need for this symbol.  */
5960               if (h != NULL)
5961                 {
5962                   struct elf_dyn_relocs *p;
5963                   struct elf_dyn_relocs **head;
5964
5965                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5966                   p = *head;
5967                   if (p == NULL || p->sec != sec)
5968                     {
5969                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5970                       if (p == NULL)
5971                         return FALSE;
5972                       p->next = *head;
5973                       *head = p;
5974                       p->sec = sec;
5975                       p->count = 0;
5976                       p->pc_count = 0;
5977                     }
5978                   p->count += 1;
5979                   if (!must_be_dyn_reloc (info, r_type))
5980                     p->pc_count += 1;
5981                 }
5982               else
5983                 {
5984                   /* Track dynamic relocs needed for local syms too.
5985                      We really need local syms available to do this
5986                      easily.  Oh well.  */
5987                   struct ppc_dyn_relocs *p;
5988                   struct ppc_dyn_relocs **head;
5989                   bfd_boolean is_ifunc;
5990                   asection *s;
5991                   void *vpp;
5992                   Elf_Internal_Sym *isym;
5993
5994                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5995                                                 abfd, r_symndx);
5996                   if (isym == NULL)
5997                     return FALSE;
5998
5999                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6000                   if (s == NULL)
6001                     s = sec;
6002
6003                   vpp = &elf_section_data (s)->local_dynrel;
6004                   head = (struct ppc_dyn_relocs **) vpp;
6005                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6006                   p = *head;
6007                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6008                     p = p->next;
6009                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6010                     {
6011                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6012                       if (p == NULL)
6013                         return FALSE;
6014                       p->next = *head;
6015                       *head = p;
6016                       p->sec = sec;
6017                       p->ifunc = is_ifunc;
6018                       p->count = 0;
6019                     }
6020                   p->count += 1;
6021                 }
6022             }
6023           break;
6024
6025         default:
6026           break;
6027         }
6028     }
6029
6030   return TRUE;
6031 }
6032
6033 /* Merge backend specific data from an object file to the output
6034    object file when linking.  */
6035
6036 static bfd_boolean
6037 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6038 {
6039   bfd *obfd = info->output_bfd;
6040   unsigned long iflags, oflags;
6041
6042   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6043     return TRUE;
6044
6045   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6046     return TRUE;
6047
6048   if (!_bfd_generic_verify_endian_match (ibfd, info))
6049     return FALSE;
6050
6051   iflags = elf_elfheader (ibfd)->e_flags;
6052   oflags = elf_elfheader (obfd)->e_flags;
6053
6054   if (iflags & ~EF_PPC64_ABI)
6055     {
6056       _bfd_error_handler
6057         /* xgettext:c-format */
6058         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6059       bfd_set_error (bfd_error_bad_value);
6060       return FALSE;
6061     }
6062   else if (iflags != oflags && iflags != 0)
6063     {
6064       _bfd_error_handler
6065         /* xgettext:c-format */
6066         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6067          ibfd, iflags, oflags);
6068       bfd_set_error (bfd_error_bad_value);
6069       return FALSE;
6070     }
6071
6072   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6073
6074   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6075   _bfd_elf_merge_object_attributes (ibfd, info);
6076
6077   return TRUE;
6078 }
6079
6080 static bfd_boolean
6081 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6082 {
6083   /* Print normal ELF private data.  */
6084   _bfd_elf_print_private_bfd_data (abfd, ptr);
6085
6086   if (elf_elfheader (abfd)->e_flags != 0)
6087     {
6088       FILE *file = ptr;
6089
6090       fprintf (file, _("private flags = 0x%lx:"),
6091                elf_elfheader (abfd)->e_flags);
6092
6093       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6094         fprintf (file, _(" [abiv%ld]"),
6095                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6096       fputc ('\n', file);
6097     }
6098
6099   return TRUE;
6100 }
6101
6102 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6103    of the code entry point, and its section, which must be in the same
6104    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6105
6106 static bfd_vma
6107 opd_entry_value (asection *opd_sec,
6108                  bfd_vma offset,
6109                  asection **code_sec,
6110                  bfd_vma *code_off,
6111                  bfd_boolean in_code_sec)
6112 {
6113   bfd *opd_bfd = opd_sec->owner;
6114   Elf_Internal_Rela *relocs;
6115   Elf_Internal_Rela *lo, *hi, *look;
6116   bfd_vma val;
6117
6118   /* No relocs implies we are linking a --just-symbols object, or looking
6119      at a final linked executable with addr2line or somesuch.  */
6120   if (opd_sec->reloc_count == 0)
6121     {
6122       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6123
6124       if (contents == NULL)
6125         {
6126           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6127             return (bfd_vma) -1;
6128           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6129         }
6130
6131       /* PR 17512: file: 64b9dfbb.  */
6132       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6133         return (bfd_vma) -1;
6134
6135       val = bfd_get_64 (opd_bfd, contents + offset);
6136       if (code_sec != NULL)
6137         {
6138           asection *sec, *likely = NULL;
6139
6140           if (in_code_sec)
6141             {
6142               sec = *code_sec;
6143               if (sec->vma <= val
6144                   && val < sec->vma + sec->size)
6145                 likely = sec;
6146               else
6147                 val = -1;
6148             }
6149           else
6150             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6151               if (sec->vma <= val
6152                   && (sec->flags & SEC_LOAD) != 0
6153                   && (sec->flags & SEC_ALLOC) != 0)
6154                 likely = sec;
6155           if (likely != NULL)
6156             {
6157               *code_sec = likely;
6158               if (code_off != NULL)
6159                 *code_off = val - likely->vma;
6160             }
6161         }
6162       return val;
6163     }
6164
6165   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6166
6167   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6168   if (relocs == NULL)
6169     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6170   /* PR 17512: file: df8e1fd6.  */
6171   if (relocs == NULL)
6172     return (bfd_vma) -1;
6173
6174   /* Go find the opd reloc at the sym address.  */
6175   lo = relocs;
6176   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6177   val = (bfd_vma) -1;
6178   while (lo < hi)
6179     {
6180       look = lo + (hi - lo) / 2;
6181       if (look->r_offset < offset)
6182         lo = look + 1;
6183       else if (look->r_offset > offset)
6184         hi = look;
6185       else
6186         {
6187           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6188
6189           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6190               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6191             {
6192               unsigned long symndx = ELF64_R_SYM (look->r_info);
6193               asection *sec = NULL;
6194
6195               if (symndx >= symtab_hdr->sh_info
6196                   && elf_sym_hashes (opd_bfd) != NULL)
6197                 {
6198                   struct elf_link_hash_entry **sym_hashes;
6199                   struct elf_link_hash_entry *rh;
6200
6201                   sym_hashes = elf_sym_hashes (opd_bfd);
6202                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6203                   if (rh != NULL)
6204                     {
6205                       rh = elf_follow_link (rh);
6206                       if (rh->root.type != bfd_link_hash_defined
6207                           && rh->root.type != bfd_link_hash_defweak)
6208                         break;
6209                       if (rh->root.u.def.section->owner == opd_bfd)
6210                         {
6211                           val = rh->root.u.def.value;
6212                           sec = rh->root.u.def.section;
6213                         }
6214                     }
6215                 }
6216
6217               if (sec == NULL)
6218                 {
6219                   Elf_Internal_Sym *sym;
6220
6221                   if (symndx < symtab_hdr->sh_info)
6222                     {
6223                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6224                       if (sym == NULL)
6225                         {
6226                           size_t symcnt = symtab_hdr->sh_info;
6227                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6228                                                       symcnt, 0,
6229                                                       NULL, NULL, NULL);
6230                           if (sym == NULL)
6231                             break;
6232                           symtab_hdr->contents = (bfd_byte *) sym;
6233                         }
6234                       sym += symndx;
6235                     }
6236                   else
6237                     {
6238                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6239                                                   1, symndx,
6240                                                   NULL, NULL, NULL);
6241                       if (sym == NULL)
6242                         break;
6243                     }
6244                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6245                   if (sec == NULL)
6246                     break;
6247                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6248                   val = sym->st_value;
6249                 }
6250
6251               val += look->r_addend;
6252               if (code_off != NULL)
6253                 *code_off = val;
6254               if (code_sec != NULL)
6255                 {
6256                   if (in_code_sec && *code_sec != sec)
6257                     return -1;
6258                   else
6259                     *code_sec = sec;
6260                 }
6261               if (sec->output_section != NULL)
6262                 val += sec->output_section->vma + sec->output_offset;
6263             }
6264           break;
6265         }
6266     }
6267
6268   return val;
6269 }
6270
6271 /* If the ELF symbol SYM might be a function in SEC, return the
6272    function size and set *CODE_OFF to the function's entry point,
6273    otherwise return zero.  */
6274
6275 static bfd_size_type
6276 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6277                               bfd_vma *code_off)
6278 {
6279   bfd_size_type size;
6280
6281   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6282                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6283     return 0;
6284
6285   size = 0;
6286   if (!(sym->flags & BSF_SYNTHETIC))
6287     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6288
6289   if (strcmp (sym->section->name, ".opd") == 0)
6290     {
6291       struct _opd_sec_data *opd = get_opd_info (sym->section);
6292       bfd_vma symval = sym->value;
6293
6294       if (opd != NULL
6295           && opd->adjust != NULL
6296           && elf_section_data (sym->section)->relocs != NULL)
6297         {
6298           /* opd_entry_value will use cached relocs that have been
6299              adjusted, but with raw symbols.  That means both local
6300              and global symbols need adjusting.  */
6301           long adjust = opd->adjust[OPD_NDX (symval)];
6302           if (adjust == -1)
6303             return 0;
6304           symval += adjust;
6305         }
6306
6307       if (opd_entry_value (sym->section, symval,
6308                            &sec, code_off, TRUE) == (bfd_vma) -1)
6309         return 0;
6310       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6311          symbol.  This size has nothing to do with the code size of the
6312          function, which is what we're supposed to return, but the
6313          code size isn't available without looking up the dot-sym.
6314          However, doing that would be a waste of time particularly
6315          since elf_find_function will look at the dot-sym anyway.
6316          Now, elf_find_function will keep the largest size of any
6317          function sym found at the code address of interest, so return
6318          1 here to avoid it incorrectly caching a larger function size
6319          for a small function.  This does mean we return the wrong
6320          size for a new-ABI function of size 24, but all that does is
6321          disable caching for such functions.  */
6322       if (size == 24)
6323         size = 1;
6324     }
6325   else
6326     {
6327       if (sym->section != sec)
6328         return 0;
6329       *code_off = sym->value;
6330     }
6331   if (size == 0)
6332     size = 1;
6333   return size;
6334 }
6335
6336 /* Return true if symbol is a strong function defined in an ELFv2
6337    object with st_other localentry bits of zero, ie. its local entry
6338    point coincides with its global entry point.  */
6339
6340 static bfd_boolean
6341 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6342 {
6343   return (h != NULL
6344           && h->type == STT_FUNC
6345           && h->root.type == bfd_link_hash_defined
6346           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6347           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6348           && is_ppc64_elf (h->root.u.def.section->owner)
6349           && abiversion (h->root.u.def.section->owner) >= 2);
6350 }
6351
6352 /* Return true if symbol is defined in a regular object file.  */
6353
6354 static bfd_boolean
6355 is_static_defined (struct elf_link_hash_entry *h)
6356 {
6357   return ((h->root.type == bfd_link_hash_defined
6358            || h->root.type == bfd_link_hash_defweak)
6359           && h->root.u.def.section != NULL
6360           && h->root.u.def.section->output_section != NULL);
6361 }
6362
6363 /* If FDH is a function descriptor symbol, return the associated code
6364    entry symbol if it is defined.  Return NULL otherwise.  */
6365
6366 static struct ppc_link_hash_entry *
6367 defined_code_entry (struct ppc_link_hash_entry *fdh)
6368 {
6369   if (fdh->is_func_descriptor)
6370     {
6371       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6372       if (fh->elf.root.type == bfd_link_hash_defined
6373           || fh->elf.root.type == bfd_link_hash_defweak)
6374         return fh;
6375     }
6376   return NULL;
6377 }
6378
6379 /* If FH is a function code entry symbol, return the associated
6380    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6381
6382 static struct ppc_link_hash_entry *
6383 defined_func_desc (struct ppc_link_hash_entry *fh)
6384 {
6385   if (fh->oh != NULL
6386       && fh->oh->is_func_descriptor)
6387     {
6388       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6389       if (fdh->elf.root.type == bfd_link_hash_defined
6390           || fdh->elf.root.type == bfd_link_hash_defweak)
6391         return fdh;
6392     }
6393   return NULL;
6394 }
6395
6396 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6397
6398 /* Garbage collect sections, after first dealing with dot-symbols.  */
6399
6400 static bfd_boolean
6401 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6402 {
6403   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6404
6405   if (htab != NULL && htab->need_func_desc_adj)
6406     {
6407       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6408       htab->need_func_desc_adj = 0;
6409     }
6410   return bfd_elf_gc_sections (abfd, info);
6411 }
6412
6413 /* Mark all our entry sym sections, both opd and code section.  */
6414
6415 static void
6416 ppc64_elf_gc_keep (struct bfd_link_info *info)
6417 {
6418   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6419   struct bfd_sym_chain *sym;
6420
6421   if (htab == NULL)
6422     return;
6423
6424   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6425     {
6426       struct ppc_link_hash_entry *eh, *fh;
6427       asection *sec;
6428
6429       eh = (struct ppc_link_hash_entry *)
6430         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6431       if (eh == NULL)
6432         continue;
6433       if (eh->elf.root.type != bfd_link_hash_defined
6434           && eh->elf.root.type != bfd_link_hash_defweak)
6435         continue;
6436
6437       fh = defined_code_entry (eh);
6438       if (fh != NULL)
6439         {
6440           sec = fh->elf.root.u.def.section;
6441           sec->flags |= SEC_KEEP;
6442         }
6443       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6444                && opd_entry_value (eh->elf.root.u.def.section,
6445                                    eh->elf.root.u.def.value,
6446                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6447         sec->flags |= SEC_KEEP;
6448
6449       sec = eh->elf.root.u.def.section;
6450       sec->flags |= SEC_KEEP;
6451     }
6452 }
6453
6454 /* Mark sections containing dynamically referenced symbols.  When
6455    building shared libraries, we must assume that any visible symbol is
6456    referenced.  */
6457
6458 static bfd_boolean
6459 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6460 {
6461   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6462   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6463   struct ppc_link_hash_entry *fdh;
6464   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6465
6466   /* Dynamic linking info is on the func descriptor sym.  */
6467   fdh = defined_func_desc (eh);
6468   if (fdh != NULL)
6469     eh = fdh;
6470
6471   if ((eh->elf.root.type == bfd_link_hash_defined
6472        || eh->elf.root.type == bfd_link_hash_defweak)
6473       && (eh->elf.ref_dynamic
6474           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6475               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6476               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6477               && (!bfd_link_executable (info)
6478                   || info->gc_keep_exported
6479                   || info->export_dynamic
6480                   || (eh->elf.dynamic
6481                       && d != NULL
6482                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6483               && (eh->elf.versioned >= versioned
6484                   || !bfd_hide_sym_by_version (info->version_info,
6485                                                eh->elf.root.root.string)))))
6486     {
6487       asection *code_sec;
6488       struct ppc_link_hash_entry *fh;
6489
6490       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6491
6492       /* Function descriptor syms cause the associated
6493          function code sym section to be marked.  */
6494       fh = defined_code_entry (eh);
6495       if (fh != NULL)
6496         {
6497           code_sec = fh->elf.root.u.def.section;
6498           code_sec->flags |= SEC_KEEP;
6499         }
6500       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6501                && opd_entry_value (eh->elf.root.u.def.section,
6502                                    eh->elf.root.u.def.value,
6503                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6504         code_sec->flags |= SEC_KEEP;
6505     }
6506
6507   return TRUE;
6508 }
6509
6510 /* Return the section that should be marked against GC for a given
6511    relocation.  */
6512
6513 static asection *
6514 ppc64_elf_gc_mark_hook (asection *sec,
6515                         struct bfd_link_info *info,
6516                         Elf_Internal_Rela *rel,
6517                         struct elf_link_hash_entry *h,
6518                         Elf_Internal_Sym *sym)
6519 {
6520   asection *rsec;
6521
6522   /* Syms return NULL if we're marking .opd, so we avoid marking all
6523      function sections, as all functions are referenced in .opd.  */
6524   rsec = NULL;
6525   if (get_opd_info (sec) != NULL)
6526     return rsec;
6527
6528   if (h != NULL)
6529     {
6530       enum elf_ppc64_reloc_type r_type;
6531       struct ppc_link_hash_entry *eh, *fh, *fdh;
6532
6533       r_type = ELF64_R_TYPE (rel->r_info);
6534       switch (r_type)
6535         {
6536         case R_PPC64_GNU_VTINHERIT:
6537         case R_PPC64_GNU_VTENTRY:
6538           break;
6539
6540         default:
6541           switch (h->root.type)
6542             {
6543             case bfd_link_hash_defined:
6544             case bfd_link_hash_defweak:
6545               eh = (struct ppc_link_hash_entry *) h;
6546               fdh = defined_func_desc (eh);
6547               if (fdh != NULL)
6548                 {
6549                   /* -mcall-aixdesc code references the dot-symbol on
6550                      a call reloc.  Mark the function descriptor too
6551                      against garbage collection.  */
6552                   fdh->elf.mark = 1;
6553                   if (fdh->elf.u.weakdef != NULL)
6554                     fdh->elf.u.weakdef->mark = 1;
6555                   eh = fdh;
6556                 }
6557
6558               /* Function descriptor syms cause the associated
6559                  function code sym section to be marked.  */
6560               fh = defined_code_entry (eh);
6561               if (fh != NULL)
6562                 {
6563                   /* They also mark their opd section.  */
6564                   eh->elf.root.u.def.section->gc_mark = 1;
6565
6566                   rsec = fh->elf.root.u.def.section;
6567                 }
6568               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6569                        && opd_entry_value (eh->elf.root.u.def.section,
6570                                            eh->elf.root.u.def.value,
6571                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6572                 eh->elf.root.u.def.section->gc_mark = 1;
6573               else
6574                 rsec = h->root.u.def.section;
6575               break;
6576
6577             case bfd_link_hash_common:
6578               rsec = h->root.u.c.p->section;
6579               break;
6580
6581             default:
6582               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6583             }
6584         }
6585     }
6586   else
6587     {
6588       struct _opd_sec_data *opd;
6589
6590       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6591       opd = get_opd_info (rsec);
6592       if (opd != NULL && opd->func_sec != NULL)
6593         {
6594           rsec->gc_mark = 1;
6595
6596           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6597         }
6598     }
6599
6600   return rsec;
6601 }
6602
6603 /* Update the .got, .plt. and dynamic reloc reference counts for the
6604    section being removed.  */
6605
6606 static bfd_boolean
6607 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6608                          asection *sec, const Elf_Internal_Rela *relocs)
6609 {
6610   struct ppc_link_hash_table *htab;
6611   Elf_Internal_Shdr *symtab_hdr;
6612   struct elf_link_hash_entry **sym_hashes;
6613   struct got_entry **local_got_ents;
6614   const Elf_Internal_Rela *rel, *relend;
6615
6616   if (bfd_link_relocatable (info))
6617     return TRUE;
6618
6619   if ((sec->flags & SEC_ALLOC) == 0)
6620     return TRUE;
6621
6622   elf_section_data (sec)->local_dynrel = NULL;
6623
6624   htab = ppc_hash_table (info);
6625   if (htab == NULL)
6626     return FALSE;
6627
6628   symtab_hdr = &elf_symtab_hdr (abfd);
6629   sym_hashes = elf_sym_hashes (abfd);
6630   local_got_ents = elf_local_got_ents (abfd);
6631
6632   relend = relocs + sec->reloc_count;
6633   for (rel = relocs; rel < relend; rel++)
6634     {
6635       unsigned long r_symndx;
6636       enum elf_ppc64_reloc_type r_type;
6637       struct elf_link_hash_entry *h = NULL;
6638       struct plt_entry **plt_list = NULL;
6639       unsigned char tls_type = 0;
6640
6641       r_symndx = ELF64_R_SYM (rel->r_info);
6642       r_type = ELF64_R_TYPE (rel->r_info);
6643       if (r_symndx >= symtab_hdr->sh_info)
6644         {
6645           struct ppc_link_hash_entry *eh;
6646           struct elf_dyn_relocs **pp;
6647           struct elf_dyn_relocs *p;
6648
6649           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6650           h = elf_follow_link (h);
6651           eh = (struct ppc_link_hash_entry *) h;
6652
6653           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6654             if (p->sec == sec)
6655               {
6656                 /* Everything must go for SEC.  */
6657                 *pp = p->next;
6658                 break;
6659               }
6660         }
6661
6662       switch (r_type)
6663         {
6664         case R_PPC64_GOT_TLSLD16:
6665         case R_PPC64_GOT_TLSLD16_LO:
6666         case R_PPC64_GOT_TLSLD16_HI:
6667         case R_PPC64_GOT_TLSLD16_HA:
6668           tls_type = TLS_TLS | TLS_LD;
6669           goto dogot;
6670
6671         case R_PPC64_GOT_TLSGD16:
6672         case R_PPC64_GOT_TLSGD16_LO:
6673         case R_PPC64_GOT_TLSGD16_HI:
6674         case R_PPC64_GOT_TLSGD16_HA:
6675           tls_type = TLS_TLS | TLS_GD;
6676           goto dogot;
6677
6678         case R_PPC64_GOT_TPREL16_DS:
6679         case R_PPC64_GOT_TPREL16_LO_DS:
6680         case R_PPC64_GOT_TPREL16_HI:
6681         case R_PPC64_GOT_TPREL16_HA:
6682           tls_type = TLS_TLS | TLS_TPREL;
6683           goto dogot;
6684
6685         case R_PPC64_GOT_DTPREL16_DS:
6686         case R_PPC64_GOT_DTPREL16_LO_DS:
6687         case R_PPC64_GOT_DTPREL16_HI:
6688         case R_PPC64_GOT_DTPREL16_HA:
6689           tls_type = TLS_TLS | TLS_DTPREL;
6690           goto dogot;
6691
6692         case R_PPC64_GOT16:
6693         case R_PPC64_GOT16_DS:
6694         case R_PPC64_GOT16_HA:
6695         case R_PPC64_GOT16_HI:
6696         case R_PPC64_GOT16_LO:
6697         case R_PPC64_GOT16_LO_DS:
6698         dogot:
6699           {
6700             struct got_entry *ent;
6701
6702             if (h != NULL)
6703               ent = h->got.glist;
6704             else
6705               ent = local_got_ents[r_symndx];
6706
6707             for (; ent != NULL; ent = ent->next)
6708               if (ent->addend == rel->r_addend
6709                   && ent->owner == abfd
6710                   && ent->tls_type == tls_type)
6711                 break;
6712             if (ent == NULL)
6713               abort ();
6714             if (ent->got.refcount > 0)
6715               ent->got.refcount -= 1;
6716           }
6717           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6718             plt_list = &h->plt.plist;
6719           break;
6720
6721         case R_PPC64_PLT16_HA:
6722         case R_PPC64_PLT16_HI:
6723         case R_PPC64_PLT16_LO:
6724         case R_PPC64_PLT32:
6725         case R_PPC64_PLT64:
6726         case R_PPC64_REL14:
6727         case R_PPC64_REL14_BRNTAKEN:
6728         case R_PPC64_REL14_BRTAKEN:
6729         case R_PPC64_REL24:
6730           if (h != NULL)
6731             plt_list = &h->plt.plist;
6732           else if (local_got_ents != NULL)
6733             {
6734               struct plt_entry **local_plt = (struct plt_entry **)
6735                 (local_got_ents + symtab_hdr->sh_info);
6736               unsigned char *local_got_tls_masks = (unsigned char *)
6737                 (local_plt + symtab_hdr->sh_info);
6738               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6739                 plt_list = local_plt + r_symndx;
6740             }
6741           break;
6742
6743         case R_PPC64_ADDR64:
6744         case R_PPC64_ADDR16:
6745         case R_PPC64_ADDR16_DS:
6746         case R_PPC64_ADDR16_HA:
6747         case R_PPC64_ADDR16_HI:
6748         case R_PPC64_ADDR16_HIGH:
6749         case R_PPC64_ADDR16_HIGHA:
6750         case R_PPC64_ADDR16_HIGHER:
6751         case R_PPC64_ADDR16_HIGHERA:
6752         case R_PPC64_ADDR16_HIGHEST:
6753         case R_PPC64_ADDR16_HIGHESTA:
6754         case R_PPC64_ADDR16_LO:
6755         case R_PPC64_ADDR16_LO_DS:
6756           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6757               && rel->r_addend == 0)
6758             plt_list = &h->plt.plist;
6759           break;
6760
6761         default:
6762           break;
6763         }
6764       if (plt_list != NULL)
6765         {
6766           struct plt_entry *ent;
6767
6768           for (ent = *plt_list; ent != NULL; ent = ent->next)
6769             if (ent->addend == rel->r_addend)
6770               break;
6771           if (ent != NULL && ent->plt.refcount > 0)
6772             ent->plt.refcount -= 1;
6773         }
6774     }
6775   return TRUE;
6776 }
6777
6778 /* The maximum size of .sfpr.  */
6779 #define SFPR_MAX (218*4)
6780
6781 struct sfpr_def_parms
6782 {
6783   const char name[12];
6784   unsigned char lo, hi;
6785   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6786   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6787 };
6788
6789 /* Auto-generate _save*, _rest* functions in .sfpr.
6790    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6791    instead.  */
6792
6793 static bfd_boolean
6794 sfpr_define (struct bfd_link_info *info,
6795              const struct sfpr_def_parms *parm,
6796              asection *stub_sec)
6797 {
6798   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6799   unsigned int i;
6800   size_t len = strlen (parm->name);
6801   bfd_boolean writing = FALSE;
6802   char sym[16];
6803
6804   if (htab == NULL)
6805     return FALSE;
6806
6807   memcpy (sym, parm->name, len);
6808   sym[len + 2] = 0;
6809
6810   for (i = parm->lo; i <= parm->hi; i++)
6811     {
6812       struct ppc_link_hash_entry *h;
6813
6814       sym[len + 0] = i / 10 + '0';
6815       sym[len + 1] = i % 10 + '0';
6816       h = (struct ppc_link_hash_entry *)
6817         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6818       if (stub_sec != NULL)
6819         {
6820           if (h != NULL
6821               && h->elf.root.type == bfd_link_hash_defined
6822               && h->elf.root.u.def.section == htab->sfpr)
6823             {
6824               struct elf_link_hash_entry *s;
6825               char buf[32];
6826               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6827               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6828               if (s == NULL)
6829                 return FALSE;
6830               if (s->root.type == bfd_link_hash_new
6831                   || (s->root.type = bfd_link_hash_defined
6832                       && s->root.u.def.section == stub_sec))
6833                 {
6834                   s->root.type = bfd_link_hash_defined;
6835                   s->root.u.def.section = stub_sec;
6836                   s->root.u.def.value = (stub_sec->size
6837                                          + h->elf.root.u.def.value);
6838                   s->ref_regular = 1;
6839                   s->def_regular = 1;
6840                   s->ref_regular_nonweak = 1;
6841                   s->forced_local = 1;
6842                   s->non_elf = 0;
6843                   s->root.linker_def = 1;
6844                 }
6845             }
6846           continue;
6847         }
6848       if (h != NULL)
6849         {
6850           h->save_res = 1;
6851           if (!h->elf.def_regular)
6852             {
6853               h->elf.root.type = bfd_link_hash_defined;
6854               h->elf.root.u.def.section = htab->sfpr;
6855               h->elf.root.u.def.value = htab->sfpr->size;
6856               h->elf.type = STT_FUNC;
6857               h->elf.def_regular = 1;
6858               h->elf.non_elf = 0;
6859               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6860               writing = TRUE;
6861               if (htab->sfpr->contents == NULL)
6862                 {
6863                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6864                   if (htab->sfpr->contents == NULL)
6865                     return FALSE;
6866                 }
6867             }
6868         }
6869       if (writing)
6870         {
6871           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6872           if (i != parm->hi)
6873             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6874           else
6875             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6876           htab->sfpr->size = p - htab->sfpr->contents;
6877         }
6878     }
6879
6880   return TRUE;
6881 }
6882
6883 static bfd_byte *
6884 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6885 {
6886   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6887   return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6892 {
6893   p = savegpr0 (abfd, p, r);
6894   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6895   p = p + 4;
6896   bfd_put_32 (abfd, BLR, p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6904   return p + 4;
6905 }
6906
6907 static bfd_byte *
6908 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6909 {
6910   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6911   p = p + 4;
6912   p = restgpr0 (abfd, p, r);
6913   bfd_put_32 (abfd, MTLR_R0, p);
6914   p = p + 4;
6915   if (r == 29)
6916     {
6917       p = restgpr0 (abfd, p, 30);
6918       p = restgpr0 (abfd, p, 31);
6919     }
6920   bfd_put_32 (abfd, BLR, p);
6921   return p + 4;
6922 }
6923
6924 static bfd_byte *
6925 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6926 {
6927   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6928   return p + 4;
6929 }
6930
6931 static bfd_byte *
6932 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6933 {
6934   p = savegpr1 (abfd, p, r);
6935   bfd_put_32 (abfd, BLR, p);
6936   return p + 4;
6937 }
6938
6939 static bfd_byte *
6940 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6941 {
6942   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6943   return p + 4;
6944 }
6945
6946 static bfd_byte *
6947 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6948 {
6949   p = restgpr1 (abfd, p, r);
6950   bfd_put_32 (abfd, BLR, p);
6951   return p + 4;
6952 }
6953
6954 static bfd_byte *
6955 savefpr (bfd *abfd, bfd_byte *p, int r)
6956 {
6957   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6958   return p + 4;
6959 }
6960
6961 static bfd_byte *
6962 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6963 {
6964   p = savefpr (abfd, p, r);
6965   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6966   p = p + 4;
6967   bfd_put_32 (abfd, BLR, p);
6968   return p + 4;
6969 }
6970
6971 static bfd_byte *
6972 restfpr (bfd *abfd, bfd_byte *p, int r)
6973 {
6974   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6975   return p + 4;
6976 }
6977
6978 static bfd_byte *
6979 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6980 {
6981   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6982   p = p + 4;
6983   p = restfpr (abfd, p, r);
6984   bfd_put_32 (abfd, MTLR_R0, p);
6985   p = p + 4;
6986   if (r == 29)
6987     {
6988       p = restfpr (abfd, p, 30);
6989       p = restfpr (abfd, p, 31);
6990     }
6991   bfd_put_32 (abfd, BLR, p);
6992   return p + 4;
6993 }
6994
6995 static bfd_byte *
6996 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6997 {
6998   p = savefpr (abfd, p, r);
6999   bfd_put_32 (abfd, BLR, p);
7000   return p + 4;
7001 }
7002
7003 static bfd_byte *
7004 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7005 {
7006   p = restfpr (abfd, p, r);
7007   bfd_put_32 (abfd, BLR, p);
7008   return p + 4;
7009 }
7010
7011 static bfd_byte *
7012 savevr (bfd *abfd, bfd_byte *p, int r)
7013 {
7014   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7015   p = p + 4;
7016   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7017   return p + 4;
7018 }
7019
7020 static bfd_byte *
7021 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7022 {
7023   p = savevr (abfd, p, r);
7024   bfd_put_32 (abfd, BLR, p);
7025   return p + 4;
7026 }
7027
7028 static bfd_byte *
7029 restvr (bfd *abfd, bfd_byte *p, int r)
7030 {
7031   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7032   p = p + 4;
7033   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7034   return p + 4;
7035 }
7036
7037 static bfd_byte *
7038 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7039 {
7040   p = restvr (abfd, p, r);
7041   bfd_put_32 (abfd, BLR, p);
7042   return p + 4;
7043 }
7044
7045 /* Called via elf_link_hash_traverse to transfer dynamic linking
7046    information on function code symbol entries to their corresponding
7047    function descriptor symbol entries.  */
7048
7049 static bfd_boolean
7050 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7051 {
7052   struct bfd_link_info *info;
7053   struct ppc_link_hash_table *htab;
7054   struct ppc_link_hash_entry *fh;
7055   struct ppc_link_hash_entry *fdh;
7056   bfd_boolean force_local;
7057
7058   fh = (struct ppc_link_hash_entry *) h;
7059   if (fh->elf.root.type == bfd_link_hash_indirect)
7060     return TRUE;
7061
7062   if (!fh->is_func)
7063     return TRUE;
7064
7065   if (fh->elf.root.root.string[0] != '.'
7066       || fh->elf.root.root.string[1] == '\0')
7067     return TRUE;
7068
7069   info = inf;
7070   htab = ppc_hash_table (info);
7071   if (htab == NULL)
7072     return FALSE;
7073
7074   /* Find the corresponding function descriptor symbol.  */
7075   fdh = lookup_fdh (fh, htab);
7076
7077   /* Resolve undefined references to dot-symbols as the value
7078      in the function descriptor, if we have one in a regular object.
7079      This is to satisfy cases like ".quad .foo".  Calls to functions
7080      in dynamic objects are handled elsewhere.  */
7081   if ((fh->elf.root.type == bfd_link_hash_undefined
7082        || fh->elf.root.type == bfd_link_hash_undefweak)
7083       && (fdh->elf.root.type == bfd_link_hash_defined
7084           || fdh->elf.root.type == bfd_link_hash_defweak)
7085       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7086       && opd_entry_value (fdh->elf.root.u.def.section,
7087                           fdh->elf.root.u.def.value,
7088                           &fh->elf.root.u.def.section,
7089                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7090     {
7091       fh->elf.root.type = fdh->elf.root.type;
7092       fh->elf.forced_local = 1;
7093       fh->elf.def_regular = fdh->elf.def_regular;
7094       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7095     }
7096
7097   if (!fh->elf.dynamic)
7098     {
7099       struct plt_entry *ent;
7100
7101       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7102         if (ent->plt.refcount > 0)
7103           break;
7104       if (ent == NULL)
7105         return TRUE;
7106     }
7107
7108   /* Create a descriptor as undefined if necessary.  */
7109   if (fdh == NULL
7110       && !bfd_link_executable (info)
7111       && (fh->elf.root.type == bfd_link_hash_undefined
7112           || fh->elf.root.type == bfd_link_hash_undefweak))
7113     {
7114       fdh = make_fdh (info, fh);
7115       if (fdh == NULL)
7116         return FALSE;
7117     }
7118
7119   /* We can't support overriding of symbols on a fake descriptor.  */
7120   if (fdh != NULL
7121       && fdh->fake
7122       && (fh->elf.root.type == bfd_link_hash_defined
7123           || fh->elf.root.type == bfd_link_hash_defweak))
7124     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7125
7126   /* Transfer dynamic linking information to the function descriptor.  */
7127   if (fdh != NULL)
7128     {
7129       fdh->elf.ref_regular |= fh->elf.ref_regular;
7130       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7131       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7132       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7133       fdh->elf.dynamic |= fh->elf.dynamic;
7134       fdh->elf.needs_plt |= (fh->elf.needs_plt
7135                              || fh->elf.type == STT_FUNC
7136                              || fh->elf.type == STT_GNU_IFUNC);
7137       move_plt_plist (fh, fdh);
7138
7139       if (!fdh->elf.forced_local
7140           && fh->elf.dynindx != -1)
7141         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7142           return FALSE;
7143     }
7144
7145   /* Now that the info is on the function descriptor, clear the
7146      function code sym info.  Any function code syms for which we
7147      don't have a definition in a regular file, we force local.
7148      This prevents a shared library from exporting syms that have
7149      been imported from another library.  Function code syms that
7150      are really in the library we must leave global to prevent the
7151      linker dragging in a definition from a static library.  */
7152   force_local = (!fh->elf.def_regular
7153                  || fdh == NULL
7154                  || !fdh->elf.def_regular
7155                  || fdh->elf.forced_local);
7156   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7157
7158   return TRUE;
7159 }
7160
7161 static const struct sfpr_def_parms save_res_funcs[] =
7162   {
7163     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7164     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7165     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7166     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7167     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7168     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7169     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7170     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7171     { "._savef", 14, 31, savefpr, savefpr1_tail },
7172     { "._restf", 14, 31, restfpr, restfpr1_tail },
7173     { "_savevr_", 20, 31, savevr, savevr_tail },
7174     { "_restvr_", 20, 31, restvr, restvr_tail }
7175   };
7176
7177 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7178    this hook to a) provide some gcc support functions, and b) transfer
7179    dynamic linking information gathered so far on function code symbol
7180    entries, to their corresponding function descriptor symbol entries.  */
7181
7182 static bfd_boolean
7183 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7184                             struct bfd_link_info *info)
7185 {
7186   struct ppc_link_hash_table *htab;
7187
7188   htab = ppc_hash_table (info);
7189   if (htab == NULL)
7190     return FALSE;
7191
7192   /* Provide any missing _save* and _rest* functions.  */
7193   if (htab->sfpr != NULL)
7194     {
7195       unsigned int i;
7196
7197       htab->sfpr->size = 0;
7198       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7199         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7200           return FALSE;
7201       if (htab->sfpr->size == 0)
7202         htab->sfpr->flags |= SEC_EXCLUDE;
7203     }
7204
7205   if (bfd_link_relocatable (info))
7206     return TRUE;
7207
7208   if (htab->elf.hgot != NULL)
7209     {
7210       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7211       /* Make .TOC. defined so as to prevent it being made dynamic.
7212          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7213       if (!htab->elf.hgot->def_regular
7214           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7215         {
7216           htab->elf.hgot->root.type = bfd_link_hash_defined;
7217           htab->elf.hgot->root.u.def.value = 0;
7218           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7219           htab->elf.hgot->def_regular = 1;
7220           htab->elf.hgot->root.linker_def = 1;
7221         }
7222       htab->elf.hgot->type = STT_OBJECT;
7223       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7224                                | STV_HIDDEN);
7225     }
7226
7227   if (htab->need_func_desc_adj)
7228     {
7229       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7230       htab->need_func_desc_adj = 0;
7231     }
7232
7233   return TRUE;
7234 }
7235
7236 /* Return true if we have dynamic relocs against H that apply to
7237    read-only sections.  */
7238
7239 static bfd_boolean
7240 readonly_dynrelocs (struct elf_link_hash_entry *h)
7241 {
7242   struct ppc_link_hash_entry *eh;
7243   struct elf_dyn_relocs *p;
7244
7245   eh = (struct ppc_link_hash_entry *) h;
7246   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7247     {
7248       asection *s = p->sec->output_section;
7249
7250       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7251         return TRUE;
7252     }
7253   return FALSE;
7254 }
7255
7256 /* Return true if we have dynamic relocs against H or any of its weak
7257    aliases, that apply to read-only sections.  */
7258
7259 static bfd_boolean
7260 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7261 {
7262   struct ppc_link_hash_entry *eh;
7263
7264   eh = (struct ppc_link_hash_entry *) h;
7265   do
7266     {
7267       if (readonly_dynrelocs (&eh->elf))
7268         return TRUE;
7269       eh = eh->weakref;
7270     } while (eh != NULL && &eh->elf != h);
7271
7272   return FALSE;
7273 }
7274
7275 /* Return whether EH has pc-relative dynamic relocs.  */
7276
7277 static bfd_boolean
7278 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7279 {
7280   struct elf_dyn_relocs *p;
7281
7282   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7283     if (p->pc_count != 0)
7284       return TRUE;
7285   return FALSE;
7286 }
7287
7288 /* Return true if a global entry stub will be created for H.  Valid
7289    for ELFv2 before plt entries have been allocated.  */
7290
7291 static bfd_boolean
7292 global_entry_stub (struct elf_link_hash_entry *h)
7293 {
7294   struct plt_entry *pent;
7295
7296   if (!h->pointer_equality_needed
7297       || h->def_regular)
7298     return FALSE;
7299
7300   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7301     if (pent->plt.refcount > 0
7302         && pent->addend == 0)
7303       return TRUE;
7304
7305   return FALSE;
7306 }
7307
7308 /* Adjust a symbol defined by a dynamic object and referenced by a
7309    regular object.  The current definition is in some section of the
7310    dynamic object, but we're not including those sections.  We have to
7311    change the definition to something the rest of the link can
7312    understand.  */
7313
7314 static bfd_boolean
7315 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7316                                  struct elf_link_hash_entry *h)
7317 {
7318   struct ppc_link_hash_table *htab;
7319   asection *s, *srel;
7320
7321   htab = ppc_hash_table (info);
7322   if (htab == NULL)
7323     return FALSE;
7324
7325   /* Deal with function syms.  */
7326   if (h->type == STT_FUNC
7327       || h->type == STT_GNU_IFUNC
7328       || h->needs_plt)
7329     {
7330       /* Clear procedure linkage table information for any symbol that
7331          won't need a .plt entry.  */
7332       struct plt_entry *ent;
7333       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7334         if (ent->plt.refcount > 0)
7335           break;
7336       if (ent == NULL
7337           || (h->type != STT_GNU_IFUNC
7338               && (SYMBOL_CALLS_LOCAL (info, h)
7339                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7340           || ((struct ppc_link_hash_entry *) h)->save_res)
7341         {
7342           h->plt.plist = NULL;
7343           h->needs_plt = 0;
7344           h->pointer_equality_needed = 0;
7345         }
7346       else if (abiversion (info->output_bfd) >= 2)
7347         {
7348           /* Taking a function's address in a read/write section
7349              doesn't require us to define the function symbol in the
7350              executable on a global entry stub.  A dynamic reloc can
7351              be used instead.  The reason we prefer a few more dynamic
7352              relocs is that calling via a global entry stub costs a
7353              few more instructions, and pointer_equality_needed causes
7354              extra work in ld.so when resolving these symbols.  */
7355           if (global_entry_stub (h)
7356               && !alias_readonly_dynrelocs (h))
7357             {
7358               h->pointer_equality_needed = 0;
7359               /* After adjust_dynamic_symbol, non_got_ref set in
7360                  the non-pic case means that dyn_relocs for this
7361                  symbol should be discarded.  */
7362               h->non_got_ref = 0;
7363             }
7364
7365           /* If making a plt entry, then we don't need copy relocs.  */
7366           return TRUE;
7367         }
7368     }
7369   else
7370     h->plt.plist = NULL;
7371
7372   /* If this is a weak symbol, and there is a real definition, the
7373      processor independent code will have arranged for us to see the
7374      real definition first, and we can just use the same value.  */
7375   if (h->u.weakdef != NULL)
7376     {
7377       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7378                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7379       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7380       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7381       if (ELIMINATE_COPY_RELOCS)
7382         h->non_got_ref = h->u.weakdef->non_got_ref;
7383       return TRUE;
7384     }
7385
7386   /* If we are creating a shared library, we must presume that the
7387      only references to the symbol are via the global offset table.
7388      For such cases we need not do anything here; the relocations will
7389      be handled correctly by relocate_section.  */
7390   if (bfd_link_pic (info))
7391     return TRUE;
7392
7393   /* If there are no references to this symbol that do not use the
7394      GOT, we don't need to generate a copy reloc.  */
7395   if (!h->non_got_ref)
7396     return TRUE;
7397
7398   /* Don't generate a copy reloc for symbols defined in the executable.  */
7399   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7400
7401       /* If -z nocopyreloc was given, don't generate them either.  */
7402       || info->nocopyreloc
7403
7404       /* If we didn't find any dynamic relocs in read-only sections, then
7405          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7406       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7407
7408       /* Protected variables do not work with .dynbss.  The copy in
7409          .dynbss won't be used by the shared library with the protected
7410          definition for the variable.  Text relocations are preferable
7411          to an incorrect program.  */
7412       || h->protected_def)
7413     {
7414       h->non_got_ref = 0;
7415       return TRUE;
7416     }
7417
7418   if (h->plt.plist != NULL)
7419     {
7420       /* We should never get here, but unfortunately there are versions
7421          of gcc out there that improperly (for this ABI) put initialized
7422          function pointers, vtable refs and suchlike in read-only
7423          sections.  Allow them to proceed, but warn that this might
7424          break at runtime.  */
7425       info->callbacks->einfo
7426         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7427            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7428          h->root.root.string);
7429     }
7430
7431   /* This is a reference to a symbol defined by a dynamic object which
7432      is not a function.  */
7433
7434   /* We must allocate the symbol in our .dynbss section, which will
7435      become part of the .bss section of the executable.  There will be
7436      an entry for this symbol in the .dynsym section.  The dynamic
7437      object will contain position independent code, so all references
7438      from the dynamic object to this symbol will go through the global
7439      offset table.  The dynamic linker will use the .dynsym entry to
7440      determine the address it must put in the global offset table, so
7441      both the dynamic object and the regular object will refer to the
7442      same memory location for the variable.  */
7443
7444   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7445      to copy the initial value out of the dynamic object and into the
7446      runtime process image.  We need to remember the offset into the
7447      .rela.bss section we are going to use.  */
7448   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7449     {
7450       s = htab->elf.sdynrelro;
7451       srel = htab->elf.sreldynrelro;
7452     }
7453   else
7454     {
7455       s = htab->elf.sdynbss;
7456       srel = htab->elf.srelbss;
7457     }
7458   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7459     {
7460       srel->size += sizeof (Elf64_External_Rela);
7461       h->needs_copy = 1;
7462     }
7463
7464   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7465 }
7466
7467 /* If given a function descriptor symbol, hide both the function code
7468    sym and the descriptor.  */
7469 static void
7470 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7471                        struct elf_link_hash_entry *h,
7472                        bfd_boolean force_local)
7473 {
7474   struct ppc_link_hash_entry *eh;
7475   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7476
7477   eh = (struct ppc_link_hash_entry *) h;
7478   if (eh->is_func_descriptor)
7479     {
7480       struct ppc_link_hash_entry *fh = eh->oh;
7481
7482       if (fh == NULL)
7483         {
7484           const char *p, *q;
7485           struct elf_link_hash_table *htab = elf_hash_table (info);
7486           char save;
7487
7488           /* We aren't supposed to use alloca in BFD because on
7489              systems which do not have alloca the version in libiberty
7490              calls xmalloc, which might cause the program to crash
7491              when it runs out of memory.  This function doesn't have a
7492              return status, so there's no way to gracefully return an
7493              error.  So cheat.  We know that string[-1] can be safely
7494              accessed;  It's either a string in an ELF string table,
7495              or allocated in an objalloc structure.  */
7496
7497           p = eh->elf.root.root.string - 1;
7498           save = *p;
7499           *(char *) p = '.';
7500           fh = (struct ppc_link_hash_entry *)
7501             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7502           *(char *) p = save;
7503
7504           /* Unfortunately, if it so happens that the string we were
7505              looking for was allocated immediately before this string,
7506              then we overwrote the string terminator.  That's the only
7507              reason the lookup should fail.  */
7508           if (fh == NULL)
7509             {
7510               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7511               while (q >= eh->elf.root.root.string && *q == *p)
7512                 --q, --p;
7513               if (q < eh->elf.root.root.string && *p == '.')
7514                 fh = (struct ppc_link_hash_entry *)
7515                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7516             }
7517           if (fh != NULL)
7518             {
7519               eh->oh = fh;
7520               fh->oh = eh;
7521             }
7522         }
7523       if (fh != NULL)
7524         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7525     }
7526 }
7527
7528 static bfd_boolean
7529 get_sym_h (struct elf_link_hash_entry **hp,
7530            Elf_Internal_Sym **symp,
7531            asection **symsecp,
7532            unsigned char **tls_maskp,
7533            Elf_Internal_Sym **locsymsp,
7534            unsigned long r_symndx,
7535            bfd *ibfd)
7536 {
7537   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7538
7539   if (r_symndx >= symtab_hdr->sh_info)
7540     {
7541       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7542       struct elf_link_hash_entry *h;
7543
7544       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7545       h = elf_follow_link (h);
7546
7547       if (hp != NULL)
7548         *hp = h;
7549
7550       if (symp != NULL)
7551         *symp = NULL;
7552
7553       if (symsecp != NULL)
7554         {
7555           asection *symsec = NULL;
7556           if (h->root.type == bfd_link_hash_defined
7557               || h->root.type == bfd_link_hash_defweak)
7558             symsec = h->root.u.def.section;
7559           *symsecp = symsec;
7560         }
7561
7562       if (tls_maskp != NULL)
7563         {
7564           struct ppc_link_hash_entry *eh;
7565
7566           eh = (struct ppc_link_hash_entry *) h;
7567           *tls_maskp = &eh->tls_mask;
7568         }
7569     }
7570   else
7571     {
7572       Elf_Internal_Sym *sym;
7573       Elf_Internal_Sym *locsyms = *locsymsp;
7574
7575       if (locsyms == NULL)
7576         {
7577           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7578           if (locsyms == NULL)
7579             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7580                                             symtab_hdr->sh_info,
7581                                             0, NULL, NULL, NULL);
7582           if (locsyms == NULL)
7583             return FALSE;
7584           *locsymsp = locsyms;
7585         }
7586       sym = locsyms + r_symndx;
7587
7588       if (hp != NULL)
7589         *hp = NULL;
7590
7591       if (symp != NULL)
7592         *symp = sym;
7593
7594       if (symsecp != NULL)
7595         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7596
7597       if (tls_maskp != NULL)
7598         {
7599           struct got_entry **lgot_ents;
7600           unsigned char *tls_mask;
7601
7602           tls_mask = NULL;
7603           lgot_ents = elf_local_got_ents (ibfd);
7604           if (lgot_ents != NULL)
7605             {
7606               struct plt_entry **local_plt = (struct plt_entry **)
7607                 (lgot_ents + symtab_hdr->sh_info);
7608               unsigned char *lgot_masks = (unsigned char *)
7609                 (local_plt + symtab_hdr->sh_info);
7610               tls_mask = &lgot_masks[r_symndx];
7611             }
7612           *tls_maskp = tls_mask;
7613         }
7614     }
7615   return TRUE;
7616 }
7617
7618 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7619    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7620    type suitable for optimization, and 1 otherwise.  */
7621
7622 static int
7623 get_tls_mask (unsigned char **tls_maskp,
7624               unsigned long *toc_symndx,
7625               bfd_vma *toc_addend,
7626               Elf_Internal_Sym **locsymsp,
7627               const Elf_Internal_Rela *rel,
7628               bfd *ibfd)
7629 {
7630   unsigned long r_symndx;
7631   int next_r;
7632   struct elf_link_hash_entry *h;
7633   Elf_Internal_Sym *sym;
7634   asection *sec;
7635   bfd_vma off;
7636
7637   r_symndx = ELF64_R_SYM (rel->r_info);
7638   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7639     return 0;
7640
7641   if ((*tls_maskp != NULL && **tls_maskp != 0)
7642       || sec == NULL
7643       || ppc64_elf_section_data (sec) == NULL
7644       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7645     return 1;
7646
7647   /* Look inside a TOC section too.  */
7648   if (h != NULL)
7649     {
7650       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7651       off = h->root.u.def.value;
7652     }
7653   else
7654     off = sym->st_value;
7655   off += rel->r_addend;
7656   BFD_ASSERT (off % 8 == 0);
7657   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7658   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7659   if (toc_symndx != NULL)
7660     *toc_symndx = r_symndx;
7661   if (toc_addend != NULL)
7662     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7663   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7664     return 0;
7665   if ((h == NULL || is_static_defined (h))
7666       && (next_r == -1 || next_r == -2))
7667     return 1 - next_r;
7668   return 1;
7669 }
7670
7671 /* Find (or create) an entry in the tocsave hash table.  */
7672
7673 static struct tocsave_entry *
7674 tocsave_find (struct ppc_link_hash_table *htab,
7675               enum insert_option insert,
7676               Elf_Internal_Sym **local_syms,
7677               const Elf_Internal_Rela *irela,
7678               bfd *ibfd)
7679 {
7680   unsigned long r_indx;
7681   struct elf_link_hash_entry *h;
7682   Elf_Internal_Sym *sym;
7683   struct tocsave_entry ent, *p;
7684   hashval_t hash;
7685   struct tocsave_entry **slot;
7686
7687   r_indx = ELF64_R_SYM (irela->r_info);
7688   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7689     return NULL;
7690   if (ent.sec == NULL || ent.sec->output_section == NULL)
7691     {
7692       _bfd_error_handler
7693         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7694       return NULL;
7695     }
7696
7697   if (h != NULL)
7698     ent.offset = h->root.u.def.value;
7699   else
7700     ent.offset = sym->st_value;
7701   ent.offset += irela->r_addend;
7702
7703   hash = tocsave_htab_hash (&ent);
7704   slot = ((struct tocsave_entry **)
7705           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7706   if (slot == NULL)
7707     return NULL;
7708
7709   if (*slot == NULL)
7710     {
7711       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7712       if (p == NULL)
7713         return NULL;
7714       *p = ent;
7715       *slot = p;
7716     }
7717   return *slot;
7718 }
7719
7720 /* Adjust all global syms defined in opd sections.  In gcc generated
7721    code for the old ABI, these will already have been done.  */
7722
7723 static bfd_boolean
7724 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7725 {
7726   struct ppc_link_hash_entry *eh;
7727   asection *sym_sec;
7728   struct _opd_sec_data *opd;
7729
7730   if (h->root.type == bfd_link_hash_indirect)
7731     return TRUE;
7732
7733   if (h->root.type != bfd_link_hash_defined
7734       && h->root.type != bfd_link_hash_defweak)
7735     return TRUE;
7736
7737   eh = (struct ppc_link_hash_entry *) h;
7738   if (eh->adjust_done)
7739     return TRUE;
7740
7741   sym_sec = eh->elf.root.u.def.section;
7742   opd = get_opd_info (sym_sec);
7743   if (opd != NULL && opd->adjust != NULL)
7744     {
7745       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7746       if (adjust == -1)
7747         {
7748           /* This entry has been deleted.  */
7749           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7750           if (dsec == NULL)
7751             {
7752               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7753                 if (discarded_section (dsec))
7754                   {
7755                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7756                     break;
7757                   }
7758             }
7759           eh->elf.root.u.def.value = 0;
7760           eh->elf.root.u.def.section = dsec;
7761         }
7762       else
7763         eh->elf.root.u.def.value += adjust;
7764       eh->adjust_done = 1;
7765     }
7766   return TRUE;
7767 }
7768
7769 /* Handles decrementing dynamic reloc counts for the reloc specified by
7770    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7771    have already been determined.  */
7772
7773 static bfd_boolean
7774 dec_dynrel_count (bfd_vma r_info,
7775                   asection *sec,
7776                   struct bfd_link_info *info,
7777                   Elf_Internal_Sym **local_syms,
7778                   struct elf_link_hash_entry *h,
7779                   Elf_Internal_Sym *sym)
7780 {
7781   enum elf_ppc64_reloc_type r_type;
7782   asection *sym_sec = NULL;
7783
7784   /* Can this reloc be dynamic?  This switch, and later tests here
7785      should be kept in sync with the code in check_relocs.  */
7786   r_type = ELF64_R_TYPE (r_info);
7787   switch (r_type)
7788     {
7789     default:
7790       return TRUE;
7791
7792     case R_PPC64_TPREL16:
7793     case R_PPC64_TPREL16_LO:
7794     case R_PPC64_TPREL16_HI:
7795     case R_PPC64_TPREL16_HA:
7796     case R_PPC64_TPREL16_DS:
7797     case R_PPC64_TPREL16_LO_DS:
7798     case R_PPC64_TPREL16_HIGH:
7799     case R_PPC64_TPREL16_HIGHA:
7800     case R_PPC64_TPREL16_HIGHER:
7801     case R_PPC64_TPREL16_HIGHERA:
7802     case R_PPC64_TPREL16_HIGHEST:
7803     case R_PPC64_TPREL16_HIGHESTA:
7804     case R_PPC64_TPREL64:
7805     case R_PPC64_DTPMOD64:
7806     case R_PPC64_DTPREL64:
7807     case R_PPC64_ADDR64:
7808     case R_PPC64_REL30:
7809     case R_PPC64_REL32:
7810     case R_PPC64_REL64:
7811     case R_PPC64_ADDR14:
7812     case R_PPC64_ADDR14_BRNTAKEN:
7813     case R_PPC64_ADDR14_BRTAKEN:
7814     case R_PPC64_ADDR16:
7815     case R_PPC64_ADDR16_DS:
7816     case R_PPC64_ADDR16_HA:
7817     case R_PPC64_ADDR16_HI:
7818     case R_PPC64_ADDR16_HIGH:
7819     case R_PPC64_ADDR16_HIGHA:
7820     case R_PPC64_ADDR16_HIGHER:
7821     case R_PPC64_ADDR16_HIGHERA:
7822     case R_PPC64_ADDR16_HIGHEST:
7823     case R_PPC64_ADDR16_HIGHESTA:
7824     case R_PPC64_ADDR16_LO:
7825     case R_PPC64_ADDR16_LO_DS:
7826     case R_PPC64_ADDR24:
7827     case R_PPC64_ADDR32:
7828     case R_PPC64_UADDR16:
7829     case R_PPC64_UADDR32:
7830     case R_PPC64_UADDR64:
7831     case R_PPC64_TOC:
7832       break;
7833     }
7834
7835   if (local_syms != NULL)
7836     {
7837       unsigned long r_symndx;
7838       bfd *ibfd = sec->owner;
7839
7840       r_symndx = ELF64_R_SYM (r_info);
7841       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7842         return FALSE;
7843     }
7844
7845   if ((bfd_link_pic (info)
7846        && (must_be_dyn_reloc (info, r_type)
7847            || (h != NULL
7848                && (!SYMBOLIC_BIND (info, h)
7849                    || h->root.type == bfd_link_hash_defweak
7850                    || !h->def_regular))))
7851       || (ELIMINATE_COPY_RELOCS
7852           && !bfd_link_pic (info)
7853           && h != NULL
7854           && (h->root.type == bfd_link_hash_defweak
7855               || !h->def_regular)))
7856     ;
7857   else
7858     return TRUE;
7859
7860   if (h != NULL)
7861     {
7862       struct elf_dyn_relocs *p;
7863       struct elf_dyn_relocs **pp;
7864       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7865
7866       /* elf_gc_sweep may have already removed all dyn relocs associated
7867          with local syms for a given section.  Also, symbol flags are
7868          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7869          report a dynreloc miscount.  */
7870       if (*pp == NULL && info->gc_sections)
7871         return TRUE;
7872
7873       while ((p = *pp) != NULL)
7874         {
7875           if (p->sec == sec)
7876             {
7877               if (!must_be_dyn_reloc (info, r_type))
7878                 p->pc_count -= 1;
7879               p->count -= 1;
7880               if (p->count == 0)
7881                 *pp = p->next;
7882               return TRUE;
7883             }
7884           pp = &p->next;
7885         }
7886     }
7887   else
7888     {
7889       struct ppc_dyn_relocs *p;
7890       struct ppc_dyn_relocs **pp;
7891       void *vpp;
7892       bfd_boolean is_ifunc;
7893
7894       if (local_syms == NULL)
7895         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7896       if (sym_sec == NULL)
7897         sym_sec = sec;
7898
7899       vpp = &elf_section_data (sym_sec)->local_dynrel;
7900       pp = (struct ppc_dyn_relocs **) vpp;
7901
7902       if (*pp == NULL && info->gc_sections)
7903         return TRUE;
7904
7905       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7906       while ((p = *pp) != NULL)
7907         {
7908           if (p->sec == sec && p->ifunc == is_ifunc)
7909             {
7910               p->count -= 1;
7911               if (p->count == 0)
7912                 *pp = p->next;
7913               return TRUE;
7914             }
7915           pp = &p->next;
7916         }
7917     }
7918
7919   /* xgettext:c-format */
7920   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7921                           sec->owner, sec);
7922   bfd_set_error (bfd_error_bad_value);
7923   return FALSE;
7924 }
7925
7926 /* Remove unused Official Procedure Descriptor entries.  Currently we
7927    only remove those associated with functions in discarded link-once
7928    sections, or weakly defined functions that have been overridden.  It
7929    would be possible to remove many more entries for statically linked
7930    applications.  */
7931
7932 bfd_boolean
7933 ppc64_elf_edit_opd (struct bfd_link_info *info)
7934 {
7935   bfd *ibfd;
7936   bfd_boolean some_edited = FALSE;
7937   asection *need_pad = NULL;
7938   struct ppc_link_hash_table *htab;
7939
7940   htab = ppc_hash_table (info);
7941   if (htab == NULL)
7942     return FALSE;
7943
7944   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7945     {
7946       asection *sec;
7947       Elf_Internal_Rela *relstart, *rel, *relend;
7948       Elf_Internal_Shdr *symtab_hdr;
7949       Elf_Internal_Sym *local_syms;
7950       struct _opd_sec_data *opd;
7951       bfd_boolean need_edit, add_aux_fields, broken;
7952       bfd_size_type cnt_16b = 0;
7953
7954       if (!is_ppc64_elf (ibfd))
7955         continue;
7956
7957       sec = bfd_get_section_by_name (ibfd, ".opd");
7958       if (sec == NULL || sec->size == 0)
7959         continue;
7960
7961       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7962         continue;
7963
7964       if (sec->output_section == bfd_abs_section_ptr)
7965         continue;
7966
7967       /* Look through the section relocs.  */
7968       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7969         continue;
7970
7971       local_syms = NULL;
7972       symtab_hdr = &elf_symtab_hdr (ibfd);
7973
7974       /* Read the relocations.  */
7975       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7976                                             info->keep_memory);
7977       if (relstart == NULL)
7978         return FALSE;
7979
7980       /* First run through the relocs to check they are sane, and to
7981          determine whether we need to edit this opd section.  */
7982       need_edit = FALSE;
7983       broken = FALSE;
7984       need_pad = sec;
7985       relend = relstart + sec->reloc_count;
7986       for (rel = relstart; rel < relend; )
7987         {
7988           enum elf_ppc64_reloc_type r_type;
7989           unsigned long r_symndx;
7990           asection *sym_sec;
7991           struct elf_link_hash_entry *h;
7992           Elf_Internal_Sym *sym;
7993           bfd_vma offset;
7994
7995           /* .opd contains an array of 16 or 24 byte entries.  We're
7996              only interested in the reloc pointing to a function entry
7997              point.  */
7998           offset = rel->r_offset;
7999           if (rel + 1 == relend
8000               || rel[1].r_offset != offset + 8)
8001             {
8002               /* If someone messes with .opd alignment then after a
8003                  "ld -r" we might have padding in the middle of .opd.
8004                  Also, there's nothing to prevent someone putting
8005                  something silly in .opd with the assembler.  No .opd
8006                  optimization for them!  */
8007             broken_opd:
8008               _bfd_error_handler
8009                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
8010               broken = TRUE;
8011               break;
8012             }
8013
8014           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8015               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8016             {
8017               _bfd_error_handler
8018                 /* xgettext:c-format */
8019                 (_("%B: unexpected reloc type %u in .opd section"),
8020                  ibfd, r_type);
8021               broken = TRUE;
8022               break;
8023             }
8024
8025           r_symndx = ELF64_R_SYM (rel->r_info);
8026           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8027                           r_symndx, ibfd))
8028             goto error_ret;
8029
8030           if (sym_sec == NULL || sym_sec->owner == NULL)
8031             {
8032               const char *sym_name;
8033               if (h != NULL)
8034                 sym_name = h->root.root.string;
8035               else
8036                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8037                                              sym_sec);
8038
8039               _bfd_error_handler
8040                 /* xgettext:c-format */
8041                 (_("%B: undefined sym `%s' in .opd section"),
8042                  ibfd, sym_name);
8043               broken = TRUE;
8044               break;
8045             }
8046
8047           /* opd entries are always for functions defined in the
8048              current input bfd.  If the symbol isn't defined in the
8049              input bfd, then we won't be using the function in this
8050              bfd;  It must be defined in a linkonce section in another
8051              bfd, or is weak.  It's also possible that we are
8052              discarding the function due to a linker script /DISCARD/,
8053              which we test for via the output_section.  */
8054           if (sym_sec->owner != ibfd
8055               || sym_sec->output_section == bfd_abs_section_ptr)
8056             need_edit = TRUE;
8057
8058           rel += 2;
8059           if (rel + 1 == relend
8060               || (rel + 2 < relend
8061                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8062             ++rel;
8063
8064           if (rel == relend)
8065             {
8066               if (sec->size == offset + 24)
8067                 {
8068                   need_pad = NULL;
8069                   break;
8070                 }
8071               if (sec->size == offset + 16)
8072                 {
8073                   cnt_16b++;
8074                   break;
8075                 }
8076               goto broken_opd;
8077             }
8078           else if (rel + 1 < relend
8079                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8080                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8081             {
8082               if (rel[0].r_offset == offset + 16)
8083                 cnt_16b++;
8084               else if (rel[0].r_offset != offset + 24)
8085                 goto broken_opd;
8086             }
8087           else
8088             goto broken_opd;
8089         }
8090
8091       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8092
8093       if (!broken && (need_edit || add_aux_fields))
8094         {
8095           Elf_Internal_Rela *write_rel;
8096           Elf_Internal_Shdr *rel_hdr;
8097           bfd_byte *rptr, *wptr;
8098           bfd_byte *new_contents;
8099           bfd_size_type amt;
8100
8101           new_contents = NULL;
8102           amt = OPD_NDX (sec->size) * sizeof (long);
8103           opd = &ppc64_elf_section_data (sec)->u.opd;
8104           opd->adjust = bfd_zalloc (sec->owner, amt);
8105           if (opd->adjust == NULL)
8106             return FALSE;
8107           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8108
8109           /* This seems a waste of time as input .opd sections are all
8110              zeros as generated by gcc, but I suppose there's no reason
8111              this will always be so.  We might start putting something in
8112              the third word of .opd entries.  */
8113           if ((sec->flags & SEC_IN_MEMORY) == 0)
8114             {
8115               bfd_byte *loc;
8116               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8117                 {
8118                   if (loc != NULL)
8119                     free (loc);
8120                 error_ret:
8121                   if (local_syms != NULL
8122                       && symtab_hdr->contents != (unsigned char *) local_syms)
8123                     free (local_syms);
8124                   if (elf_section_data (sec)->relocs != relstart)
8125                     free (relstart);
8126                   return FALSE;
8127                 }
8128               sec->contents = loc;
8129               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8130             }
8131
8132           elf_section_data (sec)->relocs = relstart;
8133
8134           new_contents = sec->contents;
8135           if (add_aux_fields)
8136             {
8137               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8138               if (new_contents == NULL)
8139                 return FALSE;
8140               need_pad = NULL;
8141             }
8142           wptr = new_contents;
8143           rptr = sec->contents;
8144           write_rel = relstart;
8145           for (rel = relstart; rel < relend; )
8146             {
8147               unsigned long r_symndx;
8148               asection *sym_sec;
8149               struct elf_link_hash_entry *h;
8150               struct ppc_link_hash_entry *fdh = NULL;
8151               Elf_Internal_Sym *sym;
8152               long opd_ent_size;
8153               Elf_Internal_Rela *next_rel;
8154               bfd_boolean skip;
8155
8156               r_symndx = ELF64_R_SYM (rel->r_info);
8157               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8158                               r_symndx, ibfd))
8159                 goto error_ret;
8160
8161               next_rel = rel + 2;
8162               if (next_rel + 1 == relend
8163                   || (next_rel + 2 < relend
8164                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8165                 ++next_rel;
8166
8167               /* See if the .opd entry is full 24 byte or
8168                  16 byte (with fd_aux entry overlapped with next
8169                  fd_func).  */
8170               opd_ent_size = 24;
8171               if (next_rel == relend)
8172                 {
8173                   if (sec->size == rel->r_offset + 16)
8174                     opd_ent_size = 16;
8175                 }
8176               else if (next_rel->r_offset == rel->r_offset + 16)
8177                 opd_ent_size = 16;
8178
8179               if (h != NULL
8180                   && h->root.root.string[0] == '.')
8181                 {
8182                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8183                   if (fdh != NULL)
8184                     {
8185                       fdh = ppc_follow_link (fdh);
8186                       if (fdh->elf.root.type != bfd_link_hash_defined
8187                           && fdh->elf.root.type != bfd_link_hash_defweak)
8188                         fdh = NULL;
8189                     }
8190                 }
8191
8192               skip = (sym_sec->owner != ibfd
8193                       || sym_sec->output_section == bfd_abs_section_ptr);
8194               if (skip)
8195                 {
8196                   if (fdh != NULL && sym_sec->owner == ibfd)
8197                     {
8198                       /* Arrange for the function descriptor sym
8199                          to be dropped.  */
8200                       fdh->elf.root.u.def.value = 0;
8201                       fdh->elf.root.u.def.section = sym_sec;
8202                     }
8203                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8204
8205                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8206                     rel = next_rel;
8207                   else
8208                     while (1)
8209                       {
8210                         if (!dec_dynrel_count (rel->r_info, sec, info,
8211                                                NULL, h, sym))
8212                           goto error_ret;
8213
8214                         if (++rel == next_rel)
8215                           break;
8216
8217                         r_symndx = ELF64_R_SYM (rel->r_info);
8218                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8219                                         r_symndx, ibfd))
8220                           goto error_ret;
8221                       }
8222                 }
8223               else
8224                 {
8225                   /* We'll be keeping this opd entry.  */
8226                   long adjust;
8227
8228                   if (fdh != NULL)
8229                     {
8230                       /* Redefine the function descriptor symbol to
8231                          this location in the opd section.  It is
8232                          necessary to update the value here rather
8233                          than using an array of adjustments as we do
8234                          for local symbols, because various places
8235                          in the generic ELF code use the value
8236                          stored in u.def.value.  */
8237                       fdh->elf.root.u.def.value = wptr - new_contents;
8238                       fdh->adjust_done = 1;
8239                     }
8240
8241                   /* Local syms are a bit tricky.  We could
8242                      tweak them as they can be cached, but
8243                      we'd need to look through the local syms
8244                      for the function descriptor sym which we
8245                      don't have at the moment.  So keep an
8246                      array of adjustments.  */
8247                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8248                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8249
8250                   if (wptr != rptr)
8251                     memcpy (wptr, rptr, opd_ent_size);
8252                   wptr += opd_ent_size;
8253                   if (add_aux_fields && opd_ent_size == 16)
8254                     {
8255                       memset (wptr, '\0', 8);
8256                       wptr += 8;
8257                     }
8258
8259                   /* We need to adjust any reloc offsets to point to the
8260                      new opd entries.  */
8261                   for ( ; rel != next_rel; ++rel)
8262                     {
8263                       rel->r_offset += adjust;
8264                       if (write_rel != rel)
8265                         memcpy (write_rel, rel, sizeof (*rel));
8266                       ++write_rel;
8267                     }
8268                 }
8269
8270               rptr += opd_ent_size;
8271             }
8272
8273           sec->size = wptr - new_contents;
8274           sec->reloc_count = write_rel - relstart;
8275           if (add_aux_fields)
8276             {
8277               free (sec->contents);
8278               sec->contents = new_contents;
8279             }
8280
8281           /* Fudge the header size too, as this is used later in
8282              elf_bfd_final_link if we are emitting relocs.  */
8283           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8284           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8285           some_edited = TRUE;
8286         }
8287       else if (elf_section_data (sec)->relocs != relstart)
8288         free (relstart);
8289
8290       if (local_syms != NULL
8291           && symtab_hdr->contents != (unsigned char *) local_syms)
8292         {
8293           if (!info->keep_memory)
8294             free (local_syms);
8295           else
8296             symtab_hdr->contents = (unsigned char *) local_syms;
8297         }
8298     }
8299
8300   if (some_edited)
8301     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8302
8303   /* If we are doing a final link and the last .opd entry is just 16 byte
8304      long, add a 8 byte padding after it.  */
8305   if (need_pad != NULL && !bfd_link_relocatable (info))
8306     {
8307       bfd_byte *p;
8308
8309       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8310         {
8311           BFD_ASSERT (need_pad->size > 0);
8312
8313           p = bfd_malloc (need_pad->size + 8);
8314           if (p == NULL)
8315             return FALSE;
8316
8317           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8318                                           p, 0, need_pad->size))
8319             return FALSE;
8320
8321           need_pad->contents = p;
8322           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8323         }
8324       else
8325         {
8326           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8327           if (p == NULL)
8328             return FALSE;
8329
8330           need_pad->contents = p;
8331         }
8332
8333       memset (need_pad->contents + need_pad->size, 0, 8);
8334       need_pad->size += 8;
8335     }
8336
8337   return TRUE;
8338 }
8339
8340 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8341
8342 asection *
8343 ppc64_elf_tls_setup (struct bfd_link_info *info)
8344 {
8345   struct ppc_link_hash_table *htab;
8346
8347   htab = ppc_hash_table (info);
8348   if (htab == NULL)
8349     return NULL;
8350
8351   if (abiversion (info->output_bfd) == 1)
8352     htab->opd_abi = 1;
8353
8354   if (htab->params->no_multi_toc)
8355     htab->do_multi_toc = 0;
8356   else if (!htab->do_multi_toc)
8357     htab->params->no_multi_toc = 1;
8358
8359   /* Default to --no-plt-localentry, as this option can cause problems
8360      with symbol interposition.  For example, glibc libpthread.so and
8361      libc.so duplicate many pthread symbols, with a fallback
8362      implementation in libc.so.  In some cases the fallback does more
8363      work than the pthread implementation.  __pthread_condattr_destroy
8364      is one such symbol: the libpthread.so implementation is
8365      localentry:0 while the libc.so implementation is localentry:8.
8366      An app that "cleverly" uses dlopen to only load necessary
8367      libraries at runtime may omit loading libpthread.so when not
8368      running multi-threaded, which then results in the libc.so
8369      fallback symbols being used and ld.so complaining.  Now there
8370      are workarounds in ld (see non_zero_localentry) to detect the
8371      pthread situation, but that may not be the only case where
8372      --plt-localentry can cause trouble.  */
8373   if (htab->params->plt_localentry0 < 0)
8374     htab->params->plt_localentry0 = 0;
8375   if (htab->params->plt_localentry0
8376       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8377                                FALSE, FALSE, FALSE) == NULL)
8378     info->callbacks->einfo
8379       (_("%P: warning: --plt-localentry is especially dangerous without "
8380          "ld.so support to detect ABI violations.\n"));
8381
8382   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8383                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8384                                               FALSE, FALSE, TRUE));
8385   /* Move dynamic linking info to the function descriptor sym.  */
8386   if (htab->tls_get_addr != NULL)
8387     func_desc_adjust (&htab->tls_get_addr->elf, info);
8388   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8389                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8390                                                  FALSE, FALSE, TRUE));
8391   if (htab->params->tls_get_addr_opt)
8392     {
8393       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8394
8395       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8396                                   FALSE, FALSE, TRUE);
8397       if (opt != NULL)
8398         func_desc_adjust (opt, info);
8399       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8400                                      FALSE, FALSE, TRUE);
8401       if (opt_fd != NULL
8402           && (opt_fd->root.type == bfd_link_hash_defined
8403               || opt_fd->root.type == bfd_link_hash_defweak))
8404         {
8405           /* If glibc supports an optimized __tls_get_addr call stub,
8406              signalled by the presence of __tls_get_addr_opt, and we'll
8407              be calling __tls_get_addr via a plt call stub, then
8408              make __tls_get_addr point to __tls_get_addr_opt.  */
8409           tga_fd = &htab->tls_get_addr_fd->elf;
8410           if (htab->elf.dynamic_sections_created
8411               && tga_fd != NULL
8412               && (tga_fd->type == STT_FUNC
8413                   || tga_fd->needs_plt)
8414               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8415                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8416             {
8417               struct plt_entry *ent;
8418
8419               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8420                 if (ent->plt.refcount > 0)
8421                   break;
8422               if (ent != NULL)
8423                 {
8424                   tga_fd->root.type = bfd_link_hash_indirect;
8425                   tga_fd->root.u.i.link = &opt_fd->root;
8426                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8427                   opt_fd->mark = 1;
8428                   if (opt_fd->dynindx != -1)
8429                     {
8430                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8431                       opt_fd->dynindx = -1;
8432                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8433                                               opt_fd->dynstr_index);
8434                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8435                         return NULL;
8436                     }
8437                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8438                   tga = &htab->tls_get_addr->elf;
8439                   if (opt != NULL && tga != NULL)
8440                     {
8441                       tga->root.type = bfd_link_hash_indirect;
8442                       tga->root.u.i.link = &opt->root;
8443                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8444                       opt->mark = 1;
8445                       _bfd_elf_link_hash_hide_symbol (info, opt,
8446                                                       tga->forced_local);
8447                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8448                     }
8449                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8450                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8451                   if (htab->tls_get_addr != NULL)
8452                     {
8453                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8454                       htab->tls_get_addr->is_func = 1;
8455                     }
8456                 }
8457             }
8458         }
8459       else if (htab->params->tls_get_addr_opt < 0)
8460         htab->params->tls_get_addr_opt = 0;
8461     }
8462   return _bfd_elf_tls_setup (info->output_bfd, info);
8463 }
8464
8465 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8466    HASH1 or HASH2.  */
8467
8468 static bfd_boolean
8469 branch_reloc_hash_match (const bfd *ibfd,
8470                          const Elf_Internal_Rela *rel,
8471                          const struct ppc_link_hash_entry *hash1,
8472                          const struct ppc_link_hash_entry *hash2)
8473 {
8474   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8475   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8476   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8477
8478   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8479     {
8480       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8481       struct elf_link_hash_entry *h;
8482
8483       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8484       h = elf_follow_link (h);
8485       if (h == &hash1->elf || h == &hash2->elf)
8486         return TRUE;
8487     }
8488   return FALSE;
8489 }
8490
8491 /* Run through all the TLS relocs looking for optimization
8492    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8493    a preliminary section layout so that we know the TLS segment
8494    offsets.  We can't optimize earlier because some optimizations need
8495    to know the tp offset, and we need to optimize before allocating
8496    dynamic relocations.  */
8497
8498 bfd_boolean
8499 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8500 {
8501   bfd *ibfd;
8502   asection *sec;
8503   struct ppc_link_hash_table *htab;
8504   unsigned char *toc_ref;
8505   int pass;
8506
8507   if (!bfd_link_executable (info))
8508     return TRUE;
8509
8510   htab = ppc_hash_table (info);
8511   if (htab == NULL)
8512     return FALSE;
8513
8514   /* Make two passes over the relocs.  On the first pass, mark toc
8515      entries involved with tls relocs, and check that tls relocs
8516      involved in setting up a tls_get_addr call are indeed followed by
8517      such a call.  If they are not, we can't do any tls optimization.
8518      On the second pass twiddle tls_mask flags to notify
8519      relocate_section that optimization can be done, and adjust got
8520      and plt refcounts.  */
8521   toc_ref = NULL;
8522   for (pass = 0; pass < 2; ++pass)
8523     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8524       {
8525         Elf_Internal_Sym *locsyms = NULL;
8526         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8527
8528         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8529           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8530             {
8531               Elf_Internal_Rela *relstart, *rel, *relend;
8532               bfd_boolean found_tls_get_addr_arg = 0;
8533
8534               /* Read the relocations.  */
8535               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8536                                                     info->keep_memory);
8537               if (relstart == NULL)
8538                 {
8539                   free (toc_ref);
8540                   return FALSE;
8541                 }
8542
8543               relend = relstart + sec->reloc_count;
8544               for (rel = relstart; rel < relend; rel++)
8545                 {
8546                   enum elf_ppc64_reloc_type r_type;
8547                   unsigned long r_symndx;
8548                   struct elf_link_hash_entry *h;
8549                   Elf_Internal_Sym *sym;
8550                   asection *sym_sec;
8551                   unsigned char *tls_mask;
8552                   unsigned char tls_set, tls_clear, tls_type = 0;
8553                   bfd_vma value;
8554                   bfd_boolean ok_tprel, is_local;
8555                   long toc_ref_index = 0;
8556                   int expecting_tls_get_addr = 0;
8557                   bfd_boolean ret = FALSE;
8558
8559                   r_symndx = ELF64_R_SYM (rel->r_info);
8560                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8561                                   r_symndx, ibfd))
8562                     {
8563                     err_free_rel:
8564                       if (elf_section_data (sec)->relocs != relstart)
8565                         free (relstart);
8566                       if (toc_ref != NULL)
8567                         free (toc_ref);
8568                       if (locsyms != NULL
8569                           && (elf_symtab_hdr (ibfd).contents
8570                               != (unsigned char *) locsyms))
8571                         free (locsyms);
8572                       return ret;
8573                     }
8574
8575                   if (h != NULL)
8576                     {
8577                       if (h->root.type == bfd_link_hash_defined
8578                           || h->root.type == bfd_link_hash_defweak)
8579                         value = h->root.u.def.value;
8580                       else if (h->root.type == bfd_link_hash_undefweak)
8581                         value = 0;
8582                       else
8583                         {
8584                           found_tls_get_addr_arg = 0;
8585                           continue;
8586                         }
8587                     }
8588                   else
8589                     /* Symbols referenced by TLS relocs must be of type
8590                        STT_TLS.  So no need for .opd local sym adjust.  */
8591                     value = sym->st_value;
8592
8593                   ok_tprel = FALSE;
8594                   is_local = FALSE;
8595                   if (h == NULL
8596                       || !h->def_dynamic)
8597                     {
8598                       is_local = TRUE;
8599                       if (h != NULL
8600                           && h->root.type == bfd_link_hash_undefweak)
8601                         ok_tprel = TRUE;
8602                       else if (sym_sec != NULL
8603                                && sym_sec->output_section != NULL)
8604                         {
8605                           value += sym_sec->output_offset;
8606                           value += sym_sec->output_section->vma;
8607                           value -= htab->elf.tls_sec->vma;
8608                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8609                                       < (bfd_vma) 1 << 32);
8610                         }
8611                     }
8612
8613                   r_type = ELF64_R_TYPE (rel->r_info);
8614                   /* If this section has old-style __tls_get_addr calls
8615                      without marker relocs, then check that each
8616                      __tls_get_addr call reloc is preceded by a reloc
8617                      that conceivably belongs to the __tls_get_addr arg
8618                      setup insn.  If we don't find matching arg setup
8619                      relocs, don't do any tls optimization.  */
8620                   if (pass == 0
8621                       && sec->has_tls_get_addr_call
8622                       && h != NULL
8623                       && (h == &htab->tls_get_addr->elf
8624                           || h == &htab->tls_get_addr_fd->elf)
8625                       && !found_tls_get_addr_arg
8626                       && is_branch_reloc (r_type))
8627                     {
8628                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8629                                                 "TLS optimization disabled\n"),
8630                                               ibfd, sec, rel->r_offset);
8631                       ret = TRUE;
8632                       goto err_free_rel;
8633                     }
8634
8635                   found_tls_get_addr_arg = 0;
8636                   switch (r_type)
8637                     {
8638                     case R_PPC64_GOT_TLSLD16:
8639                     case R_PPC64_GOT_TLSLD16_LO:
8640                       expecting_tls_get_addr = 1;
8641                       found_tls_get_addr_arg = 1;
8642                       /* Fall through.  */
8643
8644                     case R_PPC64_GOT_TLSLD16_HI:
8645                     case R_PPC64_GOT_TLSLD16_HA:
8646                       /* These relocs should never be against a symbol
8647                          defined in a shared lib.  Leave them alone if
8648                          that turns out to be the case.  */
8649                       if (!is_local)
8650                         continue;
8651
8652                       /* LD -> LE */
8653                       tls_set = 0;
8654                       tls_clear = TLS_LD;
8655                       tls_type = TLS_TLS | TLS_LD;
8656                       break;
8657
8658                     case R_PPC64_GOT_TLSGD16:
8659                     case R_PPC64_GOT_TLSGD16_LO:
8660                       expecting_tls_get_addr = 1;
8661                       found_tls_get_addr_arg = 1;
8662                       /* Fall through. */
8663
8664                     case R_PPC64_GOT_TLSGD16_HI:
8665                     case R_PPC64_GOT_TLSGD16_HA:
8666                       if (ok_tprel)
8667                         /* GD -> LE */
8668                         tls_set = 0;
8669                       else
8670                         /* GD -> IE */
8671                         tls_set = TLS_TLS | TLS_TPRELGD;
8672                       tls_clear = TLS_GD;
8673                       tls_type = TLS_TLS | TLS_GD;
8674                       break;
8675
8676                     case R_PPC64_GOT_TPREL16_DS:
8677                     case R_PPC64_GOT_TPREL16_LO_DS:
8678                     case R_PPC64_GOT_TPREL16_HI:
8679                     case R_PPC64_GOT_TPREL16_HA:
8680                       if (ok_tprel)
8681                         {
8682                           /* IE -> LE */
8683                           tls_set = 0;
8684                           tls_clear = TLS_TPREL;
8685                           tls_type = TLS_TLS | TLS_TPREL;
8686                           break;
8687                         }
8688                       continue;
8689
8690                     case R_PPC64_TLSGD:
8691                     case R_PPC64_TLSLD:
8692                       found_tls_get_addr_arg = 1;
8693                       /* Fall through.  */
8694
8695                     case R_PPC64_TLS:
8696                     case R_PPC64_TOC16:
8697                     case R_PPC64_TOC16_LO:
8698                       if (sym_sec == NULL || sym_sec != toc)
8699                         continue;
8700
8701                       /* Mark this toc entry as referenced by a TLS
8702                          code sequence.  We can do that now in the
8703                          case of R_PPC64_TLS, and after checking for
8704                          tls_get_addr for the TOC16 relocs.  */
8705                       if (toc_ref == NULL)
8706                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8707                       if (toc_ref == NULL)
8708                         goto err_free_rel;
8709
8710                       if (h != NULL)
8711                         value = h->root.u.def.value;
8712                       else
8713                         value = sym->st_value;
8714                       value += rel->r_addend;
8715                       if (value % 8 != 0)
8716                         continue;
8717                       BFD_ASSERT (value < toc->size
8718                                   && toc->output_offset % 8 == 0);
8719                       toc_ref_index = (value + toc->output_offset) / 8;
8720                       if (r_type == R_PPC64_TLS
8721                           || r_type == R_PPC64_TLSGD
8722                           || r_type == R_PPC64_TLSLD)
8723                         {
8724                           toc_ref[toc_ref_index] = 1;
8725                           continue;
8726                         }
8727
8728                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8729                         continue;
8730
8731                       tls_set = 0;
8732                       tls_clear = 0;
8733                       expecting_tls_get_addr = 2;
8734                       break;
8735
8736                     case R_PPC64_TPREL64:
8737                       if (pass == 0
8738                           || sec != toc
8739                           || toc_ref == NULL
8740                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8741                         continue;
8742                       if (ok_tprel)
8743                         {
8744                           /* IE -> LE */
8745                           tls_set = TLS_EXPLICIT;
8746                           tls_clear = TLS_TPREL;
8747                           break;
8748                         }
8749                       continue;
8750
8751                     case R_PPC64_DTPMOD64:
8752                       if (pass == 0
8753                           || sec != toc
8754                           || toc_ref == NULL
8755                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8756                         continue;
8757                       if (rel + 1 < relend
8758                           && (rel[1].r_info
8759                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8760                           && rel[1].r_offset == rel->r_offset + 8)
8761                         {
8762                           if (ok_tprel)
8763                             /* GD -> LE */
8764                             tls_set = TLS_EXPLICIT | TLS_GD;
8765                           else
8766                             /* GD -> IE */
8767                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8768                           tls_clear = TLS_GD;
8769                         }
8770                       else
8771                         {
8772                           if (!is_local)
8773                             continue;
8774
8775                           /* LD -> LE */
8776                           tls_set = TLS_EXPLICIT;
8777                           tls_clear = TLS_LD;
8778                         }
8779                       break;
8780
8781                     default:
8782                       continue;
8783                     }
8784
8785                   if (pass == 0)
8786                     {
8787                       if (!expecting_tls_get_addr
8788                           || !sec->has_tls_get_addr_call)
8789                         continue;
8790
8791                       if (rel + 1 < relend
8792                           && branch_reloc_hash_match (ibfd, rel + 1,
8793                                                       htab->tls_get_addr,
8794                                                       htab->tls_get_addr_fd))
8795                         {
8796                           if (expecting_tls_get_addr == 2)
8797                             {
8798                               /* Check for toc tls entries.  */
8799                               unsigned char *toc_tls;
8800                               int retval;
8801
8802                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8803                                                      &locsyms,
8804                                                      rel, ibfd);
8805                               if (retval == 0)
8806                                 goto err_free_rel;
8807                               if (toc_tls != NULL)
8808                                 {
8809                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8810                                     found_tls_get_addr_arg = 1;
8811                                   if (retval > 1)
8812                                     toc_ref[toc_ref_index] = 1;
8813                                 }
8814                             }
8815                           continue;
8816                         }
8817
8818                       if (expecting_tls_get_addr != 1)
8819                         continue;
8820
8821                       /* Uh oh, we didn't find the expected call.  We
8822                          could just mark this symbol to exclude it
8823                          from tls optimization but it's safer to skip
8824                          the entire optimization.  */
8825                       /* xgettext:c-format */
8826                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8827                                                 "TLS optimization disabled\n"),
8828                                               ibfd, sec, rel->r_offset);
8829                       ret = TRUE;
8830                       goto err_free_rel;
8831                     }
8832
8833                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8834                     {
8835                       struct plt_entry *ent;
8836                       for (ent = htab->tls_get_addr->elf.plt.plist;
8837                            ent != NULL;
8838                            ent = ent->next)
8839                         if (ent->addend == 0)
8840                           {
8841                             if (ent->plt.refcount > 0)
8842                               {
8843                                 ent->plt.refcount -= 1;
8844                                 expecting_tls_get_addr = 0;
8845                               }
8846                             break;
8847                           }
8848                     }
8849
8850                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8851                     {
8852                       struct plt_entry *ent;
8853                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8854                            ent != NULL;
8855                            ent = ent->next)
8856                         if (ent->addend == 0)
8857                           {
8858                             if (ent->plt.refcount > 0)
8859                               ent->plt.refcount -= 1;
8860                             break;
8861                           }
8862                     }
8863
8864                   if (tls_clear == 0)
8865                     continue;
8866
8867                   if ((tls_set & TLS_EXPLICIT) == 0)
8868                     {
8869                       struct got_entry *ent;
8870
8871                       /* Adjust got entry for this reloc.  */
8872                       if (h != NULL)
8873                         ent = h->got.glist;
8874                       else
8875                         ent = elf_local_got_ents (ibfd)[r_symndx];
8876
8877                       for (; ent != NULL; ent = ent->next)
8878                         if (ent->addend == rel->r_addend
8879                             && ent->owner == ibfd
8880                             && ent->tls_type == tls_type)
8881                           break;
8882                       if (ent == NULL)
8883                         abort ();
8884
8885                       if (tls_set == 0)
8886                         {
8887                           /* We managed to get rid of a got entry.  */
8888                           if (ent->got.refcount > 0)
8889                             ent->got.refcount -= 1;
8890                         }
8891                     }
8892                   else
8893                     {
8894                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8895                          we'll lose one or two dyn relocs.  */
8896                       if (!dec_dynrel_count (rel->r_info, sec, info,
8897                                              NULL, h, sym))
8898                         return FALSE;
8899
8900                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8901                         {
8902                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8903                                                  NULL, h, sym))
8904                             return FALSE;
8905                         }
8906                     }
8907
8908                   *tls_mask |= tls_set;
8909                   *tls_mask &= ~tls_clear;
8910                 }
8911
8912               if (elf_section_data (sec)->relocs != relstart)
8913                 free (relstart);
8914             }
8915
8916         if (locsyms != NULL
8917             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8918           {
8919             if (!info->keep_memory)
8920               free (locsyms);
8921             else
8922               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8923           }
8924       }
8925
8926   if (toc_ref != NULL)
8927     free (toc_ref);
8928   return TRUE;
8929 }
8930
8931 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8932    the values of any global symbols in a toc section that has been
8933    edited.  Globals in toc sections should be a rarity, so this function
8934    sets a flag if any are found in toc sections other than the one just
8935    edited, so that further hash table traversals can be avoided.  */
8936
8937 struct adjust_toc_info
8938 {
8939   asection *toc;
8940   unsigned long *skip;
8941   bfd_boolean global_toc_syms;
8942 };
8943
8944 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8945
8946 static bfd_boolean
8947 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8948 {
8949   struct ppc_link_hash_entry *eh;
8950   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8951   unsigned long i;
8952
8953   if (h->root.type != bfd_link_hash_defined
8954       && h->root.type != bfd_link_hash_defweak)
8955     return TRUE;
8956
8957   eh = (struct ppc_link_hash_entry *) h;
8958   if (eh->adjust_done)
8959     return TRUE;
8960
8961   if (eh->elf.root.u.def.section == toc_inf->toc)
8962     {
8963       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8964         i = toc_inf->toc->rawsize >> 3;
8965       else
8966         i = eh->elf.root.u.def.value >> 3;
8967
8968       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8969         {
8970           _bfd_error_handler
8971             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8972           do
8973             ++i;
8974           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8975           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8976         }
8977
8978       eh->elf.root.u.def.value -= toc_inf->skip[i];
8979       eh->adjust_done = 1;
8980     }
8981   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8982     toc_inf->global_toc_syms = TRUE;
8983
8984   return TRUE;
8985 }
8986
8987 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8988    on a _LO variety toc/got reloc.  */
8989
8990 static bfd_boolean
8991 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8992 {
8993   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8994           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8995           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8996           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8997           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8998           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8999           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9000           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9001           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9002           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9003           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9004           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9005           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9006           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9007           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9008           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9009           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9010               /* Exclude lfqu by testing reloc.  If relocs are ever
9011                  defined for the reduced D field in psq_lu then those
9012                  will need testing too.  */
9013               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9014           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9015               && (insn & 1) == 0)
9016           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9017           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9018               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9019               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9020           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9021               && (insn & 1) == 0));
9022 }
9023
9024 /* Examine all relocs referencing .toc sections in order to remove
9025    unused .toc entries.  */
9026
9027 bfd_boolean
9028 ppc64_elf_edit_toc (struct bfd_link_info *info)
9029 {
9030   bfd *ibfd;
9031   struct adjust_toc_info toc_inf;
9032   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9033
9034   htab->do_toc_opt = 1;
9035   toc_inf.global_toc_syms = TRUE;
9036   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9037     {
9038       asection *toc, *sec;
9039       Elf_Internal_Shdr *symtab_hdr;
9040       Elf_Internal_Sym *local_syms;
9041       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9042       unsigned long *skip, *drop;
9043       unsigned char *used;
9044       unsigned char *keep, last, some_unused;
9045
9046       if (!is_ppc64_elf (ibfd))
9047         continue;
9048
9049       toc = bfd_get_section_by_name (ibfd, ".toc");
9050       if (toc == NULL
9051           || toc->size == 0
9052           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9053           || discarded_section (toc))
9054         continue;
9055
9056       toc_relocs = NULL;
9057       local_syms = NULL;
9058       symtab_hdr = &elf_symtab_hdr (ibfd);
9059
9060       /* Look at sections dropped from the final link.  */
9061       skip = NULL;
9062       relstart = NULL;
9063       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9064         {
9065           if (sec->reloc_count == 0
9066               || !discarded_section (sec)
9067               || get_opd_info (sec)
9068               || (sec->flags & SEC_ALLOC) == 0
9069               || (sec->flags & SEC_DEBUGGING) != 0)
9070             continue;
9071
9072           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9073           if (relstart == NULL)
9074             goto error_ret;
9075
9076           /* Run through the relocs to see which toc entries might be
9077              unused.  */
9078           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9079             {
9080               enum elf_ppc64_reloc_type r_type;
9081               unsigned long r_symndx;
9082               asection *sym_sec;
9083               struct elf_link_hash_entry *h;
9084               Elf_Internal_Sym *sym;
9085               bfd_vma val;
9086
9087               r_type = ELF64_R_TYPE (rel->r_info);
9088               switch (r_type)
9089                 {
9090                 default:
9091                   continue;
9092
9093                 case R_PPC64_TOC16:
9094                 case R_PPC64_TOC16_LO:
9095                 case R_PPC64_TOC16_HI:
9096                 case R_PPC64_TOC16_HA:
9097                 case R_PPC64_TOC16_DS:
9098                 case R_PPC64_TOC16_LO_DS:
9099                   break;
9100                 }
9101
9102               r_symndx = ELF64_R_SYM (rel->r_info);
9103               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9104                               r_symndx, ibfd))
9105                 goto error_ret;
9106
9107               if (sym_sec != toc)
9108                 continue;
9109
9110               if (h != NULL)
9111                 val = h->root.u.def.value;
9112               else
9113                 val = sym->st_value;
9114               val += rel->r_addend;
9115
9116               if (val >= toc->size)
9117                 continue;
9118
9119               /* Anything in the toc ought to be aligned to 8 bytes.
9120                  If not, don't mark as unused.  */
9121               if (val & 7)
9122                 continue;
9123
9124               if (skip == NULL)
9125                 {
9126                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9127                   if (skip == NULL)
9128                     goto error_ret;
9129                 }
9130
9131               skip[val >> 3] = ref_from_discarded;
9132             }
9133
9134           if (elf_section_data (sec)->relocs != relstart)
9135             free (relstart);
9136         }
9137
9138       /* For largetoc loads of address constants, we can convert
9139          .  addis rx,2,addr@got@ha
9140          .  ld ry,addr@got@l(rx)
9141          to
9142          .  addis rx,2,addr@toc@ha
9143          .  addi ry,rx,addr@toc@l
9144          when addr is within 2G of the toc pointer.  This then means
9145          that the word storing "addr" in the toc is no longer needed.  */
9146
9147       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9148           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9149           && toc->reloc_count != 0)
9150         {
9151           /* Read toc relocs.  */
9152           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9153                                                   info->keep_memory);
9154           if (toc_relocs == NULL)
9155             goto error_ret;
9156
9157           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9158             {
9159               enum elf_ppc64_reloc_type r_type;
9160               unsigned long r_symndx;
9161               asection *sym_sec;
9162               struct elf_link_hash_entry *h;
9163               Elf_Internal_Sym *sym;
9164               bfd_vma val, addr;
9165
9166               r_type = ELF64_R_TYPE (rel->r_info);
9167               if (r_type != R_PPC64_ADDR64)
9168                 continue;
9169
9170               r_symndx = ELF64_R_SYM (rel->r_info);
9171               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9172                               r_symndx, ibfd))
9173                 goto error_ret;
9174
9175               if (sym_sec == NULL
9176                   || sym_sec->output_section == NULL
9177                   || discarded_section (sym_sec))
9178                 continue;
9179
9180               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9181                 continue;
9182
9183               if (h != NULL)
9184                 {
9185                   if (h->type == STT_GNU_IFUNC)
9186                     continue;
9187                   val = h->root.u.def.value;
9188                 }
9189               else
9190                 {
9191                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9192                     continue;
9193                   val = sym->st_value;
9194                 }
9195               val += rel->r_addend;
9196               val += sym_sec->output_section->vma + sym_sec->output_offset;
9197
9198               /* We don't yet know the exact toc pointer value, but we
9199                  know it will be somewhere in the toc section.  Don't
9200                  optimize if the difference from any possible toc
9201                  pointer is outside [ff..f80008000, 7fff7fff].  */
9202               addr = toc->output_section->vma + TOC_BASE_OFF;
9203               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9204                 continue;
9205
9206               addr = toc->output_section->vma + toc->output_section->rawsize;
9207               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9208                 continue;
9209
9210               if (skip == NULL)
9211                 {
9212                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9213                   if (skip == NULL)
9214                     goto error_ret;
9215                 }
9216
9217               skip[rel->r_offset >> 3]
9218                 |= can_optimize | ((rel - toc_relocs) << 2);
9219             }
9220         }
9221
9222       if (skip == NULL)
9223         continue;
9224
9225       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9226       if (used == NULL)
9227         {
9228         error_ret:
9229           if (local_syms != NULL
9230               && symtab_hdr->contents != (unsigned char *) local_syms)
9231             free (local_syms);
9232           if (sec != NULL
9233               && relstart != NULL
9234               && elf_section_data (sec)->relocs != relstart)
9235             free (relstart);
9236           if (toc_relocs != NULL
9237               && elf_section_data (toc)->relocs != toc_relocs)
9238             free (toc_relocs);
9239           if (skip != NULL)
9240             free (skip);
9241           return FALSE;
9242         }
9243
9244       /* Now check all kept sections that might reference the toc.
9245          Check the toc itself last.  */
9246       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9247                   : ibfd->sections);
9248            sec != NULL;
9249            sec = (sec == toc ? NULL
9250                   : sec->next == NULL ? toc
9251                   : sec->next == toc && toc->next ? toc->next
9252                   : sec->next))
9253         {
9254           int repeat;
9255
9256           if (sec->reloc_count == 0
9257               || discarded_section (sec)
9258               || get_opd_info (sec)
9259               || (sec->flags & SEC_ALLOC) == 0
9260               || (sec->flags & SEC_DEBUGGING) != 0)
9261             continue;
9262
9263           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9264                                                 info->keep_memory);
9265           if (relstart == NULL)
9266             {
9267               free (used);
9268               goto error_ret;
9269             }
9270
9271           /* Mark toc entries referenced as used.  */
9272           do
9273             {
9274               repeat = 0;
9275               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9276                 {
9277                   enum elf_ppc64_reloc_type r_type;
9278                   unsigned long r_symndx;
9279                   asection *sym_sec;
9280                   struct elf_link_hash_entry *h;
9281                   Elf_Internal_Sym *sym;
9282                   bfd_vma val;
9283                   enum {no_check, check_lo, check_ha} insn_check;
9284
9285                   r_type = ELF64_R_TYPE (rel->r_info);
9286                   switch (r_type)
9287                     {
9288                     default:
9289                       insn_check = no_check;
9290                       break;
9291
9292                     case R_PPC64_GOT_TLSLD16_HA:
9293                     case R_PPC64_GOT_TLSGD16_HA:
9294                     case R_PPC64_GOT_TPREL16_HA:
9295                     case R_PPC64_GOT_DTPREL16_HA:
9296                     case R_PPC64_GOT16_HA:
9297                     case R_PPC64_TOC16_HA:
9298                       insn_check = check_ha;
9299                       break;
9300
9301                     case R_PPC64_GOT_TLSLD16_LO:
9302                     case R_PPC64_GOT_TLSGD16_LO:
9303                     case R_PPC64_GOT_TPREL16_LO_DS:
9304                     case R_PPC64_GOT_DTPREL16_LO_DS:
9305                     case R_PPC64_GOT16_LO:
9306                     case R_PPC64_GOT16_LO_DS:
9307                     case R_PPC64_TOC16_LO:
9308                     case R_PPC64_TOC16_LO_DS:
9309                       insn_check = check_lo;
9310                       break;
9311                     }
9312
9313                   if (insn_check != no_check)
9314                     {
9315                       bfd_vma off = rel->r_offset & ~3;
9316                       unsigned char buf[4];
9317                       unsigned int insn;
9318
9319                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9320                         {
9321                           free (used);
9322                           goto error_ret;
9323                         }
9324                       insn = bfd_get_32 (ibfd, buf);
9325                       if (insn_check == check_lo
9326                           ? !ok_lo_toc_insn (insn, r_type)
9327                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9328                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9329                         {
9330                           char str[12];
9331
9332                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9333                           sprintf (str, "%#08x", insn);
9334                           info->callbacks->einfo
9335                             /* xgettext:c-format */
9336                             (_("%H: toc optimization is not supported for"
9337                                " %s instruction.\n"),
9338                              ibfd, sec, rel->r_offset & ~3, str);
9339                         }
9340                     }
9341
9342                   switch (r_type)
9343                     {
9344                     case R_PPC64_TOC16:
9345                     case R_PPC64_TOC16_LO:
9346                     case R_PPC64_TOC16_HI:
9347                     case R_PPC64_TOC16_HA:
9348                     case R_PPC64_TOC16_DS:
9349                     case R_PPC64_TOC16_LO_DS:
9350                       /* In case we're taking addresses of toc entries.  */
9351                     case R_PPC64_ADDR64:
9352                       break;
9353
9354                     default:
9355                       continue;
9356                     }
9357
9358                   r_symndx = ELF64_R_SYM (rel->r_info);
9359                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9360                                   r_symndx, ibfd))
9361                     {
9362                       free (used);
9363                       goto error_ret;
9364                     }
9365
9366                   if (sym_sec != toc)
9367                     continue;
9368
9369                   if (h != NULL)
9370                     val = h->root.u.def.value;
9371                   else
9372                     val = sym->st_value;
9373                   val += rel->r_addend;
9374
9375                   if (val >= toc->size)
9376                     continue;
9377
9378                   if ((skip[val >> 3] & can_optimize) != 0)
9379                     {
9380                       bfd_vma off;
9381                       unsigned char opc;
9382
9383                       switch (r_type)
9384                         {
9385                         case R_PPC64_TOC16_HA:
9386                           break;
9387
9388                         case R_PPC64_TOC16_LO_DS:
9389                           off = rel->r_offset;
9390                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9391                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9392                                                          off, 1))
9393                             {
9394                               free (used);
9395                               goto error_ret;
9396                             }
9397                           if ((opc & (0x3f << 2)) == (58u << 2))
9398                             break;
9399                           /* Fall through.  */
9400
9401                         default:
9402                           /* Wrong sort of reloc, or not a ld.  We may
9403                              as well clear ref_from_discarded too.  */
9404                           skip[val >> 3] = 0;
9405                         }
9406                     }
9407
9408                   if (sec != toc)
9409                     used[val >> 3] = 1;
9410                   /* For the toc section, we only mark as used if this
9411                      entry itself isn't unused.  */
9412                   else if ((used[rel->r_offset >> 3]
9413                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9414                            && !used[val >> 3])
9415                     {
9416                       /* Do all the relocs again, to catch reference
9417                          chains.  */
9418                       repeat = 1;
9419                       used[val >> 3] = 1;
9420                     }
9421                 }
9422             }
9423           while (repeat);
9424
9425           if (elf_section_data (sec)->relocs != relstart)
9426             free (relstart);
9427         }
9428
9429       /* Merge the used and skip arrays.  Assume that TOC
9430          doublewords not appearing as either used or unused belong
9431          to an entry more than one doubleword in size.  */
9432       for (drop = skip, keep = used, last = 0, some_unused = 0;
9433            drop < skip + (toc->size + 7) / 8;
9434            ++drop, ++keep)
9435         {
9436           if (*keep)
9437             {
9438               *drop &= ~ref_from_discarded;
9439               if ((*drop & can_optimize) != 0)
9440                 some_unused = 1;
9441               last = 0;
9442             }
9443           else if ((*drop & ref_from_discarded) != 0)
9444             {
9445               some_unused = 1;
9446               last = ref_from_discarded;
9447             }
9448           else
9449             *drop = last;
9450         }
9451
9452       free (used);
9453
9454       if (some_unused)
9455         {
9456           bfd_byte *contents, *src;
9457           unsigned long off;
9458           Elf_Internal_Sym *sym;
9459           bfd_boolean local_toc_syms = FALSE;
9460
9461           /* Shuffle the toc contents, and at the same time convert the
9462              skip array from booleans into offsets.  */
9463           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9464             goto error_ret;
9465
9466           elf_section_data (toc)->this_hdr.contents = contents;
9467
9468           for (src = contents, off = 0, drop = skip;
9469                src < contents + toc->size;
9470                src += 8, ++drop)
9471             {
9472               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9473                 off += 8;
9474               else if (off != 0)
9475                 {
9476                   *drop = off;
9477                   memcpy (src - off, src, 8);
9478                 }
9479             }
9480           *drop = off;
9481           toc->rawsize = toc->size;
9482           toc->size = src - contents - off;
9483
9484           /* Adjust addends for relocs against the toc section sym,
9485              and optimize any accesses we can.  */
9486           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9487             {
9488               if (sec->reloc_count == 0
9489                   || discarded_section (sec))
9490                 continue;
9491
9492               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9493                                                     info->keep_memory);
9494               if (relstart == NULL)
9495                 goto error_ret;
9496
9497               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9498                 {
9499                   enum elf_ppc64_reloc_type r_type;
9500                   unsigned long r_symndx;
9501                   asection *sym_sec;
9502                   struct elf_link_hash_entry *h;
9503                   bfd_vma val;
9504
9505                   r_type = ELF64_R_TYPE (rel->r_info);
9506                   switch (r_type)
9507                     {
9508                     default:
9509                       continue;
9510
9511                     case R_PPC64_TOC16:
9512                     case R_PPC64_TOC16_LO:
9513                     case R_PPC64_TOC16_HI:
9514                     case R_PPC64_TOC16_HA:
9515                     case R_PPC64_TOC16_DS:
9516                     case R_PPC64_TOC16_LO_DS:
9517                     case R_PPC64_ADDR64:
9518                       break;
9519                     }
9520
9521                   r_symndx = ELF64_R_SYM (rel->r_info);
9522                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9523                                   r_symndx, ibfd))
9524                     goto error_ret;
9525
9526                   if (sym_sec != toc)
9527                     continue;
9528
9529                   if (h != NULL)
9530                     val = h->root.u.def.value;
9531                   else
9532                     {
9533                       val = sym->st_value;
9534                       if (val != 0)
9535                         local_toc_syms = TRUE;
9536                     }
9537
9538                   val += rel->r_addend;
9539
9540                   if (val > toc->rawsize)
9541                     val = toc->rawsize;
9542                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9543                     continue;
9544                   else if ((skip[val >> 3] & can_optimize) != 0)
9545                     {
9546                       Elf_Internal_Rela *tocrel
9547                         = toc_relocs + (skip[val >> 3] >> 2);
9548                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9549
9550                       switch (r_type)
9551                         {
9552                         case R_PPC64_TOC16_HA:
9553                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9554                           break;
9555
9556                         case R_PPC64_TOC16_LO_DS:
9557                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9558                           break;
9559
9560                         default:
9561                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9562                             ppc_howto_init ();
9563                           info->callbacks->einfo
9564                             /* xgettext:c-format */
9565                             (_("%H: %s references "
9566                                "optimized away TOC entry\n"),
9567                              ibfd, sec, rel->r_offset,
9568                              ppc64_elf_howto_table[r_type]->name);
9569                           bfd_set_error (bfd_error_bad_value);
9570                           goto error_ret;
9571                         }
9572                       rel->r_addend = tocrel->r_addend;
9573                       elf_section_data (sec)->relocs = relstart;
9574                       continue;
9575                     }
9576
9577                   if (h != NULL || sym->st_value != 0)
9578                     continue;
9579
9580                   rel->r_addend -= skip[val >> 3];
9581                   elf_section_data (sec)->relocs = relstart;
9582                 }
9583
9584               if (elf_section_data (sec)->relocs != relstart)
9585                 free (relstart);
9586             }
9587
9588           /* We shouldn't have local or global symbols defined in the TOC,
9589              but handle them anyway.  */
9590           if (local_syms != NULL)
9591             for (sym = local_syms;
9592                  sym < local_syms + symtab_hdr->sh_info;
9593                  ++sym)
9594               if (sym->st_value != 0
9595                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9596                 {
9597                   unsigned long i;
9598
9599                   if (sym->st_value > toc->rawsize)
9600                     i = toc->rawsize >> 3;
9601                   else
9602                     i = sym->st_value >> 3;
9603
9604                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9605                     {
9606                       if (local_toc_syms)
9607                         _bfd_error_handler
9608                           (_("%s defined on removed toc entry"),
9609                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9610                       do
9611                         ++i;
9612                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9613                       sym->st_value = (bfd_vma) i << 3;
9614                     }
9615
9616                   sym->st_value -= skip[i];
9617                   symtab_hdr->contents = (unsigned char *) local_syms;
9618                 }
9619
9620           /* Adjust any global syms defined in this toc input section.  */
9621           if (toc_inf.global_toc_syms)
9622             {
9623               toc_inf.toc = toc;
9624               toc_inf.skip = skip;
9625               toc_inf.global_toc_syms = FALSE;
9626               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9627                                       &toc_inf);
9628             }
9629
9630           if (toc->reloc_count != 0)
9631             {
9632               Elf_Internal_Shdr *rel_hdr;
9633               Elf_Internal_Rela *wrel;
9634               bfd_size_type sz;
9635
9636               /* Remove unused toc relocs, and adjust those we keep.  */
9637               if (toc_relocs == NULL)
9638                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9639                                                         info->keep_memory);
9640               if (toc_relocs == NULL)
9641                 goto error_ret;
9642
9643               wrel = toc_relocs;
9644               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9645                 if ((skip[rel->r_offset >> 3]
9646                      & (ref_from_discarded | can_optimize)) == 0)
9647                   {
9648                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9649                     wrel->r_info = rel->r_info;
9650                     wrel->r_addend = rel->r_addend;
9651                     ++wrel;
9652                   }
9653                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9654                                             &local_syms, NULL, NULL))
9655                   goto error_ret;
9656
9657               elf_section_data (toc)->relocs = toc_relocs;
9658               toc->reloc_count = wrel - toc_relocs;
9659               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9660               sz = rel_hdr->sh_entsize;
9661               rel_hdr->sh_size = toc->reloc_count * sz;
9662             }
9663         }
9664       else if (toc_relocs != NULL
9665                && elf_section_data (toc)->relocs != toc_relocs)
9666         free (toc_relocs);
9667
9668       if (local_syms != NULL
9669           && symtab_hdr->contents != (unsigned char *) local_syms)
9670         {
9671           if (!info->keep_memory)
9672             free (local_syms);
9673           else
9674             symtab_hdr->contents = (unsigned char *) local_syms;
9675         }
9676       free (skip);
9677     }
9678
9679   return TRUE;
9680 }
9681
9682 /* Return true iff input section I references the TOC using
9683    instructions limited to +/-32k offsets.  */
9684
9685 bfd_boolean
9686 ppc64_elf_has_small_toc_reloc (asection *i)
9687 {
9688   return (is_ppc64_elf (i->owner)
9689           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9690 }
9691
9692 /* Allocate space for one GOT entry.  */
9693
9694 static void
9695 allocate_got (struct elf_link_hash_entry *h,
9696               struct bfd_link_info *info,
9697               struct got_entry *gent)
9698 {
9699   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9700   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9701   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9702                  ? 16 : 8);
9703   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9704                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9705   asection *got = ppc64_elf_tdata (gent->owner)->got;
9706
9707   gent->got.offset = got->size;
9708   got->size += entsize;
9709
9710   if (h->type == STT_GNU_IFUNC)
9711     {
9712       htab->elf.irelplt->size += rentsize;
9713       htab->got_reli_size += rentsize;
9714     }
9715   else if ((bfd_link_pic (info)
9716             || (htab->elf.dynamic_sections_created
9717                 && h->dynindx != -1
9718                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9719            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9720     {
9721       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9722       relgot->size += rentsize;
9723     }
9724 }
9725
9726 /* This function merges got entries in the same toc group.  */
9727
9728 static void
9729 merge_got_entries (struct got_entry **pent)
9730 {
9731   struct got_entry *ent, *ent2;
9732
9733   for (ent = *pent; ent != NULL; ent = ent->next)
9734     if (!ent->is_indirect)
9735       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9736         if (!ent2->is_indirect
9737             && ent2->addend == ent->addend
9738             && ent2->tls_type == ent->tls_type
9739             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9740           {
9741             ent2->is_indirect = TRUE;
9742             ent2->got.ent = ent;
9743           }
9744 }
9745
9746 /* If H is undefined, make it dynamic if that makes sense.  */
9747
9748 static bfd_boolean
9749 ensure_undef_dynamic (struct bfd_link_info *info,
9750                       struct elf_link_hash_entry *h)
9751 {
9752   struct elf_link_hash_table *htab = elf_hash_table (info);
9753
9754   if (htab->dynamic_sections_created
9755       && ((info->dynamic_undefined_weak != 0
9756            && h->root.type == bfd_link_hash_undefweak)
9757           || h->root.type == bfd_link_hash_undefined)
9758       && h->dynindx == -1
9759       && !h->forced_local
9760       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9761     return bfd_elf_link_record_dynamic_symbol (info, h);
9762   return TRUE;
9763 }
9764
9765 /* Allocate space in .plt, .got and associated reloc sections for
9766    dynamic relocs.  */
9767
9768 static bfd_boolean
9769 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9770 {
9771   struct bfd_link_info *info;
9772   struct ppc_link_hash_table *htab;
9773   asection *s;
9774   struct ppc_link_hash_entry *eh;
9775   struct got_entry **pgent, *gent;
9776
9777   if (h->root.type == bfd_link_hash_indirect)
9778     return TRUE;
9779
9780   info = (struct bfd_link_info *) inf;
9781   htab = ppc_hash_table (info);
9782   if (htab == NULL)
9783     return FALSE;
9784
9785   eh = (struct ppc_link_hash_entry *) h;
9786   /* Run through the TLS GD got entries first if we're changing them
9787      to TPREL.  */
9788   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9789     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9790       if (gent->got.refcount > 0
9791           && (gent->tls_type & TLS_GD) != 0)
9792         {
9793           /* This was a GD entry that has been converted to TPREL.  If
9794              there happens to be a TPREL entry we can use that one.  */
9795           struct got_entry *ent;
9796           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9797             if (ent->got.refcount > 0
9798                 && (ent->tls_type & TLS_TPREL) != 0
9799                 && ent->addend == gent->addend
9800                 && ent->owner == gent->owner)
9801               {
9802                 gent->got.refcount = 0;
9803                 break;
9804               }
9805
9806           /* If not, then we'll be using our own TPREL entry.  */
9807           if (gent->got.refcount != 0)
9808             gent->tls_type = TLS_TLS | TLS_TPREL;
9809         }
9810
9811   /* Remove any list entry that won't generate a word in the GOT before
9812      we call merge_got_entries.  Otherwise we risk merging to empty
9813      entries.  */
9814   pgent = &h->got.glist;
9815   while ((gent = *pgent) != NULL)
9816     if (gent->got.refcount > 0)
9817       {
9818         if ((gent->tls_type & TLS_LD) != 0
9819             && !h->def_dynamic)
9820           {
9821             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9822             *pgent = gent->next;
9823           }
9824         else
9825           pgent = &gent->next;
9826       }
9827     else
9828       *pgent = gent->next;
9829
9830   if (!htab->do_multi_toc)
9831     merge_got_entries (&h->got.glist);
9832
9833   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9834     if (!gent->is_indirect)
9835       {
9836         /* Make sure this symbol is output as a dynamic symbol.  */
9837         if (!ensure_undef_dynamic (info, h))
9838           return FALSE;
9839
9840         if (!is_ppc64_elf (gent->owner))
9841           abort ();
9842
9843         allocate_got (h, info, gent);
9844       }
9845
9846   /* If no dynamic sections we can't have dynamic relocs, except for
9847      IFUNCs which are handled even in static executables.  */
9848   if (!htab->elf.dynamic_sections_created
9849       && h->type != STT_GNU_IFUNC)
9850     eh->dyn_relocs = NULL;
9851
9852   /* Also discard relocs on undefined weak syms with non-default
9853      visibility, or when dynamic_undefined_weak says so.  */
9854   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9855     eh->dyn_relocs = NULL;
9856
9857   if (eh->dyn_relocs != NULL)
9858     {
9859       struct elf_dyn_relocs *p, **pp;
9860
9861       /* In the shared -Bsymbolic case, discard space allocated for
9862          dynamic pc-relative relocs against symbols which turn out to
9863          be defined in regular objects.  For the normal shared case,
9864          discard space for relocs that have become local due to symbol
9865          visibility changes.  */
9866
9867       if (bfd_link_pic (info))
9868         {
9869           /* Relocs that use pc_count are those that appear on a call
9870              insn, or certain REL relocs (see must_be_dyn_reloc) that
9871              can be generated via assembly.  We want calls to
9872              protected symbols to resolve directly to the function
9873              rather than going via the plt.  If people want function
9874              pointer comparisons to work as expected then they should
9875              avoid writing weird assembly.  */
9876           if (SYMBOL_CALLS_LOCAL (info, h))
9877             {
9878               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9879                 {
9880                   p->count -= p->pc_count;
9881                   p->pc_count = 0;
9882                   if (p->count == 0)
9883                     *pp = p->next;
9884                   else
9885                     pp = &p->next;
9886                 }
9887             }
9888
9889           if (eh->dyn_relocs != NULL)
9890             {
9891               /* Make sure this symbol is output as a dynamic symbol.  */
9892               if (!ensure_undef_dynamic (info, h))
9893                 return FALSE;
9894             }
9895         }
9896       else if (h->type == STT_GNU_IFUNC)
9897         {
9898           /* A plt entry is always created when making direct calls to
9899              an ifunc, even when building a static executable, but
9900              that doesn't cover all cases.  We may have only an ifunc
9901              initialised function pointer for a given ifunc symbol.
9902
9903              For ELFv2, dynamic relocations are not required when
9904              generating a global entry PLT stub.  */
9905           if (abiversion (info->output_bfd) >= 2)
9906             {
9907               if (global_entry_stub (h))
9908                 eh->dyn_relocs = NULL;
9909             }
9910
9911           /* For ELFv1 we have function descriptors.  Descriptors need
9912              to be treated like PLT entries and thus have dynamic
9913              relocations.  One exception is when the function
9914              descriptor is copied into .dynbss (which should only
9915              happen with ancient versions of gcc).  */
9916           else if (h->needs_copy)
9917             eh->dyn_relocs = NULL;
9918         }
9919       else if (ELIMINATE_COPY_RELOCS)
9920         {
9921           /* For the non-pic case, discard space for relocs against
9922              symbols which turn out to need copy relocs or are not
9923              dynamic.  */
9924           if (!h->non_got_ref
9925               && !h->def_regular)
9926             {
9927               /* Make sure this symbol is output as a dynamic symbol.  */
9928               if (!ensure_undef_dynamic (info, h))
9929                 return FALSE;
9930
9931               if (h->dynindx == -1)
9932                 eh->dyn_relocs = NULL;
9933             }
9934           else
9935             eh->dyn_relocs = NULL;
9936         }
9937
9938       /* Finally, allocate space.  */
9939       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9940         {
9941           asection *sreloc = elf_section_data (p->sec)->sreloc;
9942           if (eh->elf.type == STT_GNU_IFUNC)
9943             sreloc = htab->elf.irelplt;
9944           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9945         }
9946     }
9947
9948   if ((htab->elf.dynamic_sections_created
9949        && h->dynindx != -1)
9950       || h->type == STT_GNU_IFUNC)
9951     {
9952       struct plt_entry *pent;
9953       bfd_boolean doneone = FALSE;
9954       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9955         if (pent->plt.refcount > 0)
9956           {
9957             if (!htab->elf.dynamic_sections_created
9958                 || h->dynindx == -1)
9959               {
9960                 s = htab->elf.iplt;
9961                 pent->plt.offset = s->size;
9962                 s->size += PLT_ENTRY_SIZE (htab);
9963                 s = htab->elf.irelplt;
9964               }
9965             else
9966               {
9967                 /* If this is the first .plt entry, make room for the special
9968                    first entry.  */
9969                 s = htab->elf.splt;
9970                 if (s->size == 0)
9971                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9972
9973                 pent->plt.offset = s->size;
9974
9975                 /* Make room for this entry.  */
9976                 s->size += PLT_ENTRY_SIZE (htab);
9977
9978                 /* Make room for the .glink code.  */
9979                 s = htab->glink;
9980                 if (s->size == 0)
9981                   s->size += GLINK_CALL_STUB_SIZE;
9982                 if (htab->opd_abi)
9983                   {
9984                     /* We need bigger stubs past index 32767.  */
9985                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9986                       s->size += 4;
9987                     s->size += 2*4;
9988                   }
9989                 else
9990                   s->size += 4;
9991
9992                 /* We also need to make an entry in the .rela.plt section.  */
9993                 s = htab->elf.srelplt;
9994               }
9995             s->size += sizeof (Elf64_External_Rela);
9996             doneone = TRUE;
9997           }
9998         else
9999           pent->plt.offset = (bfd_vma) -1;
10000       if (!doneone)
10001         {
10002           h->plt.plist = NULL;
10003           h->needs_plt = 0;
10004         }
10005     }
10006   else
10007     {
10008       h->plt.plist = NULL;
10009       h->needs_plt = 0;
10010     }
10011
10012   return TRUE;
10013 }
10014
10015 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10016    to set up space for global entry stubs.  These are put in glink,
10017    after the branch table.  */
10018
10019 static bfd_boolean
10020 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10021 {
10022   struct bfd_link_info *info;
10023   struct ppc_link_hash_table *htab;
10024   struct plt_entry *pent;
10025   asection *s;
10026
10027   if (h->root.type == bfd_link_hash_indirect)
10028     return TRUE;
10029
10030   if (!h->pointer_equality_needed)
10031     return TRUE;
10032
10033   if (h->def_regular)
10034     return TRUE;
10035
10036   info = inf;
10037   htab = ppc_hash_table (info);
10038   if (htab == NULL)
10039     return FALSE;
10040
10041   s = htab->glink;
10042   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10043     if (pent->plt.offset != (bfd_vma) -1
10044         && pent->addend == 0)
10045       {
10046         /* For ELFv2, if this symbol is not defined in a regular file
10047            and we are not generating a shared library or pie, then we
10048            need to define the symbol in the executable on a call stub.
10049            This is to avoid text relocations.  */
10050         s->size = (s->size + 15) & -16;
10051         h->root.type = bfd_link_hash_defined;
10052         h->root.u.def.section = s;
10053         h->root.u.def.value = s->size;
10054         s->size += 16;
10055         break;
10056       }
10057   return TRUE;
10058 }
10059
10060 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10061    read-only sections.  */
10062
10063 static bfd_boolean
10064 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10065 {
10066   if (h->root.type == bfd_link_hash_indirect)
10067     return TRUE;
10068
10069   if (readonly_dynrelocs (h))
10070     {
10071       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10072
10073       /* Not an error, just cut short the traversal.  */
10074       return FALSE;
10075     }
10076   return TRUE;
10077 }
10078
10079 /* Set the sizes of the dynamic sections.  */
10080
10081 static bfd_boolean
10082 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10083                                  struct bfd_link_info *info)
10084 {
10085   struct ppc_link_hash_table *htab;
10086   bfd *dynobj;
10087   asection *s;
10088   bfd_boolean relocs;
10089   bfd *ibfd;
10090   struct got_entry *first_tlsld;
10091
10092   htab = ppc_hash_table (info);
10093   if (htab == NULL)
10094     return FALSE;
10095
10096   dynobj = htab->elf.dynobj;
10097   if (dynobj == NULL)
10098     abort ();
10099
10100   if (htab->elf.dynamic_sections_created)
10101     {
10102       /* Set the contents of the .interp section to the interpreter.  */
10103       if (bfd_link_executable (info) && !info->nointerp)
10104         {
10105           s = bfd_get_linker_section (dynobj, ".interp");
10106           if (s == NULL)
10107             abort ();
10108           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10109           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10110         }
10111     }
10112
10113   /* Set up .got offsets for local syms, and space for local dynamic
10114      relocs.  */
10115   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10116     {
10117       struct got_entry **lgot_ents;
10118       struct got_entry **end_lgot_ents;
10119       struct plt_entry **local_plt;
10120       struct plt_entry **end_local_plt;
10121       unsigned char *lgot_masks;
10122       bfd_size_type locsymcount;
10123       Elf_Internal_Shdr *symtab_hdr;
10124
10125       if (!is_ppc64_elf (ibfd))
10126         continue;
10127
10128       for (s = ibfd->sections; s != NULL; s = s->next)
10129         {
10130           struct ppc_dyn_relocs *p;
10131
10132           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10133             {
10134               if (!bfd_is_abs_section (p->sec)
10135                   && bfd_is_abs_section (p->sec->output_section))
10136                 {
10137                   /* Input section has been discarded, either because
10138                      it is a copy of a linkonce section or due to
10139                      linker script /DISCARD/, so we'll be discarding
10140                      the relocs too.  */
10141                 }
10142               else if (p->count != 0)
10143                 {
10144                   asection *srel = elf_section_data (p->sec)->sreloc;
10145                   if (p->ifunc)
10146                     srel = htab->elf.irelplt;
10147                   srel->size += p->count * sizeof (Elf64_External_Rela);
10148                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10149                     info->flags |= DF_TEXTREL;
10150                 }
10151             }
10152         }
10153
10154       lgot_ents = elf_local_got_ents (ibfd);
10155       if (!lgot_ents)
10156         continue;
10157
10158       symtab_hdr = &elf_symtab_hdr (ibfd);
10159       locsymcount = symtab_hdr->sh_info;
10160       end_lgot_ents = lgot_ents + locsymcount;
10161       local_plt = (struct plt_entry **) end_lgot_ents;
10162       end_local_plt = local_plt + locsymcount;
10163       lgot_masks = (unsigned char *) end_local_plt;
10164       s = ppc64_elf_tdata (ibfd)->got;
10165       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10166         {
10167           struct got_entry **pent, *ent;
10168
10169           pent = lgot_ents;
10170           while ((ent = *pent) != NULL)
10171             if (ent->got.refcount > 0)
10172               {
10173                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10174                   {
10175                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10176                     *pent = ent->next;
10177                   }
10178                 else
10179                   {
10180                     unsigned int ent_size = 8;
10181                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10182
10183                     ent->got.offset = s->size;
10184                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10185                       {
10186                         ent_size *= 2;
10187                         rel_size *= 2;
10188                       }
10189                     s->size += ent_size;
10190                     if ((*lgot_masks & PLT_IFUNC) != 0)
10191                       {
10192                         htab->elf.irelplt->size += rel_size;
10193                         htab->got_reli_size += rel_size;
10194                       }
10195                     else if (bfd_link_pic (info))
10196                       {
10197                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10198                         srel->size += rel_size;
10199                       }
10200                     pent = &ent->next;
10201                   }
10202               }
10203             else
10204               *pent = ent->next;
10205         }
10206
10207       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10208       for (; local_plt < end_local_plt; ++local_plt)
10209         {
10210           struct plt_entry *ent;
10211
10212           for (ent = *local_plt; ent != NULL; ent = ent->next)
10213             if (ent->plt.refcount > 0)
10214               {
10215                 s = htab->elf.iplt;
10216                 ent->plt.offset = s->size;
10217                 s->size += PLT_ENTRY_SIZE (htab);
10218
10219                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10220               }
10221             else
10222               ent->plt.offset = (bfd_vma) -1;
10223         }
10224     }
10225
10226   /* Allocate global sym .plt and .got entries, and space for global
10227      sym dynamic relocs.  */
10228   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10229   /* Stash the end of glink branch table.  */
10230   if (htab->glink != NULL)
10231     htab->glink->rawsize = htab->glink->size;
10232
10233   if (!htab->opd_abi && !bfd_link_pic (info))
10234     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10235
10236   first_tlsld = NULL;
10237   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10238     {
10239       struct got_entry *ent;
10240
10241       if (!is_ppc64_elf (ibfd))
10242         continue;
10243
10244       ent = ppc64_tlsld_got (ibfd);
10245       if (ent->got.refcount > 0)
10246         {
10247           if (!htab->do_multi_toc && first_tlsld != NULL)
10248             {
10249               ent->is_indirect = TRUE;
10250               ent->got.ent = first_tlsld;
10251             }
10252           else
10253             {
10254               if (first_tlsld == NULL)
10255                 first_tlsld = ent;
10256               s = ppc64_elf_tdata (ibfd)->got;
10257               ent->got.offset = s->size;
10258               ent->owner = ibfd;
10259               s->size += 16;
10260               if (bfd_link_pic (info))
10261                 {
10262                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10263                   srel->size += sizeof (Elf64_External_Rela);
10264                 }
10265             }
10266         }
10267       else
10268         ent->got.offset = (bfd_vma) -1;
10269     }
10270
10271   /* We now have determined the sizes of the various dynamic sections.
10272      Allocate memory for them.  */
10273   relocs = FALSE;
10274   for (s = dynobj->sections; s != NULL; s = s->next)
10275     {
10276       if ((s->flags & SEC_LINKER_CREATED) == 0)
10277         continue;
10278
10279       if (s == htab->brlt || s == htab->relbrlt)
10280         /* These haven't been allocated yet;  don't strip.  */
10281         continue;
10282       else if (s == htab->elf.sgot
10283                || s == htab->elf.splt
10284                || s == htab->elf.iplt
10285                || s == htab->glink
10286                || s == htab->elf.sdynbss
10287                || s == htab->elf.sdynrelro)
10288         {
10289           /* Strip this section if we don't need it; see the
10290              comment below.  */
10291         }
10292       else if (s == htab->glink_eh_frame)
10293         {
10294           if (!bfd_is_abs_section (s->output_section))
10295             /* Not sized yet.  */
10296             continue;
10297         }
10298       else if (CONST_STRNEQ (s->name, ".rela"))
10299         {
10300           if (s->size != 0)
10301             {
10302               if (s != htab->elf.srelplt)
10303                 relocs = TRUE;
10304
10305               /* We use the reloc_count field as a counter if we need
10306                  to copy relocs into the output file.  */
10307               s->reloc_count = 0;
10308             }
10309         }
10310       else
10311         {
10312           /* It's not one of our sections, so don't allocate space.  */
10313           continue;
10314         }
10315
10316       if (s->size == 0)
10317         {
10318           /* If we don't need this section, strip it from the
10319              output file.  This is mostly to handle .rela.bss and
10320              .rela.plt.  We must create both sections in
10321              create_dynamic_sections, because they must be created
10322              before the linker maps input sections to output
10323              sections.  The linker does that before
10324              adjust_dynamic_symbol is called, and it is that
10325              function which decides whether anything needs to go
10326              into these sections.  */
10327           s->flags |= SEC_EXCLUDE;
10328           continue;
10329         }
10330
10331       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10332         continue;
10333
10334       /* Allocate memory for the section contents.  We use bfd_zalloc
10335          here in case unused entries are not reclaimed before the
10336          section's contents are written out.  This should not happen,
10337          but this way if it does we get a R_PPC64_NONE reloc in .rela
10338          sections instead of garbage.
10339          We also rely on the section contents being zero when writing
10340          the GOT and .dynrelro.  */
10341       s->contents = bfd_zalloc (dynobj, s->size);
10342       if (s->contents == NULL)
10343         return FALSE;
10344     }
10345
10346   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10347     {
10348       if (!is_ppc64_elf (ibfd))
10349         continue;
10350
10351       s = ppc64_elf_tdata (ibfd)->got;
10352       if (s != NULL && s != htab->elf.sgot)
10353         {
10354           if (s->size == 0)
10355             s->flags |= SEC_EXCLUDE;
10356           else
10357             {
10358               s->contents = bfd_zalloc (ibfd, s->size);
10359               if (s->contents == NULL)
10360                 return FALSE;
10361             }
10362         }
10363       s = ppc64_elf_tdata (ibfd)->relgot;
10364       if (s != NULL)
10365         {
10366           if (s->size == 0)
10367             s->flags |= SEC_EXCLUDE;
10368           else
10369             {
10370               s->contents = bfd_zalloc (ibfd, s->size);
10371               if (s->contents == NULL)
10372                 return FALSE;
10373               relocs = TRUE;
10374               s->reloc_count = 0;
10375             }
10376         }
10377     }
10378
10379   if (htab->elf.dynamic_sections_created)
10380     {
10381       bfd_boolean tls_opt;
10382
10383       /* Add some entries to the .dynamic section.  We fill in the
10384          values later, in ppc64_elf_finish_dynamic_sections, but we
10385          must add the entries now so that we get the correct size for
10386          the .dynamic section.  The DT_DEBUG entry is filled in by the
10387          dynamic linker and used by the debugger.  */
10388 #define add_dynamic_entry(TAG, VAL) \
10389   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10390
10391       if (bfd_link_executable (info))
10392         {
10393           if (!add_dynamic_entry (DT_DEBUG, 0))
10394             return FALSE;
10395         }
10396
10397       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10398         {
10399           if (!add_dynamic_entry (DT_PLTGOT, 0)
10400               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10401               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10402               || !add_dynamic_entry (DT_JMPREL, 0)
10403               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10404             return FALSE;
10405         }
10406
10407       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10408         {
10409           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10410               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10411             return FALSE;
10412         }
10413
10414       tls_opt = (htab->params->tls_get_addr_opt
10415                  && htab->tls_get_addr_fd != NULL
10416                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10417       if (tls_opt || !htab->opd_abi)
10418         {
10419           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10420             return FALSE;
10421         }
10422
10423       if (relocs)
10424         {
10425           if (!add_dynamic_entry (DT_RELA, 0)
10426               || !add_dynamic_entry (DT_RELASZ, 0)
10427               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10428             return FALSE;
10429
10430           /* If any dynamic relocs apply to a read-only section,
10431              then we need a DT_TEXTREL entry.  */
10432           if ((info->flags & DF_TEXTREL) == 0)
10433             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10434
10435           if ((info->flags & DF_TEXTREL) != 0)
10436             {
10437               if (!add_dynamic_entry (DT_TEXTREL, 0))
10438                 return FALSE;
10439             }
10440         }
10441     }
10442 #undef add_dynamic_entry
10443
10444   return TRUE;
10445 }
10446
10447 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10448
10449 static bfd_boolean
10450 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10451 {
10452   if (h->plt.plist != NULL
10453       && !h->def_regular
10454       && !h->pointer_equality_needed)
10455     return FALSE;
10456
10457   return _bfd_elf_hash_symbol (h);
10458 }
10459
10460 /* Determine the type of stub needed, if any, for a call.  */
10461
10462 static inline enum ppc_stub_type
10463 ppc_type_of_stub (asection *input_sec,
10464                   const Elf_Internal_Rela *rel,
10465                   struct ppc_link_hash_entry **hash,
10466                   struct plt_entry **plt_ent,
10467                   bfd_vma destination,
10468                   unsigned long local_off)
10469 {
10470   struct ppc_link_hash_entry *h = *hash;
10471   bfd_vma location;
10472   bfd_vma branch_offset;
10473   bfd_vma max_branch_offset;
10474   enum elf_ppc64_reloc_type r_type;
10475
10476   if (h != NULL)
10477     {
10478       struct plt_entry *ent;
10479       struct ppc_link_hash_entry *fdh = h;
10480       if (h->oh != NULL
10481           && h->oh->is_func_descriptor)
10482         {
10483           fdh = ppc_follow_link (h->oh);
10484           *hash = fdh;
10485         }
10486
10487       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10488         if (ent->addend == rel->r_addend
10489             && ent->plt.offset != (bfd_vma) -1)
10490           {
10491             *plt_ent = ent;
10492             return ppc_stub_plt_call;
10493           }
10494
10495       /* Here, we know we don't have a plt entry.  If we don't have a
10496          either a defined function descriptor or a defined entry symbol
10497          in a regular object file, then it is pointless trying to make
10498          any other type of stub.  */
10499       if (!is_static_defined (&fdh->elf)
10500           && !is_static_defined (&h->elf))
10501         return ppc_stub_none;
10502     }
10503   else if (elf_local_got_ents (input_sec->owner) != NULL)
10504     {
10505       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10506       struct plt_entry **local_plt = (struct plt_entry **)
10507         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10508       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10509
10510       if (local_plt[r_symndx] != NULL)
10511         {
10512           struct plt_entry *ent;
10513
10514           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10515             if (ent->addend == rel->r_addend
10516                 && ent->plt.offset != (bfd_vma) -1)
10517               {
10518                 *plt_ent = ent;
10519                 return ppc_stub_plt_call;
10520               }
10521         }
10522     }
10523
10524   /* Determine where the call point is.  */
10525   location = (input_sec->output_offset
10526               + input_sec->output_section->vma
10527               + rel->r_offset);
10528
10529   branch_offset = destination - location;
10530   r_type = ELF64_R_TYPE (rel->r_info);
10531
10532   /* Determine if a long branch stub is needed.  */
10533   max_branch_offset = 1 << 25;
10534   if (r_type != R_PPC64_REL24)
10535     max_branch_offset = 1 << 15;
10536
10537   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10538     /* We need a stub.  Figure out whether a long_branch or plt_branch
10539        is needed later.  */
10540     return ppc_stub_long_branch;
10541
10542   return ppc_stub_none;
10543 }
10544
10545 /* With power7 weakly ordered memory model, it is possible for ld.so
10546    to update a plt entry in one thread and have another thread see a
10547    stale zero toc entry.  To avoid this we need some sort of acquire
10548    barrier in the call stub.  One solution is to make the load of the
10549    toc word seem to appear to depend on the load of the function entry
10550    word.  Another solution is to test for r2 being zero, and branch to
10551    the appropriate glink entry if so.
10552
10553    .    fake dep barrier        compare
10554    .    ld 12,xxx(2)            ld 12,xxx(2)
10555    .    mtctr 12                mtctr 12
10556    .    xor 11,12,12            ld 2,xxx+8(2)
10557    .    add 2,2,11              cmpldi 2,0
10558    .    ld 2,xxx+8(2)           bnectr+
10559    .    bctr                    b <glink_entry>
10560
10561    The solution involving the compare turns out to be faster, so
10562    that's what we use unless the branch won't reach.  */
10563
10564 #define ALWAYS_USE_FAKE_DEP 0
10565 #define ALWAYS_EMIT_R2SAVE 0
10566
10567 #define PPC_LO(v) ((v) & 0xffff)
10568 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10569 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10570
10571 static inline unsigned int
10572 plt_stub_size (struct ppc_link_hash_table *htab,
10573                struct ppc_stub_hash_entry *stub_entry,
10574                bfd_vma off)
10575 {
10576   unsigned size = 12;
10577
10578   if (ALWAYS_EMIT_R2SAVE
10579       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10580     size += 4;
10581   if (PPC_HA (off) != 0)
10582     size += 4;
10583   if (htab->opd_abi)
10584     {
10585       size += 4;
10586       if (htab->params->plt_static_chain)
10587         size += 4;
10588       if (htab->params->plt_thread_safe
10589           && htab->elf.dynamic_sections_created
10590           && stub_entry->h != NULL
10591           && stub_entry->h->elf.dynindx != -1)
10592         size += 8;
10593       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10594         size += 4;
10595     }
10596   if (stub_entry->h != NULL
10597       && (stub_entry->h == htab->tls_get_addr_fd
10598           || stub_entry->h == htab->tls_get_addr)
10599       && htab->params->tls_get_addr_opt)
10600     {
10601       size += 7 * 4;
10602       if (ALWAYS_EMIT_R2SAVE
10603           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10604         size += 6 * 4;
10605     }
10606   return size;
10607 }
10608
10609 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10610    then return the padding needed to do so.  */
10611 static inline unsigned int
10612 plt_stub_pad (struct ppc_link_hash_table *htab,
10613               struct ppc_stub_hash_entry *stub_entry,
10614               bfd_vma plt_off)
10615 {
10616   int stub_align = 1 << htab->params->plt_stub_align;
10617   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10618   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10619
10620   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10621       > ((stub_size - 1) & -stub_align))
10622     return stub_align - (stub_off & (stub_align - 1));
10623   return 0;
10624 }
10625
10626 /* Build a .plt call stub.  */
10627
10628 static inline bfd_byte *
10629 build_plt_stub (struct ppc_link_hash_table *htab,
10630                 struct ppc_stub_hash_entry *stub_entry,
10631                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10632 {
10633   bfd *obfd = htab->params->stub_bfd;
10634   bfd_boolean plt_load_toc = htab->opd_abi;
10635   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10636   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10637                                  && htab->elf.dynamic_sections_created
10638                                  && stub_entry->h != NULL
10639                                  && stub_entry->h->elf.dynindx != -1);
10640   bfd_boolean use_fake_dep = plt_thread_safe;
10641   bfd_vma cmp_branch_off = 0;
10642
10643   if (!ALWAYS_USE_FAKE_DEP
10644       && plt_load_toc
10645       && plt_thread_safe
10646       && !((stub_entry->h == htab->tls_get_addr_fd
10647             || stub_entry->h == htab->tls_get_addr)
10648            && htab->params->tls_get_addr_opt))
10649     {
10650       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10651       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10652                           / PLT_ENTRY_SIZE (htab));
10653       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10654       bfd_vma to, from;
10655
10656       if (pltindex > 32768)
10657         glinkoff += (pltindex - 32768) * 4;
10658       to = (glinkoff
10659             + htab->glink->output_offset
10660             + htab->glink->output_section->vma);
10661       from = (p - stub_entry->group->stub_sec->contents
10662               + 4 * (ALWAYS_EMIT_R2SAVE
10663                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10664               + 4 * (PPC_HA (offset) != 0)
10665               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10666                      != PPC_HA (offset))
10667               + 4 * (plt_static_chain != 0)
10668               + 20
10669               + stub_entry->group->stub_sec->output_offset
10670               + stub_entry->group->stub_sec->output_section->vma);
10671       cmp_branch_off = to - from;
10672       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10673     }
10674
10675   if (PPC_HA (offset) != 0)
10676     {
10677       if (r != NULL)
10678         {
10679           if (ALWAYS_EMIT_R2SAVE
10680               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10681             r[0].r_offset += 4;
10682           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10683           r[1].r_offset = r[0].r_offset + 4;
10684           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10685           r[1].r_addend = r[0].r_addend;
10686           if (plt_load_toc)
10687             {
10688               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10689                 {
10690                   r[2].r_offset = r[1].r_offset + 4;
10691                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10692                   r[2].r_addend = r[0].r_addend;
10693                 }
10694               else
10695                 {
10696                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10697                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10698                   r[2].r_addend = r[0].r_addend + 8;
10699                   if (plt_static_chain)
10700                     {
10701                       r[3].r_offset = r[2].r_offset + 4;
10702                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10703                       r[3].r_addend = r[0].r_addend + 16;
10704                     }
10705                 }
10706             }
10707         }
10708       if (ALWAYS_EMIT_R2SAVE
10709           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10710         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10711       if (plt_load_toc)
10712         {
10713           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10714           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10715         }
10716       else
10717         {
10718           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10719           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10720         }
10721       if (plt_load_toc
10722           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10723         {
10724           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10725           offset = 0;
10726         }
10727       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10728       if (plt_load_toc)
10729         {
10730           if (use_fake_dep)
10731             {
10732               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10733               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10734             }
10735           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10736           if (plt_static_chain)
10737             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10738         }
10739     }
10740   else
10741     {
10742       if (r != NULL)
10743         {
10744           if (ALWAYS_EMIT_R2SAVE
10745               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10746             r[0].r_offset += 4;
10747           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10748           if (plt_load_toc)
10749             {
10750               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10751                 {
10752                   r[1].r_offset = r[0].r_offset + 4;
10753                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10754                   r[1].r_addend = r[0].r_addend;
10755                 }
10756               else
10757                 {
10758                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10759                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10760                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10761                   if (plt_static_chain)
10762                     {
10763                       r[2].r_offset = r[1].r_offset + 4;
10764                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10765                       r[2].r_addend = r[0].r_addend + 8;
10766                     }
10767                 }
10768             }
10769         }
10770       if (ALWAYS_EMIT_R2SAVE
10771           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10772         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10773       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10774       if (plt_load_toc
10775           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10776         {
10777           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10778           offset = 0;
10779         }
10780       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10781       if (plt_load_toc)
10782         {
10783           if (use_fake_dep)
10784             {
10785               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10786               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10787             }
10788           if (plt_static_chain)
10789             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10790           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10791         }
10792     }
10793   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10794     {
10795       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10796       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10797       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10798     }
10799   else
10800     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10801   return p;
10802 }
10803
10804 /* Build a special .plt call stub for __tls_get_addr.  */
10805
10806 #define LD_R11_0R3      0xe9630000
10807 #define LD_R12_0R3      0xe9830000
10808 #define MR_R0_R3        0x7c601b78
10809 #define CMPDI_R11_0     0x2c2b0000
10810 #define ADD_R3_R12_R13  0x7c6c6a14
10811 #define BEQLR           0x4d820020
10812 #define MR_R3_R0        0x7c030378
10813 #define STD_R11_0R1     0xf9610000
10814 #define BCTRL           0x4e800421
10815 #define LD_R11_0R1      0xe9610000
10816 #define MTLR_R11        0x7d6803a6
10817
10818 static inline bfd_byte *
10819 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10820                          struct ppc_stub_hash_entry *stub_entry,
10821                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10822 {
10823   bfd *obfd = htab->params->stub_bfd;
10824
10825   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10826   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10827   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10828   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10829   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10830   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10831   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10832   if (r != NULL)
10833     r[0].r_offset += 7 * 4;
10834   if (!ALWAYS_EMIT_R2SAVE
10835       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10836     return build_plt_stub (htab, stub_entry, p, offset, r);
10837
10838   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10839   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10840
10841   if (r != NULL)
10842     r[0].r_offset += 2 * 4;
10843   p = build_plt_stub (htab, stub_entry, p, offset, r);
10844   bfd_put_32 (obfd, BCTRL, p - 4);
10845
10846   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10847   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10848   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10849   bfd_put_32 (obfd, BLR, p),                    p += 4;
10850
10851   return p;
10852 }
10853
10854 static Elf_Internal_Rela *
10855 get_relocs (asection *sec, int count)
10856 {
10857   Elf_Internal_Rela *relocs;
10858   struct bfd_elf_section_data *elfsec_data;
10859
10860   elfsec_data = elf_section_data (sec);
10861   relocs = elfsec_data->relocs;
10862   if (relocs == NULL)
10863     {
10864       bfd_size_type relsize;
10865       relsize = sec->reloc_count * sizeof (*relocs);
10866       relocs = bfd_alloc (sec->owner, relsize);
10867       if (relocs == NULL)
10868         return NULL;
10869       elfsec_data->relocs = relocs;
10870       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10871                                           sizeof (Elf_Internal_Shdr));
10872       if (elfsec_data->rela.hdr == NULL)
10873         return NULL;
10874       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10875                                         * sizeof (Elf64_External_Rela));
10876       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10877       sec->reloc_count = 0;
10878     }
10879   relocs += sec->reloc_count;
10880   sec->reloc_count += count;
10881   return relocs;
10882 }
10883
10884 static bfd_vma
10885 get_r2off (struct bfd_link_info *info,
10886            struct ppc_stub_hash_entry *stub_entry)
10887 {
10888   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10889   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10890
10891   if (r2off == 0)
10892     {
10893       /* Support linking -R objects.  Get the toc pointer from the
10894          opd entry.  */
10895       char buf[8];
10896       if (!htab->opd_abi)
10897         return r2off;
10898       asection *opd = stub_entry->h->elf.root.u.def.section;
10899       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10900
10901       if (strcmp (opd->name, ".opd") != 0
10902           || opd->reloc_count != 0)
10903         {
10904           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10905                                   stub_entry->h->elf.root.root.string);
10906           bfd_set_error (bfd_error_bad_value);
10907           return (bfd_vma) -1;
10908         }
10909       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10910         return (bfd_vma) -1;
10911       r2off = bfd_get_64 (opd->owner, buf);
10912       r2off -= elf_gp (info->output_bfd);
10913     }
10914   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10915   return r2off;
10916 }
10917
10918 static bfd_boolean
10919 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10920 {
10921   struct ppc_stub_hash_entry *stub_entry;
10922   struct ppc_branch_hash_entry *br_entry;
10923   struct bfd_link_info *info;
10924   struct ppc_link_hash_table *htab;
10925   bfd_byte *loc;
10926   bfd_byte *p;
10927   bfd_vma dest, off;
10928   int size;
10929   Elf_Internal_Rela *r;
10930   asection *plt;
10931
10932   /* Massage our args to the form they really have.  */
10933   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10934   info = in_arg;
10935
10936   htab = ppc_hash_table (info);
10937   if (htab == NULL)
10938     return FALSE;
10939
10940   /* Make a note of the offset within the stubs for this entry.  */
10941   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10942   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10943
10944   htab->stub_count[stub_entry->stub_type - 1] += 1;
10945   switch (stub_entry->stub_type)
10946     {
10947     case ppc_stub_long_branch:
10948     case ppc_stub_long_branch_r2off:
10949       /* Branches are relative.  This is where we are going to.  */
10950       dest = (stub_entry->target_value
10951               + stub_entry->target_section->output_offset
10952               + stub_entry->target_section->output_section->vma);
10953       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10954       off = dest;
10955
10956       /* And this is where we are coming from.  */
10957       off -= (stub_entry->stub_offset
10958               + stub_entry->group->stub_sec->output_offset
10959               + stub_entry->group->stub_sec->output_section->vma);
10960
10961       size = 4;
10962       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10963         {
10964           bfd_vma r2off = get_r2off (info, stub_entry);
10965
10966           if (r2off == (bfd_vma) -1)
10967             {
10968               htab->stub_error = TRUE;
10969               return FALSE;
10970             }
10971           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10972           loc += 4;
10973           size = 8;
10974           if (PPC_HA (r2off) != 0)
10975             {
10976               bfd_put_32 (htab->params->stub_bfd,
10977                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10978               loc += 4;
10979               size += 4;
10980             }
10981           if (PPC_LO (r2off) != 0)
10982             {
10983               bfd_put_32 (htab->params->stub_bfd,
10984                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10985               loc += 4;
10986               size += 4;
10987             }
10988           off -= size - 4;
10989         }
10990       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10991
10992       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10993         {
10994           info->callbacks->einfo
10995             (_("%P: long branch stub `%s' offset overflow\n"),
10996              stub_entry->root.string);
10997           htab->stub_error = TRUE;
10998           return FALSE;
10999         }
11000
11001       if (info->emitrelocations)
11002         {
11003           r = get_relocs (stub_entry->group->stub_sec, 1);
11004           if (r == NULL)
11005             return FALSE;
11006           r->r_offset = loc - stub_entry->group->stub_sec->contents;
11007           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11008           r->r_addend = dest;
11009           if (stub_entry->h != NULL)
11010             {
11011               struct elf_link_hash_entry **hashes;
11012               unsigned long symndx;
11013               struct ppc_link_hash_entry *h;
11014
11015               hashes = elf_sym_hashes (htab->params->stub_bfd);
11016               if (hashes == NULL)
11017                 {
11018                   bfd_size_type hsize;
11019
11020                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11021                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11022                   if (hashes == NULL)
11023                     return FALSE;
11024                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11025                   htab->stub_globals = 1;
11026                 }
11027               symndx = htab->stub_globals++;
11028               h = stub_entry->h;
11029               hashes[symndx] = &h->elf;
11030               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11031               if (h->oh != NULL && h->oh->is_func)
11032                 h = ppc_follow_link (h->oh);
11033               if (h->elf.root.u.def.section != stub_entry->target_section)
11034                 /* H is an opd symbol.  The addend must be zero.  */
11035                 r->r_addend = 0;
11036               else
11037                 {
11038                   off = (h->elf.root.u.def.value
11039                          + h->elf.root.u.def.section->output_offset
11040                          + h->elf.root.u.def.section->output_section->vma);
11041                   r->r_addend -= off;
11042                 }
11043             }
11044         }
11045       break;
11046
11047     case ppc_stub_plt_branch:
11048     case ppc_stub_plt_branch_r2off:
11049       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11050                                          stub_entry->root.string + 9,
11051                                          FALSE, FALSE);
11052       if (br_entry == NULL)
11053         {
11054           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
11055                                   stub_entry->root.string);
11056           htab->stub_error = TRUE;
11057           return FALSE;
11058         }
11059
11060       dest = (stub_entry->target_value
11061               + stub_entry->target_section->output_offset
11062               + stub_entry->target_section->output_section->vma);
11063       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11064         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11065
11066       bfd_put_64 (htab->brlt->owner, dest,
11067                   htab->brlt->contents + br_entry->offset);
11068
11069       if (br_entry->iter == htab->stub_iteration)
11070         {
11071           br_entry->iter = 0;
11072
11073           if (htab->relbrlt != NULL)
11074             {
11075               /* Create a reloc for the branch lookup table entry.  */
11076               Elf_Internal_Rela rela;
11077               bfd_byte *rl;
11078
11079               rela.r_offset = (br_entry->offset
11080                                + htab->brlt->output_offset
11081                                + htab->brlt->output_section->vma);
11082               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11083               rela.r_addend = dest;
11084
11085               rl = htab->relbrlt->contents;
11086               rl += (htab->relbrlt->reloc_count++
11087                      * sizeof (Elf64_External_Rela));
11088               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11089             }
11090           else if (info->emitrelocations)
11091             {
11092               r = get_relocs (htab->brlt, 1);
11093               if (r == NULL)
11094                 return FALSE;
11095               /* brlt, being SEC_LINKER_CREATED does not go through the
11096                  normal reloc processing.  Symbols and offsets are not
11097                  translated from input file to output file form, so
11098                  set up the offset per the output file.  */
11099               r->r_offset = (br_entry->offset
11100                              + htab->brlt->output_offset
11101                              + htab->brlt->output_section->vma);
11102               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11103               r->r_addend = dest;
11104             }
11105         }
11106
11107       dest = (br_entry->offset
11108               + htab->brlt->output_offset
11109               + htab->brlt->output_section->vma);
11110
11111       off = (dest
11112              - elf_gp (htab->brlt->output_section->owner)
11113              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11114
11115       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11116         {
11117           info->callbacks->einfo
11118             (_("%P: linkage table error against `%T'\n"),
11119              stub_entry->root.string);
11120           bfd_set_error (bfd_error_bad_value);
11121           htab->stub_error = TRUE;
11122           return FALSE;
11123         }
11124
11125       if (info->emitrelocations)
11126         {
11127           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11128           if (r == NULL)
11129             return FALSE;
11130           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11131           if (bfd_big_endian (info->output_bfd))
11132             r[0].r_offset += 2;
11133           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11134             r[0].r_offset += 4;
11135           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11136           r[0].r_addend = dest;
11137           if (PPC_HA (off) != 0)
11138             {
11139               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11140               r[1].r_offset = r[0].r_offset + 4;
11141               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11142               r[1].r_addend = r[0].r_addend;
11143             }
11144         }
11145
11146       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11147         {
11148           if (PPC_HA (off) != 0)
11149             {
11150               size = 16;
11151               bfd_put_32 (htab->params->stub_bfd,
11152                           ADDIS_R12_R2 | PPC_HA (off), loc);
11153               loc += 4;
11154               bfd_put_32 (htab->params->stub_bfd,
11155                           LD_R12_0R12 | PPC_LO (off), loc);
11156             }
11157           else
11158             {
11159               size = 12;
11160               bfd_put_32 (htab->params->stub_bfd,
11161                           LD_R12_0R2 | PPC_LO (off), loc);
11162             }
11163         }
11164       else
11165         {
11166           bfd_vma r2off = get_r2off (info, stub_entry);
11167
11168           if (r2off == (bfd_vma) -1)
11169             {
11170               htab->stub_error = TRUE;
11171               return FALSE;
11172             }
11173
11174           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11175           loc += 4;
11176           size = 16;
11177           if (PPC_HA (off) != 0)
11178             {
11179               size += 4;
11180               bfd_put_32 (htab->params->stub_bfd,
11181                           ADDIS_R12_R2 | PPC_HA (off), loc);
11182               loc += 4;
11183               bfd_put_32 (htab->params->stub_bfd,
11184                           LD_R12_0R12 | PPC_LO (off), loc);
11185             }
11186           else
11187             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11188
11189           if (PPC_HA (r2off) != 0)
11190             {
11191               size += 4;
11192               loc += 4;
11193               bfd_put_32 (htab->params->stub_bfd,
11194                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11195             }
11196           if (PPC_LO (r2off) != 0)
11197             {
11198               size += 4;
11199               loc += 4;
11200               bfd_put_32 (htab->params->stub_bfd,
11201                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11202             }
11203         }
11204       loc += 4;
11205       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11206       loc += 4;
11207       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11208       break;
11209
11210     case ppc_stub_plt_call:
11211     case ppc_stub_plt_call_r2save:
11212       if (stub_entry->h != NULL
11213           && stub_entry->h->is_func_descriptor
11214           && stub_entry->h->oh != NULL)
11215         {
11216           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11217
11218           /* If the old-ABI "dot-symbol" is undefined make it weak so
11219              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11220           if (fh->elf.root.type == bfd_link_hash_undefined
11221               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11222                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11223             fh->elf.root.type = bfd_link_hash_undefweak;
11224         }
11225
11226       /* Now build the stub.  */
11227       dest = stub_entry->plt_ent->plt.offset & ~1;
11228       if (dest >= (bfd_vma) -2)
11229         abort ();
11230
11231       plt = htab->elf.splt;
11232       if (!htab->elf.dynamic_sections_created
11233           || stub_entry->h == NULL
11234           || stub_entry->h->elf.dynindx == -1)
11235         plt = htab->elf.iplt;
11236
11237       dest += plt->output_offset + plt->output_section->vma;
11238
11239       if (stub_entry->h == NULL
11240           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11241         {
11242           Elf_Internal_Rela rela;
11243           bfd_byte *rl;
11244
11245           rela.r_offset = dest;
11246           if (htab->opd_abi)
11247             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11248           else
11249             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11250           rela.r_addend = (stub_entry->target_value
11251                            + stub_entry->target_section->output_offset
11252                            + stub_entry->target_section->output_section->vma);
11253
11254           rl = (htab->elf.irelplt->contents
11255                 + (htab->elf.irelplt->reloc_count++
11256                    * sizeof (Elf64_External_Rela)));
11257           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11258           stub_entry->plt_ent->plt.offset |= 1;
11259           htab->local_ifunc_resolver = 1;
11260         }
11261
11262       off = (dest
11263              - elf_gp (plt->output_section->owner)
11264              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11265
11266       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11267         {
11268           info->callbacks->einfo
11269             /* xgettext:c-format */
11270             (_("%P: linkage table error against `%T'\n"),
11271              stub_entry->h != NULL
11272              ? stub_entry->h->elf.root.root.string
11273              : "<local sym>");
11274           bfd_set_error (bfd_error_bad_value);
11275           htab->stub_error = TRUE;
11276           return FALSE;
11277         }
11278
11279       if (htab->params->plt_stub_align != 0)
11280         {
11281           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11282
11283           stub_entry->group->stub_sec->size += pad;
11284           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11285           loc += pad;
11286         }
11287
11288       r = NULL;
11289       if (info->emitrelocations)
11290         {
11291           r = get_relocs (stub_entry->group->stub_sec,
11292                           ((PPC_HA (off) != 0)
11293                            + (htab->opd_abi
11294                               ? 2 + (htab->params->plt_static_chain
11295                                      && PPC_HA (off + 16) == PPC_HA (off))
11296                               : 1)));
11297           if (r == NULL)
11298             return FALSE;
11299           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11300           if (bfd_big_endian (info->output_bfd))
11301             r[0].r_offset += 2;
11302           r[0].r_addend = dest;
11303         }
11304       if (stub_entry->h != NULL
11305           && (stub_entry->h == htab->tls_get_addr_fd
11306               || stub_entry->h == htab->tls_get_addr)
11307           && htab->params->tls_get_addr_opt)
11308         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11309       else
11310         p = build_plt_stub (htab, stub_entry, loc, off, r);
11311       size = p - loc;
11312       break;
11313
11314     case ppc_stub_save_res:
11315       return TRUE;
11316
11317     default:
11318       BFD_FAIL ();
11319       return FALSE;
11320     }
11321
11322   stub_entry->group->stub_sec->size += size;
11323
11324   if (htab->params->emit_stub_syms)
11325     {
11326       struct elf_link_hash_entry *h;
11327       size_t len1, len2;
11328       char *name;
11329       const char *const stub_str[] = { "long_branch",
11330                                        "long_branch_r2off",
11331                                        "plt_branch",
11332                                        "plt_branch_r2off",
11333                                        "plt_call",
11334                                        "plt_call" };
11335
11336       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11337       len2 = strlen (stub_entry->root.string);
11338       name = bfd_malloc (len1 + len2 + 2);
11339       if (name == NULL)
11340         return FALSE;
11341       memcpy (name, stub_entry->root.string, 9);
11342       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11343       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11344       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11345       if (h == NULL)
11346         return FALSE;
11347       if (h->root.type == bfd_link_hash_new)
11348         {
11349           h->root.type = bfd_link_hash_defined;
11350           h->root.u.def.section = stub_entry->group->stub_sec;
11351           h->root.u.def.value = stub_entry->stub_offset;
11352           h->ref_regular = 1;
11353           h->def_regular = 1;
11354           h->ref_regular_nonweak = 1;
11355           h->forced_local = 1;
11356           h->non_elf = 0;
11357           h->root.linker_def = 1;
11358         }
11359     }
11360
11361   return TRUE;
11362 }
11363
11364 /* As above, but don't actually build the stub.  Just bump offset so
11365    we know stub section sizes, and select plt_branch stubs where
11366    long_branch stubs won't do.  */
11367
11368 static bfd_boolean
11369 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11370 {
11371   struct ppc_stub_hash_entry *stub_entry;
11372   struct bfd_link_info *info;
11373   struct ppc_link_hash_table *htab;
11374   bfd_vma off;
11375   int size;
11376
11377   /* Massage our args to the form they really have.  */
11378   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11379   info = in_arg;
11380
11381   htab = ppc_hash_table (info);
11382   if (htab == NULL)
11383     return FALSE;
11384
11385   if (stub_entry->h != NULL
11386       && stub_entry->h->save_res
11387       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11388       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11389     {
11390       /* Don't make stubs to out-of-line register save/restore
11391          functions.  Instead, emit copies of the functions.  */
11392       stub_entry->group->needs_save_res = 1;
11393       stub_entry->stub_type = ppc_stub_save_res;
11394       return TRUE;
11395     }
11396
11397   if (stub_entry->stub_type == ppc_stub_plt_call
11398       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11399     {
11400       asection *plt;
11401       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11402       if (off >= (bfd_vma) -2)
11403         abort ();
11404       plt = htab->elf.splt;
11405       if (!htab->elf.dynamic_sections_created
11406           || stub_entry->h == NULL
11407           || stub_entry->h->elf.dynindx == -1)
11408         plt = htab->elf.iplt;
11409       off += (plt->output_offset
11410               + plt->output_section->vma
11411               - elf_gp (plt->output_section->owner)
11412               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11413
11414       size = plt_stub_size (htab, stub_entry, off);
11415       if (stub_entry->h != NULL
11416           && (stub_entry->h == htab->tls_get_addr_fd
11417               || stub_entry->h == htab->tls_get_addr)
11418           && htab->params->tls_get_addr_opt
11419           && (ALWAYS_EMIT_R2SAVE
11420               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11421         stub_entry->group->tls_get_addr_opt_bctrl
11422           = stub_entry->group->stub_sec->size + size - 5 * 4;
11423
11424       if (htab->params->plt_stub_align)
11425         size += plt_stub_pad (htab, stub_entry, off);
11426       if (info->emitrelocations)
11427         {
11428           stub_entry->group->stub_sec->reloc_count
11429             += ((PPC_HA (off) != 0)
11430                 + (htab->opd_abi
11431                    ? 2 + (htab->params->plt_static_chain
11432                           && PPC_HA (off + 16) == PPC_HA (off))
11433                    : 1));
11434           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11435         }
11436     }
11437   else
11438     {
11439       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11440          variants.  */
11441       bfd_vma r2off = 0;
11442       bfd_vma local_off = 0;
11443
11444       off = (stub_entry->target_value
11445              + stub_entry->target_section->output_offset
11446              + stub_entry->target_section->output_section->vma);
11447       off -= (stub_entry->group->stub_sec->size
11448               + stub_entry->group->stub_sec->output_offset
11449               + stub_entry->group->stub_sec->output_section->vma);
11450
11451       /* Reset the stub type from the plt variant in case we now
11452          can reach with a shorter stub.  */
11453       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11454         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11455
11456       size = 4;
11457       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11458         {
11459           r2off = get_r2off (info, stub_entry);
11460           if (r2off == (bfd_vma) -1)
11461             {
11462               htab->stub_error = TRUE;
11463               return FALSE;
11464             }
11465           size = 8;
11466           if (PPC_HA (r2off) != 0)
11467             size += 4;
11468           if (PPC_LO (r2off) != 0)
11469             size += 4;
11470           off -= size - 4;
11471         }
11472
11473       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11474
11475       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11476          Do the same for -R objects without function descriptors.  */
11477       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11478           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11479               && r2off == 0
11480               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11481         {
11482           struct ppc_branch_hash_entry *br_entry;
11483
11484           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11485                                              stub_entry->root.string + 9,
11486                                              TRUE, FALSE);
11487           if (br_entry == NULL)
11488             {
11489               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11490                                       stub_entry->root.string);
11491               htab->stub_error = TRUE;
11492               return FALSE;
11493             }
11494
11495           if (br_entry->iter != htab->stub_iteration)
11496             {
11497               br_entry->iter = htab->stub_iteration;
11498               br_entry->offset = htab->brlt->size;
11499               htab->brlt->size += 8;
11500
11501               if (htab->relbrlt != NULL)
11502                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11503               else if (info->emitrelocations)
11504                 {
11505                   htab->brlt->reloc_count += 1;
11506                   htab->brlt->flags |= SEC_RELOC;
11507                 }
11508             }
11509
11510           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11511           off = (br_entry->offset
11512                  + htab->brlt->output_offset
11513                  + htab->brlt->output_section->vma
11514                  - elf_gp (htab->brlt->output_section->owner)
11515                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11516
11517           if (info->emitrelocations)
11518             {
11519               stub_entry->group->stub_sec->reloc_count
11520                 += 1 + (PPC_HA (off) != 0);
11521               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11522             }
11523
11524           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11525             {
11526               size = 12;
11527               if (PPC_HA (off) != 0)
11528                 size = 16;
11529             }
11530           else
11531             {
11532               size = 16;
11533               if (PPC_HA (off) != 0)
11534                 size += 4;
11535
11536               if (PPC_HA (r2off) != 0)
11537                 size += 4;
11538               if (PPC_LO (r2off) != 0)
11539                 size += 4;
11540             }
11541         }
11542       else if (info->emitrelocations)
11543         {
11544           stub_entry->group->stub_sec->reloc_count += 1;
11545           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11546         }
11547     }
11548
11549   stub_entry->group->stub_sec->size += size;
11550   return TRUE;
11551 }
11552
11553 /* Set up various things so that we can make a list of input sections
11554    for each output section included in the link.  Returns -1 on error,
11555    0 when no stubs will be needed, and 1 on success.  */
11556
11557 int
11558 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11559 {
11560   unsigned int id;
11561   bfd_size_type amt;
11562   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11563
11564   if (htab == NULL)
11565     return -1;
11566
11567   htab->sec_info_arr_size = bfd_get_next_section_id ();
11568   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11569   htab->sec_info = bfd_zmalloc (amt);
11570   if (htab->sec_info == NULL)
11571     return -1;
11572
11573   /* Set toc_off for com, und, abs and ind sections.  */
11574   for (id = 0; id < 3; id++)
11575     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11576
11577   return 1;
11578 }
11579
11580 /* Set up for first pass at multitoc partitioning.  */
11581
11582 void
11583 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11584 {
11585   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11586
11587   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11588   htab->toc_bfd = NULL;
11589   htab->toc_first_sec = NULL;
11590 }
11591
11592 /* The linker repeatedly calls this function for each TOC input section
11593    and linker generated GOT section.  Group input bfds such that the toc
11594    within a group is less than 64k in size.  */
11595
11596 bfd_boolean
11597 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11598 {
11599   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11600   bfd_vma addr, off, limit;
11601
11602   if (htab == NULL)
11603     return FALSE;
11604
11605   if (!htab->second_toc_pass)
11606     {
11607       /* Keep track of the first .toc or .got section for this input bfd.  */
11608       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11609
11610       if (new_bfd)
11611         {
11612           htab->toc_bfd = isec->owner;
11613           htab->toc_first_sec = isec;
11614         }
11615
11616       addr = isec->output_offset + isec->output_section->vma;
11617       off = addr - htab->toc_curr;
11618       limit = 0x80008000;
11619       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11620         limit = 0x10000;
11621       if (off + isec->size > limit)
11622         {
11623           addr = (htab->toc_first_sec->output_offset
11624                   + htab->toc_first_sec->output_section->vma);
11625           htab->toc_curr = addr;
11626           htab->toc_curr &= -TOC_BASE_ALIGN;
11627         }
11628
11629       /* toc_curr is the base address of this toc group.  Set elf_gp
11630          for the input section to be the offset relative to the
11631          output toc base plus 0x8000.  Making the input elf_gp an
11632          offset allows us to move the toc as a whole without
11633          recalculating input elf_gp.  */
11634       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11635       off += TOC_BASE_OFF;
11636
11637       /* Die if someone uses a linker script that doesn't keep input
11638          file .toc and .got together.  */
11639       if (new_bfd
11640           && elf_gp (isec->owner) != 0
11641           && elf_gp (isec->owner) != off)
11642         return FALSE;
11643
11644       elf_gp (isec->owner) = off;
11645       return TRUE;
11646     }
11647
11648   /* During the second pass toc_first_sec points to the start of
11649      a toc group, and toc_curr is used to track the old elf_gp.
11650      We use toc_bfd to ensure we only look at each bfd once.  */
11651   if (htab->toc_bfd == isec->owner)
11652     return TRUE;
11653   htab->toc_bfd = isec->owner;
11654
11655   if (htab->toc_first_sec == NULL
11656       || htab->toc_curr != elf_gp (isec->owner))
11657     {
11658       htab->toc_curr = elf_gp (isec->owner);
11659       htab->toc_first_sec = isec;
11660     }
11661   addr = (htab->toc_first_sec->output_offset
11662           + htab->toc_first_sec->output_section->vma);
11663   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11664   elf_gp (isec->owner) = off;
11665
11666   return TRUE;
11667 }
11668
11669 /* Called via elf_link_hash_traverse to merge GOT entries for global
11670    symbol H.  */
11671
11672 static bfd_boolean
11673 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11674 {
11675   if (h->root.type == bfd_link_hash_indirect)
11676     return TRUE;
11677
11678   merge_got_entries (&h->got.glist);
11679
11680   return TRUE;
11681 }
11682
11683 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11684    symbol H.  */
11685
11686 static bfd_boolean
11687 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11688 {
11689   struct got_entry *gent;
11690
11691   if (h->root.type == bfd_link_hash_indirect)
11692     return TRUE;
11693
11694   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11695     if (!gent->is_indirect)
11696       allocate_got (h, (struct bfd_link_info *) inf, gent);
11697   return TRUE;
11698 }
11699
11700 /* Called on the first multitoc pass after the last call to
11701    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11702    entries.  */
11703
11704 bfd_boolean
11705 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11706 {
11707   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11708   struct bfd *ibfd, *ibfd2;
11709   bfd_boolean done_something;
11710
11711   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11712
11713   if (!htab->do_multi_toc)
11714     return FALSE;
11715
11716   /* Merge global sym got entries within a toc group.  */
11717   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11718
11719   /* And tlsld_got.  */
11720   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11721     {
11722       struct got_entry *ent, *ent2;
11723
11724       if (!is_ppc64_elf (ibfd))
11725         continue;
11726
11727       ent = ppc64_tlsld_got (ibfd);
11728       if (!ent->is_indirect
11729           && ent->got.offset != (bfd_vma) -1)
11730         {
11731           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11732             {
11733               if (!is_ppc64_elf (ibfd2))
11734                 continue;
11735
11736               ent2 = ppc64_tlsld_got (ibfd2);
11737               if (!ent2->is_indirect
11738                   && ent2->got.offset != (bfd_vma) -1
11739                   && elf_gp (ibfd2) == elf_gp (ibfd))
11740                 {
11741                   ent2->is_indirect = TRUE;
11742                   ent2->got.ent = ent;
11743                 }
11744             }
11745         }
11746     }
11747
11748   /* Zap sizes of got sections.  */
11749   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11750   htab->elf.irelplt->size -= htab->got_reli_size;
11751   htab->got_reli_size = 0;
11752
11753   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11754     {
11755       asection *got, *relgot;
11756
11757       if (!is_ppc64_elf (ibfd))
11758         continue;
11759
11760       got = ppc64_elf_tdata (ibfd)->got;
11761       if (got != NULL)
11762         {
11763           got->rawsize = got->size;
11764           got->size = 0;
11765           relgot = ppc64_elf_tdata (ibfd)->relgot;
11766           relgot->rawsize = relgot->size;
11767           relgot->size = 0;
11768         }
11769     }
11770
11771   /* Now reallocate the got, local syms first.  We don't need to
11772      allocate section contents again since we never increase size.  */
11773   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11774     {
11775       struct got_entry **lgot_ents;
11776       struct got_entry **end_lgot_ents;
11777       struct plt_entry **local_plt;
11778       struct plt_entry **end_local_plt;
11779       unsigned char *lgot_masks;
11780       bfd_size_type locsymcount;
11781       Elf_Internal_Shdr *symtab_hdr;
11782       asection *s;
11783
11784       if (!is_ppc64_elf (ibfd))
11785         continue;
11786
11787       lgot_ents = elf_local_got_ents (ibfd);
11788       if (!lgot_ents)
11789         continue;
11790
11791       symtab_hdr = &elf_symtab_hdr (ibfd);
11792       locsymcount = symtab_hdr->sh_info;
11793       end_lgot_ents = lgot_ents + locsymcount;
11794       local_plt = (struct plt_entry **) end_lgot_ents;
11795       end_local_plt = local_plt + locsymcount;
11796       lgot_masks = (unsigned char *) end_local_plt;
11797       s = ppc64_elf_tdata (ibfd)->got;
11798       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11799         {
11800           struct got_entry *ent;
11801
11802           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11803             {
11804               unsigned int ent_size = 8;
11805               unsigned int rel_size = sizeof (Elf64_External_Rela);
11806
11807               ent->got.offset = s->size;
11808               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11809                 {
11810                   ent_size *= 2;
11811                   rel_size *= 2;
11812                 }
11813               s->size += ent_size;
11814               if ((*lgot_masks & PLT_IFUNC) != 0)
11815                 {
11816                   htab->elf.irelplt->size += rel_size;
11817                   htab->got_reli_size += rel_size;
11818                 }
11819               else if (bfd_link_pic (info))
11820                 {
11821                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11822                   srel->size += rel_size;
11823                 }
11824             }
11825         }
11826     }
11827
11828   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11829
11830   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11831     {
11832       struct got_entry *ent;
11833
11834       if (!is_ppc64_elf (ibfd))
11835         continue;
11836
11837       ent = ppc64_tlsld_got (ibfd);
11838       if (!ent->is_indirect
11839           && ent->got.offset != (bfd_vma) -1)
11840         {
11841           asection *s = ppc64_elf_tdata (ibfd)->got;
11842           ent->got.offset = s->size;
11843           s->size += 16;
11844           if (bfd_link_pic (info))
11845             {
11846               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11847               srel->size += sizeof (Elf64_External_Rela);
11848             }
11849         }
11850     }
11851
11852   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11853   if (!done_something)
11854     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11855       {
11856         asection *got;
11857
11858         if (!is_ppc64_elf (ibfd))
11859           continue;
11860
11861         got = ppc64_elf_tdata (ibfd)->got;
11862         if (got != NULL)
11863           {
11864             done_something = got->rawsize != got->size;
11865             if (done_something)
11866               break;
11867           }
11868       }
11869
11870   if (done_something)
11871     (*htab->params->layout_sections_again) ();
11872
11873   /* Set up for second pass over toc sections to recalculate elf_gp
11874      on input sections.  */
11875   htab->toc_bfd = NULL;
11876   htab->toc_first_sec = NULL;
11877   htab->second_toc_pass = TRUE;
11878   return done_something;
11879 }
11880
11881 /* Called after second pass of multitoc partitioning.  */
11882
11883 void
11884 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11885 {
11886   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11887
11888   /* After the second pass, toc_curr tracks the TOC offset used
11889      for code sections below in ppc64_elf_next_input_section.  */
11890   htab->toc_curr = TOC_BASE_OFF;
11891 }
11892
11893 /* No toc references were found in ISEC.  If the code in ISEC makes no
11894    calls, then there's no need to use toc adjusting stubs when branching
11895    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11896    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11897    needed, and 2 if a cyclical call-graph was found but no other reason
11898    for a stub was detected.  If called from the top level, a return of
11899    2 means the same as a return of 0.  */
11900
11901 static int
11902 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11903 {
11904   int ret;
11905
11906   /* Mark this section as checked.  */
11907   isec->call_check_done = 1;
11908
11909   /* We know none of our code bearing sections will need toc stubs.  */
11910   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11911     return 0;
11912
11913   if (isec->size == 0)
11914     return 0;
11915
11916   if (isec->output_section == NULL)
11917     return 0;
11918
11919   ret = 0;
11920   if (isec->reloc_count != 0)
11921     {
11922       Elf_Internal_Rela *relstart, *rel;
11923       Elf_Internal_Sym *local_syms;
11924       struct ppc_link_hash_table *htab;
11925
11926       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11927                                             info->keep_memory);
11928       if (relstart == NULL)
11929         return -1;
11930
11931       /* Look for branches to outside of this section.  */
11932       local_syms = NULL;
11933       htab = ppc_hash_table (info);
11934       if (htab == NULL)
11935         return -1;
11936
11937       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11938         {
11939           enum elf_ppc64_reloc_type r_type;
11940           unsigned long r_symndx;
11941           struct elf_link_hash_entry *h;
11942           struct ppc_link_hash_entry *eh;
11943           Elf_Internal_Sym *sym;
11944           asection *sym_sec;
11945           struct _opd_sec_data *opd;
11946           bfd_vma sym_value;
11947           bfd_vma dest;
11948
11949           r_type = ELF64_R_TYPE (rel->r_info);
11950           if (r_type != R_PPC64_REL24
11951               && r_type != R_PPC64_REL14
11952               && r_type != R_PPC64_REL14_BRTAKEN
11953               && r_type != R_PPC64_REL14_BRNTAKEN)
11954             continue;
11955
11956           r_symndx = ELF64_R_SYM (rel->r_info);
11957           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11958                           isec->owner))
11959             {
11960               ret = -1;
11961               break;
11962             }
11963
11964           /* Calls to dynamic lib functions go through a plt call stub
11965              that uses r2.  */
11966           eh = (struct ppc_link_hash_entry *) h;
11967           if (eh != NULL
11968               && (eh->elf.plt.plist != NULL
11969                   || (eh->oh != NULL
11970                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11971             {
11972               ret = 1;
11973               break;
11974             }
11975
11976           if (sym_sec == NULL)
11977             /* Ignore other undefined symbols.  */
11978             continue;
11979
11980           /* Assume branches to other sections not included in the
11981              link need stubs too, to cover -R and absolute syms.  */
11982           if (sym_sec->output_section == NULL)
11983             {
11984               ret = 1;
11985               break;
11986             }
11987
11988           if (h == NULL)
11989             sym_value = sym->st_value;
11990           else
11991             {
11992               if (h->root.type != bfd_link_hash_defined
11993                   && h->root.type != bfd_link_hash_defweak)
11994                 abort ();
11995               sym_value = h->root.u.def.value;
11996             }
11997           sym_value += rel->r_addend;
11998
11999           /* If this branch reloc uses an opd sym, find the code section.  */
12000           opd = get_opd_info (sym_sec);
12001           if (opd != NULL)
12002             {
12003               if (h == NULL && opd->adjust != NULL)
12004                 {
12005                   long adjust;
12006
12007                   adjust = opd->adjust[OPD_NDX (sym_value)];
12008                   if (adjust == -1)
12009                     /* Assume deleted functions won't ever be called.  */
12010                     continue;
12011                   sym_value += adjust;
12012                 }
12013
12014               dest = opd_entry_value (sym_sec, sym_value,
12015                                       &sym_sec, NULL, FALSE);
12016               if (dest == (bfd_vma) -1)
12017                 continue;
12018             }
12019           else
12020             dest = (sym_value
12021                     + sym_sec->output_offset
12022                     + sym_sec->output_section->vma);
12023
12024           /* Ignore branch to self.  */
12025           if (sym_sec == isec)
12026             continue;
12027
12028           /* If the called function uses the toc, we need a stub.  */
12029           if (sym_sec->has_toc_reloc
12030               || sym_sec->makes_toc_func_call)
12031             {
12032               ret = 1;
12033               break;
12034             }
12035
12036           /* Assume any branch that needs a long branch stub might in fact
12037              need a plt_branch stub.  A plt_branch stub uses r2.  */
12038           else if (dest - (isec->output_offset
12039                            + isec->output_section->vma
12040                            + rel->r_offset) + (1 << 25)
12041                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12042                                                              ? h->other
12043                                                              : sym->st_other))
12044             {
12045               ret = 1;
12046               break;
12047             }
12048
12049           /* If calling back to a section in the process of being
12050              tested, we can't say for sure that no toc adjusting stubs
12051              are needed, so don't return zero.  */
12052           else if (sym_sec->call_check_in_progress)
12053             ret = 2;
12054
12055           /* Branches to another section that itself doesn't have any TOC
12056              references are OK.  Recursively call ourselves to check.  */
12057           else if (!sym_sec->call_check_done)
12058             {
12059               int recur;
12060
12061               /* Mark current section as indeterminate, so that other
12062                  sections that call back to current won't be marked as
12063                  known.  */
12064               isec->call_check_in_progress = 1;
12065               recur = toc_adjusting_stub_needed (info, sym_sec);
12066               isec->call_check_in_progress = 0;
12067
12068               if (recur != 0)
12069                 {
12070                   ret = recur;
12071                   if (recur != 2)
12072                     break;
12073                 }
12074             }
12075         }
12076
12077       if (local_syms != NULL
12078           && (elf_symtab_hdr (isec->owner).contents
12079               != (unsigned char *) local_syms))
12080         free (local_syms);
12081       if (elf_section_data (isec)->relocs != relstart)
12082         free (relstart);
12083     }
12084
12085   if ((ret & 1) == 0
12086       && isec->map_head.s != NULL
12087       && (strcmp (isec->output_section->name, ".init") == 0
12088           || strcmp (isec->output_section->name, ".fini") == 0))
12089     {
12090       if (isec->map_head.s->has_toc_reloc
12091           || isec->map_head.s->makes_toc_func_call)
12092         ret = 1;
12093       else if (!isec->map_head.s->call_check_done)
12094         {
12095           int recur;
12096           isec->call_check_in_progress = 1;
12097           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12098           isec->call_check_in_progress = 0;
12099           if (recur != 0)
12100             ret = recur;
12101         }
12102     }
12103
12104   if (ret == 1)
12105     isec->makes_toc_func_call = 1;
12106
12107   return ret;
12108 }
12109
12110 /* The linker repeatedly calls this function for each input section,
12111    in the order that input sections are linked into output sections.
12112    Build lists of input sections to determine groupings between which
12113    we may insert linker stubs.  */
12114
12115 bfd_boolean
12116 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12117 {
12118   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12119
12120   if (htab == NULL)
12121     return FALSE;
12122
12123   if ((isec->output_section->flags & SEC_CODE) != 0
12124       && isec->output_section->id < htab->sec_info_arr_size)
12125     {
12126       /* This happens to make the list in reverse order,
12127          which is what we want.  */
12128       htab->sec_info[isec->id].u.list
12129         = htab->sec_info[isec->output_section->id].u.list;
12130       htab->sec_info[isec->output_section->id].u.list = isec;
12131     }
12132
12133   if (htab->multi_toc_needed)
12134     {
12135       /* Analyse sections that aren't already flagged as needing a
12136          valid toc pointer.  Exclude .fixup for the linux kernel.
12137          .fixup contains branches, but only back to the function that
12138          hit an exception.  */
12139       if (!(isec->has_toc_reloc
12140             || (isec->flags & SEC_CODE) == 0
12141             || strcmp (isec->name, ".fixup") == 0
12142             || isec->call_check_done))
12143         {
12144           if (toc_adjusting_stub_needed (info, isec) < 0)
12145             return FALSE;
12146         }
12147       /* Make all sections use the TOC assigned for this object file.
12148          This will be wrong for pasted sections;  We fix that in
12149          check_pasted_section().  */
12150       if (elf_gp (isec->owner) != 0)
12151         htab->toc_curr = elf_gp (isec->owner);
12152     }
12153
12154   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12155   return TRUE;
12156 }
12157
12158 /* Check that all .init and .fini sections use the same toc, if they
12159    have toc relocs.  */
12160
12161 static bfd_boolean
12162 check_pasted_section (struct bfd_link_info *info, const char *name)
12163 {
12164   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12165
12166   if (o != NULL)
12167     {
12168       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12169       bfd_vma toc_off = 0;
12170       asection *i;
12171
12172       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12173         if (i->has_toc_reloc)
12174           {
12175             if (toc_off == 0)
12176               toc_off = htab->sec_info[i->id].toc_off;
12177             else if (toc_off != htab->sec_info[i->id].toc_off)
12178               return FALSE;
12179           }
12180
12181       if (toc_off == 0)
12182         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12183           if (i->makes_toc_func_call)
12184             {
12185               toc_off = htab->sec_info[i->id].toc_off;
12186               break;
12187             }
12188
12189       /* Make sure the whole pasted function uses the same toc offset.  */
12190       if (toc_off != 0)
12191         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12192           htab->sec_info[i->id].toc_off = toc_off;
12193     }
12194   return TRUE;
12195 }
12196
12197 bfd_boolean
12198 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12199 {
12200   return (check_pasted_section (info, ".init")
12201           & check_pasted_section (info, ".fini"));
12202 }
12203
12204 /* See whether we can group stub sections together.  Grouping stub
12205    sections may result in fewer stubs.  More importantly, we need to
12206    put all .init* and .fini* stubs at the beginning of the .init or
12207    .fini output sections respectively, because glibc splits the
12208    _init and _fini functions into multiple parts.  Putting a stub in
12209    the middle of a function is not a good idea.  */
12210
12211 static bfd_boolean
12212 group_sections (struct bfd_link_info *info,
12213                 bfd_size_type stub_group_size,
12214                 bfd_boolean stubs_always_before_branch)
12215 {
12216   struct ppc_link_hash_table *htab;
12217   asection *osec;
12218   bfd_boolean suppress_size_errors;
12219
12220   htab = ppc_hash_table (info);
12221   if (htab == NULL)
12222     return FALSE;
12223
12224   suppress_size_errors = FALSE;
12225   if (stub_group_size == 1)
12226     {
12227       /* Default values.  */
12228       if (stubs_always_before_branch)
12229         stub_group_size = 0x1e00000;
12230       else
12231         stub_group_size = 0x1c00000;
12232       suppress_size_errors = TRUE;
12233     }
12234
12235   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12236     {
12237       asection *tail;
12238
12239       if (osec->id >= htab->sec_info_arr_size)
12240         continue;
12241
12242       tail = htab->sec_info[osec->id].u.list;
12243       while (tail != NULL)
12244         {
12245           asection *curr;
12246           asection *prev;
12247           bfd_size_type total;
12248           bfd_boolean big_sec;
12249           bfd_vma curr_toc;
12250           struct map_stub *group;
12251           bfd_size_type group_size;
12252
12253           curr = tail;
12254           total = tail->size;
12255           group_size = (ppc64_elf_section_data (tail) != NULL
12256                         && ppc64_elf_section_data (tail)->has_14bit_branch
12257                         ? stub_group_size >> 10 : stub_group_size);
12258
12259           big_sec = total > group_size;
12260           if (big_sec && !suppress_size_errors)
12261             /* xgettext:c-format */
12262             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12263                                 tail->owner, tail);
12264           curr_toc = htab->sec_info[tail->id].toc_off;
12265
12266           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12267                  && ((total += curr->output_offset - prev->output_offset)
12268                      < (ppc64_elf_section_data (prev) != NULL
12269                         && ppc64_elf_section_data (prev)->has_14bit_branch
12270                         ? (group_size = stub_group_size >> 10) : group_size))
12271                  && htab->sec_info[prev->id].toc_off == curr_toc)
12272             curr = prev;
12273
12274           /* OK, the size from the start of CURR to the end is less
12275              than group_size and thus can be handled by one stub
12276              section.  (or the tail section is itself larger than
12277              group_size, in which case we may be toast.)  We should
12278              really be keeping track of the total size of stubs added
12279              here, as stubs contribute to the final output section
12280              size.  That's a little tricky, and this way will only
12281              break if stubs added make the total size more than 2^25,
12282              ie. for the default stub_group_size, if stubs total more
12283              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12284           group = bfd_alloc (curr->owner, sizeof (*group));
12285           if (group == NULL)
12286             return FALSE;
12287           group->link_sec = curr;
12288           group->stub_sec = NULL;
12289           group->needs_save_res = 0;
12290           group->tls_get_addr_opt_bctrl = -1u;
12291           group->next = htab->group;
12292           htab->group = group;
12293           do
12294             {
12295               prev = htab->sec_info[tail->id].u.list;
12296               /* Set up this stub group.  */
12297               htab->sec_info[tail->id].u.group = group;
12298             }
12299           while (tail != curr && (tail = prev) != NULL);
12300
12301           /* But wait, there's more!  Input sections up to group_size
12302              bytes before the stub section can be handled by it too.
12303              Don't do this if we have a really large section after the
12304              stubs, as adding more stubs increases the chance that
12305              branches may not reach into the stub section.  */
12306           if (!stubs_always_before_branch && !big_sec)
12307             {
12308               total = 0;
12309               while (prev != NULL
12310                      && ((total += tail->output_offset - prev->output_offset)
12311                          < (ppc64_elf_section_data (prev) != NULL
12312                             && ppc64_elf_section_data (prev)->has_14bit_branch
12313                             ? (group_size = stub_group_size >> 10) : group_size))
12314                      && htab->sec_info[prev->id].toc_off == curr_toc)
12315                 {
12316                   tail = prev;
12317                   prev = htab->sec_info[tail->id].u.list;
12318                   htab->sec_info[tail->id].u.group = group;
12319                 }
12320             }
12321           tail = prev;
12322         }
12323     }
12324   return TRUE;
12325 }
12326
12327 static const unsigned char glink_eh_frame_cie[] =
12328 {
12329   0, 0, 0, 16,                          /* length.  */
12330   0, 0, 0, 0,                           /* id.  */
12331   1,                                    /* CIE version.  */
12332   'z', 'R', 0,                          /* Augmentation string.  */
12333   4,                                    /* Code alignment.  */
12334   0x78,                                 /* Data alignment.  */
12335   65,                                   /* RA reg.  */
12336   1,                                    /* Augmentation size.  */
12337   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12338   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12339 };
12340
12341 static size_t
12342 stub_eh_frame_size (struct map_stub *group, size_t align)
12343 {
12344   size_t this_size = 17;
12345   if (group->tls_get_addr_opt_bctrl != -1u)
12346     {
12347       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12348       if (to_bctrl < 64)
12349         this_size += 1;
12350       else if (to_bctrl < 256)
12351         this_size += 2;
12352       else if (to_bctrl < 65536)
12353         this_size += 3;
12354       else
12355         this_size += 5;
12356       this_size += 6;
12357     }
12358   this_size = (this_size + align - 1) & -align;
12359   return this_size;
12360 }
12361
12362 /* Stripping output sections is normally done before dynamic section
12363    symbols have been allocated.  This function is called later, and
12364    handles cases like htab->brlt which is mapped to its own output
12365    section.  */
12366
12367 static void
12368 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12369 {
12370   if (isec->size == 0
12371       && isec->output_section->size == 0
12372       && !(isec->output_section->flags & SEC_KEEP)
12373       && !bfd_section_removed_from_list (info->output_bfd,
12374                                          isec->output_section)
12375       && elf_section_data (isec->output_section)->dynindx == 0)
12376     {
12377       isec->output_section->flags |= SEC_EXCLUDE;
12378       bfd_section_list_remove (info->output_bfd, isec->output_section);
12379       info->output_bfd->section_count--;
12380     }
12381 }
12382
12383 /* Determine and set the size of the stub section for a final link.
12384
12385    The basic idea here is to examine all the relocations looking for
12386    PC-relative calls to a target that is unreachable with a "bl"
12387    instruction.  */
12388
12389 bfd_boolean
12390 ppc64_elf_size_stubs (struct bfd_link_info *info)
12391 {
12392   bfd_size_type stub_group_size;
12393   bfd_boolean stubs_always_before_branch;
12394   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12395
12396   if (htab == NULL)
12397     return FALSE;
12398
12399   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12400     htab->params->plt_thread_safe = 1;
12401   if (!htab->opd_abi)
12402     htab->params->plt_thread_safe = 0;
12403   else if (htab->params->plt_thread_safe == -1)
12404     {
12405       static const char *const thread_starter[] =
12406         {
12407           "pthread_create",
12408           /* libstdc++ */
12409           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12410           /* librt */
12411           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12412           "mq_notify", "create_timer",
12413           /* libanl */
12414           "getaddrinfo_a",
12415           /* libgomp */
12416           "GOMP_parallel",
12417           "GOMP_parallel_start",
12418           "GOMP_parallel_loop_static",
12419           "GOMP_parallel_loop_static_start",
12420           "GOMP_parallel_loop_dynamic",
12421           "GOMP_parallel_loop_dynamic_start",
12422           "GOMP_parallel_loop_guided",
12423           "GOMP_parallel_loop_guided_start",
12424           "GOMP_parallel_loop_runtime",
12425           "GOMP_parallel_loop_runtime_start",
12426           "GOMP_parallel_sections",
12427           "GOMP_parallel_sections_start",
12428           /* libgo */
12429           "__go_go",
12430         };
12431       unsigned i;
12432
12433       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12434         {
12435           struct elf_link_hash_entry *h;
12436           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12437                                     FALSE, FALSE, TRUE);
12438           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12439           if (htab->params->plt_thread_safe)
12440             break;
12441         }
12442     }
12443   stubs_always_before_branch = htab->params->group_size < 0;
12444   if (htab->params->group_size < 0)
12445     stub_group_size = -htab->params->group_size;
12446   else
12447     stub_group_size = htab->params->group_size;
12448
12449   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12450     return FALSE;
12451
12452 #define STUB_SHRINK_ITER 20
12453   /* Loop until no stubs added.  After iteration 20 of this loop we may
12454      exit on a stub section shrinking.  This is to break out of a
12455      pathological case where adding stubs on one iteration decreases
12456      section gaps (perhaps due to alignment), which then requires
12457      fewer or smaller stubs on the next iteration.  */
12458
12459   while (1)
12460     {
12461       bfd *input_bfd;
12462       unsigned int bfd_indx;
12463       struct map_stub *group;
12464
12465       htab->stub_iteration += 1;
12466
12467       for (input_bfd = info->input_bfds, bfd_indx = 0;
12468            input_bfd != NULL;
12469            input_bfd = input_bfd->link.next, bfd_indx++)
12470         {
12471           Elf_Internal_Shdr *symtab_hdr;
12472           asection *section;
12473           Elf_Internal_Sym *local_syms = NULL;
12474
12475           if (!is_ppc64_elf (input_bfd))
12476             continue;
12477
12478           /* We'll need the symbol table in a second.  */
12479           symtab_hdr = &elf_symtab_hdr (input_bfd);
12480           if (symtab_hdr->sh_info == 0)
12481             continue;
12482
12483           /* Walk over each section attached to the input bfd.  */
12484           for (section = input_bfd->sections;
12485                section != NULL;
12486                section = section->next)
12487             {
12488               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12489
12490               /* If there aren't any relocs, then there's nothing more
12491                  to do.  */
12492               if ((section->flags & SEC_RELOC) == 0
12493                   || (section->flags & SEC_ALLOC) == 0
12494                   || (section->flags & SEC_LOAD) == 0
12495                   || (section->flags & SEC_CODE) == 0
12496                   || section->reloc_count == 0)
12497                 continue;
12498
12499               /* If this section is a link-once section that will be
12500                  discarded, then don't create any stubs.  */
12501               if (section->output_section == NULL
12502                   || section->output_section->owner != info->output_bfd)
12503                 continue;
12504
12505               /* Get the relocs.  */
12506               internal_relocs
12507                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12508                                              info->keep_memory);
12509               if (internal_relocs == NULL)
12510                 goto error_ret_free_local;
12511
12512               /* Now examine each relocation.  */
12513               irela = internal_relocs;
12514               irelaend = irela + section->reloc_count;
12515               for (; irela < irelaend; irela++)
12516                 {
12517                   enum elf_ppc64_reloc_type r_type;
12518                   unsigned int r_indx;
12519                   enum ppc_stub_type stub_type;
12520                   struct ppc_stub_hash_entry *stub_entry;
12521                   asection *sym_sec, *code_sec;
12522                   bfd_vma sym_value, code_value;
12523                   bfd_vma destination;
12524                   unsigned long local_off;
12525                   bfd_boolean ok_dest;
12526                   struct ppc_link_hash_entry *hash;
12527                   struct ppc_link_hash_entry *fdh;
12528                   struct elf_link_hash_entry *h;
12529                   Elf_Internal_Sym *sym;
12530                   char *stub_name;
12531                   const asection *id_sec;
12532                   struct _opd_sec_data *opd;
12533                   struct plt_entry *plt_ent;
12534
12535                   r_type = ELF64_R_TYPE (irela->r_info);
12536                   r_indx = ELF64_R_SYM (irela->r_info);
12537
12538                   if (r_type >= R_PPC64_max)
12539                     {
12540                       bfd_set_error (bfd_error_bad_value);
12541                       goto error_ret_free_internal;
12542                     }
12543
12544                   /* Only look for stubs on branch instructions.  */
12545                   if (r_type != R_PPC64_REL24
12546                       && r_type != R_PPC64_REL14
12547                       && r_type != R_PPC64_REL14_BRTAKEN
12548                       && r_type != R_PPC64_REL14_BRNTAKEN)
12549                     continue;
12550
12551                   /* Now determine the call target, its name, value,
12552                      section.  */
12553                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12554                                   r_indx, input_bfd))
12555                     goto error_ret_free_internal;
12556                   hash = (struct ppc_link_hash_entry *) h;
12557
12558                   ok_dest = FALSE;
12559                   fdh = NULL;
12560                   sym_value = 0;
12561                   if (hash == NULL)
12562                     {
12563                       sym_value = sym->st_value;
12564                       if (sym_sec != NULL
12565                           && sym_sec->output_section != NULL)
12566                         ok_dest = TRUE;
12567                     }
12568                   else if (hash->elf.root.type == bfd_link_hash_defined
12569                            || hash->elf.root.type == bfd_link_hash_defweak)
12570                     {
12571                       sym_value = hash->elf.root.u.def.value;
12572                       if (sym_sec->output_section != NULL)
12573                         ok_dest = TRUE;
12574                     }
12575                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12576                            || hash->elf.root.type == bfd_link_hash_undefined)
12577                     {
12578                       /* Recognise an old ABI func code entry sym, and
12579                          use the func descriptor sym instead if it is
12580                          defined.  */
12581                       if (hash->elf.root.root.string[0] == '.'
12582                           && hash->oh != NULL)
12583                         {
12584                           fdh = ppc_follow_link (hash->oh);
12585                           if (fdh->elf.root.type == bfd_link_hash_defined
12586                               || fdh->elf.root.type == bfd_link_hash_defweak)
12587                             {
12588                               sym_sec = fdh->elf.root.u.def.section;
12589                               sym_value = fdh->elf.root.u.def.value;
12590                               if (sym_sec->output_section != NULL)
12591                                 ok_dest = TRUE;
12592                             }
12593                           else
12594                             fdh = NULL;
12595                         }
12596                     }
12597                   else
12598                     {
12599                       bfd_set_error (bfd_error_bad_value);
12600                       goto error_ret_free_internal;
12601                     }
12602
12603                   destination = 0;
12604                   local_off = 0;
12605                   if (ok_dest)
12606                     {
12607                       sym_value += irela->r_addend;
12608                       destination = (sym_value
12609                                      + sym_sec->output_offset
12610                                      + sym_sec->output_section->vma);
12611                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12612                                                             ? hash->elf.other
12613                                                             : sym->st_other);
12614                     }
12615
12616                   code_sec = sym_sec;
12617                   code_value = sym_value;
12618                   opd = get_opd_info (sym_sec);
12619                   if (opd != NULL)
12620                     {
12621                       bfd_vma dest;
12622
12623                       if (hash == NULL && opd->adjust != NULL)
12624                         {
12625                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12626                           if (adjust == -1)
12627                             continue;
12628                           code_value += adjust;
12629                           sym_value += adjust;
12630                         }
12631                       dest = opd_entry_value (sym_sec, sym_value,
12632                                               &code_sec, &code_value, FALSE);
12633                       if (dest != (bfd_vma) -1)
12634                         {
12635                           destination = dest;
12636                           if (fdh != NULL)
12637                             {
12638                               /* Fixup old ABI sym to point at code
12639                                  entry.  */
12640                               hash->elf.root.type = bfd_link_hash_defweak;
12641                               hash->elf.root.u.def.section = code_sec;
12642                               hash->elf.root.u.def.value = code_value;
12643                             }
12644                         }
12645                     }
12646
12647                   /* Determine what (if any) linker stub is needed.  */
12648                   plt_ent = NULL;
12649                   stub_type = ppc_type_of_stub (section, irela, &hash,
12650                                                 &plt_ent, destination,
12651                                                 local_off);
12652
12653                   if (stub_type != ppc_stub_plt_call)
12654                     {
12655                       /* Check whether we need a TOC adjusting stub.
12656                          Since the linker pastes together pieces from
12657                          different object files when creating the
12658                          _init and _fini functions, it may be that a
12659                          call to what looks like a local sym is in
12660                          fact a call needing a TOC adjustment.  */
12661                       if (code_sec != NULL
12662                           && code_sec->output_section != NULL
12663                           && (htab->sec_info[code_sec->id].toc_off
12664                               != htab->sec_info[section->id].toc_off)
12665                           && (code_sec->has_toc_reloc
12666                               || code_sec->makes_toc_func_call))
12667                         stub_type = ppc_stub_long_branch_r2off;
12668                     }
12669
12670                   if (stub_type == ppc_stub_none)
12671                     continue;
12672
12673                   /* __tls_get_addr calls might be eliminated.  */
12674                   if (stub_type != ppc_stub_plt_call
12675                       && hash != NULL
12676                       && (hash == htab->tls_get_addr
12677                           || hash == htab->tls_get_addr_fd)
12678                       && section->has_tls_reloc
12679                       && irela != internal_relocs)
12680                     {
12681                       /* Get tls info.  */
12682                       unsigned char *tls_mask;
12683
12684                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12685                                          irela - 1, input_bfd))
12686                         goto error_ret_free_internal;
12687                       if (*tls_mask != 0)
12688                         continue;
12689                     }
12690
12691                   if (stub_type == ppc_stub_plt_call)
12692                     {
12693                       if (!htab->opd_abi
12694                           && htab->params->plt_localentry0 != 0
12695                           && is_elfv2_localentry0 (&hash->elf))
12696                         htab->has_plt_localentry0 = 1;
12697                       else if (irela + 1 < irelaend
12698                                && irela[1].r_offset == irela->r_offset + 4
12699                                && (ELF64_R_TYPE (irela[1].r_info)
12700                                    == R_PPC64_TOCSAVE))
12701                         {
12702                           if (!tocsave_find (htab, INSERT,
12703                                              &local_syms, irela + 1, input_bfd))
12704                             goto error_ret_free_internal;
12705                         }
12706                       else
12707                         stub_type = ppc_stub_plt_call_r2save;
12708                     }
12709
12710                   /* Support for grouping stub sections.  */
12711                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12712
12713                   /* Get the name of this stub.  */
12714                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12715                   if (!stub_name)
12716                     goto error_ret_free_internal;
12717
12718                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12719                                                      stub_name, FALSE, FALSE);
12720                   if (stub_entry != NULL)
12721                     {
12722                       /* The proper stub has already been created.  */
12723                       free (stub_name);
12724                       if (stub_type == ppc_stub_plt_call_r2save)
12725                         stub_entry->stub_type = stub_type;
12726                       continue;
12727                     }
12728
12729                   stub_entry = ppc_add_stub (stub_name, section, info);
12730                   if (stub_entry == NULL)
12731                     {
12732                       free (stub_name);
12733                     error_ret_free_internal:
12734                       if (elf_section_data (section)->relocs == NULL)
12735                         free (internal_relocs);
12736                     error_ret_free_local:
12737                       if (local_syms != NULL
12738                           && (symtab_hdr->contents
12739                               != (unsigned char *) local_syms))
12740                         free (local_syms);
12741                       return FALSE;
12742                     }
12743
12744                   stub_entry->stub_type = stub_type;
12745                   if (stub_type != ppc_stub_plt_call
12746                       && stub_type != ppc_stub_plt_call_r2save)
12747                     {
12748                       stub_entry->target_value = code_value;
12749                       stub_entry->target_section = code_sec;
12750                     }
12751                   else
12752                     {
12753                       stub_entry->target_value = sym_value;
12754                       stub_entry->target_section = sym_sec;
12755                     }
12756                   stub_entry->h = hash;
12757                   stub_entry->plt_ent = plt_ent;
12758                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12759
12760                   if (stub_entry->h != NULL)
12761                     htab->stub_globals += 1;
12762                 }
12763
12764               /* We're done with the internal relocs, free them.  */
12765               if (elf_section_data (section)->relocs != internal_relocs)
12766                 free (internal_relocs);
12767             }
12768
12769           if (local_syms != NULL
12770               && symtab_hdr->contents != (unsigned char *) local_syms)
12771             {
12772               if (!info->keep_memory)
12773                 free (local_syms);
12774               else
12775                 symtab_hdr->contents = (unsigned char *) local_syms;
12776             }
12777         }
12778
12779       /* We may have added some stubs.  Find out the new size of the
12780          stub sections.  */
12781       for (group = htab->group; group != NULL; group = group->next)
12782         if (group->stub_sec != NULL)
12783           {
12784             asection *stub_sec = group->stub_sec;
12785
12786             if (htab->stub_iteration <= STUB_SHRINK_ITER
12787                 || stub_sec->rawsize < stub_sec->size)
12788               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12789               stub_sec->rawsize = stub_sec->size;
12790             stub_sec->size = 0;
12791             stub_sec->reloc_count = 0;
12792             stub_sec->flags &= ~SEC_RELOC;
12793           }
12794
12795       htab->brlt->size = 0;
12796       htab->brlt->reloc_count = 0;
12797       htab->brlt->flags &= ~SEC_RELOC;
12798       if (htab->relbrlt != NULL)
12799         htab->relbrlt->size = 0;
12800
12801       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12802
12803       for (group = htab->group; group != NULL; group = group->next)
12804         if (group->needs_save_res)
12805           group->stub_sec->size += htab->sfpr->size;
12806
12807       if (info->emitrelocations
12808           && htab->glink != NULL && htab->glink->size != 0)
12809         {
12810           htab->glink->reloc_count = 1;
12811           htab->glink->flags |= SEC_RELOC;
12812         }
12813
12814       if (htab->glink_eh_frame != NULL
12815           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12816           && htab->glink_eh_frame->output_section->size != 0)
12817         {
12818           size_t size = 0, align = 4;
12819
12820           for (group = htab->group; group != NULL; group = group->next)
12821             if (group->stub_sec != NULL)
12822               size += stub_eh_frame_size (group, align);
12823           if (htab->glink != NULL && htab->glink->size != 0)
12824             size += (24 + align - 1) & -align;
12825           if (size != 0)
12826             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12827           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12828           size = (size + align - 1) & -align;
12829           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12830           htab->glink_eh_frame->size = size;
12831         }
12832
12833       if (htab->params->plt_stub_align != 0)
12834         for (group = htab->group; group != NULL; group = group->next)
12835           if (group->stub_sec != NULL)
12836             group->stub_sec->size = ((group->stub_sec->size
12837                                       + (1 << htab->params->plt_stub_align) - 1)
12838                                      & -(1 << htab->params->plt_stub_align));
12839
12840       for (group = htab->group; group != NULL; group = group->next)
12841         if (group->stub_sec != NULL
12842             && group->stub_sec->rawsize != group->stub_sec->size
12843             && (htab->stub_iteration <= STUB_SHRINK_ITER
12844                 || group->stub_sec->rawsize < group->stub_sec->size))
12845           break;
12846
12847       if (group == NULL
12848           && (htab->glink_eh_frame == NULL
12849               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12850         break;
12851
12852       /* Ask the linker to do its stuff.  */
12853       (*htab->params->layout_sections_again) ();
12854     }
12855
12856   if (htab->glink_eh_frame != NULL
12857       && htab->glink_eh_frame->size != 0)
12858     {
12859       bfd_vma val;
12860       bfd_byte *p, *last_fde;
12861       size_t last_fde_len, size, align, pad;
12862       struct map_stub *group;
12863
12864       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12865       if (p == NULL)
12866         return FALSE;
12867       htab->glink_eh_frame->contents = p;
12868       last_fde = p;
12869       align = 4;
12870
12871       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12872       /* CIE length (rewrite in case little-endian).  */
12873       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12874       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12875       p += last_fde_len + 4;
12876
12877       for (group = htab->group; group != NULL; group = group->next)
12878         if (group->stub_sec != NULL)
12879           {
12880             last_fde = p;
12881             last_fde_len = stub_eh_frame_size (group, align) - 4;
12882             /* FDE length.  */
12883             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12884             p += 4;
12885             /* CIE pointer.  */
12886             val = p - htab->glink_eh_frame->contents;
12887             bfd_put_32 (htab->elf.dynobj, val, p);
12888             p += 4;
12889             /* Offset to stub section, written later.  */
12890             p += 4;
12891             /* stub section size.  */
12892             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12893             p += 4;
12894             /* Augmentation.  */
12895             p += 1;
12896             if (group->tls_get_addr_opt_bctrl != -1u)
12897               {
12898                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12899
12900                 /* This FDE needs more than just the default.
12901                    Describe __tls_get_addr_opt stub LR.  */
12902                 if (to_bctrl < 64)
12903                   *p++ = DW_CFA_advance_loc + to_bctrl;
12904                 else if (to_bctrl < 256)
12905                   {
12906                     *p++ = DW_CFA_advance_loc1;
12907                     *p++ = to_bctrl;
12908                   }
12909                 else if (to_bctrl < 65536)
12910                   {
12911                     *p++ = DW_CFA_advance_loc2;
12912                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12913                     p += 2;
12914                   }
12915                 else
12916                   {
12917                     *p++ = DW_CFA_advance_loc4;
12918                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12919                     p += 4;
12920                   }
12921                 *p++ = DW_CFA_offset_extended_sf;
12922                 *p++ = 65;
12923                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12924                 *p++ = DW_CFA_advance_loc + 4;
12925                 *p++ = DW_CFA_restore_extended;
12926                 *p++ = 65;
12927               }
12928             /* Pad.  */
12929             p = last_fde + last_fde_len + 4;
12930           }
12931       if (htab->glink != NULL && htab->glink->size != 0)
12932         {
12933           last_fde = p;
12934           last_fde_len = ((24 + align - 1) & -align) - 4;
12935           /* FDE length.  */
12936           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12937           p += 4;
12938           /* CIE pointer.  */
12939           val = p - htab->glink_eh_frame->contents;
12940           bfd_put_32 (htab->elf.dynobj, val, p);
12941           p += 4;
12942           /* Offset to .glink, written later.  */
12943           p += 4;
12944           /* .glink size.  */
12945           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12946           p += 4;
12947           /* Augmentation.  */
12948           p += 1;
12949
12950           *p++ = DW_CFA_advance_loc + 1;
12951           *p++ = DW_CFA_register;
12952           *p++ = 65;
12953           *p++ = htab->opd_abi ? 12 : 0;
12954           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12955           *p++ = DW_CFA_restore_extended;
12956           *p++ = 65;
12957           p += ((24 + align - 1) & -align) - 24;
12958         }
12959       /* Subsume any padding into the last FDE if user .eh_frame
12960          sections are aligned more than glink_eh_frame.  Otherwise any
12961          zero padding will be seen as a terminator.  */
12962       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12963       size = p - htab->glink_eh_frame->contents;
12964       pad = ((size + align - 1) & -align) - size;
12965       htab->glink_eh_frame->size = size + pad;
12966       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12967     }
12968
12969   maybe_strip_output (info, htab->brlt);
12970   if (htab->glink_eh_frame != NULL)
12971     maybe_strip_output (info, htab->glink_eh_frame);
12972
12973   return TRUE;
12974 }
12975
12976 /* Called after we have determined section placement.  If sections
12977    move, we'll be called again.  Provide a value for TOCstart.  */
12978
12979 bfd_vma
12980 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12981 {
12982   asection *s;
12983   bfd_vma TOCstart, adjust;
12984
12985   if (info != NULL)
12986     {
12987       struct elf_link_hash_entry *h;
12988       struct elf_link_hash_table *htab = elf_hash_table (info);
12989
12990       if (is_elf_hash_table (htab)
12991           && htab->hgot != NULL)
12992         h = htab->hgot;
12993       else
12994         {
12995           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12996           if (is_elf_hash_table (htab))
12997             htab->hgot = h;
12998         }
12999       if (h != NULL
13000           && h->root.type == bfd_link_hash_defined
13001           && !h->root.linker_def
13002           && (!is_elf_hash_table (htab)
13003               || h->def_regular))
13004         {
13005           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13006                       + h->root.u.def.section->output_offset
13007                       + h->root.u.def.section->output_section->vma);
13008           _bfd_set_gp_value (obfd, TOCstart);
13009           return TOCstart;
13010         }
13011     }
13012
13013   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13014      order.  The TOC starts where the first of these sections starts.  */
13015   s = bfd_get_section_by_name (obfd, ".got");
13016   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13017     s = bfd_get_section_by_name (obfd, ".toc");
13018   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13019     s = bfd_get_section_by_name (obfd, ".tocbss");
13020   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13021     s = bfd_get_section_by_name (obfd, ".plt");
13022   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13023     {
13024       /* This may happen for
13025          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13026          .toc directive
13027          o  bad linker script
13028          o --gc-sections and empty TOC sections
13029
13030          FIXME: Warn user?  */
13031
13032       /* Look for a likely section.  We probably won't even be
13033          using TOCstart.  */
13034       for (s = obfd->sections; s != NULL; s = s->next)
13035         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13036                          | SEC_EXCLUDE))
13037             == (SEC_ALLOC | SEC_SMALL_DATA))
13038           break;
13039       if (s == NULL)
13040         for (s = obfd->sections; s != NULL; s = s->next)
13041           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13042               == (SEC_ALLOC | SEC_SMALL_DATA))
13043             break;
13044       if (s == NULL)
13045         for (s = obfd->sections; s != NULL; s = s->next)
13046           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13047               == SEC_ALLOC)
13048             break;
13049       if (s == NULL)
13050         for (s = obfd->sections; s != NULL; s = s->next)
13051           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13052             break;
13053     }
13054
13055   TOCstart = 0;
13056   if (s != NULL)
13057     TOCstart = s->output_section->vma + s->output_offset;
13058
13059   /* Force alignment.  */
13060   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13061   TOCstart -= adjust;
13062   _bfd_set_gp_value (obfd, TOCstart);
13063
13064   if (info != NULL && s != NULL)
13065     {
13066       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13067
13068       if (htab != NULL)
13069         {
13070           if (htab->elf.hgot != NULL)
13071             {
13072               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13073               htab->elf.hgot->root.u.def.section = s;
13074             }
13075         }
13076       else
13077         {
13078           struct bfd_link_hash_entry *bh = NULL;
13079           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13080                                             s, TOC_BASE_OFF - adjust,
13081                                             NULL, FALSE, FALSE, &bh);
13082         }
13083     }
13084   return TOCstart;
13085 }
13086
13087 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13088    write out any global entry stubs.  */
13089
13090 static bfd_boolean
13091 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13092 {
13093   struct bfd_link_info *info;
13094   struct ppc_link_hash_table *htab;
13095   struct plt_entry *pent;
13096   asection *s;
13097
13098   if (h->root.type == bfd_link_hash_indirect)
13099     return TRUE;
13100
13101   if (!h->pointer_equality_needed)
13102     return TRUE;
13103
13104   if (h->def_regular)
13105     return TRUE;
13106
13107   info = inf;
13108   htab = ppc_hash_table (info);
13109   if (htab == NULL)
13110     return FALSE;
13111
13112   s = htab->glink;
13113   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13114     if (pent->plt.offset != (bfd_vma) -1
13115         && pent->addend == 0)
13116       {
13117         bfd_byte *p;
13118         asection *plt;
13119         bfd_vma off;
13120
13121         p = s->contents + h->root.u.def.value;
13122         plt = htab->elf.splt;
13123         if (!htab->elf.dynamic_sections_created
13124             || h->dynindx == -1)
13125           plt = htab->elf.iplt;
13126         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13127         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13128
13129         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13130           {
13131             info->callbacks->einfo
13132               (_("%P: linkage table error against `%T'\n"),
13133                h->root.root.string);
13134             bfd_set_error (bfd_error_bad_value);
13135             htab->stub_error = TRUE;
13136           }
13137
13138         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13139         if (htab->params->emit_stub_syms)
13140           {
13141             size_t len = strlen (h->root.root.string);
13142             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13143
13144             if (name == NULL)
13145               return FALSE;
13146
13147             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13148             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13149             if (h == NULL)
13150               return FALSE;
13151             if (h->root.type == bfd_link_hash_new)
13152               {
13153                 h->root.type = bfd_link_hash_defined;
13154                 h->root.u.def.section = s;
13155                 h->root.u.def.value = p - s->contents;
13156                 h->ref_regular = 1;
13157                 h->def_regular = 1;
13158                 h->ref_regular_nonweak = 1;
13159                 h->forced_local = 1;
13160                 h->non_elf = 0;
13161                 h->root.linker_def = 1;
13162               }
13163           }
13164
13165         if (PPC_HA (off) != 0)
13166           {
13167             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13168             p += 4;
13169           }
13170         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13171         p += 4;
13172         bfd_put_32 (s->owner, MTCTR_R12, p);
13173         p += 4;
13174         bfd_put_32 (s->owner, BCTR, p);
13175         break;
13176       }
13177   return TRUE;
13178 }
13179
13180 /* Build all the stubs associated with the current output file.
13181    The stubs are kept in a hash table attached to the main linker
13182    hash table.  This function is called via gldelf64ppc_finish.  */
13183
13184 bfd_boolean
13185 ppc64_elf_build_stubs (struct bfd_link_info *info,
13186                        char **stats)
13187 {
13188   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13189   struct map_stub *group;
13190   asection *stub_sec;
13191   bfd_byte *p;
13192   int stub_sec_count = 0;
13193
13194   if (htab == NULL)
13195     return FALSE;
13196
13197   /* Allocate memory to hold the linker stubs.  */
13198   for (group = htab->group; group != NULL; group = group->next)
13199     if ((stub_sec = group->stub_sec) != NULL
13200         && stub_sec->size != 0)
13201       {
13202         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13203         if (stub_sec->contents == NULL)
13204           return FALSE;
13205         stub_sec->size = 0;
13206       }
13207
13208   if (htab->glink != NULL && htab->glink->size != 0)
13209     {
13210       unsigned int indx;
13211       bfd_vma plt0;
13212
13213       /* Build the .glink plt call stub.  */
13214       if (htab->params->emit_stub_syms)
13215         {
13216           struct elf_link_hash_entry *h;
13217           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13218                                     TRUE, FALSE, FALSE);
13219           if (h == NULL)
13220             return FALSE;
13221           if (h->root.type == bfd_link_hash_new)
13222             {
13223               h->root.type = bfd_link_hash_defined;
13224               h->root.u.def.section = htab->glink;
13225               h->root.u.def.value = 8;
13226               h->ref_regular = 1;
13227               h->def_regular = 1;
13228               h->ref_regular_nonweak = 1;
13229               h->forced_local = 1;
13230               h->non_elf = 0;
13231               h->root.linker_def = 1;
13232             }
13233         }
13234       plt0 = (htab->elf.splt->output_section->vma
13235               + htab->elf.splt->output_offset
13236               - 16);
13237       if (info->emitrelocations)
13238         {
13239           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13240           if (r == NULL)
13241             return FALSE;
13242           r->r_offset = (htab->glink->output_offset
13243                          + htab->glink->output_section->vma);
13244           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13245           r->r_addend = plt0;
13246         }
13247       p = htab->glink->contents;
13248       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13249       bfd_put_64 (htab->glink->owner, plt0, p);
13250       p += 8;
13251       if (htab->opd_abi)
13252         {
13253           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13254           p += 4;
13255           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13256           p += 4;
13257           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13258           p += 4;
13259           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13260           p += 4;
13261           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13262           p += 4;
13263           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13264           p += 4;
13265           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13266           p += 4;
13267           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13268           p += 4;
13269           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13270           p += 4;
13271           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13272           p += 4;
13273         }
13274       else
13275         {
13276           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13277           p += 4;
13278           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13279           p += 4;
13280           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13281           p += 4;
13282           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13283           p += 4;
13284           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13285           p += 4;
13286           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13287           p += 4;
13288           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13289           p += 4;
13290           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13291           p += 4;
13292           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13293           p += 4;
13294           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13295           p += 4;
13296           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13297           p += 4;
13298           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13299           p += 4;
13300           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13301           p += 4;
13302         }
13303       bfd_put_32 (htab->glink->owner, BCTR, p);
13304       p += 4;
13305       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13306         {
13307           bfd_put_32 (htab->glink->owner, NOP, p);
13308           p += 4;
13309         }
13310
13311       /* Build the .glink lazy link call stubs.  */
13312       indx = 0;
13313       while (p < htab->glink->contents + htab->glink->rawsize)
13314         {
13315           if (htab->opd_abi)
13316             {
13317               if (indx < 0x8000)
13318                 {
13319                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13320                   p += 4;
13321                 }
13322               else
13323                 {
13324                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13325                   p += 4;
13326                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13327                               p);
13328                   p += 4;
13329                 }
13330             }
13331           bfd_put_32 (htab->glink->owner,
13332                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13333           indx++;
13334           p += 4;
13335         }
13336
13337       /* Build .glink global entry stubs.  */
13338       if (htab->glink->size > htab->glink->rawsize)
13339         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13340     }
13341
13342   if (htab->brlt != NULL && htab->brlt->size != 0)
13343     {
13344       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13345                                          htab->brlt->size);
13346       if (htab->brlt->contents == NULL)
13347         return FALSE;
13348     }
13349   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13350     {
13351       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13352                                             htab->relbrlt->size);
13353       if (htab->relbrlt->contents == NULL)
13354         return FALSE;
13355     }
13356
13357   /* Build the stubs as directed by the stub hash table.  */
13358   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13359
13360   for (group = htab->group; group != NULL; group = group->next)
13361     if (group->needs_save_res)
13362       {
13363         stub_sec = group->stub_sec;
13364         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13365                 htab->sfpr->size);
13366         if (htab->params->emit_stub_syms)
13367           {
13368             unsigned int i;
13369
13370             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13371               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13372                 return FALSE;
13373           }
13374         stub_sec->size += htab->sfpr->size;
13375       }
13376
13377   if (htab->relbrlt != NULL)
13378     htab->relbrlt->reloc_count = 0;
13379
13380   if (htab->params->plt_stub_align != 0)
13381     for (group = htab->group; group != NULL; group = group->next)
13382       if ((stub_sec = group->stub_sec) != NULL)
13383         stub_sec->size = ((stub_sec->size
13384                            + (1 << htab->params->plt_stub_align) - 1)
13385                           & -(1 << htab->params->plt_stub_align));
13386
13387   for (group = htab->group; group != NULL; group = group->next)
13388     if ((stub_sec = group->stub_sec) != NULL)
13389       {
13390         stub_sec_count += 1;
13391         if (stub_sec->rawsize != stub_sec->size
13392             && (htab->stub_iteration <= STUB_SHRINK_ITER
13393                 || stub_sec->rawsize < stub_sec->size))
13394           break;
13395       }
13396
13397   /* Note that the glink_eh_frame check here is not only testing that
13398      the generated size matched the calculated size but also that
13399      bfd_elf_discard_info didn't make any changes to the section.  */
13400   if (group != NULL
13401       || (htab->glink_eh_frame != NULL
13402           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13403     {
13404       htab->stub_error = TRUE;
13405       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13406     }
13407
13408   if (htab->stub_error)
13409     return FALSE;
13410
13411   if (stats != NULL)
13412     {
13413       *stats = bfd_malloc (500);
13414       if (*stats == NULL)
13415         return FALSE;
13416
13417       sprintf (*stats, _("linker stubs in %u group%s\n"
13418                          "  branch       %lu\n"
13419                          "  toc adjust   %lu\n"
13420                          "  long branch  %lu\n"
13421                          "  long toc adj %lu\n"
13422                          "  plt call     %lu\n"
13423                          "  plt call toc %lu\n"
13424                          "  global entry %lu"),
13425                stub_sec_count,
13426                stub_sec_count == 1 ? "" : "s",
13427                htab->stub_count[ppc_stub_long_branch - 1],
13428                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13429                htab->stub_count[ppc_stub_plt_branch - 1],
13430                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13431                htab->stub_count[ppc_stub_plt_call - 1],
13432                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13433                htab->stub_count[ppc_stub_global_entry - 1]);
13434     }
13435   return TRUE;
13436 }
13437
13438 /* What to do when ld finds relocations against symbols defined in
13439    discarded sections.  */
13440
13441 static unsigned int
13442 ppc64_elf_action_discarded (asection *sec)
13443 {
13444   if (strcmp (".opd", sec->name) == 0)
13445     return 0;
13446
13447   if (strcmp (".toc", sec->name) == 0)
13448     return 0;
13449
13450   if (strcmp (".toc1", sec->name) == 0)
13451     return 0;
13452
13453   return _bfd_elf_default_action_discarded (sec);
13454 }
13455
13456 /* The RELOCATE_SECTION function is called by the ELF backend linker
13457    to handle the relocations for a section.
13458
13459    The relocs are always passed as Rela structures; if the section
13460    actually uses Rel structures, the r_addend field will always be
13461    zero.
13462
13463    This function is responsible for adjust the section contents as
13464    necessary, and (if using Rela relocs and generating a
13465    relocatable output file) adjusting the reloc addend as
13466    necessary.
13467
13468    This function does not have to worry about setting the reloc
13469    address or the reloc symbol index.
13470
13471    LOCAL_SYMS is a pointer to the swapped in local symbols.
13472
13473    LOCAL_SECTIONS is an array giving the section in the input file
13474    corresponding to the st_shndx field of each local symbol.
13475
13476    The global hash table entry for the global symbols can be found
13477    via elf_sym_hashes (input_bfd).
13478
13479    When generating relocatable output, this function must handle
13480    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13481    going to be the section symbol corresponding to the output
13482    section, which means that the addend must be adjusted
13483    accordingly.  */
13484
13485 static bfd_boolean
13486 ppc64_elf_relocate_section (bfd *output_bfd,
13487                             struct bfd_link_info *info,
13488                             bfd *input_bfd,
13489                             asection *input_section,
13490                             bfd_byte *contents,
13491                             Elf_Internal_Rela *relocs,
13492                             Elf_Internal_Sym *local_syms,
13493                             asection **local_sections)
13494 {
13495   struct ppc_link_hash_table *htab;
13496   Elf_Internal_Shdr *symtab_hdr;
13497   struct elf_link_hash_entry **sym_hashes;
13498   Elf_Internal_Rela *rel;
13499   Elf_Internal_Rela *wrel;
13500   Elf_Internal_Rela *relend;
13501   Elf_Internal_Rela outrel;
13502   bfd_byte *loc;
13503   struct got_entry **local_got_ents;
13504   bfd_vma TOCstart;
13505   bfd_boolean ret = TRUE;
13506   bfd_boolean is_opd;
13507   /* Assume 'at' branch hints.  */
13508   bfd_boolean is_isa_v2 = TRUE;
13509   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13510
13511   /* Initialize howto table if needed.  */
13512   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13513     ppc_howto_init ();
13514
13515   htab = ppc_hash_table (info);
13516   if (htab == NULL)
13517     return FALSE;
13518
13519   /* Don't relocate stub sections.  */
13520   if (input_section->owner == htab->params->stub_bfd)
13521     return TRUE;
13522
13523   BFD_ASSERT (is_ppc64_elf (input_bfd));
13524
13525   local_got_ents = elf_local_got_ents (input_bfd);
13526   TOCstart = elf_gp (output_bfd);
13527   symtab_hdr = &elf_symtab_hdr (input_bfd);
13528   sym_hashes = elf_sym_hashes (input_bfd);
13529   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13530
13531   rel = wrel = relocs;
13532   relend = relocs + input_section->reloc_count;
13533   for (; rel < relend; wrel++, rel++)
13534     {
13535       enum elf_ppc64_reloc_type r_type;
13536       bfd_vma addend;
13537       bfd_reloc_status_type r;
13538       Elf_Internal_Sym *sym;
13539       asection *sec;
13540       struct elf_link_hash_entry *h_elf;
13541       struct ppc_link_hash_entry *h;
13542       struct ppc_link_hash_entry *fdh;
13543       const char *sym_name;
13544       unsigned long r_symndx, toc_symndx;
13545       bfd_vma toc_addend;
13546       unsigned char tls_mask, tls_gd, tls_type;
13547       unsigned char sym_type;
13548       bfd_vma relocation;
13549       bfd_boolean unresolved_reloc;
13550       bfd_boolean warned;
13551       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13552       unsigned int insn;
13553       unsigned int mask;
13554       struct ppc_stub_hash_entry *stub_entry;
13555       bfd_vma max_br_offset;
13556       bfd_vma from;
13557       Elf_Internal_Rela orig_rel;
13558       reloc_howto_type *howto;
13559       struct reloc_howto_struct alt_howto;
13560
13561     again:
13562       orig_rel = *rel;
13563
13564       r_type = ELF64_R_TYPE (rel->r_info);
13565       r_symndx = ELF64_R_SYM (rel->r_info);
13566
13567       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13568          symbol of the previous ADDR64 reloc.  The symbol gives us the
13569          proper TOC base to use.  */
13570       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13571           && wrel != relocs
13572           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13573           && is_opd)
13574         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13575
13576       sym = NULL;
13577       sec = NULL;
13578       h_elf = NULL;
13579       sym_name = NULL;
13580       unresolved_reloc = FALSE;
13581       warned = FALSE;
13582
13583       if (r_symndx < symtab_hdr->sh_info)
13584         {
13585           /* It's a local symbol.  */
13586           struct _opd_sec_data *opd;
13587
13588           sym = local_syms + r_symndx;
13589           sec = local_sections[r_symndx];
13590           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13591           sym_type = ELF64_ST_TYPE (sym->st_info);
13592           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13593           opd = get_opd_info (sec);
13594           if (opd != NULL && opd->adjust != NULL)
13595             {
13596               long adjust = opd->adjust[OPD_NDX (sym->st_value
13597                                                  + rel->r_addend)];
13598               if (adjust == -1)
13599                 relocation = 0;
13600               else
13601                 {
13602                   /* If this is a relocation against the opd section sym
13603                      and we have edited .opd, adjust the reloc addend so
13604                      that ld -r and ld --emit-relocs output is correct.
13605                      If it is a reloc against some other .opd symbol,
13606                      then the symbol value will be adjusted later.  */
13607                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13608                     rel->r_addend += adjust;
13609                   else
13610                     relocation += adjust;
13611                 }
13612             }
13613         }
13614       else
13615         {
13616           bfd_boolean ignored;
13617
13618           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13619                                    r_symndx, symtab_hdr, sym_hashes,
13620                                    h_elf, sec, relocation,
13621                                    unresolved_reloc, warned, ignored);
13622           sym_name = h_elf->root.root.string;
13623           sym_type = h_elf->type;
13624           if (sec != NULL
13625               && sec->owner == output_bfd
13626               && strcmp (sec->name, ".opd") == 0)
13627             {
13628               /* This is a symbol defined in a linker script.  All
13629                  such are defined in output sections, even those
13630                  defined by simple assignment from a symbol defined in
13631                  an input section.  Transfer the symbol to an
13632                  appropriate input .opd section, so that a branch to
13633                  this symbol will be mapped to the location specified
13634                  by the opd entry.  */
13635               struct bfd_link_order *lo;
13636               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13637                 if (lo->type == bfd_indirect_link_order)
13638                   {
13639                     asection *isec = lo->u.indirect.section;
13640                     if (h_elf->root.u.def.value >= isec->output_offset
13641                         && h_elf->root.u.def.value < (isec->output_offset
13642                                                       + isec->size))
13643                       {
13644                         h_elf->root.u.def.value -= isec->output_offset;
13645                         h_elf->root.u.def.section = isec;
13646                         sec = isec;
13647                         break;
13648                       }
13649                   }
13650             }
13651         }
13652       h = (struct ppc_link_hash_entry *) h_elf;
13653
13654       if (sec != NULL && discarded_section (sec))
13655         {
13656           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13657                                input_bfd, input_section,
13658                                contents + rel->r_offset);
13659           wrel->r_offset = rel->r_offset;
13660           wrel->r_info = 0;
13661           wrel->r_addend = 0;
13662
13663           /* For ld -r, remove relocations in debug sections against
13664              sections defined in discarded sections.  Not done for
13665              non-debug to preserve relocs in .eh_frame which the
13666              eh_frame editing code expects to be present.  */
13667           if (bfd_link_relocatable (info)
13668               && (input_section->flags & SEC_DEBUGGING))
13669             wrel--;
13670
13671           continue;
13672         }
13673
13674       if (bfd_link_relocatable (info))
13675         goto copy_reloc;
13676
13677       if (h != NULL && &h->elf == htab->elf.hgot)
13678         {
13679           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13680           sec = bfd_abs_section_ptr;
13681           unresolved_reloc = FALSE;
13682         }
13683
13684       /* TLS optimizations.  Replace instruction sequences and relocs
13685          based on information we collected in tls_optimize.  We edit
13686          RELOCS so that --emit-relocs will output something sensible
13687          for the final instruction stream.  */
13688       tls_mask = 0;
13689       tls_gd = 0;
13690       toc_symndx = 0;
13691       if (h != NULL)
13692         tls_mask = h->tls_mask;
13693       else if (local_got_ents != NULL)
13694         {
13695           struct plt_entry **local_plt = (struct plt_entry **)
13696             (local_got_ents + symtab_hdr->sh_info);
13697           unsigned char *lgot_masks = (unsigned char *)
13698             (local_plt + symtab_hdr->sh_info);
13699           tls_mask = lgot_masks[r_symndx];
13700         }
13701       if (tls_mask == 0
13702           && (r_type == R_PPC64_TLS
13703               || r_type == R_PPC64_TLSGD
13704               || r_type == R_PPC64_TLSLD))
13705         {
13706           /* Check for toc tls entries.  */
13707           unsigned char *toc_tls;
13708
13709           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13710                              &local_syms, rel, input_bfd))
13711             return FALSE;
13712
13713           if (toc_tls)
13714             tls_mask = *toc_tls;
13715         }
13716
13717       /* Check that tls relocs are used with tls syms, and non-tls
13718          relocs are used with non-tls syms.  */
13719       if (r_symndx != STN_UNDEF
13720           && r_type != R_PPC64_NONE
13721           && (h == NULL
13722               || h->elf.root.type == bfd_link_hash_defined
13723               || h->elf.root.type == bfd_link_hash_defweak)
13724           && (IS_PPC64_TLS_RELOC (r_type)
13725               != (sym_type == STT_TLS
13726                   || (sym_type == STT_SECTION
13727                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13728         {
13729           if (tls_mask != 0
13730               && (r_type == R_PPC64_TLS
13731                   || r_type == R_PPC64_TLSGD
13732                   || r_type == R_PPC64_TLSLD))
13733             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13734             ;
13735           else
13736             info->callbacks->einfo
13737               (!IS_PPC64_TLS_RELOC (r_type)
13738                /* xgettext:c-format */
13739                ? _("%H: %s used with TLS symbol `%T'\n")
13740                /* xgettext:c-format */
13741                : _("%H: %s used with non-TLS symbol `%T'\n"),
13742                input_bfd, input_section, rel->r_offset,
13743                ppc64_elf_howto_table[r_type]->name,
13744                sym_name);
13745         }
13746
13747       /* Ensure reloc mapping code below stays sane.  */
13748       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13749           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13750           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13751           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13752           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13753           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13754           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13755           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13756           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13757           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13758         abort ();
13759
13760       switch (r_type)
13761         {
13762         default:
13763           break;
13764
13765         case R_PPC64_LO_DS_OPT:
13766           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13767           if ((insn & (0x3f << 26)) != 58u << 26)
13768             abort ();
13769           insn += (14u << 26) - (58u << 26);
13770           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13771           r_type = R_PPC64_TOC16_LO;
13772           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13773           break;
13774
13775         case R_PPC64_TOC16:
13776         case R_PPC64_TOC16_LO:
13777         case R_PPC64_TOC16_DS:
13778         case R_PPC64_TOC16_LO_DS:
13779           {
13780             /* Check for toc tls entries.  */
13781             unsigned char *toc_tls;
13782             int retval;
13783
13784             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13785                                    &local_syms, rel, input_bfd);
13786             if (retval == 0)
13787               return FALSE;
13788
13789             if (toc_tls)
13790               {
13791                 tls_mask = *toc_tls;
13792                 if (r_type == R_PPC64_TOC16_DS
13793                     || r_type == R_PPC64_TOC16_LO_DS)
13794                   {
13795                     if (tls_mask != 0
13796                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13797                       goto toctprel;
13798                   }
13799                 else
13800                   {
13801                     /* If we found a GD reloc pair, then we might be
13802                        doing a GD->IE transition.  */
13803                     if (retval == 2)
13804                       {
13805                         tls_gd = TLS_TPRELGD;
13806                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13807                           goto tls_ldgd_opt;
13808                       }
13809                     else if (retval == 3)
13810                       {
13811                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13812                           goto tls_ldgd_opt;
13813                       }
13814                   }
13815               }
13816           }
13817           break;
13818
13819         case R_PPC64_GOT_TPREL16_HI:
13820         case R_PPC64_GOT_TPREL16_HA:
13821           if (tls_mask != 0
13822               && (tls_mask & TLS_TPREL) == 0)
13823             {
13824               rel->r_offset -= d_offset;
13825               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13826               r_type = R_PPC64_NONE;
13827               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13828             }
13829           break;
13830
13831         case R_PPC64_GOT_TPREL16_DS:
13832         case R_PPC64_GOT_TPREL16_LO_DS:
13833           if (tls_mask != 0
13834               && (tls_mask & TLS_TPREL) == 0)
13835             {
13836             toctprel:
13837               insn = bfd_get_32 (input_bfd,
13838                                  contents + rel->r_offset - d_offset);
13839               insn &= 31 << 21;
13840               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13841               bfd_put_32 (input_bfd, insn,
13842                           contents + rel->r_offset - d_offset);
13843               r_type = R_PPC64_TPREL16_HA;
13844               if (toc_symndx != 0)
13845                 {
13846                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13847                   rel->r_addend = toc_addend;
13848                   /* We changed the symbol.  Start over in order to
13849                      get h, sym, sec etc. right.  */
13850                   goto again;
13851                 }
13852               else
13853                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13854             }
13855           break;
13856
13857         case R_PPC64_TLS:
13858           if (tls_mask != 0
13859               && (tls_mask & TLS_TPREL) == 0)
13860             {
13861               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13862               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13863               if (insn == 0)
13864                 abort ();
13865               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13866               /* Was PPC64_TLS which sits on insn boundary, now
13867                  PPC64_TPREL16_LO which is at low-order half-word.  */
13868               rel->r_offset += d_offset;
13869               r_type = R_PPC64_TPREL16_LO;
13870               if (toc_symndx != 0)
13871                 {
13872                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13873                   rel->r_addend = toc_addend;
13874                   /* We changed the symbol.  Start over in order to
13875                      get h, sym, sec etc. right.  */
13876                   goto again;
13877                 }
13878               else
13879                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13880             }
13881           break;
13882
13883         case R_PPC64_GOT_TLSGD16_HI:
13884         case R_PPC64_GOT_TLSGD16_HA:
13885           tls_gd = TLS_TPRELGD;
13886           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13887             goto tls_gdld_hi;
13888           break;
13889
13890         case R_PPC64_GOT_TLSLD16_HI:
13891         case R_PPC64_GOT_TLSLD16_HA:
13892           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13893             {
13894             tls_gdld_hi:
13895               if ((tls_mask & tls_gd) != 0)
13896                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13897                           + R_PPC64_GOT_TPREL16_DS);
13898               else
13899                 {
13900                   rel->r_offset -= d_offset;
13901                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13902                   r_type = R_PPC64_NONE;
13903                 }
13904               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13905             }
13906           break;
13907
13908         case R_PPC64_GOT_TLSGD16:
13909         case R_PPC64_GOT_TLSGD16_LO:
13910           tls_gd = TLS_TPRELGD;
13911           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13912             goto tls_ldgd_opt;
13913           break;
13914
13915         case R_PPC64_GOT_TLSLD16:
13916         case R_PPC64_GOT_TLSLD16_LO:
13917           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13918             {
13919               unsigned int insn1, insn2;
13920               bfd_vma offset;
13921
13922             tls_ldgd_opt:
13923               offset = (bfd_vma) -1;
13924               /* If not using the newer R_PPC64_TLSGD/LD to mark
13925                  __tls_get_addr calls, we must trust that the call
13926                  stays with its arg setup insns, ie. that the next
13927                  reloc is the __tls_get_addr call associated with
13928                  the current reloc.  Edit both insns.  */
13929               if (input_section->has_tls_get_addr_call
13930                   && rel + 1 < relend
13931                   && branch_reloc_hash_match (input_bfd, rel + 1,
13932                                               htab->tls_get_addr,
13933                                               htab->tls_get_addr_fd))
13934                 offset = rel[1].r_offset;
13935               /* We read the low GOT_TLS (or TOC16) insn because we
13936                  need to keep the destination reg.  It may be
13937                  something other than the usual r3, and moved to r3
13938                  before the call by intervening code.  */
13939               insn1 = bfd_get_32 (input_bfd,
13940                                   contents + rel->r_offset - d_offset);
13941               if ((tls_mask & tls_gd) != 0)
13942                 {
13943                   /* IE */
13944                   insn1 &= (0x1f << 21) | (0x1f << 16);
13945                   insn1 |= 58 << 26;    /* ld */
13946                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13947                   if (offset != (bfd_vma) -1)
13948                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13949                   if ((tls_mask & TLS_EXPLICIT) == 0)
13950                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13951                               + R_PPC64_GOT_TPREL16_DS);
13952                   else
13953                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13954                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13955                 }
13956               else
13957                 {
13958                   /* LE */
13959                   insn1 &= 0x1f << 21;
13960                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13961                   insn2 = 0x38630000;   /* addi 3,3,0 */
13962                   if (tls_gd == 0)
13963                     {
13964                       /* Was an LD reloc.  */
13965                       if (toc_symndx)
13966                         sec = local_sections[toc_symndx];
13967                       for (r_symndx = 0;
13968                            r_symndx < symtab_hdr->sh_info;
13969                            r_symndx++)
13970                         if (local_sections[r_symndx] == sec)
13971                           break;
13972                       if (r_symndx >= symtab_hdr->sh_info)
13973                         r_symndx = STN_UNDEF;
13974                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13975                       if (r_symndx != STN_UNDEF)
13976                         rel->r_addend -= (local_syms[r_symndx].st_value
13977                                           + sec->output_offset
13978                                           + sec->output_section->vma);
13979                     }
13980                   else if (toc_symndx != 0)
13981                     {
13982                       r_symndx = toc_symndx;
13983                       rel->r_addend = toc_addend;
13984                     }
13985                   r_type = R_PPC64_TPREL16_HA;
13986                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13987                   if (offset != (bfd_vma) -1)
13988                     {
13989                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13990                                                     R_PPC64_TPREL16_LO);
13991                       rel[1].r_offset = offset + d_offset;
13992                       rel[1].r_addend = rel->r_addend;
13993                     }
13994                 }
13995               bfd_put_32 (input_bfd, insn1,
13996                           contents + rel->r_offset - d_offset);
13997               if (offset != (bfd_vma) -1)
13998                 bfd_put_32 (input_bfd, insn2, contents + offset);
13999               if ((tls_mask & tls_gd) == 0
14000                   && (tls_gd == 0 || toc_symndx != 0))
14001                 {
14002                   /* We changed the symbol.  Start over in order
14003                      to get h, sym, sec etc. right.  */
14004                   goto again;
14005                 }
14006             }
14007           break;
14008
14009         case R_PPC64_TLSGD:
14010           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
14011             {
14012               unsigned int insn2;
14013               bfd_vma offset = rel->r_offset;
14014
14015               if ((tls_mask & TLS_TPRELGD) != 0)
14016                 {
14017                   /* IE */
14018                   r_type = R_PPC64_NONE;
14019                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14020                 }
14021               else
14022                 {
14023                   /* LE */
14024                   if (toc_symndx != 0)
14025                     {
14026                       r_symndx = toc_symndx;
14027                       rel->r_addend = toc_addend;
14028                     }
14029                   r_type = R_PPC64_TPREL16_LO;
14030                   rel->r_offset = offset + d_offset;
14031                   insn2 = 0x38630000;   /* addi 3,3,0 */
14032                 }
14033               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14034               /* Zap the reloc on the _tls_get_addr call too.  */
14035               BFD_ASSERT (offset == rel[1].r_offset);
14036               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14037               bfd_put_32 (input_bfd, insn2, contents + offset);
14038               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14039                 goto again;
14040             }
14041           break;
14042
14043         case R_PPC64_TLSLD:
14044           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14045             {
14046               unsigned int insn2;
14047               bfd_vma offset = rel->r_offset;
14048
14049               if (toc_symndx)
14050                 sec = local_sections[toc_symndx];
14051               for (r_symndx = 0;
14052                    r_symndx < symtab_hdr->sh_info;
14053                    r_symndx++)
14054                 if (local_sections[r_symndx] == sec)
14055                   break;
14056               if (r_symndx >= symtab_hdr->sh_info)
14057                 r_symndx = STN_UNDEF;
14058               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14059               if (r_symndx != STN_UNDEF)
14060                 rel->r_addend -= (local_syms[r_symndx].st_value
14061                                   + sec->output_offset
14062                                   + sec->output_section->vma);
14063
14064               r_type = R_PPC64_TPREL16_LO;
14065               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14066               rel->r_offset = offset + d_offset;
14067               /* Zap the reloc on the _tls_get_addr call too.  */
14068               BFD_ASSERT (offset == rel[1].r_offset);
14069               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14070               insn2 = 0x38630000;       /* addi 3,3,0 */
14071               bfd_put_32 (input_bfd, insn2, contents + offset);
14072               goto again;
14073             }
14074           break;
14075
14076         case R_PPC64_DTPMOD64:
14077           if (rel + 1 < relend
14078               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14079               && rel[1].r_offset == rel->r_offset + 8)
14080             {
14081               if ((tls_mask & TLS_GD) == 0)
14082                 {
14083                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14084                   if ((tls_mask & TLS_TPRELGD) != 0)
14085                     r_type = R_PPC64_TPREL64;
14086                   else
14087                     {
14088                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14089                       r_type = R_PPC64_NONE;
14090                     }
14091                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14092                 }
14093             }
14094           else
14095             {
14096               if ((tls_mask & TLS_LD) == 0)
14097                 {
14098                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14099                   r_type = R_PPC64_NONE;
14100                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14101                 }
14102             }
14103           break;
14104
14105         case R_PPC64_TPREL64:
14106           if ((tls_mask & TLS_TPREL) == 0)
14107             {
14108               r_type = R_PPC64_NONE;
14109               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14110             }
14111           break;
14112
14113         case R_PPC64_ENTRY:
14114           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14115           if (!bfd_link_pic (info)
14116               && !info->traditional_format
14117               && relocation + 0x80008000 <= 0xffffffff)
14118             {
14119               unsigned int insn1, insn2;
14120
14121               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14122               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14123               if ((insn1 & ~0xfffc) == LD_R2_0R12
14124                   && insn2 == ADD_R2_R2_R12)
14125                 {
14126                   bfd_put_32 (input_bfd,
14127                               LIS_R2 + PPC_HA (relocation),
14128                               contents + rel->r_offset);
14129                   bfd_put_32 (input_bfd,
14130                               ADDI_R2_R2 + PPC_LO (relocation),
14131                               contents + rel->r_offset + 4);
14132                 }
14133             }
14134           else
14135             {
14136               relocation -= (rel->r_offset
14137                              + input_section->output_offset
14138                              + input_section->output_section->vma);
14139               if (relocation + 0x80008000 <= 0xffffffff)
14140                 {
14141                   unsigned int insn1, insn2;
14142
14143                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14144                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14145                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14146                       && insn2 == ADD_R2_R2_R12)
14147                     {
14148                       bfd_put_32 (input_bfd,
14149                                   ADDIS_R2_R12 + PPC_HA (relocation),
14150                                   contents + rel->r_offset);
14151                       bfd_put_32 (input_bfd,
14152                                   ADDI_R2_R2 + PPC_LO (relocation),
14153                                   contents + rel->r_offset + 4);
14154                     }
14155                 }
14156             }
14157           break;
14158
14159         case R_PPC64_REL16_HA:
14160           /* If we are generating a non-PIC executable, edit
14161              .  0:      addis 2,12,.TOC.-0b@ha
14162              .          addi 2,2,.TOC.-0b@l
14163              used by ELFv2 global entry points to set up r2, to
14164              .          lis 2,.TOC.@ha
14165              .          addi 2,2,.TOC.@l
14166              if .TOC. is in range.  */
14167           if (!bfd_link_pic (info)
14168               && !info->traditional_format
14169               && !htab->opd_abi
14170               && rel->r_addend == d_offset
14171               && h != NULL && &h->elf == htab->elf.hgot
14172               && rel + 1 < relend
14173               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14174               && rel[1].r_offset == rel->r_offset + 4
14175               && rel[1].r_addend == rel->r_addend + 4
14176               && relocation + 0x80008000 <= 0xffffffff)
14177             {
14178               unsigned int insn1, insn2;
14179               bfd_vma offset = rel->r_offset - d_offset;
14180               insn1 = bfd_get_32 (input_bfd, contents + offset);
14181               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14182               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14183                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14184                 {
14185                   r_type = R_PPC64_ADDR16_HA;
14186                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14187                   rel->r_addend -= d_offset;
14188                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14189                   rel[1].r_addend -= d_offset + 4;
14190                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14191                 }
14192             }
14193           break;
14194         }
14195
14196       /* Handle other relocations that tweak non-addend part of insn.  */
14197       insn = 0;
14198       max_br_offset = 1 << 25;
14199       addend = rel->r_addend;
14200       reloc_dest = DEST_NORMAL;
14201       switch (r_type)
14202         {
14203         default:
14204           break;
14205
14206         case R_PPC64_TOCSAVE:
14207           if (relocation + addend == (rel->r_offset
14208                                       + input_section->output_offset
14209                                       + input_section->output_section->vma)
14210               && tocsave_find (htab, NO_INSERT,
14211                                &local_syms, rel, input_bfd))
14212             {
14213               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14214               if (insn == NOP
14215                   || insn == CROR_151515 || insn == CROR_313131)
14216                 bfd_put_32 (input_bfd,
14217                             STD_R2_0R1 + STK_TOC (htab),
14218                             contents + rel->r_offset);
14219             }
14220           break;
14221
14222           /* Branch taken prediction relocations.  */
14223         case R_PPC64_ADDR14_BRTAKEN:
14224         case R_PPC64_REL14_BRTAKEN:
14225           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14226           /* Fall through.  */
14227
14228           /* Branch not taken prediction relocations.  */
14229         case R_PPC64_ADDR14_BRNTAKEN:
14230         case R_PPC64_REL14_BRNTAKEN:
14231           insn |= bfd_get_32 (input_bfd,
14232                               contents + rel->r_offset) & ~(0x01 << 21);
14233           /* Fall through.  */
14234
14235         case R_PPC64_REL14:
14236           max_br_offset = 1 << 15;
14237           /* Fall through.  */
14238
14239         case R_PPC64_REL24:
14240           /* Calls to functions with a different TOC, such as calls to
14241              shared objects, need to alter the TOC pointer.  This is
14242              done using a linkage stub.  A REL24 branching to these
14243              linkage stubs needs to be followed by a nop, as the nop
14244              will be replaced with an instruction to restore the TOC
14245              base pointer.  */
14246           fdh = h;
14247           if (h != NULL
14248               && h->oh != NULL
14249               && h->oh->is_func_descriptor)
14250             fdh = ppc_follow_link (h->oh);
14251           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14252                                            htab);
14253           if (stub_entry != NULL
14254               && (stub_entry->stub_type == ppc_stub_plt_call
14255                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14256                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14257                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14258             {
14259               bfd_boolean can_plt_call = FALSE;
14260
14261               if (stub_entry->stub_type == ppc_stub_plt_call
14262                   && !htab->opd_abi
14263                   && htab->params->plt_localentry0 != 0
14264                   && is_elfv2_localentry0 (&h->elf))
14265                 {
14266                   /* The function doesn't use or change r2.  */
14267                   can_plt_call = TRUE;
14268                 }
14269
14270               /* All of these stubs may modify r2, so there must be a
14271                  branch and link followed by a nop.  The nop is
14272                  replaced by an insn to restore r2.  */
14273               else if (rel->r_offset + 8 <= input_section->size)
14274                 {
14275                   unsigned long br;
14276
14277                   br = bfd_get_32 (input_bfd,
14278                                    contents + rel->r_offset);
14279                   if ((br & 1) != 0)
14280                     {
14281                       unsigned long nop;
14282
14283                       nop = bfd_get_32 (input_bfd,
14284                                         contents + rel->r_offset + 4);
14285                       if (nop == NOP
14286                           || nop == CROR_151515 || nop == CROR_313131)
14287                         {
14288                           if (h != NULL
14289                               && (h == htab->tls_get_addr_fd
14290                                   || h == htab->tls_get_addr)
14291                               && htab->params->tls_get_addr_opt)
14292                             {
14293                               /* Special stub used, leave nop alone.  */
14294                             }
14295                           else
14296                             bfd_put_32 (input_bfd,
14297                                         LD_R2_0R1 + STK_TOC (htab),
14298                                         contents + rel->r_offset + 4);
14299                           can_plt_call = TRUE;
14300                         }
14301                     }
14302                 }
14303
14304               if (!can_plt_call && h != NULL)
14305                 {
14306                   const char *name = h->elf.root.root.string;
14307
14308                   if (*name == '.')
14309                     ++name;
14310
14311                   if (strncmp (name, "__libc_start_main", 17) == 0
14312                       && (name[17] == 0 || name[17] == '@'))
14313                     {
14314                       /* Allow crt1 branch to go via a toc adjusting
14315                          stub.  Other calls that never return could do
14316                          the same, if we could detect such.  */
14317                       can_plt_call = TRUE;
14318                     }
14319                 }
14320
14321               if (!can_plt_call)
14322                 {
14323                   /* g++ as of 20130507 emits self-calls without a
14324                      following nop.  This is arguably wrong since we
14325                      have conflicting information.  On the one hand a
14326                      global symbol and on the other a local call
14327                      sequence, but don't error for this special case.
14328                      It isn't possible to cheaply verify we have
14329                      exactly such a call.  Allow all calls to the same
14330                      section.  */
14331                   asection *code_sec = sec;
14332
14333                   if (get_opd_info (sec) != NULL)
14334                     {
14335                       bfd_vma off = (relocation + addend
14336                                      - sec->output_section->vma
14337                                      - sec->output_offset);
14338
14339                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14340                     }
14341                   if (code_sec == input_section)
14342                     can_plt_call = TRUE;
14343                 }
14344
14345               if (!can_plt_call)
14346                 {
14347                   if (stub_entry->stub_type == ppc_stub_plt_call
14348                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14349                     info->callbacks->einfo
14350                       /* xgettext:c-format */
14351                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14352                          "recompile with -fPIC\n"),
14353                        input_bfd, input_section, rel->r_offset, sym_name);
14354                   else
14355                     info->callbacks->einfo
14356                       /* xgettext:c-format */
14357                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14358                          "(-mcmodel=small toc adjust stub)\n"),
14359                        input_bfd, input_section, rel->r_offset, sym_name);
14360
14361                   bfd_set_error (bfd_error_bad_value);
14362                   ret = FALSE;
14363                 }
14364
14365               if (can_plt_call
14366                   && (stub_entry->stub_type == ppc_stub_plt_call
14367                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14368                 unresolved_reloc = FALSE;
14369             }
14370
14371           if ((stub_entry == NULL
14372                || stub_entry->stub_type == ppc_stub_long_branch
14373                || stub_entry->stub_type == ppc_stub_plt_branch)
14374               && get_opd_info (sec) != NULL)
14375             {
14376               /* The branch destination is the value of the opd entry. */
14377               bfd_vma off = (relocation + addend
14378                              - sec->output_section->vma
14379                              - sec->output_offset);
14380               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14381               if (dest != (bfd_vma) -1)
14382                 {
14383                   relocation = dest;
14384                   addend = 0;
14385                   reloc_dest = DEST_OPD;
14386                 }
14387             }
14388
14389           /* If the branch is out of reach we ought to have a long
14390              branch stub.  */
14391           from = (rel->r_offset
14392                   + input_section->output_offset
14393                   + input_section->output_section->vma);
14394
14395           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14396                                                   ? fdh->elf.other
14397                                                   : sym->st_other);
14398
14399           if (stub_entry != NULL
14400               && (stub_entry->stub_type == ppc_stub_long_branch
14401                   || stub_entry->stub_type == ppc_stub_plt_branch)
14402               && (r_type == R_PPC64_ADDR14_BRTAKEN
14403                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14404                   || (relocation + addend - from + max_br_offset
14405                       < 2 * max_br_offset)))
14406             /* Don't use the stub if this branch is in range.  */
14407             stub_entry = NULL;
14408
14409           if (stub_entry != NULL)
14410             {
14411               /* Munge up the value and addend so that we call the stub
14412                  rather than the procedure directly.  */
14413               asection *stub_sec = stub_entry->group->stub_sec;
14414
14415               if (stub_entry->stub_type == ppc_stub_save_res)
14416                 relocation += (stub_sec->output_offset
14417                                + stub_sec->output_section->vma
14418                                + stub_sec->size - htab->sfpr->size
14419                                - htab->sfpr->output_offset
14420                                - htab->sfpr->output_section->vma);
14421               else
14422                 relocation = (stub_entry->stub_offset
14423                               + stub_sec->output_offset
14424                               + stub_sec->output_section->vma);
14425               addend = 0;
14426               reloc_dest = DEST_STUB;
14427
14428               if ((stub_entry->stub_type == ppc_stub_plt_call
14429                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14430                   && (ALWAYS_EMIT_R2SAVE
14431                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14432                   && rel + 1 < relend
14433                   && rel[1].r_offset == rel->r_offset + 4
14434                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14435                 relocation += 4;
14436             }
14437
14438           if (insn != 0)
14439             {
14440               if (is_isa_v2)
14441                 {
14442                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14443                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14444                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14445                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14446                     insn |= 0x02 << 21;
14447                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14448                     insn |= 0x08 << 21;
14449                   else
14450                     break;
14451                 }
14452               else
14453                 {
14454                   /* Invert 'y' bit if not the default.  */
14455                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14456                     insn ^= 0x01 << 21;
14457                 }
14458
14459               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14460             }
14461
14462           /* NOP out calls to undefined weak functions.
14463              We can thus call a weak function without first
14464              checking whether the function is defined.  */
14465           else if (h != NULL
14466                    && h->elf.root.type == bfd_link_hash_undefweak
14467                    && h->elf.dynindx == -1
14468                    && r_type == R_PPC64_REL24
14469                    && relocation == 0
14470                    && addend == 0)
14471             {
14472               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14473               goto copy_reloc;
14474             }
14475           break;
14476         }
14477
14478       /* Set `addend'.  */
14479       tls_type = 0;
14480       switch (r_type)
14481         {
14482         default:
14483           info->callbacks->einfo
14484             /* xgettext:c-format */
14485             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14486              input_bfd, (int) r_type, sym_name);
14487
14488           bfd_set_error (bfd_error_bad_value);
14489           ret = FALSE;
14490           goto copy_reloc;
14491
14492         case R_PPC64_NONE:
14493         case R_PPC64_TLS:
14494         case R_PPC64_TLSGD:
14495         case R_PPC64_TLSLD:
14496         case R_PPC64_TOCSAVE:
14497         case R_PPC64_GNU_VTINHERIT:
14498         case R_PPC64_GNU_VTENTRY:
14499         case R_PPC64_ENTRY:
14500           goto copy_reloc;
14501
14502           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14503              address in the GOT as relocation value instead of the
14504              symbol's value itself.  Also, create a GOT entry for the
14505              symbol and put the symbol value there.  */
14506         case R_PPC64_GOT_TLSGD16:
14507         case R_PPC64_GOT_TLSGD16_LO:
14508         case R_PPC64_GOT_TLSGD16_HI:
14509         case R_PPC64_GOT_TLSGD16_HA:
14510           tls_type = TLS_TLS | TLS_GD;
14511           goto dogot;
14512
14513         case R_PPC64_GOT_TLSLD16:
14514         case R_PPC64_GOT_TLSLD16_LO:
14515         case R_PPC64_GOT_TLSLD16_HI:
14516         case R_PPC64_GOT_TLSLD16_HA:
14517           tls_type = TLS_TLS | TLS_LD;
14518           goto dogot;
14519
14520         case R_PPC64_GOT_TPREL16_DS:
14521         case R_PPC64_GOT_TPREL16_LO_DS:
14522         case R_PPC64_GOT_TPREL16_HI:
14523         case R_PPC64_GOT_TPREL16_HA:
14524           tls_type = TLS_TLS | TLS_TPREL;
14525           goto dogot;
14526
14527         case R_PPC64_GOT_DTPREL16_DS:
14528         case R_PPC64_GOT_DTPREL16_LO_DS:
14529         case R_PPC64_GOT_DTPREL16_HI:
14530         case R_PPC64_GOT_DTPREL16_HA:
14531           tls_type = TLS_TLS | TLS_DTPREL;
14532           goto dogot;
14533
14534         case R_PPC64_GOT16:
14535         case R_PPC64_GOT16_LO:
14536         case R_PPC64_GOT16_HI:
14537         case R_PPC64_GOT16_HA:
14538         case R_PPC64_GOT16_DS:
14539         case R_PPC64_GOT16_LO_DS:
14540         dogot:
14541           {
14542             /* Relocation is to the entry for this symbol in the global
14543                offset table.  */
14544             asection *got;
14545             bfd_vma *offp;
14546             bfd_vma off;
14547             unsigned long indx = 0;
14548             struct got_entry *ent;
14549
14550             if (tls_type == (TLS_TLS | TLS_LD)
14551                 && (h == NULL
14552                     || !h->elf.def_dynamic))
14553               ent = ppc64_tlsld_got (input_bfd);
14554             else
14555               {
14556                 if (h != NULL)
14557                   {
14558                     if (!htab->elf.dynamic_sections_created
14559                         || h->elf.dynindx == -1
14560                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14561                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14562                       /* This is actually a static link, or it is a
14563                          -Bsymbolic link and the symbol is defined
14564                          locally, or the symbol was forced to be local
14565                          because of a version file.  */
14566                       ;
14567                     else
14568                       {
14569                         indx = h->elf.dynindx;
14570                         unresolved_reloc = FALSE;
14571                       }
14572                     ent = h->elf.got.glist;
14573                   }
14574                 else
14575                   {
14576                     if (local_got_ents == NULL)
14577                       abort ();
14578                     ent = local_got_ents[r_symndx];
14579                   }
14580
14581                 for (; ent != NULL; ent = ent->next)
14582                   if (ent->addend == orig_rel.r_addend
14583                       && ent->owner == input_bfd
14584                       && ent->tls_type == tls_type)
14585                     break;
14586               }
14587
14588             if (ent == NULL)
14589               abort ();
14590             if (ent->is_indirect)
14591               ent = ent->got.ent;
14592             offp = &ent->got.offset;
14593             got = ppc64_elf_tdata (ent->owner)->got;
14594             if (got == NULL)
14595               abort ();
14596
14597             /* The offset must always be a multiple of 8.  We use the
14598                least significant bit to record whether we have already
14599                processed this entry.  */
14600             off = *offp;
14601             if ((off & 1) != 0)
14602               off &= ~1;
14603             else
14604               {
14605                 /* Generate relocs for the dynamic linker, except in
14606                    the case of TLSLD where we'll use one entry per
14607                    module.  */
14608                 asection *relgot;
14609                 bfd_boolean ifunc;
14610
14611                 *offp = off | 1;
14612                 relgot = NULL;
14613                 ifunc = (h != NULL
14614                          ? h->elf.type == STT_GNU_IFUNC
14615                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14616                 if (ifunc)
14617                   {
14618                     relgot = htab->elf.irelplt;
14619                     if (indx == 0)
14620                       htab->local_ifunc_resolver = 1;
14621                     else if (is_static_defined (&h->elf))
14622                       htab->maybe_local_ifunc_resolver = 1;
14623                   }
14624                 else if (indx != 0
14625                          || (bfd_link_pic (info)
14626                              && (h == NULL
14627                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14628                                  || (tls_type == (TLS_TLS | TLS_LD)
14629                                      && !h->elf.def_dynamic))))
14630                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14631                 if (relgot != NULL)
14632                   {
14633                     outrel.r_offset = (got->output_section->vma
14634                                        + got->output_offset
14635                                        + off);
14636                     outrel.r_addend = addend;
14637                     if (tls_type & (TLS_LD | TLS_GD))
14638                       {
14639                         outrel.r_addend = 0;
14640                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14641                         if (tls_type == (TLS_TLS | TLS_GD))
14642                           {
14643                             loc = relgot->contents;
14644                             loc += (relgot->reloc_count++
14645                                     * sizeof (Elf64_External_Rela));
14646                             bfd_elf64_swap_reloca_out (output_bfd,
14647                                                        &outrel, loc);
14648                             outrel.r_offset += 8;
14649                             outrel.r_addend = addend;
14650                             outrel.r_info
14651                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14652                           }
14653                       }
14654                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14655                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14656                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14657                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14658                     else if (indx != 0)
14659                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14660                     else
14661                       {
14662                         if (ifunc)
14663                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14664                         else
14665                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14666
14667                         /* Write the .got section contents for the sake
14668                            of prelink.  */
14669                         loc = got->contents + off;
14670                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14671                                     loc);
14672                       }
14673
14674                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14675                       {
14676                         outrel.r_addend += relocation;
14677                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14678                           {
14679                             if (htab->elf.tls_sec == NULL)
14680                               outrel.r_addend = 0;
14681                             else
14682                               outrel.r_addend -= htab->elf.tls_sec->vma;
14683                           }
14684                       }
14685                     loc = relgot->contents;
14686                     loc += (relgot->reloc_count++
14687                             * sizeof (Elf64_External_Rela));
14688                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14689                   }
14690
14691                 /* Init the .got section contents here if we're not
14692                    emitting a reloc.  */
14693                 else
14694                   {
14695                     relocation += addend;
14696                     if (tls_type != 0)
14697                       {
14698                         if (htab->elf.tls_sec == NULL)
14699                           relocation = 0;
14700                         else
14701                           {
14702                             if (tls_type & TLS_LD)
14703                               relocation = 0;
14704                             else
14705                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14706                             if (tls_type & TLS_TPREL)
14707                               relocation += DTP_OFFSET - TP_OFFSET;
14708                           }
14709
14710                         if (tls_type & (TLS_GD | TLS_LD))
14711                           {
14712                             bfd_put_64 (output_bfd, relocation,
14713                                         got->contents + off + 8);
14714                             relocation = 1;
14715                           }
14716                       }
14717                     bfd_put_64 (output_bfd, relocation,
14718                                 got->contents + off);
14719                   }
14720               }
14721
14722             if (off >= (bfd_vma) -2)
14723               abort ();
14724
14725             relocation = got->output_section->vma + got->output_offset + off;
14726             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14727           }
14728           break;
14729
14730         case R_PPC64_PLT16_HA:
14731         case R_PPC64_PLT16_HI:
14732         case R_PPC64_PLT16_LO:
14733         case R_PPC64_PLT32:
14734         case R_PPC64_PLT64:
14735           /* Relocation is to the entry for this symbol in the
14736              procedure linkage table.  */
14737           {
14738             struct plt_entry **plt_list = NULL;
14739             if (h != NULL)
14740               plt_list = &h->elf.plt.plist;
14741             else if (local_got_ents != NULL)
14742               {
14743                 struct plt_entry **local_plt = (struct plt_entry **)
14744                   (local_got_ents + symtab_hdr->sh_info);
14745                 unsigned char *local_got_tls_masks = (unsigned char *)
14746                   (local_plt + symtab_hdr->sh_info);
14747                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14748                   plt_list = local_plt + r_symndx;
14749               }
14750             if (plt_list)
14751               {
14752                 struct plt_entry *ent;
14753
14754                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14755                   if (ent->plt.offset != (bfd_vma) -1
14756                       && ent->addend == orig_rel.r_addend)
14757                     {
14758                       asection *plt;
14759
14760                       plt = htab->elf.splt;
14761                       if (!htab->elf.dynamic_sections_created
14762                           || h == NULL
14763                           || h->elf.dynindx == -1)
14764                         plt = htab->elf.iplt;
14765                       relocation = (plt->output_section->vma
14766                                     + plt->output_offset
14767                                     + ent->plt.offset);
14768                       addend = 0;
14769                       unresolved_reloc = FALSE;
14770                       break;
14771                     }
14772               }
14773           }
14774           break;
14775
14776         case R_PPC64_TOC:
14777           /* Relocation value is TOC base.  */
14778           relocation = TOCstart;
14779           if (r_symndx == STN_UNDEF)
14780             relocation += htab->sec_info[input_section->id].toc_off;
14781           else if (unresolved_reloc)
14782             ;
14783           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14784             relocation += htab->sec_info[sec->id].toc_off;
14785           else
14786             unresolved_reloc = TRUE;
14787           goto dodyn;
14788
14789           /* TOC16 relocs.  We want the offset relative to the TOC base,
14790              which is the address of the start of the TOC plus 0x8000.
14791              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14792              in this order.  */
14793         case R_PPC64_TOC16:
14794         case R_PPC64_TOC16_LO:
14795         case R_PPC64_TOC16_HI:
14796         case R_PPC64_TOC16_DS:
14797         case R_PPC64_TOC16_LO_DS:
14798         case R_PPC64_TOC16_HA:
14799           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14800           break;
14801
14802           /* Relocate against the beginning of the section.  */
14803         case R_PPC64_SECTOFF:
14804         case R_PPC64_SECTOFF_LO:
14805         case R_PPC64_SECTOFF_HI:
14806         case R_PPC64_SECTOFF_DS:
14807         case R_PPC64_SECTOFF_LO_DS:
14808         case R_PPC64_SECTOFF_HA:
14809           if (sec != NULL)
14810             addend -= sec->output_section->vma;
14811           break;
14812
14813         case R_PPC64_REL16:
14814         case R_PPC64_REL16_LO:
14815         case R_PPC64_REL16_HI:
14816         case R_PPC64_REL16_HA:
14817         case R_PPC64_REL16DX_HA:
14818           break;
14819
14820         case R_PPC64_REL14:
14821         case R_PPC64_REL14_BRNTAKEN:
14822         case R_PPC64_REL14_BRTAKEN:
14823         case R_PPC64_REL24:
14824           break;
14825
14826         case R_PPC64_TPREL16:
14827         case R_PPC64_TPREL16_LO:
14828         case R_PPC64_TPREL16_HI:
14829         case R_PPC64_TPREL16_HA:
14830         case R_PPC64_TPREL16_DS:
14831         case R_PPC64_TPREL16_LO_DS:
14832         case R_PPC64_TPREL16_HIGH:
14833         case R_PPC64_TPREL16_HIGHA:
14834         case R_PPC64_TPREL16_HIGHER:
14835         case R_PPC64_TPREL16_HIGHERA:
14836         case R_PPC64_TPREL16_HIGHEST:
14837         case R_PPC64_TPREL16_HIGHESTA:
14838           if (h != NULL
14839               && h->elf.root.type == bfd_link_hash_undefweak
14840               && h->elf.dynindx == -1)
14841             {
14842               /* Make this relocation against an undefined weak symbol
14843                  resolve to zero.  This is really just a tweak, since
14844                  code using weak externs ought to check that they are
14845                  defined before using them.  */
14846               bfd_byte *p = contents + rel->r_offset - d_offset;
14847
14848               insn = bfd_get_32 (input_bfd, p);
14849               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14850               if (insn != 0)
14851                 bfd_put_32 (input_bfd, insn, p);
14852               break;
14853             }
14854           if (htab->elf.tls_sec != NULL)
14855             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14856           /* The TPREL16 relocs shouldn't really be used in shared
14857              libs or with non-local symbols as that will result in
14858              DT_TEXTREL being set, but support them anyway.  */
14859           goto dodyn;
14860
14861         case R_PPC64_DTPREL16:
14862         case R_PPC64_DTPREL16_LO:
14863         case R_PPC64_DTPREL16_HI:
14864         case R_PPC64_DTPREL16_HA:
14865         case R_PPC64_DTPREL16_DS:
14866         case R_PPC64_DTPREL16_LO_DS:
14867         case R_PPC64_DTPREL16_HIGH:
14868         case R_PPC64_DTPREL16_HIGHA:
14869         case R_PPC64_DTPREL16_HIGHER:
14870         case R_PPC64_DTPREL16_HIGHERA:
14871         case R_PPC64_DTPREL16_HIGHEST:
14872         case R_PPC64_DTPREL16_HIGHESTA:
14873           if (htab->elf.tls_sec != NULL)
14874             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14875           break;
14876
14877         case R_PPC64_ADDR64_LOCAL:
14878           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14879                                               ? h->elf.other
14880                                               : sym->st_other);
14881           break;
14882
14883         case R_PPC64_DTPMOD64:
14884           relocation = 1;
14885           addend = 0;
14886           goto dodyn;
14887
14888         case R_PPC64_TPREL64:
14889           if (htab->elf.tls_sec != NULL)
14890             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14891           goto dodyn;
14892
14893         case R_PPC64_DTPREL64:
14894           if (htab->elf.tls_sec != NULL)
14895             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14896           /* Fall through.  */
14897
14898           /* Relocations that may need to be propagated if this is a
14899              dynamic object.  */
14900         case R_PPC64_REL30:
14901         case R_PPC64_REL32:
14902         case R_PPC64_REL64:
14903         case R_PPC64_ADDR14:
14904         case R_PPC64_ADDR14_BRNTAKEN:
14905         case R_PPC64_ADDR14_BRTAKEN:
14906         case R_PPC64_ADDR16:
14907         case R_PPC64_ADDR16_DS:
14908         case R_PPC64_ADDR16_HA:
14909         case R_PPC64_ADDR16_HI:
14910         case R_PPC64_ADDR16_HIGH:
14911         case R_PPC64_ADDR16_HIGHA:
14912         case R_PPC64_ADDR16_HIGHER:
14913         case R_PPC64_ADDR16_HIGHERA:
14914         case R_PPC64_ADDR16_HIGHEST:
14915         case R_PPC64_ADDR16_HIGHESTA:
14916         case R_PPC64_ADDR16_LO:
14917         case R_PPC64_ADDR16_LO_DS:
14918         case R_PPC64_ADDR24:
14919         case R_PPC64_ADDR32:
14920         case R_PPC64_ADDR64:
14921         case R_PPC64_UADDR16:
14922         case R_PPC64_UADDR32:
14923         case R_PPC64_UADDR64:
14924         dodyn:
14925           if ((input_section->flags & SEC_ALLOC) == 0)
14926             break;
14927
14928           if (NO_OPD_RELOCS && is_opd)
14929             break;
14930
14931           if (bfd_link_pic (info)
14932               ? ((h == NULL
14933                   || h->dyn_relocs != NULL)
14934                  && ((h != NULL && pc_dynrelocs (h))
14935                      || must_be_dyn_reloc (info, r_type)))
14936               : (h != NULL
14937                  ? h->dyn_relocs != NULL
14938                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14939             {
14940               bfd_boolean skip, relocate;
14941               asection *sreloc;
14942               bfd_vma out_off;
14943               long indx = 0;
14944
14945               /* When generating a dynamic object, these relocations
14946                  are copied into the output file to be resolved at run
14947                  time.  */
14948
14949               skip = FALSE;
14950               relocate = FALSE;
14951
14952               out_off = _bfd_elf_section_offset (output_bfd, info,
14953                                                  input_section, rel->r_offset);
14954               if (out_off == (bfd_vma) -1)
14955                 skip = TRUE;
14956               else if (out_off == (bfd_vma) -2)
14957                 skip = TRUE, relocate = TRUE;
14958               out_off += (input_section->output_section->vma
14959                           + input_section->output_offset);
14960               outrel.r_offset = out_off;
14961               outrel.r_addend = rel->r_addend;
14962
14963               /* Optimize unaligned reloc use.  */
14964               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14965                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14966                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14967               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14968                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14969                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14970               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14971                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14972                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14973
14974               if (skip)
14975                 memset (&outrel, 0, sizeof outrel);
14976               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14977                        && !is_opd
14978                        && r_type != R_PPC64_TOC)
14979                 {
14980                   indx = h->elf.dynindx;
14981                   BFD_ASSERT (indx != -1);
14982                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14983                 }
14984               else
14985                 {
14986                   /* This symbol is local, or marked to become local,
14987                      or this is an opd section reloc which must point
14988                      at a local function.  */
14989                   outrel.r_addend += relocation;
14990                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14991                     {
14992                       if (is_opd && h != NULL)
14993                         {
14994                           /* Lie about opd entries.  This case occurs
14995                              when building shared libraries and we
14996                              reference a function in another shared
14997                              lib.  The same thing happens for a weak
14998                              definition in an application that's
14999                              overridden by a strong definition in a
15000                              shared lib.  (I believe this is a generic
15001                              bug in binutils handling of weak syms.)
15002                              In these cases we won't use the opd
15003                              entry in this lib.  */
15004                           unresolved_reloc = FALSE;
15005                         }
15006                       if (!is_opd
15007                           && r_type == R_PPC64_ADDR64
15008                           && (h != NULL
15009                               ? h->elf.type == STT_GNU_IFUNC
15010                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15011                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15012                       else
15013                         {
15014                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15015
15016                           /* We need to relocate .opd contents for ld.so.
15017                              Prelink also wants simple and consistent rules
15018                              for relocs.  This make all RELATIVE relocs have
15019                              *r_offset equal to r_addend.  */
15020                           relocate = TRUE;
15021                         }
15022                     }
15023                   else
15024                     {
15025                       if (h != NULL
15026                           ? h->elf.type == STT_GNU_IFUNC
15027                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15028                         {
15029                           info->callbacks->einfo
15030                             /* xgettext:c-format */
15031                             (_("%H: %s for indirect "
15032                                "function `%T' unsupported\n"),
15033                              input_bfd, input_section, rel->r_offset,
15034                              ppc64_elf_howto_table[r_type]->name,
15035                              sym_name);
15036                           ret = FALSE;
15037                         }
15038                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15039                         ;
15040                       else if (sec == NULL || sec->owner == NULL)
15041                         {
15042                           bfd_set_error (bfd_error_bad_value);
15043                           return FALSE;
15044                         }
15045                       else
15046                         {
15047                           asection *osec;
15048
15049                           osec = sec->output_section;
15050                           indx = elf_section_data (osec)->dynindx;
15051
15052                           if (indx == 0)
15053                             {
15054                               if ((osec->flags & SEC_READONLY) == 0
15055                                   && htab->elf.data_index_section != NULL)
15056                                 osec = htab->elf.data_index_section;
15057                               else
15058                                 osec = htab->elf.text_index_section;
15059                               indx = elf_section_data (osec)->dynindx;
15060                             }
15061                           BFD_ASSERT (indx != 0);
15062
15063                           /* We are turning this relocation into one
15064                              against a section symbol, so subtract out
15065                              the output section's address but not the
15066                              offset of the input section in the output
15067                              section.  */
15068                           outrel.r_addend -= osec->vma;
15069                         }
15070
15071                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15072                     }
15073                 }
15074
15075               sreloc = elf_section_data (input_section)->sreloc;
15076               if (h != NULL
15077                   ? h->elf.type == STT_GNU_IFUNC
15078                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15079                 {
15080                   sreloc = htab->elf.irelplt;
15081                   if (indx == 0)
15082                     htab->local_ifunc_resolver = 1;
15083                   else if (is_static_defined (&h->elf))
15084                     htab->maybe_local_ifunc_resolver = 1;
15085                 }
15086               if (sreloc == NULL)
15087                 abort ();
15088
15089               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15090                   >= sreloc->size)
15091                 abort ();
15092               loc = sreloc->contents;
15093               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15094               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15095
15096               /* If this reloc is against an external symbol, it will
15097                  be computed at runtime, so there's no need to do
15098                  anything now.  However, for the sake of prelink ensure
15099                  that the section contents are a known value.  */
15100               if (! relocate)
15101                 {
15102                   unresolved_reloc = FALSE;
15103                   /* The value chosen here is quite arbitrary as ld.so
15104                      ignores section contents except for the special
15105                      case of .opd where the contents might be accessed
15106                      before relocation.  Choose zero, as that won't
15107                      cause reloc overflow.  */
15108                   relocation = 0;
15109                   addend = 0;
15110                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15111                      to improve backward compatibility with older
15112                      versions of ld.  */
15113                   if (r_type == R_PPC64_ADDR64)
15114                     addend = outrel.r_addend;
15115                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15116                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15117                     addend = outrel.r_offset;
15118                 }
15119             }
15120           break;
15121
15122         case R_PPC64_COPY:
15123         case R_PPC64_GLOB_DAT:
15124         case R_PPC64_JMP_SLOT:
15125         case R_PPC64_JMP_IREL:
15126         case R_PPC64_RELATIVE:
15127           /* We shouldn't ever see these dynamic relocs in relocatable
15128              files.  */
15129           /* Fall through.  */
15130
15131         case R_PPC64_PLTGOT16:
15132         case R_PPC64_PLTGOT16_DS:
15133         case R_PPC64_PLTGOT16_HA:
15134         case R_PPC64_PLTGOT16_HI:
15135         case R_PPC64_PLTGOT16_LO:
15136         case R_PPC64_PLTGOT16_LO_DS:
15137         case R_PPC64_PLTREL32:
15138         case R_PPC64_PLTREL64:
15139           /* These ones haven't been implemented yet.  */
15140
15141           info->callbacks->einfo
15142             /* xgettext:c-format */
15143             (_("%P: %B: %s is not supported for `%T'\n"),
15144              input_bfd,
15145              ppc64_elf_howto_table[r_type]->name, sym_name);
15146
15147           bfd_set_error (bfd_error_invalid_operation);
15148           ret = FALSE;
15149           goto copy_reloc;
15150         }
15151
15152       /* Multi-instruction sequences that access the TOC can be
15153          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15154          to             nop;           addi rb,r2,x;  */
15155       switch (r_type)
15156         {
15157         default:
15158           break;
15159
15160         case R_PPC64_GOT_TLSLD16_HI:
15161         case R_PPC64_GOT_TLSGD16_HI:
15162         case R_PPC64_GOT_TPREL16_HI:
15163         case R_PPC64_GOT_DTPREL16_HI:
15164         case R_PPC64_GOT16_HI:
15165         case R_PPC64_TOC16_HI:
15166           /* These relocs would only be useful if building up an
15167              offset to later add to r2, perhaps in an indexed
15168              addressing mode instruction.  Don't try to optimize.
15169              Unfortunately, the possibility of someone building up an
15170              offset like this or even with the HA relocs, means that
15171              we need to check the high insn when optimizing the low
15172              insn.  */
15173           break;
15174
15175         case R_PPC64_GOT_TLSLD16_HA:
15176         case R_PPC64_GOT_TLSGD16_HA:
15177         case R_PPC64_GOT_TPREL16_HA:
15178         case R_PPC64_GOT_DTPREL16_HA:
15179         case R_PPC64_GOT16_HA:
15180         case R_PPC64_TOC16_HA:
15181           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15182               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15183             {
15184               bfd_byte *p = contents + (rel->r_offset & ~3);
15185               bfd_put_32 (input_bfd, NOP, p);
15186             }
15187           break;
15188
15189         case R_PPC64_GOT_TLSLD16_LO:
15190         case R_PPC64_GOT_TLSGD16_LO:
15191         case R_PPC64_GOT_TPREL16_LO_DS:
15192         case R_PPC64_GOT_DTPREL16_LO_DS:
15193         case R_PPC64_GOT16_LO:
15194         case R_PPC64_GOT16_LO_DS:
15195         case R_PPC64_TOC16_LO:
15196         case R_PPC64_TOC16_LO_DS:
15197           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15198               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15199             {
15200               bfd_byte *p = contents + (rel->r_offset & ~3);
15201               insn = bfd_get_32 (input_bfd, p);
15202               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15203                 {
15204                   /* Transform addic to addi when we change reg.  */
15205                   insn &= ~((0x3f << 26) | (0x1f << 16));
15206                   insn |= (14u << 26) | (2 << 16);
15207                 }
15208               else
15209                 {
15210                   insn &= ~(0x1f << 16);
15211                   insn |= 2 << 16;
15212                 }
15213               bfd_put_32 (input_bfd, insn, p);
15214             }
15215           break;
15216         }
15217
15218       /* Do any further special processing.  */
15219       howto = ppc64_elf_howto_table[(int) r_type];
15220       switch (r_type)
15221         {
15222         default:
15223           break;
15224
15225         case R_PPC64_REL16_HA:
15226         case R_PPC64_REL16DX_HA:
15227         case R_PPC64_ADDR16_HA:
15228         case R_PPC64_ADDR16_HIGHA:
15229         case R_PPC64_ADDR16_HIGHERA:
15230         case R_PPC64_ADDR16_HIGHESTA:
15231         case R_PPC64_TOC16_HA:
15232         case R_PPC64_SECTOFF_HA:
15233         case R_PPC64_TPREL16_HA:
15234         case R_PPC64_TPREL16_HIGHA:
15235         case R_PPC64_TPREL16_HIGHERA:
15236         case R_PPC64_TPREL16_HIGHESTA:
15237         case R_PPC64_DTPREL16_HA:
15238         case R_PPC64_DTPREL16_HIGHA:
15239         case R_PPC64_DTPREL16_HIGHERA:
15240         case R_PPC64_DTPREL16_HIGHESTA:
15241           /* It's just possible that this symbol is a weak symbol
15242              that's not actually defined anywhere. In that case,
15243              'sec' would be NULL, and we should leave the symbol
15244              alone (it will be set to zero elsewhere in the link).  */
15245           if (sec == NULL)
15246             break;
15247           /* Fall through.  */
15248
15249         case R_PPC64_GOT16_HA:
15250         case R_PPC64_PLTGOT16_HA:
15251         case R_PPC64_PLT16_HA:
15252         case R_PPC64_GOT_TLSGD16_HA:
15253         case R_PPC64_GOT_TLSLD16_HA:
15254         case R_PPC64_GOT_TPREL16_HA:
15255         case R_PPC64_GOT_DTPREL16_HA:
15256           /* Add 0x10000 if sign bit in 0:15 is set.
15257              Bits 0:15 are not used.  */
15258           addend += 0x8000;
15259           break;
15260
15261         case R_PPC64_ADDR16_DS:
15262         case R_PPC64_ADDR16_LO_DS:
15263         case R_PPC64_GOT16_DS:
15264         case R_PPC64_GOT16_LO_DS:
15265         case R_PPC64_PLT16_LO_DS:
15266         case R_PPC64_SECTOFF_DS:
15267         case R_PPC64_SECTOFF_LO_DS:
15268         case R_PPC64_TOC16_DS:
15269         case R_PPC64_TOC16_LO_DS:
15270         case R_PPC64_PLTGOT16_DS:
15271         case R_PPC64_PLTGOT16_LO_DS:
15272         case R_PPC64_GOT_TPREL16_DS:
15273         case R_PPC64_GOT_TPREL16_LO_DS:
15274         case R_PPC64_GOT_DTPREL16_DS:
15275         case R_PPC64_GOT_DTPREL16_LO_DS:
15276         case R_PPC64_TPREL16_DS:
15277         case R_PPC64_TPREL16_LO_DS:
15278         case R_PPC64_DTPREL16_DS:
15279         case R_PPC64_DTPREL16_LO_DS:
15280           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15281           mask = 3;
15282           /* If this reloc is against an lq, lxv, or stxv insn, then
15283              the value must be a multiple of 16.  This is somewhat of
15284              a hack, but the "correct" way to do this by defining _DQ
15285              forms of all the _DS relocs bloats all reloc switches in
15286              this file.  It doesn't make much sense to use these
15287              relocs in data, so testing the insn should be safe.  */
15288           if ((insn & (0x3f << 26)) == (56u << 26)
15289               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15290             mask = 15;
15291           relocation += addend;
15292           addend = insn & (mask ^ 3);
15293           if ((relocation & mask) != 0)
15294             {
15295               relocation ^= relocation & mask;
15296               info->callbacks->einfo
15297                 /* xgettext:c-format */
15298                 (_("%H: error: %s not a multiple of %u\n"),
15299                  input_bfd, input_section, rel->r_offset,
15300                  howto->name,
15301                  mask + 1);
15302               bfd_set_error (bfd_error_bad_value);
15303               ret = FALSE;
15304               goto copy_reloc;
15305             }
15306           break;
15307         }
15308
15309       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15310          because such sections are not SEC_ALLOC and thus ld.so will
15311          not process them.  */
15312       if (unresolved_reloc
15313           && !((input_section->flags & SEC_DEBUGGING) != 0
15314                && h->elf.def_dynamic)
15315           && _bfd_elf_section_offset (output_bfd, info, input_section,
15316                                       rel->r_offset) != (bfd_vma) -1)
15317         {
15318           info->callbacks->einfo
15319             /* xgettext:c-format */
15320             (_("%H: unresolvable %s against `%T'\n"),
15321              input_bfd, input_section, rel->r_offset,
15322              howto->name,
15323              h->elf.root.root.string);
15324           ret = FALSE;
15325         }
15326
15327       /* 16-bit fields in insns mostly have signed values, but a
15328          few insns have 16-bit unsigned values.  Really, we should
15329          have different reloc types.  */
15330       if (howto->complain_on_overflow != complain_overflow_dont
15331           && howto->dst_mask == 0xffff
15332           && (input_section->flags & SEC_CODE) != 0)
15333         {
15334           enum complain_overflow complain = complain_overflow_signed;
15335
15336           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15337           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15338             complain = complain_overflow_bitfield;
15339           else if (howto->rightshift == 0
15340                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15341                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15342                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15343                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15344                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15345                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15346             complain = complain_overflow_unsigned;
15347           if (howto->complain_on_overflow != complain)
15348             {
15349               alt_howto = *howto;
15350               alt_howto.complain_on_overflow = complain;
15351               howto = &alt_howto;
15352             }
15353         }
15354
15355       if (r_type == R_PPC64_REL16DX_HA)
15356         {
15357           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15358           if (rel->r_offset + 4 > input_section->size)
15359             r = bfd_reloc_outofrange;
15360           else
15361             {
15362               relocation += addend;
15363               relocation -= (rel->r_offset
15364                              + input_section->output_offset
15365                              + input_section->output_section->vma);
15366               relocation = (bfd_signed_vma) relocation >> 16;
15367               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15368               insn &= ~0x1fffc1;
15369               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15370               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15371               r = bfd_reloc_ok;
15372               if (relocation + 0x8000 > 0xffff)
15373                 r = bfd_reloc_overflow;
15374             }
15375         }
15376       else
15377         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15378                                       rel->r_offset, relocation, addend);
15379
15380       if (r != bfd_reloc_ok)
15381         {
15382           char *more_info = NULL;
15383           const char *reloc_name = howto->name;
15384
15385           if (reloc_dest != DEST_NORMAL)
15386             {
15387               more_info = bfd_malloc (strlen (reloc_name) + 8);
15388               if (more_info != NULL)
15389                 {
15390                   strcpy (more_info, reloc_name);
15391                   strcat (more_info, (reloc_dest == DEST_OPD
15392                                       ? " (OPD)" : " (stub)"));
15393                   reloc_name = more_info;
15394                 }
15395             }
15396
15397           if (r == bfd_reloc_overflow)
15398             {
15399               /* On code like "if (foo) foo();" don't report overflow
15400                  on a branch to zero when foo is undefined.  */
15401               if (!warned
15402                   && (reloc_dest == DEST_STUB
15403                       || !(h != NULL
15404                            && (h->elf.root.type == bfd_link_hash_undefweak
15405                                || h->elf.root.type == bfd_link_hash_undefined)
15406                            && is_branch_reloc (r_type))))
15407                 info->callbacks->reloc_overflow (info, &h->elf.root,
15408                                                  sym_name, reloc_name,
15409                                                  orig_rel.r_addend,
15410                                                  input_bfd, input_section,
15411                                                  rel->r_offset);
15412             }
15413           else
15414             {
15415               info->callbacks->einfo
15416                 /* xgettext:c-format */
15417                 (_("%H: %s against `%T': error %d\n"),
15418                  input_bfd, input_section, rel->r_offset,
15419                  reloc_name, sym_name, (int) r);
15420               ret = FALSE;
15421             }
15422           if (more_info != NULL)
15423             free (more_info);
15424         }
15425     copy_reloc:
15426       if (wrel != rel)
15427         *wrel = *rel;
15428     }
15429
15430   if (wrel != rel)
15431     {
15432       Elf_Internal_Shdr *rel_hdr;
15433       size_t deleted = rel - wrel;
15434
15435       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15436       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15437       if (rel_hdr->sh_size == 0)
15438         {
15439           /* It is too late to remove an empty reloc section.  Leave
15440              one NONE reloc.
15441              ??? What is wrong with an empty section???  */
15442           rel_hdr->sh_size = rel_hdr->sh_entsize;
15443           deleted -= 1;
15444         }
15445       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15446       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15447       input_section->reloc_count -= deleted;
15448     }
15449
15450   /* If we're emitting relocations, then shortly after this function
15451      returns, reloc offsets and addends for this section will be
15452      adjusted.  Worse, reloc symbol indices will be for the output
15453      file rather than the input.  Save a copy of the relocs for
15454      opd_entry_value.  */
15455   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15456     {
15457       bfd_size_type amt;
15458       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15459       rel = bfd_alloc (input_bfd, amt);
15460       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15461       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15462       if (rel == NULL)
15463         return FALSE;
15464       memcpy (rel, relocs, amt);
15465     }
15466   return ret;
15467 }
15468
15469 /* Adjust the value of any local symbols in opd sections.  */
15470
15471 static int
15472 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15473                               const char *name ATTRIBUTE_UNUSED,
15474                               Elf_Internal_Sym *elfsym,
15475                               asection *input_sec,
15476                               struct elf_link_hash_entry *h)
15477 {
15478   struct _opd_sec_data *opd;
15479   long adjust;
15480   bfd_vma value;
15481
15482   if (h != NULL)
15483     return 1;
15484
15485   opd = get_opd_info (input_sec);
15486   if (opd == NULL || opd->adjust == NULL)
15487     return 1;
15488
15489   value = elfsym->st_value - input_sec->output_offset;
15490   if (!bfd_link_relocatable (info))
15491     value -= input_sec->output_section->vma;
15492
15493   adjust = opd->adjust[OPD_NDX (value)];
15494   if (adjust == -1)
15495     return 2;
15496
15497   elfsym->st_value += adjust;
15498   return 1;
15499 }
15500
15501 /* Finish up dynamic symbol handling.  We set the contents of various
15502    dynamic sections here.  */
15503
15504 static bfd_boolean
15505 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15506                                  struct bfd_link_info *info,
15507                                  struct elf_link_hash_entry *h,
15508                                  Elf_Internal_Sym *sym)
15509 {
15510   struct ppc_link_hash_table *htab;
15511   struct plt_entry *ent;
15512   Elf_Internal_Rela rela;
15513   bfd_byte *loc;
15514
15515   htab = ppc_hash_table (info);
15516   if (htab == NULL)
15517     return FALSE;
15518
15519   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15520     if (ent->plt.offset != (bfd_vma) -1)
15521       {
15522         /* This symbol has an entry in the procedure linkage
15523            table.  Set it up.  */
15524         if (!htab->elf.dynamic_sections_created
15525             || h->dynindx == -1)
15526           {
15527             BFD_ASSERT (h->type == STT_GNU_IFUNC
15528                         && h->def_regular
15529                         && (h->root.type == bfd_link_hash_defined
15530                             || h->root.type == bfd_link_hash_defweak));
15531             rela.r_offset = (htab->elf.iplt->output_section->vma
15532                              + htab->elf.iplt->output_offset
15533                              + ent->plt.offset);
15534             if (htab->opd_abi)
15535               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15536             else
15537               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15538             rela.r_addend = (h->root.u.def.value
15539                              + h->root.u.def.section->output_offset
15540                              + h->root.u.def.section->output_section->vma
15541                              + ent->addend);
15542             loc = (htab->elf.irelplt->contents
15543                    + (htab->elf.irelplt->reloc_count++
15544                       * sizeof (Elf64_External_Rela)));
15545             htab->local_ifunc_resolver = 1;
15546           }
15547         else
15548           {
15549             rela.r_offset = (htab->elf.splt->output_section->vma
15550                              + htab->elf.splt->output_offset
15551                              + ent->plt.offset);
15552             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15553             rela.r_addend = ent->addend;
15554             loc = (htab->elf.srelplt->contents
15555                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15556                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15557             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15558               htab->maybe_local_ifunc_resolver = 1;
15559           }
15560         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15561
15562         if (!htab->opd_abi)
15563           {
15564             if (!h->def_regular)
15565               {
15566                 /* Mark the symbol as undefined, rather than as
15567                    defined in glink.  Leave the value if there were
15568                    any relocations where pointer equality matters
15569                    (this is a clue for the dynamic linker, to make
15570                    function pointer comparisons work between an
15571                    application and shared library), otherwise set it
15572                    to zero.  */
15573                 sym->st_shndx = SHN_UNDEF;
15574                 if (!h->pointer_equality_needed)
15575                   sym->st_value = 0;
15576                 else if (!h->ref_regular_nonweak)
15577                   {
15578                     /* This breaks function pointer comparisons, but
15579                        that is better than breaking tests for a NULL
15580                        function pointer.  */
15581                     sym->st_value = 0;
15582                   }
15583               }
15584           }
15585       }
15586
15587   if (h->needs_copy)
15588     {
15589       /* This symbol needs a copy reloc.  Set it up.  */
15590       asection *srel;
15591
15592       if (h->dynindx == -1
15593           || (h->root.type != bfd_link_hash_defined
15594               && h->root.type != bfd_link_hash_defweak)
15595           || htab->elf.srelbss == NULL
15596           || htab->elf.sreldynrelro == NULL)
15597         abort ();
15598
15599       rela.r_offset = (h->root.u.def.value
15600                        + h->root.u.def.section->output_section->vma
15601                        + h->root.u.def.section->output_offset);
15602       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15603       rela.r_addend = 0;
15604       if (h->root.u.def.section == htab->elf.sdynrelro)
15605         srel = htab->elf.sreldynrelro;
15606       else
15607         srel = htab->elf.srelbss;
15608       loc = srel->contents;
15609       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15610       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15611     }
15612
15613   return TRUE;
15614 }
15615
15616 /* Used to decide how to sort relocs in an optimal manner for the
15617    dynamic linker, before writing them out.  */
15618
15619 static enum elf_reloc_type_class
15620 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15621                             const asection *rel_sec,
15622                             const Elf_Internal_Rela *rela)
15623 {
15624   enum elf_ppc64_reloc_type r_type;
15625   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15626
15627   if (rel_sec == htab->elf.irelplt)
15628     return reloc_class_ifunc;
15629
15630   r_type = ELF64_R_TYPE (rela->r_info);
15631   switch (r_type)
15632     {
15633     case R_PPC64_RELATIVE:
15634       return reloc_class_relative;
15635     case R_PPC64_JMP_SLOT:
15636       return reloc_class_plt;
15637     case R_PPC64_COPY:
15638       return reloc_class_copy;
15639     default:
15640       return reloc_class_normal;
15641     }
15642 }
15643
15644 /* Finish up the dynamic sections.  */
15645
15646 static bfd_boolean
15647 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15648                                    struct bfd_link_info *info)
15649 {
15650   struct ppc_link_hash_table *htab;
15651   bfd *dynobj;
15652   asection *sdyn;
15653
15654   htab = ppc_hash_table (info);
15655   if (htab == NULL)
15656     return FALSE;
15657
15658   dynobj = htab->elf.dynobj;
15659   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15660
15661   if (htab->elf.dynamic_sections_created)
15662     {
15663       Elf64_External_Dyn *dyncon, *dynconend;
15664
15665       if (sdyn == NULL || htab->elf.sgot == NULL)
15666         abort ();
15667
15668       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15669       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15670       for (; dyncon < dynconend; dyncon++)
15671         {
15672           Elf_Internal_Dyn dyn;
15673           asection *s;
15674
15675           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15676
15677           switch (dyn.d_tag)
15678             {
15679             default:
15680               continue;
15681
15682             case DT_PPC64_GLINK:
15683               s = htab->glink;
15684               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15685               /* We stupidly defined DT_PPC64_GLINK to be the start
15686                  of glink rather than the first entry point, which is
15687                  what ld.so needs, and now have a bigger stub to
15688                  support automatic multiple TOCs.  */
15689               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15690               break;
15691
15692             case DT_PPC64_OPD:
15693               s = bfd_get_section_by_name (output_bfd, ".opd");
15694               if (s == NULL)
15695                 continue;
15696               dyn.d_un.d_ptr = s->vma;
15697               break;
15698
15699             case DT_PPC64_OPT:
15700               if (htab->do_multi_toc && htab->multi_toc_needed)
15701                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15702               if (htab->has_plt_localentry0)
15703                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15704               break;
15705
15706             case DT_PPC64_OPDSZ:
15707               s = bfd_get_section_by_name (output_bfd, ".opd");
15708               if (s == NULL)
15709                 continue;
15710               dyn.d_un.d_val = s->size;
15711               break;
15712
15713             case DT_PLTGOT:
15714               s = htab->elf.splt;
15715               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15716               break;
15717
15718             case DT_JMPREL:
15719               s = htab->elf.srelplt;
15720               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15721               break;
15722
15723             case DT_PLTRELSZ:
15724               dyn.d_un.d_val = htab->elf.srelplt->size;
15725               break;
15726
15727             case DT_TEXTREL:
15728               if (htab->local_ifunc_resolver)
15729                 info->callbacks->einfo
15730                   (_("%X%P: text relocations and GNU indirect "
15731                      "functions will result in a segfault at runtime\n"));
15732               else if (htab->maybe_local_ifunc_resolver)
15733                 info->callbacks->einfo
15734                   (_("%P: warning: text relocations and GNU indirect "
15735                      "functions may result in a segfault at runtime\n"));
15736               continue;
15737             }
15738
15739           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15740         }
15741     }
15742
15743   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15744       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15745     {
15746       /* Fill in the first entry in the global offset table.
15747          We use it to hold the link-time TOCbase.  */
15748       bfd_put_64 (output_bfd,
15749                   elf_gp (output_bfd) + TOC_BASE_OFF,
15750                   htab->elf.sgot->contents);
15751
15752       /* Set .got entry size.  */
15753       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15754     }
15755
15756   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15757       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15758     {
15759       /* Set .plt entry size.  */
15760       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15761         = PLT_ENTRY_SIZE (htab);
15762     }
15763
15764   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15765      brlt ourselves if emitrelocations.  */
15766   if (htab->brlt != NULL
15767       && htab->brlt->reloc_count != 0
15768       && !_bfd_elf_link_output_relocs (output_bfd,
15769                                        htab->brlt,
15770                                        elf_section_data (htab->brlt)->rela.hdr,
15771                                        elf_section_data (htab->brlt)->relocs,
15772                                        NULL))
15773     return FALSE;
15774
15775   if (htab->glink != NULL
15776       && htab->glink->reloc_count != 0
15777       && !_bfd_elf_link_output_relocs (output_bfd,
15778                                        htab->glink,
15779                                        elf_section_data (htab->glink)->rela.hdr,
15780                                        elf_section_data (htab->glink)->relocs,
15781                                        NULL))
15782     return FALSE;
15783
15784   if (htab->glink_eh_frame != NULL
15785       && htab->glink_eh_frame->size != 0)
15786     {
15787       bfd_vma val;
15788       bfd_byte *p;
15789       struct map_stub *group;
15790       size_t align = 4;
15791
15792       p = htab->glink_eh_frame->contents;
15793       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15794
15795       for (group = htab->group; group != NULL; group = group->next)
15796         if (group->stub_sec != NULL)
15797           {
15798             /* Offset to stub section.  */
15799             val = (group->stub_sec->output_section->vma
15800                    + group->stub_sec->output_offset);
15801             val -= (htab->glink_eh_frame->output_section->vma
15802                     + htab->glink_eh_frame->output_offset
15803                     + (p + 8 - htab->glink_eh_frame->contents));
15804             if (val + 0x80000000 > 0xffffffff)
15805               {
15806                 info->callbacks->einfo
15807                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15808                    group->stub_sec->name);
15809                 return FALSE;
15810               }
15811             bfd_put_32 (dynobj, val, p + 8);
15812             p += stub_eh_frame_size (group, align);
15813           }
15814       if (htab->glink != NULL && htab->glink->size != 0)
15815         {
15816           /* Offset to .glink.  */
15817           val = (htab->glink->output_section->vma
15818                  + htab->glink->output_offset
15819                  + 8);
15820           val -= (htab->glink_eh_frame->output_section->vma
15821                   + htab->glink_eh_frame->output_offset
15822                   + (p + 8 - htab->glink_eh_frame->contents));
15823           if (val + 0x80000000 > 0xffffffff)
15824             {
15825               info->callbacks->einfo
15826                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15827                  htab->glink->name);
15828               return FALSE;
15829             }
15830           bfd_put_32 (dynobj, val, p + 8);
15831           p += (24 + align - 1) & -align;
15832         }
15833
15834       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15835           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15836                                                htab->glink_eh_frame,
15837                                                htab->glink_eh_frame->contents))
15838         return FALSE;
15839     }
15840
15841   /* We need to handle writing out multiple GOT sections ourselves,
15842      since we didn't add them to DYNOBJ.  We know dynobj is the first
15843      bfd.  */
15844   while ((dynobj = dynobj->link.next) != NULL)
15845     {
15846       asection *s;
15847
15848       if (!is_ppc64_elf (dynobj))
15849         continue;
15850
15851       s = ppc64_elf_tdata (dynobj)->got;
15852       if (s != NULL
15853           && s->size != 0
15854           && s->output_section != bfd_abs_section_ptr
15855           && !bfd_set_section_contents (output_bfd, s->output_section,
15856                                         s->contents, s->output_offset,
15857                                         s->size))
15858         return FALSE;
15859       s = ppc64_elf_tdata (dynobj)->relgot;
15860       if (s != NULL
15861           && s->size != 0
15862           && s->output_section != bfd_abs_section_ptr
15863           && !bfd_set_section_contents (output_bfd, s->output_section,
15864                                         s->contents, s->output_offset,
15865                                         s->size))
15866         return FALSE;
15867     }
15868
15869   return TRUE;
15870 }
15871
15872 #include "elf64-target.h"
15873
15874 /* FreeBSD support */
15875
15876 #undef  TARGET_LITTLE_SYM
15877 #undef  TARGET_LITTLE_NAME
15878
15879 #undef  TARGET_BIG_SYM
15880 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15881 #undef  TARGET_BIG_NAME
15882 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15883
15884 #undef  ELF_OSABI
15885 #define ELF_OSABI       ELFOSABI_FREEBSD
15886
15887 #undef  elf64_bed
15888 #define elf64_bed       elf64_powerpc_fbsd_bed
15889
15890 #include "elf64-target.h"