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